wip fix

app/srv/ws/sync/actions/page_load.ts

@@ -1,6 +1,7 @@
 import { EPage } from "../../../../web/src/nova/ed/logic/ed-global";
 import { initLoadComp } from "../../../../web/src/nova/view/logic/meta/comp/init-load-comp";
 import { genMeta } from "../../../../web/src/nova/view/logic/meta/meta";
+import { simplifyMeta } from "../../../../web/src/nova/view/logic/meta/simplify";
 import { GenMetaP } from "../../../../web/src/nova/view/logic/meta/types";
 import { IItem } from "../../../../web/src/utils/types/item";
 import { DPage } from "../../../../web/src/utils/types/root";
@@ -177,7 +178,7 @@ export const page_load: SAction["page"]["load"] = async function (
 };
 
 const scanMeta = async (doc: DPage, sync: SyncConnection) => {
-  const meta: EPage["meta"] = {};
+  const meta: GenMetaP["meta"] = {};
   const mcomps: GenMetaP["comps"] = {};
 
   const loading = {} as Record<string, Promise<void>>;
@@ -221,9 +222,9 @@ const scanMeta = async (doc: DPage, sync: SyncConnection) => {
   for (const [id, v] of Object.entries(mcomps)) {
     const snap = snapshot.get("comp", id);
     if (snap) {
-      comps[id] = { comp: v.comp, snapshot: await gzipAsync(snap.bin) };
+      comps[id] = { id, snapshot: await gzipAsync(snap.bin) };
     }
   }
 
-  return { meta, comps, entry };
+  return { meta: simplifyMeta(meta), comps, entry };
 };

app/web/src/nova/ed/logic/ed-global.ts

@@ -11,7 +11,7 @@ import { ISection } from "../../../utils/types/section";
 import { IText, MText } from "../../../utils/types/text";
 import { PageItem } from "../panel/popup/page/page-tree";
 import { FMCompDef } from "../../../utils/types/meta-fn";
-import { IMeta } from "../../view/logic/meta/types";
+import { IMeta, ISimpleMeta } from "../../view/logic/meta/types";
 
 export const EmptySite = {
   id: "",
@@ -49,8 +49,8 @@ const EmptyPage = {
   url: "",
   snapshot: null as null | Uint8Array,
   entry: [] as string[],
-  meta: {} as Record<string, IMeta>,
-  comps: {} as Record<string, { comp: IItem; snapshot: null | Uint8Array }>,
+  meta: {} as Record<string, ISimpleMeta>,
+  comps: {} as Record<string, EComp>,
 };
 
 const EmptyComp = {

app/web/src/nova/view/logic/meta/comp.tsx

@@ -4,7 +4,7 @@ import { instantiate } from "./comp/instantiate";
 import { walkProp } from "./comp/walk-prop";
 import { genMeta } from "./meta";
 import { applyRefIds } from "./ref-ids";
-import { simplify } from "./simplify";
+import { simplifyItem } from "./simplify";
 import { GenMetaArg, GenMetaP, IMeta } from "./types";
 
 export const genComp = (
@@ -32,7 +32,7 @@ export const genComp = (
       instantiate(item, pcomp.comp, ref_ids, mref_ids);
 
       const meta: IMeta = {
-        item: simplify(item),
+        item: simplifyItem(item),
         parent: {
           id: arg.parent.item.id,
           instance_id: arg.parent?.instance?.id,

app/web/src/nova/view/logic/meta/meta.tsx

@@ -1,7 +1,7 @@
 import { IItem, MItem } from "../../../../utils/types/item";
 import { genComp } from "./comp";
 import { applyRefIds } from "./ref-ids";
-import { simplify } from "./simplify";
+import { simplifyItem } from "./simplify";
 import { GenMetaArg, GenMetaP, IMeta } from "./types";
 
 export const genMeta = (p: GenMetaP, arg: GenMetaArg) => {
@@ -21,14 +21,14 @@ export const genMeta = (p: GenMetaP, arg: GenMetaArg) => {
     const item = arg.item as IItem;
     const mitem = arg.mitem as MItem | undefined;
 
-    const r = applyRefIds(item, mitem, parent);
+    const r = applyRefIds(item, mitem, parent, p.smeta);
     if (item.type === "item" && item.component?.id) {
       genComp(p, arg, r);
       return;
     }
 
     const meta: IMeta = {
-      item: simplify(item),
+      item: simplifyItem(item),
       parent: {
         id: arg.parent?.item.id || "root",
         instance_id: arg.parent?.instance?.id,

app/web/src/nova/view/logic/meta/ref-ids.tsx

@@ -3,13 +3,15 @@ import { TypedMap } from "yjs-types";
 import { IContent, MContent } from "../../../../utils/types/general";
 import { IItem } from "../../../../utils/types/item";
 import set from "lodash.set";
+import { ISimpleMeta } from "./types";
 
 const timeouts = {} as Record<string, any>;
 
 export const applyRefIds = (
   item: IContent,
   mitem?: MContent,
-  parent?: { instance?: IItem; minstance?: MContent }
+  parent?: { instance?: IItem; minstance?: MContent },
+  smeta?: Record<string, ISimpleMeta>
 ) => {
   const instance = parent?.instance;
 

app/web/src/nova/view/logic/meta/simplify.tsx

@@ -1,6 +1,7 @@
 import { IItem } from "../../../../utils/types/item";
+import { IMeta, ISimpleMeta } from "./types";
 
-export const simplify = (item: IItem) => {
+export const simplifyItem = (item: IItem) => {
   const newitem = {} as any;
   for (const [k, v] of Object.entries(item)) {
     if (k === "childs") {
@@ -16,3 +17,26 @@ export const simplify = (item: IItem) => {
   }
   return newitem as IItem;
 };
+
+export const simplifyMeta = (allmeta: Record<string, IMeta>) => {
+  const smeta = {} as Record<string, ISimpleMeta>;
+
+  for (const [k, meta] of Object.entries(allmeta)) {
+    smeta[k] = {
+      id: meta.item.id,
+      parent: meta.parent
+        ? {
+            id: meta.parent.id,
+            comp_id: meta.parent.comp_id,
+            instance_id: meta.parent.instance_id,
+          }
+        : undefined,
+      comp: meta.item.component?.id
+        ? { id: meta.item.component.id, ref_ids: meta.item.component.ref_ids }
+        : undefined,
+      scope: meta.scope.def,
+    };
+  }
+
+  return smeta;
+};

app/web/src/nova/view/logic/meta/types.ts

@@ -10,6 +10,7 @@ export type GenMetaP = {
     item_exists?: (arg: { old: IMeta; new: IMeta }) => void;
     item_new?: (arg: { new: IMeta }) => void;
   };
+  smeta?: Record<string, ISimpleMeta>;
   set_mitem?: boolean;
   set_meta?: boolean;
 };
@@ -29,6 +30,20 @@ export type GenMetaArg = {
   };
 };
 
+export type ISimpleMeta = {
+  id: string;
+  comp?: {
+    id: string;
+    ref_ids: Record<string, string>;
+  };
+  parent?: {
+    id: string;
+    instance_id?: string;
+    comp_id?: string;
+  };
+  scope: IMeta["scope"]["def"];
+};
+
 export type IMeta = {
   item: IItem;
   mitem?: MItem;