@blocklet/pages-kit-inner-components 0.1.3 → 0.1.5

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

@@ -0,0 +1,966 @@
+import { l as D, c as Me, g as $e } from "./components-k4kCJg_V.js";
+import { memoize as Be } from "@blocklet/quickjs";
+import { getComponentWebEndpoint as xe, getResources as Ve, call as Ge } from "@blocklet/sdk/lib/component";
+import h from "@blocklet/sdk/lib/config";
+import { reactive as Je } from "@reactivedata/reactive";
+import { syncedStore as qe, getYjsValue as se } from "@syncedstore/core";
+import { mkdirSync as R, writeFileSync as X, existsSync as $, readFileSync as x, renameSync as me, rmSync as Te, lstatSync as Y, readdirSync as ze, mkdtempSync as Ke, createWriteStream as He } from "fs";
+import { globSync as ae } from "glob";
+import * as ne from "lib0/decoding";
+import * as v from "lib0/encoding";
+import { debounce as Oe, pick as Ye, union as We, get as le, cloneDeep as Xe, isEmpty as Qe, set as ge } from "lodash";
+import { LRUCache as Pe } from "lru-cache";
+import { customAlphabet as Ze } from "nanoid";
+import et from "p-limit";
+import tt, { join as A, dirname as k, basename as B } from "path";
+import { pipeline as st } from "stream/promises";
+import { x as nt } from "tar";
+import { joinURL as V } from "ufo";
+import rt from "wait-on";
+import { encodeAwarenessUpdate as he, removeAwarenessStates as ot, applyAwarenessUpdate as at, Awareness as it } from "y-protocols/awareness";
+import { writeUpdate as ct, writeSyncStep1 as lt, readSyncMessage as pt } from "y-protocols/sync";
+import * as G from "yaml";
+import * as M from "yjs";
+import dt from "lodash/isNil";
+import { DataTypes as b, Sequelize as ut, Model as De, Op as ft } from "sequelize";
+import "sqlite3";
+h.env.mode;
+const mt = "image-bin";
+h.env.INIT_TEMPLATE_PATH;
+const gt = process.env.DATABASE_URL || tt.join(h.env.dataDir, "db/pages-kit.db"), ye = h, es = () => h.env.tenantMode === "multiple", ts = () => {
+  var t;
+  return (dt(ye.env.preferences.multiTenantAllProjectAccessPassports) ? [] : (t = ye.env.preferences.multiTenantAllProjectAccessPassports) == null ? void 0 : t.split(",")) || [];
+}, ht = b.sqlite.DATE.parse;
+b.sqlite.DATE.parse = (t, s) => typeof t == "number" ? new Date(t) : ht(t, s);
+const z = new ut({
+  dialect: "sqlite",
+  storage: gt,
+  benchmark: process.env.ENABLE_SEQUELIZE_BENCHMARK === "true",
+  retry: {
+    match: [/SQLITE_BUSY/],
+    name: "query",
+    max: 10
+  },
+  // eslint-disable-next-line no-console
+  logging: process.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 te extends De {
+  // Foreign key to Component
+}
+te.init(
+  {
+    id: {
+      type: b.UUID,
+      allowNull: !1,
+      primaryKey: !0,
+      defaultValue: b.UUIDV4
+    },
+    projectId: {
+      type: b.UUID,
+      allowNull: !1
+    },
+    componentId: {
+      type: b.STRING,
+      allowNull: !1
+    }
+  },
+  { sequelize: z, tableName: "ProjectComponents", timestamps: !1 }
+);
+class F extends De {
+  static async getProjectByIdOrSlug(s) {
+    return F.findOne({
+      where: {
+        [ft.or]: [{ id: s }, { slug: s }]
+      }
+    });
+  }
+}
+F.init(
+  {
+    id: {
+      type: b.UUID,
+      defaultValue: b.UUIDV4,
+      primaryKey: !0
+    },
+    name: {
+      type: b.STRING,
+      allowNull: !1
+    },
+    description: b.TEXT,
+    createdAt: b.DATE,
+    updatedAt: b.DATE,
+    createdBy: {
+      type: b.STRING,
+      allowNull: !1
+    },
+    updatedBy: {
+      type: b.STRING,
+      allowNull: !1
+    },
+    slug: b.STRING,
+    icon: b.STRING,
+    pinnedAt: b.DATE,
+    useAllResources: b.BOOLEAN,
+    relatedBlocklets: {
+      type: b.JSON,
+      allowNull: !1,
+      defaultValue: {},
+      get() {
+        return this.getDataValue("relatedBlocklets") || {};
+      },
+      set(t) {
+        this.setDataValue("relatedBlocklets", JSON.stringify(t || {}));
+      }
+    }
+  },
+  { sequelize: z, paranoid: !0 }
+);
+F.hasMany(te, {
+  foreignKey: "projectId",
+  as: "components"
+});
+const yt = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o", Se = "page", ie = "trigger-reload-project-resource", je = yt, St = "z2qa7rr3eUyVnWp2PCxEVARuUfLFh6cE5V2xV", { uploadToMediaKit: wt } = require("@blocklet/uploader-server"), we = Ze("abcdefghijklmnopqrstuvwxyz0123456789", 16), pe = /^\w+(\w|-|\.)+\w+\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm)$/, J = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/i, Ee = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/gi, Et = 1e4, At = 3e4, K = 0, re = 1, bt = 0, vt = 1, ce = h, H = A(process.env.BLOCKLET_DATA_DIR, "site-state"), ss = ["production", "draft"], ns = ["production"];
+function ke(t) {
+  return (t == null ? void 0 : t.replace(/\//g, "|")) || "";
+}
+function It() {
+  var e;
+  const t = ce.env.languages.map((n) => ({ locale: n.code, name: n.name })), s = (e = t[0]) == null ? void 0 : e.locale;
+  return {
+    pageIds: [],
+    pages: {},
+    components: {},
+    supportedLocales: t,
+    config: { defaultLocale: s },
+    resources: {}
+  };
+}
+const U = class U extends M.Doc {
+  constructor(s) {
+    super(), this.options = s, this.states = {}, this.conns = /* @__PURE__ */ new Map(), this.awarenessChangeHandler = ({ added: e, updated: n, removed: r }, a) => {
+      const l = e.concat(n, r);
+      if (a !== null) {
+        const c = this.conns.get(a);
+        c && (e.forEach((f) => {
+          c.add(f);
+        }), r.forEach((f) => {
+          c.delete(f);
+        }));
+      }
+      const i = v.createEncoder();
+      v.writeVarUint(i, re), v.writeVarUint8Array(i, he(this.awareness, l));
+      const o = v.toUint8Array(i);
+      this.conns.forEach((c, f) => this.send(f, o));
+    }, this.updateHandler = (e) => {
+      const n = v.createEncoder();
+      v.writeVarUint(n, K), ct(n, e);
+      const r = v.toUint8Array(n);
+      this.conns.forEach((a, l) => this.send(l, r));
+    }, this.ensureDataStructure = () => {
+      var l;
+      const { supportedLocales: e, pages: n, pageIds: r, config: a } = this.syncedStore;
+      {
+        const i = new Set(Object.keys(n));
+        let o = 0;
+        for (; o < r.length; ) {
+          const c = r[o];
+          i.has(c) ? (i.delete(c), o++) : r.splice(o, 1);
+        }
+      }
+      e.splice(0, e.length), e.push(...ce.env.languages.map((i) => ({ locale: i.code, name: i.name }))), a.defaultLocale = (l = e[0]) == null ? void 0 : l.locale;
+      {
+        let i = 0;
+        const o = /* @__PURE__ */ new Set();
+        for (; i < e.length; ) {
+          const { locale: c } = e[i];
+          o.has(c) ? e.splice(i, 1) : (i++, o.add(c));
+        }
+      }
+    }, this.send = (e, n) => {
+      e.readyState !== bt && e.readyState !== vt && this.closeConn(e);
+      try {
+        e.send(n, (r) => {
+          r && this.closeConn(e);
+        });
+      } catch {
+        this.closeConn(e);
+      }
+    }, this.closeConn = (e) => {
+      if (e.removeAllListeners(), this.conns.has(e)) {
+        const n = this.conns.get(e);
+        this.conns.delete(e), n && ot(this.awareness, Array.from(n), null);
+      }
+      e.close();
+    }, this.autoSave = Oe(() => {
+      R(k(this.draftYjsFilePath), { recursive: !0 }), X(this.draftYjsFilePath, M.encodeStateAsUpdate(this));
+    }, Et), this.save = ({ flush: e = !1 } = {}) => {
+      this.autoSave(), e && this.autoSave.flush();
+    }, this.publish = async ({ mode: e, pages: n }) => {
+      const r = await this.getState("draft"), a = await this.getState("production");
+      await ve(r, a, { pages: n, pageMergeMode: "replace", deletePages: !0, publishMode: e }), a.config.publishedAt = (/* @__PURE__ */ new Date()).getTime();
+      for (const l of n || 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, n) => {
+      var i, o, c;
+      const r = JSON.parse(JSON.stringify(n));
+      (i = e.config).fontFamily ?? (i.fontFamily = {});
+      const a = (o = r.config) == null ? void 0 : o.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((f, p) => {
+        this.transact(async () => {
+          try {
+            const g = await ve(e, n);
+            f(g);
+          } catch (g) {
+            p(g);
+          }
+        });
+      });
+    }, 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 n = !0;
+      const r = setInterval(() => {
+        if (!n)
+          this.conns.has(e) && this.closeConn(e), clearInterval(r);
+        else if (this.conns.has(e)) {
+          n = !1;
+          try {
+            e.ping();
+          } catch {
+            this.closeConn(e), clearInterval(r);
+          }
+        }
+      }, At);
+      e.on("close", () => {
+        this.closeConn(e), clearInterval(r);
+      }), e.on("pong", () => {
+        n = !0;
+      });
+      {
+        const a = v.createEncoder();
+        v.writeVarUint(a, K), lt(a, this), this.send(e, v.toUint8Array(a));
+        const l = this.awareness.getStates();
+        if (l.size > 0) {
+          const i = v.createEncoder();
+          v.writeVarUint(i, re), v.writeVarUint8Array(i, he(this.awareness, Array.from(l.keys()))), this.send(e, v.toUint8Array(i));
+        }
+      }
+    }, this.messageListener = (e, n) => {
+      try {
+        const r = v.createEncoder(), a = ne.createDecoder(n), l = ne.readVarUint(a);
+        switch (l) {
+          case K:
+            v.writeVarUint(r, K), pt(a, r, this, null), v.length(r) > 1 && (this.ensureDataStructure(), this.send(e, v.toUint8Array(r)));
+            break;
+          case re: {
+            at(this.awareness, ne.readVarUint8Array(a), e);
+            break;
+          }
+          default:
+            D.warn(`Unsupported messageType ${l}`);
+        }
+      } catch (r) {
+        D.error(r);
+      }
+      this.save();
+    }, $(this.draftYjsFilePath) && M.applyUpdate(this, x(this.draftYjsFilePath)), this.syncedStore = Je(
+      qe(
+        { pages: {}, pageIds: [], components: {}, supportedLocales: [], config: {}, resources: {} },
+        this
+      )
+    ), this.initObserver(), this.on("update", this.updateHandler), this.awareness = new it(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 = A(H, s), n = A(H, `@del-${s}`);
+      me(e, n);
+    } catch (e) {
+      D.error("Failed to safe delete project state dir:", e);
+    }
+  }
+  static get projectIds() {
+    return ae("*/", {
+      cwd: H,
+      ignore: ["@del-*", "@tmp-*", ".*", "staging", "production", "@backup-*"]
+      // Ignore temp directories and hidden files
+    });
+  }
+  static get allShared() {
+    return this.projectIds.map((s) => U.shared(s));
+  }
+  static shared(s) {
+    if (!s)
+      throw new Error("Should provide project context");
+    let e = this.sharedInstances.get(s);
+    return e || (e = new U({
+      path: A(H, s)
+    }), this.sharedInstances.set(s, e), e);
+  }
+  destroy() {
+    this.conns.forEach((s, e) => this.closeConn(e)), this.awareness.destroy(), super.destroy();
+  }
+  initObserver() {
+    const s = (n) => {
+      n.observeDeep((r) => {
+        r.some((a) => a.changes.keys.has("updatedAt") || a.changes.keys.has("publishedAt")) || n.set("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
+      });
+    };
+    this.syncedStore.pages && Object.keys(this.syncedStore.pages).forEach((n) => {
+      const r = se(this.syncedStore.pages[n]);
+      r && r instanceof M.Map && s(r);
+    });
+    const e = se(this.syncedStore.pages);
+    e && e instanceof M.Map && e.observe((n) => {
+      n.changes.keys.forEach((r, a) => {
+        if (r.action === "add") {
+          const l = se(this.syncedStore.pages[a]);
+          l && l instanceof M.Map && s(l);
+        }
+      });
+    });
+  }
+  get draftYjsFilePath() {
+    return A(this.options.path, "draft.yjs");
+  }
+  async getState(s) {
+    var e, n, r, a;
+    if (s === "draft")
+      return JSON.parse(JSON.stringify(this.syncedStore));
+    if (!this.states[s] && (this.states[s] = await Ue(this.getPublishDir(s), { includeResources: !0 }) ?? It(), !((n = (e = this.states[s]) == null ? void 0 : e.config) != null && n.defaultLocale))) {
+      (r = this.states[s]).config ?? (r.config = {});
+      const l = ce.env.languages.map((i) => ({ locale: i.code, name: i.name }));
+      this.states[s].config.defaultLocale = (a = l[0]) == null ? void 0 : a.locale;
+    }
+    return {
+      ...this.states[s],
+      resources: await Ct().then(async (l) => {
+        var f, p, g, I;
+        const { pages: i, components: o } = Ye(l, "pages", "components");
+        let c = o;
+        if ((p = (f = this.states[s]) == null ? void 0 : f.resources) != null && p.components)
+          c = {
+            ...(I = (g = this.states[s]) == null ? void 0 : g.resources) == null ? void 0 : I.components
+          };
+        else {
+          const T = B(this.options.path), O = await F.findByPk(T);
+          if (O != null && O.useAllResources)
+            c = o;
+          else {
+            const N = (await te.findAll({ where: { projectId: T } })).map((m) => m.componentId);
+            c = Object.fromEntries(
+              Object.entries(o || {}).filter(([m]) => N.includes(m))
+            );
+          }
+        }
+        return { pages: i, components: c };
+      }).catch(() => ({}))
+    };
+  }
+  async setState(s, e) {
+    const n = await Dt(e, { exportAssets: !1, includeResources: !0 }), r = this.getPublishDir(s);
+    R(k(r), { recursive: !0 }), Te(r, { force: !0, recursive: !0 }), me(n, r), this.states[s] = e;
+  }
+  getPublishDir(s) {
+    return A(this.options.path, s);
+  }
+  static async pageUrlMap(s) {
+    const { projectIds: e } = this, n = {};
+    for (const r of e) {
+      const a = await F.findByPk(r);
+      if (!a) continue;
+      const l = await U.shared(r).getState(s), i = We(
+        h.env.languages.map((o) => o.code),
+        l.supportedLocales.map((o) => o.locale)
+      );
+      for (const o of l.pageIds) {
+        const c = l.pages[o];
+        if (!c || s === "production" && !c.isPublic)
+          continue;
+        const f = c.slug, p = a.slug || r, g = {
+          projectId: r,
+          projectSlug: p,
+          pageSlug: f,
+          pageId: o,
+          // default locale
+          defaultLocale: i == null ? void 0 : i[0],
+          locales: i,
+          publishedAt: l.config.publishedAt,
+          isPublic: c.isPublic,
+          isTemplate: c.isTemplate
+        };
+        p && (n[V("/", p, f)] = {
+          ...g,
+          shouldRedirect: !0,
+          mainPage: !0
+        }), n[V("/", r, f)] = {
+          ...g,
+          shouldRedirect: !0,
+          mainPage: !0
+        };
+        for (const I of i) {
+          const T = { ...g, locale: I };
+          n[V("/", I, r, f)] = T, p && (n[V("/", I, p, f)] = T);
+        }
+      }
+    }
+    return n;
+  }
+};
+U.INSTANCE_TTL = 30 * 60 * 1e3, U.sharedInstances = new Pe({
+  max: 100,
+  // Maximum number of instances to store
+  ttl: U.INSTANCE_TTL,
+  dispose: (s) => {
+    s.destroy();
+  }
+});
+let Q = U;
+function Ce() {
+  return Ke(A(h.env.dataDir, "tmp-"));
+}
+function Z(t, s, e = []) {
+  return Array.isArray(t) ? t.flatMap((n, r) => Z(n, s, [...e, r])) : typeof t == "object" ? t === null ? [] : Object.entries(t).flatMap(([n, r]) => Z(r, s, [...e, n])) : s(t) ? [e] : [];
+}
+function C(t) {
+  return t.filter((s) => s != null);
+}
+async function Tt(t, s, e) {
+  if (!t || !$(t) || !Y(t).isFile())
+    return null;
+  let n = e[t];
+  return n || (n = (async () => (await wt({
+    filePath: t,
+    fileName: s
+  })).data.filename)(), e[t] = n), n;
+}
+const Ot = async (t, s) => {
+  const e = B(t), n = await Ge({
+    name: je,
+    path: V("/uploads", e),
+    responseType: "stream",
+    method: "GET"
+  });
+  if (n.status >= 200 && n.status < 400) {
+    const r = He(s);
+    await st(n.data, r);
+  } else
+    throw new Error(`download asset failed ${n.status}`);
+}, Pt = async (t, s) => {
+  await Promise.all(
+    t.map(async (e) => {
+      try {
+        await Ot(e, A(s, B(e)));
+      } catch (n) {
+        D.error(`Failed to export assets: ${e}, ${n}`);
+      }
+    })
+  );
+};
+function Le(t) {
+  return pe.test(t) ? [t] : J.test(t) ? (Ee.lastIndex = 0, Array.from(t.matchAll(Ee)).map((e) => e[1]).filter((e) => !!e)) : [];
+}
+async function oe(t, s, e) {
+  const { getFilename: n, exportAssets: r } = e, a = A(s, n(t));
+  if (R(k(a), { recursive: !0 }), X(a, G.stringify(t)), r) {
+    const i = Z(
+      t,
+      (o) => typeof o == "string" && (pe.test(o) || J.test(o))
+    ).map((o) => {
+      const c = le(t, o);
+      return Le(c);
+    }).flat().filter(Boolean);
+    await Pt(i, k(a));
+  }
+}
+const Ae = new Pe({
+  max: 1e3,
+  ttl: 30 * 24 * 60 * 60 * 1e3
+});
+async function be(t, s, e) {
+  var i;
+  const n = Z(
+    t,
+    (o) => typeof o == "string" && (pe.test(o) || J.test(o))
+  ), r = et(2), a = n.map(
+    (o) => r(async () => {
+      try {
+        const c = le(t, o), f = Le(c);
+        for (const p of f) {
+          const g = B(p), I = e.getFilePath(p, o), T = I ? `${I}:${g}` : g, O = Ae.get(T);
+          if (O) {
+            J.test(c) || ge(t, o, O);
+            return;
+          }
+          const L = await Tt(I, g, s);
+          L && (J.test(c) || ge(t, o, L), Ae.set(T, L));
+        }
+      } catch (c) {
+        D.error(`Failed to process upload for path ${o.join(".")}:`, c.message || c.reason);
+      }
+    })
+  ), l = await Promise.allSettled(a);
+  (i = e.onFinish) == null || i.call(e, l);
+}
+async function Dt(t, {
+  exportAssets: s,
+  pageIds: e = "all",
+  componentIds: n = "all",
+  rawConfig: r,
+  includeResources: a = !1
+} = {}) {
+  var N, _, m, w, S, E;
+  const l = e === "all" ? t.pageIds : e, i = jt({
+    state: t,
+    pageIds: l,
+    componentIds: n === "all" ? Object.keys(t.components) : n
+  }), o = (u, d) => {
+    var y;
+    return {
+      id: u.id,
+      name: u.name,
+      isTemplateSection: u.isTemplateSection ?? !1,
+      component: u.component,
+      config: u.config,
+      visibility: u.visibility,
+      properties: ((y = u.locales) == null ? void 0 : y[d]) ?? {}
+    };
+  }, c = (u, d) => {
+    var y;
+    return {
+      id: u.id,
+      createdAt: u.createdAt,
+      updatedAt: u.updatedAt,
+      publishedAt: u.publishedAt,
+      isPublic: u.isPublic ?? !0,
+      isTemplate: u.isTemplate ?? !1,
+      meta: ((y = u.locales) == null ? void 0 : y[d]) ?? {},
+      sections: C(
+        u.sectionIds.map((P) => {
+          const j = u.sections[P];
+          return j && o(j, d);
+        })
+      )
+    };
+  }, f = C(
+    t.supportedLocales.map((u) => u.locale).flatMap(
+      (u) => l.map((d) => {
+        const y = t.pages[d];
+        return y && {
+          locale: u,
+          slug: y.slug,
+          page: c(y, u)
+        };
+      })
+    )
+  ), p = Ce(), g = A(p, "pages");
+  R(g, { recursive: !0 });
+  const I = A(p, "components");
+  R(I, { recursive: !0 });
+  for (const { locale: u, slug: d, page: y } of f)
+    await oe(y, g, {
+      getFilename: () => `${ke(d) || "index"}.${u}.yml`,
+      exportAssets: s
+    });
+  for (const u of i) {
+    const d = (N = t.components[u]) == null ? void 0 : N.data;
+    d && await oe(d, I, {
+      getFilename: (y) => `${y.name || "unnamed"}.${y.id}.yml`,
+      exportAssets: s
+    });
+  }
+  const T = A(p, ".blocklet/pages/pages.config.yml");
+  R(k(T), { recursive: !0 });
+  const O = {
+    pages: C(
+      l.map((u) => {
+        const d = t.pages[u];
+        return d && { id: u, slug: d.slug };
+      })
+    ),
+    components: C(
+      i.map((u) => {
+        var y;
+        const d = (y = t.components[u]) == null ? void 0 : y.data;
+        return d && {
+          id: u,
+          name: d.name
+        };
+      })
+    ),
+    ...a ? {
+      resources: {
+        components: C(
+          Object.keys(((_ = t.resources) == null ? void 0 : _.components) || {}).map((u) => {
+            var d, y, P, j;
+            return {
+              id: u,
+              name: (j = (P = (y = (d = t.resources) == null ? void 0 : d.components) == null ? void 0 : y[u]) == null ? void 0 : P.component) == null ? void 0 : j.name
+            };
+          })
+        )
+      }
+    } : {},
+    supportedLocales: t.supportedLocales,
+    config: t.config
+  };
+  X(T, G.stringify(O));
+  const L = A(p, "config.source.json");
+  if (r && X(L, JSON.stringify(r)), a) {
+    const u = A(p, "resources"), d = A(u, "components");
+    R(d, { recursive: !0 });
+    for (const y of Object.keys(((m = t == null ? void 0 : t.resources) == null ? void 0 : m.components) ?? {})) {
+      const P = (E = (S = (w = t.resources) == null ? void 0 : w.components) == null ? void 0 : S[y]) == null ? void 0 : E.component;
+      P && await oe(P, d, {
+        getFilename: (j) => `${j.name || "unnamed"}.${j.id}.yml`,
+        exportAssets: s
+      });
+    }
+  }
+  return p;
+}
+async function Ue(t, { importAssets: s, includeResources: e } = {}) {
+  var a, l, i;
+  if (!$(t))
+    return null;
+  let n, r = !1;
+  try {
+    Y(t).isDirectory() ? n = t : /\.(tgz|gz|tar)$/.test(t) && (r = !0, n = Ce(), await nt({ file: t, C: n }));
+    const o = ae("**/.blocklet/pages/pages.config.yml", { cwd: n, absolute: !0 }).at(0), c = o && A(k(o), "../../pages"), f = o && A(k(o), "../../components"), p = o && A(k(o), "../../chunks");
+    if (!o)
+      return null;
+    const g = G.parse(x(o).toString()), I = (m, w, S) => {
+      let E = A(m, `${w}${S ? `.${S}` : ""}.yml`);
+      return (!$(E) || !Y(E).isFile()) && (E = A(m, w, `index${S ? `.${S}` : ""}.yml`), !$(E) || !Y(E)) ? null : G.parse(x(E).toString());
+    }, T = (m, w) => {
+      try {
+        const S = ae(`*.${w}.yml`, { cwd: m, absolute: !0 })[0];
+        return S ? G.parse(x(S).toString()) : null;
+      } catch (S) {
+        D.error("parse component error", S);
+      }
+      return null;
+    }, O = C(
+      g.pages.map(({ slug: m }) => {
+        var u;
+        const w = C(
+          g.supportedLocales.map(({ locale: d }) => {
+            const y = c ? I(c, ke(m), d) : void 0;
+            if (y)
+              return { locale: d, page: y };
+            const P = c ? I(c, m, d) : void 0;
+            return P && { locale: d, page: P };
+          })
+        ), S = (u = w[0]) == null ? void 0 : u.page;
+        if (!S)
+          return null;
+        const E = S.sections.map((d) => {
+          const y = d.id || we();
+          return {
+            id: y,
+            component: d.component,
+            config: d.config,
+            name: d.name,
+            isTemplateSection: d.isTemplateSection ?? !1,
+            visibility: d.visibility,
+            locales: Object.fromEntries(
+              C(
+                w.map(({ locale: P, page: j }) => {
+                  const fe = j.sections.find((_e) => _e.id === y);
+                  return fe && [P, fe.properties];
+                })
+              )
+            )
+          };
+        });
+        return {
+          id: S.id || we(),
+          createdAt: S.createdAt,
+          updatedAt: S.updatedAt,
+          publishedAt: S.publishedAt,
+          isPublic: S.isPublic ?? !0,
+          isTemplate: S.isTemplate ?? !1,
+          slug: m,
+          sections: Object.fromEntries(E.map((d) => [d.id, d])),
+          sectionIds: E.map((d) => d.id),
+          locales: Object.fromEntries(w.map(({ locale: d, page: y }) => [d, y.meta]))
+        };
+      })
+    ), L = f ? C(((a = g.components) == null ? void 0 : a.map(({ id: m }) => T(f, m))) ?? []) : [];
+    if (s) {
+      const m = (...w) => {
+        D.info(`[${r ? B(t) : B(A(t, "../../../../"))}] importAssets:`, ...w);
+      };
+      try {
+        m("wait image-bin api ready"), await rt({
+          resources: [`${xe(mt)}/api/sdk/uploads`],
+          validateStatus: (E) => E >= 200 && E <= 500
+        }), m("image-bin api is ready");
+        const w = {}, S = {};
+        m("start to upload assets"), await Promise.allSettled([
+          be(L, w, {
+            getFilePath: (E) => f && A(f, E),
+            onFinish: (E) => {
+              m(`upload ${E.length} component assets`);
+            }
+          }),
+          be(O, S, {
+            getFilePath: (E, u) => {
+              const d = le(O, u.slice(0, 1));
+              return c && A(c, k(d.slug), E);
+            },
+            onFinish: (E) => {
+              m(`upload ${E.length} page assets`);
+            }
+          })
+        ]), m("upload assets done"), global.gc && global.gc();
+      } catch (w) {
+        m("Error during asset import:", w);
+      }
+    }
+    const N = {};
+    if (e) {
+      const m = o && A(k(o), "../../resources/components"), w = C(
+        ((i = (l = g.resources) == null ? void 0 : l.components) == null ? void 0 : i.map(({ id: S }) => T(m, S))) ?? []
+      );
+      w.length > 0 && (N.components = Object.fromEntries(
+        w.map((S, E) => [S.id, { index: E, component: S }])
+      ));
+    }
+    const _ = {};
+    if (p && $(p)) {
+      const m = ze(p);
+      for (const w of m)
+        _[w] = x(A(p, w), "utf-8");
+    }
+    return {
+      supportedLocales: g.supportedLocales,
+      pageIds: O.map((m) => m.id),
+      components: Object.fromEntries(L.map((m, w) => [m.id, { index: w, data: m }])),
+      pages: Object.fromEntries(O.map((m) => [m.id, m])),
+      config: g.config || {},
+      resources: N,
+      chunks: _
+    };
+  } finally {
+    r && n && Te(n, { force: !0, recursive: !0 });
+  }
+}
+async function ve(t, s, {
+  pages: e,
+  pageMergeMode: n = "byUpdateTime",
+  deletePages: r = !1,
+  publishMode: a = void 0
+} = {}) {
+  try {
+    a && Me(a);
+  } catch (f) {
+    D.error("clear preload page cache error", { error: f });
+  }
+  const { pageIds: l, pages: i, supportedLocales: o } = t;
+  for (const f of e ?? l) {
+    const p = i[f];
+    if (!p) {
+      const g = s.pageIds.indexOf(f);
+      g !== -1 && r && (s.pageIds.splice(g, 1), delete s.pages[f]);
+      continue;
+    }
+    if (s.pageIds.includes(p.id)) {
+      if (n === "replace")
+        s.pages[p.id] = p;
+      else if (n === "byUpdateTime") {
+        const g = s.pages[p.id];
+        (!g || p.updatedAt && p.updatedAt > g.updatedAt) && (s.pages[p.id] = p);
+      }
+    } else
+      s.pageIds.push(p.id), s.pages[p.id] = p;
+  }
+  if (r && !e)
+    for (const f of s.pageIds)
+      t.pageIds.includes(f) || delete s.pages[f], s.pageIds = [...s.pageIds].filter((p) => t.pageIds.includes(p));
+  if (s.supportedLocales.splice(0, s.supportedLocales.length), s.supportedLocales.push(...Xe(o)), r)
+    for (const f of Object.keys(s.components))
+      delete s.components[f];
+  let c = JSON.parse(JSON.stringify(t.components));
+  c = Object.fromEntries(
+    await Promise.all(
+      Object.entries(c).map(async ([f, p]) => {
+        const g = await Ne(p == null ? void 0 : p.data);
+        return [
+          f,
+          {
+            ...p,
+            data: g
+          }
+        ];
+      })
+    )
+  ), 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 Ne = Be(
+  async (t) => {
+    var s;
+    if (!Qe(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 n = await $e(e, "PROPERTIES_SCHEMA", t.id);
+          n && n.length > 0 && t && (t.properties = {}, n.forEach((r, a) => {
+            t != null && t.properties && (t.properties[r.id] = {
+              index: a,
+              data: r
+            });
+          }));
+        } catch (n) {
+          D.error("checkPropertiesFromCode error", { componentId: t.id, name: t.name }, { error: n });
+        }
+    }
+    return t;
+  },
+  {
+    keyGenerator: (t) => JSON.stringify(["checkPropertiesFromCode", t])
+  }
+);
+function jt({
+  state: t,
+  pageIds: s = [],
+  componentIds: e = []
+}) {
+  var l;
+  const n = (i, o = /* @__PURE__ */ new Set()) => (Array.isArray(i) && i.forEach((c) => n(c, o)), i && typeof i == "object" && (typeof i.componentId == "string" && o.add(i.componentId), Object.values(i).forEach((c) => n(c, o))), o), r = new Set(e);
+  for (const i of s) {
+    const o = t.pages[i];
+    n(o, r);
+  }
+  const a = [...r];
+  for (; a.length; ) {
+    const i = a.shift();
+    r.has(i) || r.add(i);
+    const o = (l = t.components[i]) == null ? void 0 : l.data;
+    if (o)
+      for (const c of n(o))
+        r.has(c) || a.push(c);
+  }
+  return [...r];
+}
+let ee, q, de, ue;
+function Re() {
+  return ee = (async () => {
+    const t = Ve({
+      types: [
+        { did: je, type: Se },
+        { did: St, type: Se }
+      ]
+    });
+    q = (await Promise.all(
+      t.map(async (e) => {
+        const n = e.path ? await Ue(e.path, { importAssets: !1 }) : void 0;
+        return n ? { blockletId: e.did, state: n, blockletTitle: e.title } : void 0;
+      })
+    )).filter((e) => !!e), de = q.reduce(
+      (e, n) => Object.assign(
+        e,
+        Object.fromEntries(
+          Object.values(n.state.pages).map((r) => r ? [r == null ? void 0 : r.id, { page: r, blockletId: n.blockletId }] : [])
+        )
+      ),
+      {}
+    );
+    const s = q.reduce(
+      (e, n) => Object.assign(
+        e,
+        Object.fromEntries(
+          Object.values(n.state.components).map((r) => [r.data.id, { blockletId: n.blockletId, component: r.data }])
+        )
+      ),
+      {}
+    );
+    ue = Object.fromEntries(
+      await Promise.all(
+        Object.entries(s).map(async ([e, n]) => {
+          const r = await Ne(n.component);
+          return [
+            e,
+            {
+              ...n,
+              component: r
+            }
+          ];
+        })
+      )
+    );
+  })(), ee;
+}
+function kt(t) {
+  const s = Oe(
+    async () => {
+      await Re().catch((e) => {
+        D.error("load resource states error", { error: e });
+      }), await (t == null ? void 0 : t({ states: q, pages: de, components: ue }));
+    },
+    3e3,
+    { leading: !1, trailing: !0 }
+  );
+  return s(), h.events.on(h.Events.componentAdded, s), h.events.on(h.Events.componentRemoved, s), h.events.on(h.Events.componentStarted, s), h.events.on(h.Events.componentStopped, s), h.events.on(h.Events.componentUpdated, s), h.events.on(ie, s), () => {
+    h.events.off(h.Events.componentAdded, s), h.events.off(h.Events.componentRemoved, s), h.events.off(h.Events.componentStarted, s), h.events.off(h.Events.componentStopped, s), h.events.off(h.Events.componentUpdated, s), h.events.off(ie, s);
+  };
+}
+const Fe = Symbol.for("GLOBAL_RESOURCE_STATES_LISTENER_KEY"), W = globalThis;
+var Ie;
+(Ie = W[Fe]) == null || Ie.call(W);
+W[Fe] = kt(async ({ pages: t, components: s }) => {
+  const { projectIds: e } = Q;
+  await Promise.all(
+    e.map(async (n) => {
+      const r = Q.shared(n);
+      r.syncedStore.resources.pages = t;
+      const a = await F.findByPk(n);
+      if (a != null && a.useAllResources)
+        r.syncedStore.resources.components = s;
+      else {
+        const i = (await te.findAll({ where: { projectId: n } })).map((c) => c.componentId), o = Object.fromEntries(
+          Object.entries(s || {}).filter(([c]) => i.includes(c))
+        );
+        r.syncedStore.resources.components = o;
+      }
+      D.info(`update [${n}] resource states:`, {
+        pages: Object.keys(r.syncedStore.resources.pages || {}).length,
+        components: Object.keys(r.syncedStore.resources.components || {}).length
+      });
+    })
+  );
+});
+async function rs() {
+  D.info("trigger reload all project resource"), h.events.emit(ie);
+}
+async function Ct() {
+  return ee ?? (ee = Re()), await ee, { states: q, pages: de, components: ue };
+}
+export {
+  je as C,
+  F as P,
+  Se as R,
+  Q as S,
+  Ct as a,
+  H as b,
+  ss as c,
+  ns as d,
+  kt as e,
+  Ue as f,
+  ts as g,
+  rs as h,
+  es as i,
+  ve as m,
+  we as n,
+  Dt as t
+};