@blocklet/pages-kit-inner-components 0.4.22 → 0.4.24

package/lib/es/_chunks/site-state-D28bWM8J.js

@@ -0,0 +1,1490 @@
+import ee from "vite-plugin-node-polyfills/shims/process";
+import Oe from "vite-plugin-node-polyfills/shims/global";
+import { getComponentMountPoint as ot } from "@blocklet/pages-kit/builtin/utils";
+import { PreloadComponentScriptModule as Q } from "@blocklet/pages-kit/types";
+import { componentUMDName as nt, RenderNestedComponent as Ae, mergeComponent as rt } from "@blocklet/pages-kit/utils/property";
+import { memoize as ae, Sandbox as $e, BuiltinModules as at } from "@blocklet/quickjs";
+import w from "@blocklet/sdk/lib/config";
+import { LRUCache as he } from "lru-cache";
+import it, { Headers as ct } from "node-fetch";
+import { joinURL as U, parseURL as ve, withHttps as lt, getQuery as pt, withQuery as ut } from "ufo";
+import { createHash as ie } from "crypto";
+import dt from "@blocklet/logger";
+import mt from "vite-plugin-node-polyfills/shims/buffer";
+import { BuiltinModules as ft } from "@blocklet/pages-kit/utils/builtin";
+import { createBuiltinModuleTransformer as gt, isRelativeModule as Te } from "@blocklet/pages-kit/utils/typescript/builtin-module-transformer";
+import { call as Be, getResources as ht, getComponentWebEndpoint as yt } from "@blocklet/sdk/lib/component";
+import wt from "autoprefixer";
+import * as St from "esbuild";
+import { readFileSync as J, existsSync as B, lstatSync as X, readdirSync as Et, rmSync as Ve, mkdtempSync as bt, mkdirSync as M, writeFileSync as te, renameSync as Ce, createWriteStream as It } from "fs";
+import Ot from "postcss";
+import At from "tailwindcss";
+import x from "typescript";
+import { reactive as vt } from "@reactivedata/reactive";
+import { syncedStore as Tt, getYjsValue as le } from "@syncedstore/core";
+import { globSync as me } from "glob";
+import * as pe from "lib0/decoding";
+import * as C from "lib0/encoding";
+import { get as ye, isEmpty as Ct, set as Pe, debounce as Ge, pick as Pt, union as xt, cloneDeep as jt } from "lodash";
+import { customAlphabet as kt } from "nanoid";
+import Nt from "p-limit";
+import Dt, { join as O, dirname as L, basename as G } from "path";
+import { pipeline as Lt } from "stream/promises";
+import { x as Rt } from "tar";
+import Ut from "wait-on";
+import { encodeAwarenessUpdate as xe, removeAwarenessStates as _t, applyAwarenessUpdate as Mt, Awareness as Ft } from "y-protocols/awareness";
+import { writeUpdate as $t, writeSyncStep1 as Bt, readSyncMessage as Vt } from "y-protocols/sync";
+import * as H from "yaml";
+import * as $ from "yjs";
+import Gt from "lodash/isNil";
+import { DataTypes as T, Sequelize as Jt, Model as Je, Op as Ht } from "sequelize";
+import "sqlite3";
+w.env.mode;
+const Kt = "image-bin";
+w.env.INIT_TEMPLATE_PATH;
+const Wt = ee.env.DATABASE_URL || Dt.join(w.env.dataDir, "db/pages-kit.db"), je = w, no = () => w.env.tenantMode === "multiple", ro = () => {
+  var t;
+  return (Gt(je.env.preferences.multiTenantAllProjectAccessPassports) ? [] : (t = je.env.preferences.multiTenantAllProjectAccessPassports) == null ? void 0 : t.split(",")) || [];
+}, A = dt("pages-kit"), zt = T.sqlite.DATE.parse;
+T.sqlite.DATE.parse = (t, s) => typeof t == "number" ? new Date(t) : zt(t, s);
+const z = new Jt({
+  dialect: "sqlite",
+  storage: Wt,
+  benchmark: ee.env.ENABLE_SEQUELIZE_BENCHMARK === "true",
+  retry: {
+    match: [/SQLITE_BUSY/],
+    name: "query",
+    max: 10
+  },
+  // eslint-disable-next-line no-console
+  logging: ee.env.ENABLE_SEQUELIZE_LOGGING === "true" ? console.log : !1
+  // logQueryParameters: true,
+});
+z.query("pragma journal_mode = WAL;");
+z.query("pragma synchronous = normal;");
+z.query("pragma journal_size_limit = 67108864;");
+class ce extends Je {
+  // Foreign key to Component
+}
+ce.init(
+  {
+    id: {
+      type: T.UUID,
+      allowNull: !1,
+      primaryKey: !0,
+      defaultValue: T.UUIDV4
+    },
+    projectId: {
+      type: T.UUID,
+      allowNull: !1
+    },
+    componentId: {
+      type: T.STRING,
+      allowNull: !1
+    }
+  },
+  { sequelize: z, tableName: "ProjectComponents", timestamps: !1 }
+);
+class F extends Je {
+  static async getProjectByIdOrSlug(s) {
+    return F.findOne({
+      where: {
+        [Ht.or]: [{ id: s }, { slug: s }]
+      }
+    });
+  }
+}
+F.init(
+  {
+    id: {
+      type: T.UUID,
+      defaultValue: T.UUIDV4,
+      primaryKey: !0
+    },
+    name: {
+      type: T.STRING,
+      allowNull: !1
+    },
+    description: T.TEXT,
+    createdAt: T.DATE,
+    updatedAt: T.DATE,
+    createdBy: {
+      type: T.STRING,
+      allowNull: !1
+    },
+    updatedBy: {
+      type: T.STRING,
+      allowNull: !1
+    },
+    slug: T.STRING,
+    icon: T.STRING,
+    pinnedAt: T.DATE,
+    useAllResources: T.BOOLEAN,
+    relatedBlocklets: {
+      type: T.JSON,
+      allowNull: !1,
+      defaultValue: {},
+      get() {
+        return this.getDataValue("relatedBlocklets") || {};
+      },
+      set(t) {
+        this.setDataValue("relatedBlocklets", JSON.stringify(t || {}));
+      }
+    }
+  },
+  { sequelize: z, paranoid: !0 }
+);
+F.hasMany(ce, {
+  foreignKey: "projectId",
+  as: "components"
+});
+const Yt = async (t, { componentId: s }) => {
+  const e = `@tailwind components;
+@tailwind utilities;
+`, o = `.CustomComponent_${s}`;
+  return (await Ot([
+    At({ content: [{ raw: t, extension: "tsx" }] }),
+    wt({
+      overrideBrowserslist: ["> 1%", "last 2 versions"],
+      stats: {}
+    }),
+    (a) => {
+      a.walkRules((l) => {
+        l.selectors = l.selectors.map((r) => r.replace(/\.(.+)/g, `${o}.$1,${o} .$1`));
+      });
+    }
+    // FIXME: cssnano use browserslist, it is not working with the fs isolation
+    // cssnano({ preset: 'default' }),
+  ]).process(e)).css;
+}, qt = async (t, { componentId: s }) => {
+  const e = await Yt(t, { componentId: s });
+  return `export const __PagesKit_CSS__ = ${JSON.stringify(e)};
+
+${t}
+`;
+}, ke = ae(
+  async (t, s) => {
+    let e = x.transpileModule(t, {
+      compilerOptions: {
+        jsx: x.JsxEmit.React,
+        target: x.ScriptTarget.ES2016,
+        module: x.ModuleKind.ESNext
+      },
+      transformers: {
+        before: [gt(x)]
+      }
+    }).outputText;
+    if (s.tailwind && (e = await qt(e, { componentId: s.componentId })), s.module === Q.ESM) return e;
+    const o = x.transpileModule(e, {
+      compilerOptions: {
+        jsx: x.JsxEmit.React,
+        target: x.ScriptTarget.ES2016,
+        module: x.ModuleKind.CommonJS,
+        moduleResolution: x.ModuleResolutionKind.Node16
+      }
+    }).outputText;
+    return s.module === Q.CJS ? o : Xt(s.moduleName, o);
+  },
+  {
+    keyGenerator: (t, s) => {
+      const e = ie("md5").update(t).digest("hex"), o = {
+        ...s,
+        componentId: s.componentId,
+        module: s.module,
+        ...s.module !== Q.ESM ? { moduleName: s.moduleName } : {},
+        tailwind: s.tailwind
+      };
+      return JSON.stringify(["transpileModule", e, o]);
+    },
+    lruOptions: {
+      max: 100,
+      // 限制缓存项数量为100
+      ttl: 1e3 * 60 * 60
+      // 1小时过期时间
+    }
+  }
+), Qt = async (t, s) => {
+  var l, r;
+  const o = (r = (l = (await St.build({
+    entryPoints: ["index.tsx"],
+    external: Object.keys(ft),
+    format: "esm",
+    target: "esnext",
+    bundle: !0,
+    write: !1,
+    plugins: [
+      {
+        name: "vfs",
+        setup(i) {
+          let c = null;
+          i.onResolve({ filter: /.*/ }, (p) => p.path === "index.tsx" ? { path: "index.tsx", namespace: "vfs" } : p.path === "./component" ? { path: "component.tsx", namespace: "vfs" } : Te(p.path) ? { path: p.path, namespace: "vfs" } : null), i.onLoad({ filter: /.*/, namespace: "vfs" }, async (p) => {
+            var u;
+            if (p.path === "index.tsx")
+              return { contents: `export { ${s} } from './component'`, loader: "tsx" };
+            if (p.path === "component.tsx")
+              return { contents: t, loader: "tsx" };
+            if (Te(p.path)) {
+              c || (c = await tt({ ensureLoaded: !1 }));
+              const f = p.path.split("/").pop();
+              if ((u = c == null ? void 0 : c.chunks) != null && u[f])
+                return { contents: J(c.chunks[f], "utf-8"), loader: "js" };
+              const g = U("chunks", f), { data: y } = await Be({
+                name: "pages-kit",
+                method: "GET",
+                path: g
+              });
+              return { contents: y, loader: "js" };
+            }
+            return null;
+          });
+        }
+      }
+    ]
+  })).outputFiles) == null ? void 0 : l[0]) == null ? void 0 : r.contents;
+  if (!o) throw new Error("Failed to build server code");
+  const n = mt.from(o).toString();
+  return x.transpileModule(n, {
+    compilerOptions: { module: x.ModuleKind.ESNext, target: x.ScriptTarget.ES2020 }
+  }).outputText;
+}, He = ae(
+  async (t, s) => {
+    const e = await Qt(t, s);
+    return new RegExp(`export\\s+\\{\\s+${s}\\s+\\}`, "m").test(e) ? e : void 0;
+  },
+  {
+    keyGenerator: (t, s) => {
+      const e = ie("md5").update(t).digest("hex");
+      return JSON.stringify(["extractExportValueSchema", e, s]);
+    },
+    lruOptions: {
+      max: 100,
+      ttl: 1e3 * 60 * 60
+    }
+  }
+), Xt = (t, s) => {
+  const e = /\bawait\b/.test(s);
+  return `// GENERATED FILE. DO NOT EDIT.
+var ${t} = ${e ? "async" : ""} function () {
+
+  const exports = {};
+  let moduleExports = null;
+  
+  // add commonjs module compatibility layer
+  const module = { exports: moduleExports };
+  
+  // execute component code
+  ${s}
+  
+  // handle possible module.exports
+  if (module.exports && module.exports !== moduleExports) {
+    // if module.exports is used, use it first
+    return typeof module.exports === 'object' ? module.exports : { default: module.exports };
+  }
+  
+  // ensure a default export
+  if (!('default' in exports) && Object.keys(exports).length === 0) {
+    // module has no exports, return null to indicate invalid
+    return null;
+  }
+  
+  return exports;
+};
+`;
+}, K = new he({
+  max: 100
+}), Zt = 60 * 60, Ne = 60;
+function es(t) {
+  A.info("clear preload components cache", { cacheKey: t }), K.delete(t);
+}
+function ts(t) {
+  for (const s of K.keys())
+    s.includes(t) && (A.info("clear preload components cache", { cacheKey: s }), es(s));
+}
+function ss({
+  mode: t,
+  instanceId: s,
+  componentId: e,
+  locale: o
+}) {
+  return ["getPreloadComponents", t, s, e, o].join("-");
+}
+async function ao({
+  mode: t,
+  req: s,
+  state: e,
+  locale: o,
+  instances: n,
+  module: a
+}) {
+  const {
+    supportedLocales: l,
+    config: { defaultLocale: r }
+  } = e;
+  if (!r) return null;
+  const i = (await Promise.all(
+    n.map(async (g) => {
+      try {
+        const y = ss({
+          mode: t,
+          instanceId: g.id,
+          componentId: g.componentId,
+          locale: o
+        });
+        if (t !== "draft" && g.useCache && K.has(y))
+          return A.info(`get preload component from cache: ${y}`), K.get(y);
+        const v = se({ state: e, componentId: g.componentId });
+        if (!v) return null;
+        const P = await os({
+          req: s,
+          state: e,
+          componentId: v.id,
+          locale: o,
+          defaultLocale: r,
+          properties: g.properties
+        });
+        if (!P) return null;
+        const k = { instanceId: g.id, preload: P };
+        if (t !== "draft" && g.useCache) {
+          let N = Zt;
+          g.cacheDuration && (N = g.cacheDuration), A.info(`set preload component to cache(${N}s): ${y}`), K.set(y, k, {
+            ttl: N * 1e3
+          });
+        }
+        return k;
+      } catch (y) {
+        return A.error("get preload component error", { instanceId: g.id, componentId: g.componentId }, { error: y }), null;
+      }
+    })
+  )).filter((g) => !!g), c = Object.values(
+    i.reduce((g, y) => ({ ...g, ...y.preload.components }), {})
+  );
+  async function p() {
+    const g = await Promise.all(
+      c.map(async (y) => {
+        const v = nt({ componentId: y.component.id }), P = a === Q.ESM ? {
+          module: a,
+          script: await ke(y.script, {
+            componentId: y.component.id,
+            module: a,
+            tailwind: t !== "draft"
+          })
+        } : {
+          module: a,
+          script: await ke(y.script, {
+            componentId: y.component.id,
+            module: a,
+            moduleName: v,
+            tailwind: t !== "draft"
+          }),
+          moduleName: v
+        };
+        return [y.component.id, { component: y.component, script: P }];
+      })
+    );
+    return Object.fromEntries(g);
+  }
+  const u = await p();
+  return {
+    config: { defaultLocale: r, supportedLocales: l },
+    components: u,
+    instances: i.map((g) => ({
+      id: g.instanceId,
+      componentId: g.preload.component.id,
+      locales: { [g.preload.locale]: { props: g.preload.props } }
+    }))
+  };
+}
+async function os({
+  req: t,
+  state: s,
+  componentId: e,
+  locale: o,
+  defaultLocale: n,
+  properties: a
+}) {
+  const { supportedLocales: l } = s, r = se({ state: s, componentId: e });
+  if (!r) return null;
+  const i = l.some((p) => p.locale === o) ? o : n;
+  if (!i) return null;
+  const c = await Ke({ req: t, state: s, componentId: e, locale: i, defaultLocale: n, properties: a });
+  return c ? {
+    component: r,
+    ...c
+  } : null;
+}
+const ns = 20;
+async function Ke({
+  req: t,
+  depth: s = 0,
+  state: e,
+  componentId: o,
+  locale: n,
+  defaultLocale: a,
+  properties: l
+}) {
+  if (s > ns) throw new RangeError("max component depth exceeded");
+  const r = rs({ state: e, componentId: o, properties: l, locale: n });
+  if (!r) return null;
+  const { props: i } = r, c = {
+    locale: n || a,
+    components: { [r.component.id]: { component: r.component, script: r.script } },
+    props: { ...i }
+  };
+  try {
+    const p = await as({ ...r, req: t });
+    p != null && p.props && Object.assign(c.props, p.props);
+  } catch (p) {
+    A.error("preload data at server side error", { componentId: o, name: r.component.name }, { error: p });
+  }
+  return await Promise.all(
+    Object.entries(i).map(async ([p, u]) => {
+      if ((u == null ? void 0 : u.type) === Ae) {
+        const f = await Ke({
+          req: t,
+          depth: s + 1,
+          state: e,
+          componentId: u.componentId,
+          locale: n,
+          defaultLocale: a,
+          properties: u.properties
+        });
+        f && (Object.assign(c.components, f.components), Object.assign(c.props, {
+          [p]: {
+            type: Ae,
+            componentId: u.componentId,
+            props: f.props
+          }
+        }));
+      }
+    })
+  ), c;
+}
+function rs({
+  state: t,
+  componentId: s,
+  locale: e,
+  properties: o
+}) {
+  const n = se({ state: t, componentId: s });
+  if (!n) return null;
+  const a = rt({
+    componentId: s,
+    getComponent: (l) => se({ state: t, componentId: l }),
+    locale: e,
+    defaultLocale: t.config.defaultLocale,
+    properties: o
+  });
+  return a ? { component: n, script: a.script, props: { locale: e, ...a.properties } } : null;
+}
+function se({ state: t, componentId: s }) {
+  var e, o, n;
+  return ((e = t.components[s]) == null ? void 0 : e.data) ?? ((n = (o = t.resources.components) == null ? void 0 : o[s]) == null ? void 0 : n.component);
+}
+function io({ state: t, name: s }) {
+  var o, n;
+  const e = s.toLowerCase();
+  return ((o = Object.values(t.components).find((a) => {
+    var l;
+    return ((l = a.data.name) == null ? void 0 : l.toLowerCase()) === e;
+  })) == null ? void 0 : o.data) ?? ((n = t.resources.components && Object.values(t.resources.components).find((a) => {
+    var l;
+    return ((l = a.component.name) == null ? void 0 : l.toLowerCase()) === e;
+  })) == null ? void 0 : n.component);
+}
+async function as({
+  component: t,
+  script: s,
+  props: e,
+  req: o
+}) {
+  const n = await He(s, "getServerSideProps");
+  if (!n) return null;
+  let a = new AbortController();
+  const l = new Promise((r, i) => {
+    setTimeout(() => {
+      i(new Error("getServerSideProps timeout in promise race")), a && (a.abort(), a = null);
+    }, Ne * 1e3);
+  });
+  try {
+    return await Promise.race([
+      l,
+      $e.callFunction({
+        code: `${n}
+
+export async function getServerSidePropsWrapper(props) {
+  const { location, fetch } = props;
+  // 使用局部变量而不是全局变量
+  const originalLocation = typeof window !== 'undefined' ? window.location : undefined;
+  const originalFetch = globalThis.fetch;
+  
+  try {
+    globalThis.location = location;
+    globalThis.fetch = fetch;
+    return await getServerSideProps(props);
+  } finally {
+    // 清理全局状态
+    if (originalLocation) globalThis.location = originalLocation;
+    if (originalFetch) globalThis.fetch = originalFetch;
+  }
+}`,
+        filename: `${t.name || t.id}.js`,
+        moduleLoader: (r) => {
+          if (r === "@blocklet/pages-kit/builtin/utils")
+            return `const { joinURL, withQuery, getQuery, getComponentMountPoint } = globalThis
+export { joinURL, withQuery, getQuery, getComponentMountPoint }
+`;
+          if (r === "@blocklet/pages-kit/builtin/dayjs")
+            return at.dayjs;
+        },
+        global: {
+          console: {
+            // NOTE: do not return logger.xxx result, it will cause memory leak
+            // eslint-disable-next-line prettier/prettier
+            log: (...r) => {
+              A.info(...r);
+            },
+            warn: (...r) => {
+              A.warn(...r);
+            },
+            error: (...r) => {
+              A.error(...r);
+            }
+          },
+          getComponentMountPoint: ot,
+          joinURL: U,
+          withQuery: ut,
+          getQuery: pt
+        },
+        functionName: "getServerSidePropsWrapper",
+        args: [
+          {
+            // NOTE: IMPORTANT! place location and fetch (has side effect) at the args not global
+            // because the global is shared between all runtime and just init once
+            location: { href: U(lt(o.hostname), o.originalUrl) },
+            fetch: (r, { ...i } = {}) => {
+              const c = typeof r == "string" && r.startsWith("/") ? U(w.env.appUrl, r) : r;
+              if (typeof c == "string" && ve(c).host === ve(w.env.appUrl).host) {
+                const p = o.get("cookie");
+                if (p) {
+                  const u = new ct(i.headers);
+                  u.set("cookie", p), i.headers = u;
+                }
+              }
+              return it(c, {
+                ...i,
+                timeout: Ne * 1e3
+              }).then((p) => ({
+                ok: p.ok,
+                status: p.status,
+                statusText: p.statusText,
+                headers: Object.fromEntries(p.headers.entries()),
+                json: () => p.json()
+              }));
+            },
+            props: e
+          }
+        ]
+      })
+    ]);
+  } finally {
+    a = null;
+  }
+}
+const is = ae(
+  async (t, s, e) => {
+    const o = await He(t, s);
+    if (o)
+      try {
+        return await $e.callFunction({
+          code: `
+            ${o}
+
+            export function get${s}SchemaWrapper() {
+              return ${s};
+            }
+          `,
+          filename: `${e}.js`,
+          functionName: `get${s}SchemaWrapper`
+        });
+      } catch (n) {
+        return A.error(`获取 ${s} 失败`, { componentId: e, error: n }), null;
+      }
+    return null;
+  },
+  {
+    keyGenerator: (t, s, e) => {
+      const o = ie("md5").update(t).digest("hex");
+      return JSON.stringify(["getExportSchemaValueFromCode", o, s, e]);
+    },
+    lruOptions: {
+      max: 100,
+      ttl: 1e3 * 60 * 60
+    }
+  }
+), cs = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o", De = "page", fe = "trigger-reload-project-resource", We = cs, ls = "z2qa7rr3eUyVnWp2PCxEVARuUfLFh6cE5V2xV", { uploadToMediaKit: ps } = require("@blocklet/uploader-server"), Le = kt("abcdefghijklmnopqrstuvwxyz0123456789", 16), we = /^\w+(\w|-|\.)+\w+\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm)$/, W = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/i, Re = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/gi, us = 1e4, ds = 3e4, Y = 0, ue = 1, ms = 0, fs = 1, ge = w, q = O(ee.env.BLOCKLET_DATA_DIR, "site-state"), co = ["production", "draft"], lo = ["production"];
+function ze(t) {
+  return (t == null ? void 0 : t.replace(/\//g, "|")) || "";
+}
+function gs() {
+  var e;
+  const t = ge.env.languages.map((o) => ({ locale: o.code, name: o.name })), s = (e = t[0]) == null ? void 0 : e.locale;
+  return {
+    pageIds: [],
+    pages: {},
+    components: {},
+    supportedLocales: t,
+    config: { defaultLocale: s },
+    resources: {}
+  };
+}
+const _ = class _ extends $.Doc {
+  constructor(s) {
+    super(), this.options = s, this.states = {}, this.conns = /* @__PURE__ */ new Map(), this.awarenessChangeHandler = ({ added: e, updated: o, removed: n }, a) => {
+      const l = e.concat(o, n);
+      if (a !== null) {
+        const c = this.conns.get(a);
+        c && (e.forEach((p) => {
+          c.add(p);
+        }), n.forEach((p) => {
+          c.delete(p);
+        }));
+      }
+      const r = C.createEncoder();
+      C.writeVarUint(r, ue), C.writeVarUint8Array(r, xe(this.awareness, l));
+      const i = C.toUint8Array(r);
+      this.conns.forEach((c, p) => this.send(p, i));
+    }, this.updateHandler = (e) => {
+      const o = C.createEncoder();
+      C.writeVarUint(o, Y), $t(o, e);
+      const n = C.toUint8Array(o);
+      this.conns.forEach((a, l) => this.send(l, n));
+    }, this.ensureDataStructure = () => {
+      var l;
+      const { supportedLocales: e, pages: o, pageIds: n, config: a } = this.syncedStore;
+      {
+        const r = new Set(Object.keys(o));
+        let i = 0;
+        for (; i < n.length; ) {
+          const c = n[i];
+          r.has(c) ? (r.delete(c), i++) : n.splice(i, 1);
+        }
+      }
+      e.splice(0, e.length), e.push(...ge.env.languages.map((r) => ({ locale: r.code, name: r.name }))), a.defaultLocale = (l = e[0]) == null ? void 0 : l.locale;
+      {
+        let r = 0;
+        const i = /* @__PURE__ */ new Set();
+        for (; r < e.length; ) {
+          const { locale: c } = e[r];
+          i.has(c) ? e.splice(r, 1) : (r++, i.add(c));
+        }
+      }
+    }, this.send = (e, o) => {
+      e.readyState !== ms && e.readyState !== fs && this.closeConn(e);
+      try {
+        e.send(o, (n) => {
+          n && this.closeConn(e);
+        });
+      } catch {
+        this.closeConn(e);
+      }
+    }, this.closeConn = (e) => {
+      if (e.removeAllListeners(), this.conns.has(e)) {
+        const o = this.conns.get(e);
+        this.conns.delete(e), o && _t(this.awareness, Array.from(o), null);
+      }
+      e.close();
+    }, this.autoSave = Ge(() => {
+      M(L(this.draftYjsFilePath), { recursive: !0 }), te(this.draftYjsFilePath, $.encodeStateAsUpdate(this));
+    }, us), this.save = ({ flush: e = !1 } = {}) => {
+      this.autoSave(), e && this.autoSave.flush();
+    }, this.publish = async ({ mode: e, pages: o }) => {
+      const n = await this.getState("draft"), a = await this.getState("production");
+      await Me(n, a, { pages: o, pageMergeMode: "replace", deletePages: !0, publishMode: e }), a.config.publishedAt = (/* @__PURE__ */ new Date()).getTime();
+      for (const l of o || Object.keys(this.syncedStore.pages))
+        this.syncedStore.pages[l] && (this.syncedStore.pages[l].publishedAt = (/* @__PURE__ */ new Date()).toISOString());
+      await this.setState(e, a);
+    }, this.mergeState = async (e, o) => {
+      var r, i, c;
+      const n = JSON.parse(JSON.stringify(o));
+      (r = e.config).fontFamily ?? (r.fontFamily = {});
+      const a = (i = n.config) == null ? void 0 : i.fontFamily, l = (c = e.config) == null ? void 0 : c.fontFamily;
+      e.config.fontFamily.title = (a == null ? void 0 : a.title) || (l == null ? void 0 : l.title), e.config.fontFamily.description = (a == null ? void 0 : a.description) || (l == null ? void 0 : l.description), await new Promise((p, u) => {
+        this.transact(async () => {
+          try {
+            const f = await Me(e, o);
+            p(f);
+          } catch (f) {
+            u(f);
+          }
+        });
+      });
+    }, this.addConnection = (e) => {
+      if (this.conns.has(e))
+        return;
+      e.binaryType = "arraybuffer", this.conns.set(e, /* @__PURE__ */ new Set()), e.on("message", (a) => this.messageListener(e, new Uint8Array(a)));
+      let o = !0;
+      const n = setInterval(() => {
+        if (!o)
+          this.conns.has(e) && this.closeConn(e), clearInterval(n);
+        else if (this.conns.has(e)) {
+          o = !1;
+          try {
+            e.ping();
+          } catch {
+            this.closeConn(e), clearInterval(n);
+          }
+        }
+      }, ds);
+      e.on("close", () => {
+        this.closeConn(e), clearInterval(n);
+      }), e.on("pong", () => {
+        o = !0;
+      });
+      {
+        const a = C.createEncoder();
+        C.writeVarUint(a, Y), Bt(a, this), this.send(e, C.toUint8Array(a));
+        const l = this.awareness.getStates();
+        if (l.size > 0) {
+          const r = C.createEncoder();
+          C.writeVarUint(r, ue), C.writeVarUint8Array(r, xe(this.awareness, Array.from(l.keys()))), this.send(e, C.toUint8Array(r));
+        }
+      }
+    }, this.messageListener = (e, o) => {
+      try {
+        const n = C.createEncoder(), a = pe.createDecoder(o), l = pe.readVarUint(a);
+        switch (l) {
+          case Y:
+            C.writeVarUint(n, Y), Vt(a, n, this, null), C.length(n) > 1 && (this.ensureDataStructure(), this.send(e, C.toUint8Array(n)));
+            break;
+          case ue: {
+            Mt(this.awareness, pe.readVarUint8Array(a), e);
+            break;
+          }
+          default:
+            A.warn(`Unsupported messageType ${l}`);
+        }
+      } catch (n) {
+        A.error(n);
+      }
+      this.save();
+    }, B(this.draftYjsFilePath) && $.applyUpdate(this, J(this.draftYjsFilePath)), this.syncedStore = vt(
+      Tt(
+        { pages: {}, pageIds: [], components: {}, supportedLocales: [], config: {}, resources: {} },
+        this
+      )
+    ), this.initObserver(), this.on("update", this.updateHandler), this.awareness = new Ft(this), this.awareness.on("update", this.awarenessChangeHandler), this.ensureDataStructure();
+  }
+  // safe delete project state dir
+  static safeDeleteProjectStateDir(s) {
+    if (!s)
+      throw new Error("Should provide project context");
+    try {
+      const e = O(q, s), o = O(q, `@del-${s}`);
+      Ce(e, o);
+    } catch (e) {
+      A.error("Failed to safe delete project state dir:", e);
+    }
+  }
+  static get projectIds() {
+    return me("*/", {
+      cwd: q,
+      ignore: ["@del-*", "@tmp-*", ".*", "staging", "production", "@backup-*"]
+      // Ignore temp directories and hidden files
+    });
+  }
+  static get allShared() {
+    return this.projectIds.map((s) => _.shared(s));
+  }
+  static shared(s) {
+    if (!s)
+      throw new Error("Should provide project context");
+    let e = this.sharedInstances.get(s);
+    return e || (e = new _({
+      path: O(q, s)
+    }), this.sharedInstances.set(s, e), e);
+  }
+  destroy() {
+    this.conns.forEach((s, e) => this.closeConn(e)), this.awareness.destroy(), super.destroy();
+  }
+  initObserver() {
+    const s = (o) => {
+      o.observeDeep((n) => {
+        n.some((a) => a.changes.keys.has("updatedAt") || a.changes.keys.has("publishedAt")) || o.set("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
+      });
+    };
+    this.syncedStore.pages && Object.keys(this.syncedStore.pages).forEach((o) => {
+      const n = le(this.syncedStore.pages[o]);
+      n && n instanceof $.Map && s(n);
+    });
+    const e = le(this.syncedStore.pages);
+    e && e instanceof $.Map && e.observe((o) => {
+      o.changes.keys.forEach((n, a) => {
+        if (n.action === "add") {
+          const l = le(this.syncedStore.pages[a]);
+          l && l instanceof $.Map && s(l);
+        }
+      });
+    });
+  }
+  get draftYjsFilePath() {
+    return O(this.options.path, "draft.yjs");
+  }
+  async getState(s) {
+    var e, o, n, a;
+    if (s === "draft")
+      return JSON.parse(JSON.stringify(this.syncedStore));
+    if (!this.states[s] && (this.states[s] = await Qe(this.getPublishDir(s), { includeResources: !0 }) ?? gs(), !((o = (e = this.states[s]) == null ? void 0 : e.config) != null && o.defaultLocale))) {
+      (n = this.states[s]).config ?? (n.config = {});
+      const l = ge.env.languages.map((r) => ({ locale: r.code, name: r.name }));
+      this.states[s].config.defaultLocale = (a = l[0]) == null ? void 0 : a.locale;
+    }
+    return {
+      ...this.states[s],
+      resources: await tt().then(async (l) => {
+        var p, u, f, g;
+        const { pages: r, components: i } = Pt(l, "pages", "components");
+        let c = i;
+        if ((u = (p = this.states[s]) == null ? void 0 : p.resources) != null && u.components)
+          c = {
+            ...(g = (f = this.states[s]) == null ? void 0 : f.resources) == null ? void 0 : g.components
+          };
+        else {
+          const y = G(this.options.path), v = await F.findByPk(y);
+          if (v != null && v.useAllResources)
+            c = i;
+          else {
+            const k = (await ce.findAll({ where: { projectId: y } })).map((h) => h.componentId);
+            c = Object.fromEntries(
+              Object.entries(i || {}).filter(([h]) => k.includes(h))
+            );
+          }
+        }
+        return { pages: r, components: c };
+      }).catch(() => ({}))
+    };
+  }
+  async setState(s, e) {
+    const o = await Ss(e, { exportAssets: !1, includeResources: !0 }), n = this.getPublishDir(s);
+    M(L(n), { recursive: !0 }), Ve(n, { force: !0, recursive: !0 }), Ce(o, n), this.states[s] = e;
+  }
+  getPublishDir(s) {
+    return O(this.options.path, s);
+  }
+  static async pageUrlMap(s) {
+    const { projectIds: e } = this, o = {};
+    for (const n of e) {
+      const a = await F.findByPk(n);
+      if (!a) continue;
+      const l = await _.shared(n).getState(s), r = xt(
+        w.env.languages.map((i) => i.code),
+        l.supportedLocales.map((i) => i.locale)
+      );
+      for (const i of l.pageIds) {
+        const c = l.pages[i];
+        if (!c || s === "production" && !c.isPublic)
+          continue;
+        const p = c.slug, u = a.slug || n, f = {
+          projectId: n,
+          projectSlug: u,
+          pageSlug: p,
+          pageId: i,
+          // default locale
+          defaultLocale: r == null ? void 0 : r[0],
+          locales: r,
+          publishedAt: l.config.publishedAt,
+          isPublic: c.isPublic,
+          isTemplate: c.isTemplate
+        };
+        u && (o[U("/", u, p)] = {
+          ...f,
+          shouldRedirect: !0,
+          mainPage: !0
+        }), o[U("/", n, p)] = {
+          ...f,
+          shouldRedirect: !0,
+          mainPage: !0
+        };
+        for (const g of r) {
+          const y = { ...f, locale: g };
+          o[U("/", g, n, p)] = y, u && (o[U("/", g, u, p)] = y);
+        }
+      }
+    }
+    return o;
+  }
+};
+_.INSTANCE_TTL = 30 * 60 * 1e3, _.sharedInstances = new he({
+  max: 100,
+  // Maximum number of instances to store
+  ttl: _.INSTANCE_TTL,
+  dispose: (s) => {
+    s.destroy();
+  }
+});
+let oe = _;
+function Ye() {
+  return bt(O(w.env.dataDir, "tmp-"));
+}
+function ne(t, s, e = []) {
+  return Array.isArray(t) ? t.flatMap((o, n) => ne(o, s, [...e, n])) : typeof t == "object" ? t === null ? [] : Object.entries(t).flatMap(([o, n]) => ne(n, s, [...e, o])) : s(t) ? [e] : [];
+}
+function R(t) {
+  return t.filter((s) => s != null);
+}
+async function hs(t, s, e) {
+  if (!t || !B(t) || !X(t).isFile())
+    return null;
+  let o = e[t];
+  return o || (o = (async () => (await ps({
+    filePath: t,
+    fileName: s
+  })).data.filename)(), e[t] = o), o;
+}
+const ys = async (t, s) => {
+  const e = G(t), o = await Be({
+    name: We,
+    path: U("/uploads", e),
+    responseType: "stream",
+    method: "GET"
+  });
+  if (o.status >= 200 && o.status < 400) {
+    const n = It(s);
+    await Lt(o.data, n);
+  } else
+    throw new Error(`download asset failed ${o.status}`);
+}, ws = async (t, s) => {
+  await Promise.all(
+    t.map(async (e) => {
+      try {
+        await ys(e, O(s, G(e)));
+      } catch (o) {
+        A.error(`Failed to export assets: ${e}, ${o}`);
+      }
+    })
+  );
+};
+function qe(t) {
+  return we.test(t) ? [t] : W.test(t) ? (Re.lastIndex = 0, Array.from(t.matchAll(Re)).map((e) => e[1]).filter((e) => !!e)) : [];
+}
+async function de(t, s, e) {
+  const { getFilename: o, exportAssets: n } = e, a = O(s, o(t));
+  if (M(L(a), { recursive: !0 }), te(a, H.stringify(t)), n) {
+    const r = ne(
+      t,
+      (i) => typeof i == "string" && (we.test(i) || W.test(i))
+    ).map((i) => {
+      const c = ye(t, i);
+      return qe(c);
+    }).flat().filter(Boolean);
+    await ws(r, L(a));
+  }
+}
+const Ue = new he({
+  max: 1e3,
+  ttl: 30 * 24 * 60 * 60 * 1e3
+});
+async function _e(t, s, e) {
+  var r;
+  const o = ne(
+    t,
+    (i) => typeof i == "string" && (we.test(i) || W.test(i))
+  ), n = Nt(2), a = o.map(
+    (i) => n(async () => {
+      try {
+        const c = ye(t, i), p = qe(c);
+        for (const u of p) {
+          const f = G(u), g = e.getFilePath(u, i), y = g ? `${g}:${f}` : f, v = Ue.get(y);
+          if (v) {
+            W.test(c) || Pe(t, i, v);
+            return;
+          }
+          const P = await hs(g, f, s);
+          P && (W.test(c) || Pe(t, i, P), Ue.set(y, P));
+        }
+      } catch (c) {
+        A.error(`Failed to process upload for path ${i.join(".")}:`, c.message || c.reason);
+      }
+    })
+  ), l = await Promise.allSettled(a);
+  (r = e.onFinish) == null || r.call(e, l);
+}
+async function Ss(t, {
+  exportAssets: s,
+  pageIds: e = "all",
+  componentIds: o = "all",
+  rawConfig: n,
+  includeResources: a = !1
+} = {}) {
+  var k, N, h, b, E, I;
+  const l = e === "all" ? t.pageIds : e, r = Es({
+    state: t,
+    pageIds: l,
+    componentIds: o === "all" ? Object.keys(t.components) : o
+  }), i = (m, d) => {
+    var S;
+    return {
+      id: m.id,
+      name: m.name,
+      isTemplateSection: m.isTemplateSection ?? !1,
+      component: m.component,
+      config: m.config,
+      visibility: m.visibility,
+      properties: ((S = m.locales) == null ? void 0 : S[d]) ?? {}
+    };
+  }, c = (m, d) => {
+    var S;
+    return {
+      id: m.id,
+      createdAt: m.createdAt,
+      updatedAt: m.updatedAt,
+      publishedAt: m.publishedAt,
+      isPublic: m.isPublic ?? !0,
+      isTemplate: m.isTemplate ?? !1,
+      meta: ((S = m.locales) == null ? void 0 : S[d]) ?? {},
+      sections: R(
+        m.sectionIds.map((j) => {
+          const D = m.sections[j];
+          return D && i(D, d);
+        })
+      )
+    };
+  }, p = R(
+    t.supportedLocales.map((m) => m.locale).flatMap(
+      (m) => l.map((d) => {
+        const S = t.pages[d];
+        return S && {
+          locale: m,
+          slug: S.slug,
+          page: c(S, m)
+        };
+      })
+    )
+  ), u = Ye(), f = O(u, "pages");
+  M(f, { recursive: !0 });
+  const g = O(u, "components");
+  M(g, { recursive: !0 });
+  for (const { locale: m, slug: d, page: S } of p)
+    await de(S, f, {
+      getFilename: () => `${ze(d) || "index"}.${m}.yml`,
+      exportAssets: s
+    });
+  for (const m of r) {
+    const d = (k = t.components[m]) == null ? void 0 : k.data;
+    d && await de(d, g, {
+      getFilename: (S) => `${S.name || "unnamed"}.${S.id}.yml`,
+      exportAssets: s
+    });
+  }
+  const y = O(u, ".blocklet/pages/pages.config.yml");
+  M(L(y), { recursive: !0 });
+  const v = {
+    pages: R(
+      l.map((m) => {
+        const d = t.pages[m];
+        return d && { id: m, slug: d.slug };
+      })
+    ),
+    components: R(
+      r.map((m) => {
+        var S;
+        const d = (S = t.components[m]) == null ? void 0 : S.data;
+        return d && {
+          id: m,
+          name: d.name
+        };
+      })
+    ),
+    ...a ? {
+      resources: {
+        components: R(
+          Object.keys(((N = t.resources) == null ? void 0 : N.components) || {}).map((m) => {
+            var d, S, j, D;
+            return {
+              id: m,
+              name: (D = (j = (S = (d = t.resources) == null ? void 0 : d.components) == null ? void 0 : S[m]) == null ? void 0 : j.component) == null ? void 0 : D.name
+            };
+          })
+        )
+      }
+    } : {},
+    supportedLocales: t.supportedLocales,
+    config: t.config
+  };
+  te(y, H.stringify(v));
+  const P = O(u, "config.source.json");
+  if (n && te(P, JSON.stringify(n)), a) {
+    const m = O(u, "resources"), d = O(m, "components");
+    M(d, { recursive: !0 });
+    for (const S of Object.keys(((h = t == null ? void 0 : t.resources) == null ? void 0 : h.components) ?? {})) {
+      const j = (I = (E = (b = t.resources) == null ? void 0 : b.components) == null ? void 0 : E[S]) == null ? void 0 : I.component;
+      j && await de(j, d, {
+        getFilename: (D) => `${D.name || "unnamed"}.${D.id}.yml`,
+        exportAssets: s
+      });
+    }
+  }
+  return u;
+}
+async function Qe(t, { importAssets: s, includeResources: e } = {}) {
+  var a, l, r;
+  if (!B(t))
+    return null;
+  let o, n = !1;
+  try {
+    X(t).isDirectory() ? o = t : /\.(tgz|gz|tar)$/.test(t) && (n = !0, o = Ye(), await Rt({ file: t, C: o }));
+    const i = me("**/.blocklet/pages/pages.config.yml", { cwd: o, absolute: !0 }).at(0), c = i && O(L(i), "../../pages"), p = i && O(L(i), "../../components"), u = i && O(L(i), "../../chunks");
+    if (!i)
+      return null;
+    const f = H.parse(J(i).toString()), g = (h, b, E) => {
+      let I = O(h, `${b}${E ? `.${E}` : ""}.yml`);
+      return (!B(I) || !X(I).isFile()) && (I = O(h, b, `index${E ? `.${E}` : ""}.yml`), !B(I) || !X(I)) ? null : H.parse(J(I).toString());
+    }, y = (h, b) => {
+      try {
+        const E = me(`*.${b}.yml`, { cwd: h, absolute: !0 })[0];
+        return E ? H.parse(J(E).toString()) : null;
+      } catch (E) {
+        A.error("parse component error", E);
+      }
+      return null;
+    }, v = R(
+      f.pages.map(({ slug: h }) => {
+        var m;
+        const b = R(
+          f.supportedLocales.map(({ locale: d }) => {
+            const S = c ? g(c, ze(h), d) : void 0;
+            if (S)
+              return { locale: d, page: S };
+            const j = c ? g(c, h, d) : void 0;
+            return j && { locale: d, page: j };
+          })
+        ), E = (m = b[0]) == null ? void 0 : m.page;
+        if (!E)
+          return null;
+        const I = E.sections.map((d) => {
+          const S = d.id || Le();
+          return {
+            id: S,
+            component: d.component,
+            config: d.config,
+            name: d.name,
+            isTemplateSection: d.isTemplateSection ?? !1,
+            visibility: d.visibility,
+            locales: Object.fromEntries(
+              R(
+                b.map(({ locale: j, page: D }) => {
+                  const Ie = D.sections.find((st) => st.id === S);
+                  return Ie && [j, Ie.properties];
+                })
+              )
+            )
+          };
+        });
+        return {
+          id: E.id || Le(),
+          createdAt: E.createdAt,
+          updatedAt: E.updatedAt,
+          publishedAt: E.publishedAt,
+          isPublic: E.isPublic ?? !0,
+          isTemplate: E.isTemplate ?? !1,
+          slug: h,
+          sections: Object.fromEntries(I.map((d) => [d.id, d])),
+          sectionIds: I.map((d) => d.id),
+          locales: Object.fromEntries(b.map(({ locale: d, page: S }) => [d, S.meta]))
+        };
+      })
+    ), P = p ? R(((a = f.components) == null ? void 0 : a.map(({ id: h }) => y(p, h))) ?? []) : [];
+    if (s) {
+      const h = (...b) => {
+        A.info(`[${n ? G(t) : G(O(t, "../../../../"))}] importAssets:`, ...b);
+      };
+      try {
+        h("wait image-bin api ready"), await Ut({
+          resources: [`${yt(Kt)}/api/sdk/uploads`],
+          validateStatus: (I) => I >= 200 && I <= 500
+        }), h("image-bin api is ready");
+        const b = {}, E = {};
+        h("start to upload assets"), await Promise.allSettled([
+          _e(P, b, {
+            getFilePath: (I) => p && O(p, I),
+            onFinish: (I) => {
+              h(`upload ${I.length} component assets`);
+            }
+          }),
+          _e(v, E, {
+            getFilePath: (I, m) => {
+              const d = ye(v, m.slice(0, 1));
+              return c && O(c, L(d.slug), I);
+            },
+            onFinish: (I) => {
+              h(`upload ${I.length} page assets`);
+            }
+          })
+        ]), h("upload assets done"), Oe.gc && Oe.gc();
+      } catch (b) {
+        h("Error during asset import:", b);
+      }
+    }
+    const k = {};
+    if (e) {
+      const h = i && O(L(i), "../../resources/components"), b = R(
+        ((r = (l = f.resources) == null ? void 0 : l.components) == null ? void 0 : r.map(({ id: E }) => y(h, E))) ?? []
+      );
+      b.length > 0 && (k.components = Object.fromEntries(
+        b.map((E, I) => [E.id, { index: I, component: E }])
+      ));
+    }
+    const N = {};
+    if (u && B(u)) {
+      const h = Et(u);
+      for (const b of h)
+        N[b] = O(u, b);
+    }
+    return {
+      supportedLocales: f.supportedLocales,
+      pageIds: v.map((h) => h.id),
+      components: Object.fromEntries(P.map((h, b) => [h.id, { index: b, data: h }])),
+      pages: Object.fromEntries(v.map((h) => [h.id, h])),
+      config: f.config || {},
+      resources: k,
+      chunks: N
+    };
+  } finally {
+    n && o && Ve(o, { force: !0, recursive: !0 });
+  }
+}
+async function Me(t, s, {
+  pages: e,
+  pageMergeMode: o = "byUpdateTime",
+  deletePages: n = !1,
+  publishMode: a = void 0
+} = {}) {
+  try {
+    a && ts(a);
+  } catch (p) {
+    A.error("clear preload page cache error", { error: p });
+  }
+  const { pageIds: l, pages: r, supportedLocales: i } = t;
+  for (const p of e ?? l) {
+    const u = r[p];
+    if (!u) {
+      const f = s.pageIds.indexOf(p);
+      f !== -1 && n && (s.pageIds.splice(f, 1), delete s.pages[p]);
+      continue;
+    }
+    if (s.pageIds.includes(u.id)) {
+      if (o === "replace")
+        s.pages[u.id] = u;
+      else if (o === "byUpdateTime") {
+        const f = s.pages[u.id];
+        (!f || u.updatedAt && u.updatedAt > f.updatedAt) && (s.pages[u.id] = u);
+      }
+    } else
+      s.pageIds.push(u.id), s.pages[u.id] = u;
+  }
+  if (n && !e)
+    for (const p of s.pageIds)
+      t.pageIds.includes(p) || delete s.pages[p], s.pageIds = [...s.pageIds].filter((u) => t.pageIds.includes(u));
+  if (s.supportedLocales.splice(0, s.supportedLocales.length), s.supportedLocales.push(...jt(i)), n)
+    for (const p of Object.keys(s.components))
+      delete s.components[p];
+  let c = JSON.parse(JSON.stringify(t.components));
+  c = Object.fromEntries(
+    await Promise.all(
+      Object.entries(c).map(async ([p, u]) => {
+        const f = await Xe(u == null ? void 0 : u.data);
+        return [
+          p,
+          {
+            ...u,
+            data: f
+          }
+        ];
+      })
+    )
+  ), Object.assign(s.components, c), Object.assign(s.config, JSON.parse(JSON.stringify(t.config))), s.resources.components = JSON.parse(JSON.stringify(t.resources.components || {}));
+}
+const Xe = ae(
+  async (t) => {
+    var s;
+    if (!Ct(t == null ? void 0 : t.properties))
+      return t;
+    if (((s = t == null ? void 0 : t.renderer) == null ? void 0 : s.type) === "react-component") {
+      const { script: e } = (t == null ? void 0 : t.renderer) || {};
+      if (e)
+        try {
+          const o = await is(e, "PROPERTIES_SCHEMA", t.id);
+          o && o.length > 0 && t && (t.properties = {}, o.forEach((n, a) => {
+            t != null && t.properties && (t.properties[n.id] = {
+              index: a,
+              data: n
+            });
+          }));
+        } catch (o) {
+          A.error("checkPropertiesFromCode error", { componentId: t.id, name: t.name }, { error: o });
+        }
+    }
+    return t;
+  },
+  {
+    keyGenerator: (t) => {
+      var l;
+      const s = (t == null ? void 0 : t.id) || "", e = (t == null ? void 0 : t.name) || "", o = ((l = t == null ? void 0 : t.renderer) == null ? void 0 : l.type) || "", n = (t == null ? void 0 : t.properties) || {}, a = ie("md5").update(JSON.stringify(n)).digest("hex");
+      return JSON.stringify(["checkPropertiesFromCode", s, e, o, a]);
+    },
+    lruOptions: {
+      max: 100,
+      ttl: 1e3 * 60 * 60
+    }
+  }
+);
+function Es({
+  state: t,
+  pageIds: s = [],
+  componentIds: e = []
+}) {
+  var l;
+  const o = (r, i = /* @__PURE__ */ new Set()) => (Array.isArray(r) && r.forEach((c) => o(c, i)), r && typeof r == "object" && (typeof r.componentId == "string" && i.add(r.componentId), Object.values(r).forEach((c) => o(c, i))), i), n = new Set(e);
+  for (const r of s) {
+    const i = t.pages[r];
+    o(i, n);
+  }
+  const a = [...n];
+  for (; a.length; ) {
+    const r = a.shift();
+    n.has(r) || n.add(r);
+    const i = (l = t.components[r]) == null ? void 0 : l.data;
+    if (i)
+      for (const c of o(i))
+        n.has(c) || a.push(c);
+  }
+  return [...n];
+}
+let re, V, Se, Ee, be;
+function Ze() {
+  return re = (async () => {
+    const t = ht({
+      types: [
+        { did: We, type: De },
+        { did: ls, type: De }
+      ]
+    });
+    V = (await Promise.all(
+      t.map(async (e) => {
+        const o = e.path ? await Qe(e.path, { importAssets: !1 }) : void 0;
+        return o ? { blockletId: e.did, state: o, blockletTitle: e.title } : void 0;
+      })
+    )).filter((e) => !!e), Se = V.reduce(
+      (e, o) => Object.assign(
+        e,
+        Object.fromEntries(
+          Object.values(o.state.pages).map((n) => n ? [n == null ? void 0 : n.id, { page: n, blockletId: o.blockletId }] : [])
+        )
+      ),
+      {}
+    );
+    const s = V.reduce(
+      (e, o) => Object.assign(
+        e,
+        Object.fromEntries(
+          Object.values(o.state.components).map((n) => [n.data.id, { blockletId: o.blockletId, component: n.data }])
+        )
+      ),
+      {}
+    );
+    Ee = Object.fromEntries(
+      await Promise.all(
+        Object.entries(s).map(async ([e, o]) => {
+          const n = await Xe(o.component);
+          return [
+            e,
+            {
+              ...o,
+              component: n
+            }
+          ];
+        })
+      )
+    ), be = V.reduce((e, o) => Object.assign(e, o.state.chunks), {});
+  })(), re;
+}
+function bs(t) {
+  const s = Ge(
+    async () => {
+      await Ze().catch((e) => {
+        A.error("load resource states error", { error: e });
+      }), await (t == null ? void 0 : t({
+        states: V,
+        pages: Se,
+        components: Ee,
+        chunks: be
+      }));
+    },
+    3e3,
+    { leading: !1, trailing: !0 }
+  );
+  return s(), w.events.on(w.Events.componentAdded, s), w.events.on(w.Events.componentRemoved, s), w.events.on(w.Events.componentStarted, s), w.events.on(w.Events.componentStopped, s), w.events.on(w.Events.componentUpdated, s), w.events.on(fe, s), () => {
+    w.events.off(w.Events.componentAdded, s), w.events.off(w.Events.componentRemoved, s), w.events.off(w.Events.componentStarted, s), w.events.off(w.Events.componentStopped, s), w.events.off(w.Events.componentUpdated, s), w.events.off(fe, s);
+  };
+}
+const et = Symbol.for("GLOBAL_RESOURCE_STATES_LISTENER_KEY"), Z = globalThis;
+var Fe;
+(Fe = Z[et]) == null || Fe.call(Z);
+Z[et] = bs(async ({ pages: t, components: s }) => {
+  const { projectIds: e } = oe;
+  await Promise.all(
+    e.map(async (o) => {
+      const n = oe.shared(o);
+      n.syncedStore.resources.pages = t;
+      const a = await F.findByPk(o);
+      if (a != null && a.useAllResources)
+        n.syncedStore.resources.components = s;
+      else {
+        const r = (await ce.findAll({ where: { projectId: o } })).map((c) => c.componentId), i = Object.fromEntries(
+          Object.entries(s || {}).filter(([c]) => r.includes(c))
+        );
+        n.syncedStore.resources.components = i;
+      }
+      A.info(`update [${o}] resource states:`, {
+        pages: Object.keys(n.syncedStore.resources.pages || {}).length,
+        components: Object.keys(n.syncedStore.resources.components || {}).length
+      });
+    })
+  );
+});
+async function po() {
+  A.info("trigger reload all project resource"), w.events.emit(fe);
+}
+async function tt({
+  ensureLoaded: t = !0
+} = {}) {
+  return t && (re ?? (re = Ze()), await re), { states: V, pages: Se, components: Ee, chunks: be };
+}
+export {
+  We as C,
+  Ne as G,
+  F as P,
+  De as R,
+  oe as S,
+  tt as a,
+  ao as b,
+  Zt as c,
+  es as d,
+  ts as e,
+  ss as f,
+  ro as g,
+  os as h,
+  no as i,
+  se as j,
+  io as k,
+  A as l,
+  is as m,
+  Le as n,
+  q as o,
+  co as p,
+  lo as q,
+  Qe as r,
+  Me as s,
+  Ss as t,
+  bs as u,
+  po as v
+};