@blocklet/pages-kit-inner-components 0.7.4 → 0.7.6

package/lib/es/chunks/site-state-BR3S4pMJ.js

@@ -0,0 +1,2013 @@
+import { d as Je, l as p, m as lt, b as pt, I as ut, c as dt } from "./components-D4ywfyMi.js";
+import { getYjsValue as J, syncedStore as ft } from "@syncedstore/core";
+import * as F from "yjs";
+import { setPageDataSource as mt } from "@blocklet/pages-kit/utils/data-source";
+import { getRouteMetaDataByOptionIds as gt, generateParamCombinations as be } from "@blocklet/pages-kit/utils/route";
+import Ae from "lodash/cloneDeep";
+import { DataTypes as P, Sequelize as ht, Model as Ee, Op as Z } from "sequelize";
+import "sqlite3";
+import E from "@blocklet/sdk/lib/config";
+import { withoutTrailingSlash as Oe, withLeadingSlash as He, joinURL as x } from "ufo";
+import { union as yt, debounce as St } from "lodash";
+import Le from "crypto";
+import z, { mkdtempSync as wt, existsSync as It, readFileSync as Pt, createWriteStream as bt } from "fs";
+import Re from "p-limit";
+import $e, { join as A, basename as $, dirname as M } from "path";
+import { Worker as At } from "worker_threads";
+import { nextId as Ue } from "@blocklet/pages-kit/utils/common";
+import { unzipSection as Et } from "@blocklet/pages-kit/utils/page-model";
+import { getComponentDependencies as Ot } from "@blocklet/pages-kit/utils/property";
+import { getComponentWebEndpoint as Rt, getResources as Ct, call as jt } from "@blocklet/sdk/lib/component";
+import { reactive as kt } from "@reactivedata/reactive";
+import { rename as Ne, mkdir as B, rm as We, writeFile as re, lstat as oe, readFile as te, copyFile as Dt, readdir as vt } from "fs/promises";
+import { globSync as Tt, glob as ye } from "glob";
+import * as fe from "lib0/decoding";
+import * as v from "lib0/encoding";
+import Ce from "lodash/debounce";
+import je from "lodash/get";
+import ke from "lodash/isEmpty";
+import Me from "lodash/set";
+import Lt from "lodash/union";
+import { LRUCache as Ke } from "lru-cache";
+import { pipeline as $t } from "stream/promises";
+import { x as Ut } from "tar";
+import Nt from "wait-on";
+import { Awareness as Mt, encodeAwarenessUpdate as _e, removeAwarenessStates as _t, applyAwarenessUpdate as Ft } from "y-protocols/awareness";
+import { writeUpdate as xt, writeSyncStep1 as Bt, readSyncMessage as Gt } from "y-protocols/sync";
+import * as q from "yaml";
+import { m as Fe } from "./html-CNFwwbdj.js";
+import "@blocklet/pages-kit/types/state";
+const Vt = P.sqlite.DATE.parse;
+P.sqlite.DATE.parse = (t, e) => typeof t == "number" ? new Date(t) : Vt(t, e);
+const _ = new ht({
+  dialect: "sqlite",
+  storage: Je,
+  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,
+});
+_.query("PRAGMA journal_mode = WAL;");
+_.query("PRAGMA synchronous = normal;");
+_.query("PRAGMA journal_size_limit = 67108864;");
+_.query("PRAGMA cache_size = 10000;");
+process.on("SIGINT", async () => {
+  await _.close(), process.exit(0);
+});
+process.on("SIGTERM", async () => {
+  await _.close(), process.exit(0);
+});
+async function zt(t, e) {
+  try {
+    if (t.getDialect() !== "sqlite")
+      return;
+    const [s] = await t.query("SELECT 1");
+    if (!s || s.length === 0)
+      return;
+    await t.query("PRAGMA shrink_memory;");
+  } catch (s) {
+    if (s.name === "SequelizeConnectionError" || s?.message && /closed!/.test(s.message))
+      return;
+    console.error("Failed to cleanup SQLite memory", e, s);
+  }
+}
+let Se = null;
+Se && clearInterval(Se);
+Se = setInterval(
+  async () => {
+    p.info("Start cleanupSqliteMemory"), await zt(_, Je), p.info("End cleanupSqliteMemory");
+  },
+  60 * 1e3 * 10
+  // 10 minutes
+);
+const qt = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o", xe = "page", we = "trigger-reload-project-resource", Ye = qt, Jt = "z2qa7BQdkEb3TwYyEYC1psK6uvmGnHSUHt5RM", Ht = "z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o";
+class De extends Ee {
+  // Foreign key to Component
+}
+De.init(
+  {
+    id: {
+      type: P.UUID,
+      allowNull: !1,
+      primaryKey: !0,
+      defaultValue: P.UUIDV4
+    },
+    projectId: {
+      type: P.UUID,
+      allowNull: !1
+    },
+    componentId: {
+      type: P.STRING,
+      allowNull: !1
+    }
+  },
+  { sequelize: _, tableName: "ProjectComponents", timestamps: !1 }
+);
+const Wt = "SLUG_INVALID", W = (t) => ({
+  error: "slugInvalid",
+  code: Wt,
+  field: "slug",
+  message: t
+}), Kt = {
+  error: "slugRequired",
+  code: "SLUG_REQUIRED",
+  field: "slug",
+  message: () => "Project slug is required"
+}, Yt = {
+  error: "slugAlreadyExists",
+  code: "SLUG_EXISTS",
+  field: "slug",
+  message: (t) => `Project slug "${t}" already exists`
+}, Xt = [
+  /\.\./,
+  // Directory traversal
+  /<[^>]*>/,
+  // HTML/XML tags
+  /%[0-9a-f]{2}/i,
+  // Percent encoding
+  /[<>'"%;{}()\\]/,
+  // Special characters
+  // eslint-disable-next-line no-control-regex
+  /\x00/,
+  // Null byte
+  /\n|\r|\t|\v|\f/,
+  // Control characters
+  /[^a-zA-Z0-9-_@/\\:]/
+  // Only allow specific characters
+], Be = (t) => {
+  if (!t) return "";
+  if (t === "/") return "/";
+  const e = Oe(t);
+  return He(e) || "/";
+}, Qt = (t) => t.did === Ht;
+class U extends Ee {
+  static async getProjectByIdOrSlug(e, s) {
+    return e ? U.findOne({
+      where: {
+        [Z.or]: [{ id: e }, { slug: e }],
+        ...s?.createdBy ? { createdBy: s.createdBy } : {}
+      }
+    }) : null;
+  }
+  static async validateProjectSlug({
+    slug: e,
+    projectId: s
+  }) {
+    if (e == null)
+      return null;
+    if (e === "")
+      return Kt;
+    const a = e === "/" ? "/" : Oe(He(e)), o = Be(a);
+    if (a !== "/" && a.endsWith("/"))
+      return W((n) => `Project slug "${n}" cannot end with /`);
+    if (/\/{2,}/.test(a))
+      return W((n) => `Project slug "${n}" cannot contain consecutive /`);
+    if (/\s/.test(a))
+      return W((n) => `Project slug "${n}" cannot contain whitespace`);
+    if (Xt.some((n) => n.test(a)))
+      return W((n) => `Project slug "${n}" contains invalid characters`);
+    if (E.components?.filter((n) => n.mountPoint && !Qt(n)).some((n) => Be(n.mountPoint) === o))
+      return W((n) => `Project slug "${n}" conflicts with existing blocklet`);
+    const l = await U.findOne({
+      where: { slug: a }
+    });
+    return l && l?.id !== s ? Yt : null;
+  }
+}
+U.init(
+  {
+    id: {
+      type: P.UUID,
+      defaultValue: P.UUIDV4,
+      primaryKey: !0
+    },
+    name: {
+      type: P.STRING,
+      allowNull: !1
+    },
+    description: P.TEXT,
+    createdAt: P.DATE,
+    updatedAt: P.DATE,
+    createdBy: {
+      type: P.STRING,
+      allowNull: !1
+    },
+    updatedBy: {
+      type: P.STRING,
+      allowNull: !1
+    },
+    slug: P.STRING,
+    icon: P.STRING,
+    pinnedAt: P.DATE,
+    useAllResources: P.BOOLEAN,
+    npmSecret: P.STRING,
+    relatedBlocklets: {
+      type: P.JSON,
+      allowNull: !1,
+      defaultValue: {},
+      get() {
+        const t = this.getDataValue("relatedBlocklets");
+        if (typeof t == "object")
+          return t ?? {};
+        try {
+          return t ? JSON.parse(t) : {};
+        } catch (e) {
+          return p.error("Failed to parse relatedBlocklets", { error: e, rawValue: t }), {};
+        }
+      },
+      set(t) {
+        try {
+          this.setDataValue("relatedBlocklets", t ? JSON.stringify(t) : "{}");
+        } catch (e) {
+          p.error("Failed to set relatedBlocklets", { error: e, value: t }), this.setDataValue("relatedBlocklets", "{}");
+        }
+      }
+    },
+    productionState: {
+      type: P.JSON,
+      allowNull: !1,
+      defaultValue: {},
+      get() {
+        const t = this.getDataValue("productionState");
+        if (typeof t == "object")
+          return t ?? {};
+        try {
+          return t ? JSON.parse(t) : {};
+        } catch (e) {
+          return p.error("Failed to parse productionState", { error: e, rawValue: t }), {};
+        }
+      },
+      set(t) {
+        try {
+          this.setDataValue("productionState", t ? JSON.stringify(t) : "{}");
+        } catch (e) {
+          p.error("Failed to set productionState", { error: e, value: t }), this.setDataValue("productionState", "{}");
+        }
+      }
+    },
+    meta: {
+      type: P.JSON,
+      allowNull: !0
+    }
+  },
+  {
+    sequelize: _,
+    paranoid: !0,
+    indexes: [
+      {
+        name: "projects_slug_unique",
+        unique: !0,
+        fields: ["slug"]
+      },
+      {
+        name: "projects_created_by",
+        fields: ["createdBy"]
+      },
+      {
+        name: "projects_pinned_updated_meta_not_null",
+        fields: [
+          { name: "pinnedAt", order: "DESC" },
+          { name: "updatedAt", order: "DESC" }
+        ],
+        where: {
+          meta: {
+            [Z.ne]: null
+          }
+        }
+      }
+    ]
+  }
+);
+U.hasMany(De, {
+  foreignKey: "projectId",
+  as: "components"
+});
+async function G(t) {
+  try {
+    return await z.promises.access(t, z.constants.F_OK), !0;
+  } catch {
+    return !1;
+  }
+}
+function Xe(t, e) {
+  return new Promise((s, a) => {
+    const o = z.createReadStream(t), r = z.createWriteStream(e);
+    o.on("error", a), r.on("error", a), r.on("finish", s), o.pipe(r);
+  });
+}
+async function Qe(t, e) {
+  await z.promises.mkdir(e, { recursive: !0 });
+  const s = await z.promises.readdir(t, { withFileTypes: !0 });
+  for (const a of s) {
+    const o = $e.join(t, a.name), r = $e.join(e, a.name);
+    a.isDirectory() ? await Qe(o, r) : await Xe(o, r);
+  }
+}
+async function oa(t, e) {
+  (await z.promises.stat(t)).isDirectory() ? await Qe(t, e) : await Xe(t, e);
+}
+class ee extends Ee {
+}
+ee.init(
+  {
+    id: {
+      type: P.UUID,
+      primaryKey: !0,
+      defaultValue: P.UUIDV4
+    },
+    projectId: {
+      type: P.UUID,
+      allowNull: !1,
+      comment: "Project ID"
+    },
+    urlPath: {
+      type: P.STRING(512),
+      allowNull: !1,
+      unique: !0,
+      comment: "URL path, e.g. /project-slug/page-slug or /en/project-slug/page-slug"
+    },
+    projectSlug: {
+      type: P.STRING,
+      allowNull: !0,
+      comment: "Project slug"
+    },
+    pageSlug: {
+      type: P.STRING,
+      allowNull: !1,
+      comment: "Page slug"
+    },
+    pageId: {
+      type: P.UUID,
+      allowNull: !1,
+      comment: "Page ID"
+    },
+    routeId: {
+      type: P.UUID,
+      allowNull: !0,
+      comment: "Route ID (for draft mode)"
+    },
+    locale: {
+      type: P.STRING(10),
+      allowNull: !0,
+      comment: "Locale code, e.g. en, zh"
+    },
+    defaultLocale: {
+      type: P.STRING(10),
+      allowNull: !0,
+      comment: "Default locale"
+    },
+    shouldRedirect: {
+      type: P.BOOLEAN,
+      defaultValue: !1,
+      comment: "Whether this URL should redirect"
+    },
+    mainPage: {
+      type: P.BOOLEAN,
+      defaultValue: !1,
+      comment: "Whether this is the main page"
+    },
+    isPublic: {
+      type: P.BOOLEAN,
+      allowNull: !1,
+      defaultValue: !0,
+      comment: "Whether the page is public"
+    },
+    publishedAt: {
+      type: P.BIGINT,
+      allowNull: !0,
+      comment: "Published timestamp"
+    },
+    locales: {
+      type: P.JSON,
+      allowNull: !0,
+      comment: "Supported locales array"
+    },
+    createdAt: P.DATE,
+    updatedAt: P.DATE
+  },
+  {
+    sequelize: _,
+    tableName: "PageUrlMappings",
+    timestamps: !0,
+    indexes: [
+      {
+        name: "idx_project_id",
+        fields: ["projectId"]
+      },
+      {
+        name: "idx_url_path",
+        unique: !0,
+        fields: ["urlPath"]
+      },
+      {
+        name: "idx_page_id",
+        fields: ["pageId"]
+      }
+    ]
+  }
+);
+function Zt(t) {
+  const { projectId: e, projectSlug: s, state: a } = t, o = s || e, r = yt(
+    E.env.languages?.map((c) => c.code) || [],
+    a.supportedLocales?.map((c) => c.locale) || []
+  ), l = {}, n = (c, f) => {
+    o && (l[x("/", o, c)] = {
+      ...f,
+      shouldRedirect: !0,
+      mainPage: !0
+    }), l[x("/", e, c)] = {
+      ...f,
+      shouldRedirect: !0,
+      mainPage: !0
+    };
+    for (const b of r) {
+      const R = { ...f, locale: b };
+      l[x("/", b, e, c)] = R, o && (l[x("/", b, o, c)] = R);
+    }
+  };
+  for (const c of a.pageIds || []) {
+    const f = a.pages?.[c];
+    if (!f || !f.isPublic)
+      continue;
+    const b = {
+      projectId: e,
+      projectSlug: o,
+      pageSlug: f.slug,
+      pageId: c,
+      defaultLocale: r?.[0],
+      locales: r,
+      publishedAt: a.config?.publishedAt,
+      isPublic: f.isPublic
+    };
+    n(f.slug, b);
+  }
+  return l;
+}
+async function es(t, e, s) {
+  const a = t.map((r) => r.urlPath), o = await ee.findAll({
+    where: {
+      urlPath: {
+        [Z.in]: a
+      },
+      projectId: {
+        [Z.ne]: e
+      }
+    },
+    attributes: ["urlPath", "projectId", "projectSlug", "pageSlug"],
+    transaction: s,
+    raw: !0
+  });
+  if (o.length > 0) {
+    p.warn(
+      `[URL Duplicate Warning] Found ${o.length} URL conflicts for project ${e}:`
+    );
+    for (const r of o) {
+      const l = t.find((n) => n.urlPath === r.urlPath);
+      if (l) {
+        const n = r.projectSlug ? x(r.projectSlug, r.pageSlug) : r.pageSlug;
+        p.warn(
+          `  - URL "${r.urlPath}" conflicts with project ${r.projectId} (${n}). Current project trying to use same URL for page: ${l.pageSlug}`
+        );
+      }
+    }
+    p.warn(
+      "[URL Duplicate Warning] These duplicate URLs will be ignored during save. Consider using different project slugs or page slugs to avoid conflicts."
+    );
+  }
+}
+async function ts(t) {
+  const { projectId: e, transaction: s } = t;
+  try {
+    await ee.destroy({
+      where: { projectId: e },
+      transaction: s
+    });
+    const a = Zt(t), o = Object.entries(a).map(([r, l]) => ({
+      projectId: e,
+      urlPath: r,
+      projectSlug: l.projectSlug,
+      pageSlug: l.pageSlug,
+      pageId: l.pageId,
+      routeId: l.routeId,
+      locale: l.locale,
+      defaultLocale: l.defaultLocale,
+      shouldRedirect: l.shouldRedirect,
+      mainPage: l.mainPage,
+      isPublic: l.isPublic,
+      publishedAt: typeof l.publishedAt == "number" ? l.publishedAt : void 0,
+      locales: l.locales
+    }));
+    if (o.length > 0) {
+      await es(o, e, s);
+      const r = 100, l = [];
+      for (let n = 0; n < o.length; n += r) {
+        const c = o.slice(n, n + r);
+        l.push(
+          ee.bulkCreate(c, {
+            transaction: s,
+            ignoreDuplicates: !0
+            // 忽略重复数据，避免因脏数据导致整批插入失败
+          })
+        );
+      }
+      await Promise.all(l), p.info(`Regenerated ${o.length} URL mappings for project ${e}`);
+    }
+    return o.length;
+  } catch (a) {
+    throw p.error(`Failed to regenerate URL mappings for project ${e}:`, a), a;
+  }
+}
+function ne(t) {
+  t.observeDeep((e) => {
+    e.some((s) => s.changes.keys.has("updatedAt") || s.changes.keys.has("publishedAt")) || t.set("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
+  });
+}
+function Ze() {
+  return wt(A(E.env.dataDir, "tmp-"));
+}
+function ie(t, e, s = []) {
+  return Array.isArray(t) ? t.flatMap((a, o) => ie(a, e, [...s, o])) : typeof t == "object" ? t === null ? [] : Object.entries(t).flatMap(([a, o]) => ie(o, e, [...s, a])) : e(t) ? [s] : [];
+}
+function L(t) {
+  return t.filter((e) => e != null);
+}
+function ss(t) {
+  return new Promise((e, s) => {
+    let a;
+    process.env.NODE_ENV === "development" ? a = A(__dirname, "yaml-worker.js") : a = A(__dirname, "api/dist/utils/yaml-worker.js");
+    const o = new At(a);
+    o.postMessage({ payload: t }), o.on("message", (r) => {
+      r.status === "success" ? e(r.result) : s(new Error(`YAML stringify failed in worker: ${r.message}`)), o.terminate();
+    }), o.on("error", (r) => {
+      s(r);
+    }), o.on("exit", (r) => {
+      r !== 0 && s(new Error(`Worker stopped with exit code ${r}`));
+    });
+  });
+}
+function Ge(t, e) {
+  if (t === e) return !0;
+  if (!t || !e) return t === e;
+  const s = Object.keys(t), a = Object.keys(e);
+  if (s.length !== a.length) return !1;
+  if (s.length < 10) {
+    for (const l of s) {
+      if (!(l in e)) return !1;
+      const n = t[l], c = e[l];
+      if (n?.blockletId !== c?.blockletId || n?.page?.id !== c?.page?.id || n?.page?.updatedAt !== c?.page?.updatedAt || n?.component?.id !== c?.component?.id || n?.component?.updatedAt !== c?.component?.updatedAt)
+        return !1;
+    }
+    return !0;
+  }
+  const o = Le.createHash("md5").update(JSON.stringify(t, Object.keys(t).sort())).digest("hex"), r = Le.createHash("md5").update(JSON.stringify(e, Object.keys(e).sort())).digest("hex");
+  return o === r;
+}
+function as(t) {
+  t.pages && Object.keys(t.pages).forEach((s) => {
+    const a = J(t.pages[s]);
+    a && a instanceof F.Map && ne(a);
+  });
+  const e = J(t.pages);
+  e && e instanceof F.Map && e.observe((s) => {
+    s.changes.keys.forEach((a, o) => {
+      if (a.action === "add") {
+        const r = J(t.pages[o]);
+        r && r instanceof F.Map && ne(r);
+      }
+    });
+  });
+}
+function os(t) {
+  t.routes && Object.keys(t.routes).forEach((s) => {
+    const a = J(t.routes?.[s]);
+    a && a instanceof F.Map && ne(a);
+  });
+  const e = J(t.routes);
+  e && e instanceof F.Map && e.observe((s) => {
+    s.changes.keys.forEach((a, o) => {
+      if (a.action === "add") {
+        const r = J(t.routes?.[o]);
+        r && r instanceof F.Map && ne(r);
+      }
+    });
+  });
+}
+function rs(t, e) {
+  for (const s of e || Object.keys(t.routes || {})) {
+    let a = s, o = [];
+    if (s.includes("-")) {
+      const [r, ...l] = s.split("-");
+      a = r, o = l || [];
+    }
+    if (t.routes?.[a] !== void 0) {
+      t.routes[a].publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const r = t.routes[a];
+      if (!r || !r.params || r.params.length === 0)
+        continue;
+      if (s.includes("-") && o.length > 0) {
+        const l = gt(o, r);
+        l && (l.publishedAt = (/* @__PURE__ */ new Date()).toISOString());
+      }
+      if (!e) {
+        const l = be({
+          basePath: r.path,
+          params: r.params,
+          routeId: r.id,
+          paramsOptions: r.paramsOptions,
+          currentIndex: 0,
+          currentParams: [],
+          currentOptionIds: [],
+          result: []
+        });
+        for (const n of l)
+          n.routeMetaData ??= {}, n.routeMetaData.publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+  }
+}
+function me({
+  page: t,
+  route: e,
+  state: s,
+  routeId: a,
+  routePathInfo: o
+}) {
+  p.info(
+    `Executing datasource data assembly, routeId: ${a}, routePathInfo: ${JSON.stringify(o)}`
+  );
+  const r = {
+    ...Ae(t),
+    id: a,
+    slug: o?.path ?? e.path,
+    createdAt: e.createdAt,
+    updatedAt: o?.routeMetaData?.updatedAt ?? e.updatedAt,
+    publishedAt: o?.routeMetaData?.publishedAt ?? e.publishedAt,
+    isPublic: (o?.routeMetaData?.isPublic ?? e.isPublic) && e.isPublic
+  };
+  for (const l of s.supportedLocales) {
+    if (e.dataSource) {
+      let n = e.id;
+      o && (n = o.paramOptionIds.join("-"));
+      const c = e.dataSource.pathDataMappings?.[n]?.dataCache?.[l.locale] ?? e.dataSource.pathDataMappings?.[n]?.dataCache?.[s.config.defaultLocale || "en"];
+      if (!c)
+        continue;
+      mt(r, s, l.locale, c);
+    }
+    o && o.routeMetaData && (o.routeMetaData.publishedAt = (/* @__PURE__ */ new Date()).toISOString());
+  }
+  return r;
+}
+["true", "1", "yes", "y"].includes(process.env.USE_FS_CACHE_HTML ?? "");
+const ns = 60 * 60 * 1e3, Y = new Ke({
+  max: 300,
+  ttl: ns,
+  ttlResolution: 10 * 1e3,
+  // 10 seconds
+  allowStale: !0
+});
+function is(t, e = []) {
+  let s = 0;
+  const a = Array.from(Y.keys()), o = t.map((r) => Oe(r));
+  for (const r of a)
+    for (const l of o) {
+      if (Fe(r, { currentPath: l })) {
+        Y.delete(r), s++, p.info(`[Cache CLEAR] key: ${r}`);
+        break;
+      }
+      for (const n of e)
+        if (Fe(r, { currentPath: `/${n}${l}` })) {
+          Y.delete(r), s++, p.info(`[Cache CLEAR] key: ${r}`);
+          break;
+        }
+    }
+  return p.info(`[Cache CLEAR] cleared ${s} entries for paths:`, o), s;
+}
+function cs() {
+  const t = Y.size;
+  return Y.clear(), p.info(`[Cache CLEAR ALL] cleared ${t} entries`), t;
+}
+const ls = St(cs, 300);
+E.events.on(E.Events.envUpdate, ls);
+const { uploadToMediaKit: ps } = require("@blocklet/uploader-server"), ve = /^\w+(\w|-|\.)+\w+\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm)$/, X = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/i, Ve = /mediakit:\/\/([a-f0-9]{32}\.(jpe?g|png|gif|svg|bmp|webp|mp4|m4v|webm))/gi, us = 1e4, ds = 3e4, se = 0, ge = 1, fs = 0, ms = 1, Ie = E, K = A(process.env.BLOCKLET_DATA_DIR, "site-state"), ra = ["production", "draft"], na = ["production"];
+function ce(t) {
+  return t?.replace(/\//g, "|") || "";
+}
+function gs() {
+  const t = Ie.env.languages?.map((s) => ({ locale: s.code, name: s.name })) || [], e = t[0]?.locale || "en";
+  return {
+    pageIds: [],
+    pages: {},
+    routeIds: [],
+    routes: {},
+    dataSourceIds: [],
+    dataSources: {},
+    components: {},
+    supportedLocales: t,
+    config: { defaultLocale: e },
+    resources: {}
+  };
+}
+class k extends F.Doc {
+  constructor(e) {
+    super(), this.options = e, It(this.draftYjsFilePath) && F.applyUpdate(this, Pt(this.draftYjsFilePath)), this.syncedStore = kt(
+      ft(
+        {
+          pages: {},
+          pageIds: [],
+          components: {},
+          supportedLocales: [],
+          config: {},
+          resources: {},
+          routeIds: [],
+          routes: {},
+          dataSourceIds: [],
+          dataSources: {}
+        },
+        this
+      )
+    ), this.initObserver(), this.on("update", this.updateHandler), this.awareness = new Mt(this), this.awareness.on("update", this.awarenessChangeHandler), this.ensureDataStructure();
+  }
+  // 延迟释放时间：5 分钟
+  static RELEASE_DELAY = 5 * 60 * 1e3;
+  // 定期检查间隔：2 小时
+  static PERIODIC_CHECK_INTERVAL = 2 * 60 * 60 * 1e3;
+  // 2 hours
+  static sharedInstances = {};
+  // 定期检查定时器
+  static periodicCheckTimer;
+  // safe delete project state dir
+  static async safeDeleteProjectStateDir(e) {
+    if (!e)
+      throw new Error("Should provide project context");
+    try {
+      const s = A(K, e), a = A(K, `@del-${e}`);
+      await Ne(s, a);
+    } catch (s) {
+      p.error("Failed to safe delete project state dir:", s);
+    }
+  }
+  static async getProjectIds() {
+    return (await U.findAll({ attributes: ["id"], raw: !0 }))?.map((e) => e.id);
+  }
+  /** @deprecated 不再使用这个 getter 了，仅作为兼容性处理，请使用 getProjectIds 代替 */
+  static get projectIds() {
+    return Tt("*/", {
+      cwd: K,
+      ignore: ["@del-*", "@tmp-*", ".*", "staging", "production", "@backup-*", "undefined"]
+      // Ignore temp directories and hidden files
+    });
+  }
+  /** @deprecated 不再使用这个 getter 了，仅作为兼容性处理 */
+  static get allShared() {
+    return this.projectIds.map((e) => k.shared(e));
+  }
+  static shared(e) {
+    if (!e)
+      throw new Error("Should provide project context");
+    let s = k.sharedInstances[e];
+    return s || (s = new k({
+      path: A(K, e)
+    }), k.sharedInstances[e] = s, s);
+  }
+  // 轻量级 production 状态获取，不加载 draft 数据
+  static async getProductionState(e) {
+    const s = await U.findByPk(e, {
+      attributes: ["productionState"]
+    });
+    if (ke(s?.productionState)) {
+      const a = A(K, e, "production"), o = await tt(a, { includeResources: !0 }) ?? gs();
+      if (!o?.config?.defaultLocale) {
+        o.config ??= {};
+        const r = Ie.env.languages?.map((l) => ({ locale: l.code, name: l.name })) || [];
+        o.config.defaultLocale = r[0]?.locale;
+      }
+      return o;
+    }
+    return s?.productionState;
+  }
+  destroy() {
+    this.cancelRelease(), this.save({ flush: !0 }), this.conns.forEach((s, a) => this.closeConn(a)), this.awareness.destroy();
+    const e = $(this.options.path);
+    delete k.sharedInstances[e], super.destroy();
+  }
+  initObserver() {
+    as(this.syncedStore), os(this.syncedStore);
+  }
+  get draftYjsFilePath() {
+    return A(this.options.path, "draft.yjs");
+  }
+  static async getStateByProjectId({
+    projectId: e,
+    mode: s,
+    clone: a = !0
+  }) {
+    if (s === "draft") {
+      const o = k.shared(e);
+      return a ? JSON.parse(JSON.stringify(o.syncedStore)) : o.syncedStore;
+    }
+    return k.getProductionState(e);
+  }
+  async getState(e) {
+    if (e === "draft")
+      return JSON.parse(JSON.stringify(this.syncedStore));
+    const s = $(this.options.path);
+    return k.getProductionState(s);
+  }
+  async setState(e, s) {
+    if (e === "production") {
+      const r = $(this.options.path), l = Ae(s);
+      await _.transaction(async (n) => {
+        await U.update({ productionState: l }, { where: { id: r }, transaction: n });
+        const c = await U.findByPk(r, {
+          attributes: ["slug"],
+          transaction: n
+        }), f = await ts({
+          projectId: r,
+          projectSlug: c?.slug,
+          state: s,
+          transaction: n
+        });
+        p.info(`[SiteState] saved ${f} URL mappings for project ${r}`);
+      }), await this.clearPageCacheForRoutes(void 0, s);
+    }
+    const a = await ws(s, { exportAssets: !1, includeResources: !0 }), o = this.getPublishDir(e);
+    await B(M(o), { recursive: !0 }), await We(o, { force: !0, recursive: !0 }), await Ne(a, o);
+  }
+  getPublishDir(e) {
+    return A(this.options.path, e);
+  }
+  syncedStore;
+  conns = /* @__PURE__ */ new Map();
+  awareness;
+  // 延迟释放定时器
+  releaseTimer;
+  awarenessChangeHandler = ({ added: e, updated: s, removed: a }, o) => {
+    const r = e.concat(s, a);
+    if (o !== null) {
+      const c = this.conns.get(o);
+      c && (e.forEach((f) => {
+        c.add(f);
+      }), a.forEach((f) => {
+        c.delete(f);
+      }));
+    }
+    const l = v.createEncoder();
+    v.writeVarUint(l, ge), v.writeVarUint8Array(l, _e(this.awareness, r));
+    const n = v.toUint8Array(l);
+    this.conns.forEach((c, f) => this.send(f, n));
+  };
+  updateHandler = (e) => {
+    const s = v.createEncoder();
+    v.writeVarUint(s, se), xt(s, e);
+    const a = v.toUint8Array(s);
+    this.conns.forEach((o, r) => this.send(r, a));
+  };
+  ensureDataStructure = () => {
+    this.transact(() => {
+      const { supportedLocales: e, pages: s, pageIds: a, config: o, routes: r, routeIds: l } = this.syncedStore;
+      {
+        const n = new Set(Object.keys(s));
+        let c = 0;
+        for (; c < a.length; ) {
+          const f = a[c];
+          n.has(f) ? (n.delete(f), c++) : a.splice(c, 1);
+        }
+      }
+      {
+        const n = new Set(Object.keys(r));
+        let c = 0;
+        for (; c < l.length; ) {
+          const f = l[c];
+          n.has(f) ? (n.delete(f), c++) : l.splice(c, 1);
+        }
+      }
+      e.splice(0, e.length), e.push(...Ie.env.languages.map((n) => ({ locale: n.code, name: n.name }))), o.defaultLocale = e[0]?.locale;
+      {
+        let n = 0;
+        const c = /* @__PURE__ */ new Set();
+        for (; n < e.length; ) {
+          const { locale: f } = e[n];
+          c.has(f) ? e.splice(n, 1) : (n++, c.add(f));
+        }
+      }
+    });
+  };
+  send = (e, s) => {
+    e.readyState !== fs && e.readyState !== ms && this.closeConn(e);
+    try {
+      e.send(s, (a) => {
+        a && this.closeConn(e);
+      });
+    } catch {
+      this.closeConn(e);
+    }
+  };
+  closeConn = (e) => {
+    if (e.removeAllListeners(), this.conns.has(e)) {
+      const s = this.conns.get(e);
+      this.conns.delete(e), s && _t(this.awareness, Array.from(s), null);
+    }
+    e.close(), this.checkAndScheduleRelease();
+  };
+  // 检查并调度延迟释放
+  checkAndScheduleRelease() {
+    this.conns.size === 0 && this.scheduleRelease();
+  }
+  // 调度延迟释放
+  scheduleRelease() {
+    this.cancelRelease();
+    const e = $(this.options.path);
+    this.releaseTimer = setTimeout(() => {
+      p.info(`[SiteState] releasing instance due to no active connections: ${e}`), this.conns.size === 0 && (this.releaseTimer = void 0, this.destroy());
+    }, k.RELEASE_DELAY), p.info(`[SiteState] scheduled release for project ${e} in ${k.RELEASE_DELAY / 1e3}s`);
+  }
+  // 取消延迟释放
+  cancelRelease() {
+    if (this.releaseTimer) {
+      clearTimeout(this.releaseTimer), this.releaseTimer = void 0;
+      const e = $(this.options.path);
+      p.info(`[SiteState] cancelled scheduled release for project ${e}`);
+    }
+  }
+  autoSave = Ce(async () => {
+    await B(M(this.draftYjsFilePath), { recursive: !0 }), await re(this.draftYjsFilePath, F.encodeStateAsUpdate(this));
+  }, us);
+  save = ({ flush: e = !1 } = {}) => {
+    this.autoSave(), e && this.autoSave.flush();
+  };
+  publish = async ({ mode: e, routes: s }) => {
+    const a = $(this.options.path);
+    await bs(a);
+    const o = await this.getState("draft"), r = await this.getState("production");
+    await qe(o, r, { routes: s, mergeMode: "replace", deleteRoutes: !0, publishMode: e }), r.config.publishedAt = (/* @__PURE__ */ new Date()).getTime(), setImmediate(() => {
+      this.transact(() => {
+        rs(this.syncedStore, s);
+      });
+    }), await this.setState(e, r);
+  };
+  mergeState = async (e, s) => {
+    const a = JSON.parse(JSON.stringify(s));
+    e.config.fontFamily ??= {};
+    const o = a.config?.fontFamily, r = e.config?.fontFamily;
+    e.config.fontFamily.title = o?.title || r?.title, e.config.fontFamily.description = o?.description || r?.description, await new Promise((l, n) => {
+      this.transact(async () => {
+        try {
+          const c = await qe(e, s);
+          l(c);
+        } catch (c) {
+          n(c);
+        }
+      });
+    });
+  };
+  clearPageCacheForRoutes = async (e, s) => {
+    const a = $(this.options.path), r = (await U.findByPk(a))?.slug || a;
+    let l = e;
+    (!l || l.length === 0) && (l = s.pageIds ?? []), p.info(`[SiteState] clearing page cache for project ${a}, routes:`, l || []);
+    const n = s.supportedLocales.map((b) => b.locale), c = [], f = l.filter((b) => s.pageIds?.includes(b));
+    for (const b of f) {
+      const y = s.pages[b].slug;
+      r && r !== a && (r === "/" ? c.push(y) : c.push(`${r.startsWith("/") ? "" : "/"}${r}${y}`)), c.push(`/${a}${y}`);
+    }
+    if (c.length > 0)
+      try {
+        const b = is(c, n);
+        p.info(`[SiteState] cleared ${b} page cache entries for project ${a}, routes:`, l);
+      } catch {
+      }
+  };
+  addConnection = (e) => {
+    if (this.conns.has(e))
+      return;
+    this.cancelRelease(), e.binaryType = "arraybuffer", this.conns.set(e, /* @__PURE__ */ new Set()), e.on("message", (o) => this.messageListener(e, new Uint8Array(o)));
+    let s = !0;
+    const a = setInterval(() => {
+      if (!s)
+        this.conns.has(e) && this.closeConn(e), clearInterval(a);
+      else if (this.conns.has(e)) {
+        s = !1;
+        try {
+          e.ping();
+        } catch {
+          this.closeConn(e), clearInterval(a);
+        }
+      }
+    }, ds);
+    e.on("close", () => {
+      this.closeConn(e), clearInterval(a);
+    }), e.on("pong", () => {
+      s = !0;
+    });
+    {
+      const o = v.createEncoder();
+      v.writeVarUint(o, se), Bt(o, this), this.send(e, v.toUint8Array(o));
+      const r = this.awareness.getStates();
+      if (r.size > 0) {
+        const l = v.createEncoder();
+        v.writeVarUint(l, ge), v.writeVarUint8Array(l, _e(this.awareness, Array.from(r.keys()))), this.send(e, v.toUint8Array(l));
+      }
+    }
+  };
+  messageListener = (e, s) => {
+    try {
+      const a = v.createEncoder(), o = fe.createDecoder(s), r = fe.readVarUint(o);
+      switch (p.info(`[SiteState] messageListener, messageType: ${r}`), r) {
+        case se:
+          v.writeVarUint(a, se), Gt(o, a, this, null), p.info(`[SiteState] messageListener, encoder length: ${v.length(a)}`), v.length(a) > 1 && (this.ensureDataStructure(), this.send(e, v.toUint8Array(a)));
+          break;
+        case ge: {
+          Ft(this.awareness, fe.readVarUint8Array(o), e);
+          break;
+        }
+        default:
+          p.warn(`Unsupported messageType ${r}`);
+      }
+    } catch (a) {
+      p.error(a);
+    }
+    this.save();
+  };
+  // 这个方法还是需要动态的，因为可能会动态修改 projectSlug、语言之类的
+  static async pageUrlMap(e, s) {
+    if (p.info(`[SiteState] get pageUrlMap, mode: ${e}, projectId: ${s}`), e === "production") {
+      const r = s ? { projectId: s } : {}, l = await ee.findAll({
+        where: r,
+        raw: !0
+      }), n = {};
+      for (const c of l)
+        n[c.urlPath] = {
+          projectId: c.projectId,
+          projectSlug: c.projectSlug,
+          pageSlug: c.pageSlug,
+          pageId: c.pageId,
+          routeId: c.routeId,
+          locale: c.locale,
+          defaultLocale: c.defaultLocale,
+          shouldRedirect: c.shouldRedirect,
+          mainPage: c.mainPage,
+          isPublic: c.isPublic,
+          publishedAt: c.publishedAt,
+          locales: c.locales
+        };
+      return p.info(`[SiteState] loaded ${l.length} URL mappings from database`), n;
+    }
+    let a = [];
+    s ? a = [s] : a = await this.getProjectIds();
+    let o = {};
+    if (a?.length) {
+      p.info("[SiteState] find project infos from database, projectIds: ", a);
+      const r = 30, l = Re(5);
+      for (let n = 0; n < a.length; n += r) {
+        const c = a.slice(n, n + r);
+        p.info(`[SiteState] processing project batch ${n / r + 1}, ids: `, c);
+        const f = await U.findAll({
+          where: {
+            id: {
+              [Z.in]: c
+            }
+          },
+          attributes: {
+            exclude: ["relatedBlocklets"]
+          }
+        });
+        await Promise.all(
+          f?.map(
+            (b) => l(async () => {
+              const R = b.id, y = b.slug || R, g = {}, u = await k.getStateByProjectId({ projectId: b.id, mode: e, clone: !1 }), I = Lt(
+                E.env.languages?.map((O) => O.code) || [],
+                u.supportedLocales?.map((O) => O.locale) || []
+              ), C = (O, w) => {
+                y && (g[x("/", y, O)] = {
+                  ...w,
+                  shouldRedirect: !0,
+                  mainPage: !0
+                }), g[x("/", R, O)] = {
+                  ...w,
+                  shouldRedirect: !0,
+                  mainPage: !0
+                };
+                for (const D of I) {
+                  const h = { ...w, locale: D };
+                  g[x("/", D, R, O)] = h, y && (g[x("/", D, y, O)] = h);
+                }
+              };
+              if (e === "draft")
+                for (const O of u.routeIds || []) {
+                  const w = u?.routes?.[O];
+                  if (!w) continue;
+                  if (w.params && w.params.length > 0) {
+                    const S = be({
+                      basePath: w.path,
+                      params: w.params,
+                      routeId: w.id,
+                      paramsOptions: w.paramsOptions,
+                      currentIndex: 0,
+                      currentParams: [],
+                      currentOptionIds: [],
+                      result: []
+                    });
+                    for (const i of S) {
+                      const d = i.path, m = {
+                        projectId: R,
+                        projectSlug: y,
+                        pageSlug: d,
+                        pageId: w.displayTemplateId || "",
+                        routeId: O,
+                        // default locale
+                        defaultLocale: I?.[0],
+                        locales: I,
+                        publishedAt: u.config.publishedAt,
+                        isPublic: w.isPublic && i?.routeMetaData?.isPublic
+                      };
+                      C(d, m);
+                    }
+                  }
+                  const D = w.path, h = {
+                    projectId: R,
+                    projectSlug: y,
+                    pageSlug: D,
+                    pageId: w.displayTemplateId || "",
+                    routeId: O,
+                    // default locale
+                    defaultLocale: I?.[0],
+                    locales: I,
+                    publishedAt: u.config.publishedAt,
+                    isPublic: w.isPublic
+                  };
+                  C(D, h);
+                }
+              for (const O of u.pageIds || []) {
+                const w = u.pages[O];
+                if (!w) continue;
+                const D = w.slug, h = b.slug || R, S = {
+                  projectId: R,
+                  projectSlug: h,
+                  pageSlug: D,
+                  pageId: O,
+                  // default locale
+                  defaultLocale: I?.[0],
+                  locales: I,
+                  publishedAt: u.config.publishedAt,
+                  isPublic: w.isPublic,
+                  templateConfig: w.templateConfig
+                };
+                C(D, S);
+              }
+              o = { ...o, ...g };
+            })
+          )
+        );
+      }
+    }
+    return p.info("[SiteState] success get pageUrlMap"), o;
+  }
+  getDocumentSize() {
+    return F.encodeStateAsUpdate(this).byteLength;
+  }
+  static getInstancesSizeInfo() {
+    const e = [];
+    for (const [s, a] of Object.entries(k.sharedInstances)) {
+      const o = a.getDocumentSize();
+      e.push({
+        projectId: s,
+        sizeInBytes: o,
+        sizeInMB: `${(o / (1024 * 1024)).toFixed(2)} MB`,
+        activeConnections: a.conns.size
+      });
+    }
+    return e;
+  }
+  // 启动定期检查
+  static startPeriodicCheck() {
+    this.periodicCheckTimer || (this.periodicCheckTimer = setInterval(() => {
+      this.performPeriodicCheck();
+    }, this.PERIODIC_CHECK_INTERVAL), p.info(
+      `[SiteState] periodic check started, interval: ${this.PERIODIC_CHECK_INTERVAL / (60 * 60 * 1e3)} hours`
+    ));
+  }
+  // 停止定期检查
+  static stopPeriodicCheck() {
+    this.periodicCheckTimer && (clearInterval(this.periodicCheckTimer), this.periodicCheckTimer = void 0, p.info("[SiteState] periodic check stopped"));
+  }
+  // 执行定期检查
+  static performPeriodicCheck() {
+    const e = Object.keys(k.sharedInstances).length, s = [], a = [];
+    for (const [o, r] of Object.entries(k.sharedInstances))
+      r.conns.size === 0 ? s.push({ projectId: o, instance: r }) : a.push({ projectId: o, connections: r.conns.size });
+    if (p.info(
+      `[SiteState] periodic check summary: total instances: ${e}, with connections: ${a.length}, without connections: ${s.length}`
+    ), s.length > 0) {
+      p.info(
+        `[SiteState] releasing ${s.length} instances without connections:`,
+        s.map((r) => r.projectId)
+      );
+      let o = 0;
+      for (const { projectId: r, instance: l } of s)
+        try {
+          p.info(`[SiteState] releasing instance due to periodic check: ${r}`), l.destroy(), o++;
+        } catch (n) {
+          p.error(`[SiteState] failed to release instance ${r} during periodic check:`, n);
+        }
+      p.info(
+        `[SiteState] periodic check completed: ${o}/${s.length} instances released successfully`
+      );
+    } else e > 0 ? p.debug("[SiteState] periodic check: all instances have active connections") : p.debug("[SiteState] periodic check: no instances exist");
+  }
+}
+async function hs(t, e, s) {
+  if (!t || !await G(t) || !(await oe(t)).isFile())
+    return null;
+  let o = s[t];
+  return o || (o = (async () => {
+    try {
+      return (await ps({
+        filePath: t,
+        fileName: e
+      }))?.data?.filename;
+    } catch (r) {
+      return p.error(`Failed to upload asset ${t}:`, r), null;
+    }
+  })(), s[t] = o), o;
+}
+const ys = async (t, e) => {
+  const s = $(t), a = await jt({
+    name: Ye,
+    path: x("/uploads", s),
+    responseType: "stream",
+    method: "GET"
+  });
+  if (a.status >= 200 && a.status < 400) {
+    const o = bt(e);
+    await $t(a.data, o);
+  } else
+    throw new Error(`download asset failed ${a.status}`);
+}, Ss = async (t, e) => {
+  await Promise.all(
+    t.map(async (s) => {
+      try {
+        await ys(s, A(e, $(s)));
+      } catch (a) {
+        p.error(`Failed to export assets: ${s}, ${a}`);
+      }
+    })
+  );
+};
+function et(t) {
+  return ve.test(t) ? [t] : X.test(t) ? (Ve.lastIndex = 0, Array.from(t.matchAll(Ve)).map((s) => s[1]).filter((s) => !!s)) : [];
+}
+async function ae(t, e, s) {
+  const { getFilename: a, exportAssets: o, useWorker: r } = s, l = A(e, a(t));
+  await B(M(l), { recursive: !0 });
+  const n = r ? await ss(t) : q.stringify(t);
+  if (await re(l, n), o) {
+    const f = ie(
+      t,
+      (b) => typeof b == "string" && (ve.test(b) || X.test(b))
+    ).map((b) => {
+      const R = je(t, b);
+      return et(R);
+    }).flat().filter(Boolean);
+    await Ss(f, M(l));
+  }
+}
+const Pe = new Ke({
+  max: 100,
+  ttl: 1 * 60 * 1e3
+  // 1 minute
+});
+async function ze(t, e, s) {
+  const a = ie(
+    t,
+    (n) => typeof n == "string" && (ve.test(n) || X.test(n))
+  ), o = Re(2), r = a.map(
+    (n) => o(async () => {
+      try {
+        const c = je(t, n), f = et(c);
+        for (const b of f) {
+          const R = $(b), y = s.getFilePath(b, n), g = y ? `${y}:${R}` : R, u = Pe.get(g);
+          if (u) {
+            X.test(c) || Me(t, n, u);
+            return;
+          }
+          const I = await hs(y, R, e);
+          I && (X.test(c) || Me(t, n, I), Pe.set(g, I));
+        }
+      } catch (c) {
+        p.error(`Failed to process upload for path ${n.join(".")}:`, c.message || c.reason);
+      }
+    })
+  ), l = await Promise.allSettled(r);
+  s.onFinish?.(l);
+}
+async function ws(t, {
+  exportAssets: e,
+  pageIds: s = "all",
+  componentIds: a = "all",
+  rawConfig: o,
+  includeResources: r = !1,
+  routeIds: l = "all"
+} = {}) {
+  const n = s === "all" ? t.pageIds : s, c = Ot({
+    state: t,
+    pageIds: n,
+    componentIds: a === "all" ? Object.keys(t.components) : a
+  });
+  Object.entries(t.components).forEach(([i, d]) => {
+    d.data?.renderer?.type === "component-template" && c.push(i);
+  });
+  const f = l === "all" ? t.routeIds : l, b = (i) => ({
+    id: i.id,
+    name: i.name,
+    isTemplateSection: i.isTemplateSection ?? !1,
+    templateDescription: i.templateDescription,
+    /** @deprecated 已经废弃，llmConfig 从 component / resources.component 中获取 */
+    // llmConfig: section.llmConfig,
+    component: i.component,
+    config: i.config,
+    visibility: i.visibility,
+    sections: i?.sectionIds ? L(
+      i?.sectionIds?.map((d) => {
+        const m = i.sections?.[d];
+        return m && b(m);
+      })
+    ) : void 0
+    /** @deprecated 已经废弃，数据在 page.dataSource 中管理 */
+    // properties: section.locales?.[locale] ?? {},
+  }), R = (i, d) => ({
+    id: i.id,
+    createdAt: i.createdAt,
+    updatedAt: i.updatedAt,
+    publishedAt: i.publishedAt,
+    isPublic: i.isPublic ?? !0,
+    templateConfig: i.templateConfig,
+    meta: i.locales?.[d] ?? {},
+    sections: L(
+      i.sectionIds.map((m) => {
+        const j = i.sections[m];
+        return j && b(j);
+      })
+    ),
+    // 将 dataSource.sectionId.locale 转换为 dataSource.sectionId
+    dataSource: Object.fromEntries(
+      Object.entries(i.dataSource || {}).map(([m, j]) => [m, j?.[d] ?? {}])
+    )
+  }), y = (i) => ({
+    id: i.id,
+    createdAt: i.createdAt,
+    updatedAt: i.updatedAt,
+    publishedAt: i.publishedAt,
+    path: i.path,
+    handler: i.handler,
+    isPublic: i.isPublic ?? !0,
+    params: i.params ?? [],
+    enabledGenerate: i.enabledGenerate ?? !1,
+    displayTemplateId: i.displayTemplateId,
+    dataSource: i.dataSource
+  }), g = L(
+    f.map((i) => {
+      const d = t.routes[i];
+      return d && y(d);
+    })
+  ), u = L(
+    t.supportedLocales.map((i) => i.locale).flatMap(
+      (i) => n.map((d) => {
+        const m = t.pages[d];
+        return m && {
+          locale: i,
+          slug: m.slug,
+          page: R(m, i)
+        };
+      })
+    )
+  ), I = Ze(), C = A(I, "pages");
+  await B(C, { recursive: !0 });
+  const O = A(I, "components");
+  await B(O, { recursive: !0 });
+  const w = A(I, "routes");
+  await B(w, { recursive: !0 });
+  for (const { locale: i, slug: d, page: m } of u)
+    await ae(m, C, {
+      getFilename: () => `${ce(d) || "index"}.${i}.yml`,
+      exportAssets: e,
+      useWorker: !0
+    });
+  for (const i of g)
+    await ae(i, w, {
+      // getFilename: () => `${sanitizeSlug(route.path)}.yml`,
+      getFilename: () => `${ce(i.path) || "index"}.yml`,
+      exportAssets: e
+    });
+  for (const i of c) {
+    const d = t.components[i]?.data;
+    d && await ae(d, O, {
+      getFilename: (m) => `${m.name || "unnamed"}.${m.id}.yml`,
+      exportAssets: e
+    });
+  }
+  const D = A(I, ".blocklet/pages/pages.config.yml");
+  await B(M(D), { recursive: !0 });
+  const h = {
+    pages: L(
+      n.map((i) => {
+        const d = t.pages[i];
+        return d && { id: i, slug: d.slug };
+      })
+    ),
+    routes: L(
+      f.map((i) => {
+        const d = t.routes[i];
+        return d && { id: i, path: d.path };
+      })
+    ),
+    components: L(
+      c.map((i) => {
+        const d = t.components[i]?.data;
+        return d && {
+          id: i,
+          name: d.name
+        };
+      })
+    ),
+    ...r ? {
+      resources: {
+        components: L(
+          Object.keys(t.resources?.components || {}).filter((i) => c.includes(i)).map((i) => ({
+            id: i,
+            name: t.resources?.components?.[i]?.component?.name
+          }))
+        )
+      }
+    } : {},
+    supportedLocales: t.supportedLocales,
+    config: t.config
+  };
+  await re(D, q.stringify(h));
+  const S = A(I, "config.source.json");
+  if (o && await re(S, JSON.stringify(o)), r) {
+    const i = A(I, "resources"), d = A(i, "components");
+    await B(d, { recursive: !0 });
+    for (const N of Object.keys(t?.resources?.components ?? {}).filter(
+      (T) => c.includes(T)
+    )) {
+      const T = t.resources?.components?.[N]?.component;
+      T && await ae(T, d, {
+        getFilename: (V) => `${V.name || "unnamed"}.${V.id}.yml`,
+        exportAssets: e
+      });
+    }
+    const m = A(I, "chunks");
+    await B(m, { recursive: !0 });
+    const j = await Is();
+    for (const N of Object.keys(t?.resources?.components ?? {}).filter(
+      (T) => c.includes(T)
+    )) {
+      const T = t.resources?.components?.[N]?.component;
+      if (T && T.renderer?.type === "react-component") {
+        const V = T.renderer?.chunks ?? [];
+        if (V?.length > 0)
+          for (const H of V) {
+            const Te = A(m, H), de = j?.[H];
+            try {
+              de && await G(de) && !await G(Te) && await Dt(de, Te);
+            } catch (ct) {
+              p.error(`copy chunk ${H} error`, ct.message);
+            }
+          }
+      }
+    }
+  }
+  return I;
+}
+async function tt(t, { importAssets: e, includeResources: s } = {}) {
+  if (!await G(t))
+    return null;
+  let a, o = !1;
+  try {
+    (await oe(t)).isDirectory() ? a = t : /\.(tgz|gz|tar)$/.test(t) && (o = !0, a = Ze(), await Ut({ file: t, C: a }));
+    const n = (await ye("**/.blocklet/pages/pages.config.yml", { cwd: a, absolute: !0 }))[0], c = n && A(M(n), "../../pages"), f = n && A(M(n), "../../components"), b = n && A(M(n), "../../routes");
+    if (!n)
+      return null;
+    const R = await te(n, "utf-8"), y = q.parse(R), g = async (h, S, i) => {
+      let d = A(h, `${S}${i ? `.${i}` : ""}.yml`);
+      if (!await G(d) && (d = A(h, S, `index${i ? `.${i}` : ""}.yml`), !await G(d)) || !(await oe(d)).isFile())
+        return null;
+      const j = await te(d, "utf-8");
+      return q.parse(j);
+    }, u = async (h, S) => {
+      try {
+        const d = (await ye(`*.${S}.yml`, { cwd: h, absolute: !0 }))[0];
+        if (!d) return null;
+        const m = await te(d, "utf-8");
+        return q.parse(m);
+      } catch (i) {
+        p.error("parse component error", i);
+      }
+      return null;
+    }, I = async (h, S) => {
+      let i = A(h, `${S}.yml`);
+      if (!await G(i) && (i = A(h, S, "index.yml"), !await G(i)) || !(await oe(i)).isFile())
+        return null;
+      const m = await te(i, "utf-8");
+      return q.parse(m);
+    }, C = L(
+      await Promise.all(
+        y.pages.map(async ({ slug: h }) => {
+          const S = L(
+            await Promise.all(
+              y.supportedLocales.map(async ({ locale: m }) => {
+                const j = c ? await g(c, ce(h), m) : void 0;
+                if (j)
+                  return { locale: m, page: j };
+                const N = c ? await g(c, h, m) : void 0;
+                return N && { locale: m, page: N };
+              })
+            )
+          ), i = S[0]?.page;
+          if (!i)
+            return null;
+          const d = i.sections.map(Et);
+          return {
+            id: i.id || Ue(),
+            createdAt: i.createdAt,
+            updatedAt: i.updatedAt,
+            publishedAt: i.publishedAt,
+            isPublic: i.isPublic ?? !0,
+            templateConfig: i.templateConfig,
+            slug: h,
+            sections: Object.fromEntries(d.map((m) => [m.id, m])),
+            sectionIds: d.map((m) => m.id),
+            locales: Object.fromEntries(S.map(({ locale: m, page: j }) => [m, j.meta])),
+            dataSource: i.dataSource ? Object.fromEntries(
+              // 获取 dataSource 中所有 section ID
+              [...new Set(S.flatMap(({ page: m }) => Object.keys(m.dataSource ?? {})))].map((m) => [
+                m,
+                Object.fromEntries(
+                  S.map(({ locale: j, page: N }) => {
+                    const T = N.dataSource?.[m];
+                    return [j, T || {}];
+                  })
+                )
+              ])
+            ) : Object.fromEntries(
+              // 获取所有 section ID
+              [...new Set(S.flatMap(({ page: m }) => m.sections.map((j) => j.id)))].map((m) => [
+                m,
+                Object.fromEntries(
+                  S.map(({ locale: j, page: N }) => {
+                    const T = N.dataSource?.[m];
+                    if (T)
+                      return [j, T];
+                    const V = N.sections.find((H) => H.id === m);
+                    return [j, V?.properties || {}];
+                  })
+                )
+              ])
+            )
+          };
+        })
+      )
+    ), O = L(
+      await Promise.all(
+        (y?.routes || []).map(async ({ path: h }) => {
+          const S = b ? await I(b, ce(h)) : void 0;
+          return {
+            ...S,
+            id: S?.id || Ue(),
+            createdAt: S?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: S?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+            publishedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+            path: S?.path ?? `/${S?.id}`,
+            params: S?.params,
+            handler: S?.handler ?? "Pages Kit",
+            isPublic: S?.isPublic ?? !0,
+            enabledGenerate: S?.enabledGenerate ?? !1,
+            displayTemplateId: S?.displayTemplateId ?? void 0,
+            dataSource: S?.dataSource ?? {}
+          };
+        })
+      )
+    ), w = f ? L(
+      await Promise.all((y.components || []).map(async ({ id: h }) => u(f, h)))
+    ) : [];
+    if (e) {
+      const h = (...S) => {
+        p.info(`[${o ? $(t) : $(A(t, "../../../../"))}] importAssets:`, ...S);
+      };
+      try {
+        h("wait image-bin api ready"), await Nt({
+          resources: [`${Rt(ut)}/api/sdk/uploads`],
+          validateStatus: (d) => d >= 200 && d <= 500
+        }), h("image-bin api is ready");
+        const S = {}, i = {};
+        h("start to upload assets"), await Promise.allSettled([
+          ze(w, S, {
+            getFilePath: (d) => f && A(f, d),
+            onFinish: (d) => {
+              h(`upload ${d.length} component assets`);
+            }
+          }),
+          ze(C, i, {
+            getFilePath: (d, m) => {
+              const j = je(C, m.slice(0, 1));
+              return c && A(c, M(j.slug), d);
+            },
+            onFinish: (d) => {
+              h(`upload ${d.length} page assets`);
+            }
+          })
+        ]), h("upload assets done"), Pe.clear(), global.gc && global.gc();
+      } catch (S) {
+        h("Error during asset import:", S);
+      }
+    }
+    const D = {};
+    if (s) {
+      const h = n && A(M(n), "../../resources/components"), S = L(
+        await Promise.all(
+          (y.resources?.components || []).map(async ({ id: i }) => u(h, i))
+        )
+      );
+      S.length > 0 && (D.components = Object.fromEntries(
+        S.map((i, d) => [i.id, { index: d, component: i }])
+      ));
+    }
+    return {
+      supportedLocales: y.supportedLocales,
+      pageIds: C.map((h) => h.id),
+      components: Object.fromEntries(w.map((h, S) => [h.id, { index: S, data: h }])),
+      pages: Object.fromEntries(C.map((h) => [h.id, h])),
+      config: y.config || {},
+      resources: D,
+      routeIds: O.map((h) => h.id),
+      routes: Object.fromEntries(O.map((h) => [h.id, h])),
+      dataSourceIds: [],
+      dataSources: {}
+    };
+  } finally {
+    o && a && await We(a, { force: !0, recursive: !0 });
+  }
+}
+async function qe(t, e, {
+  routes: s,
+  mergeMode: a = "byUpdateTime",
+  deleteRoutes: o = !1,
+  publishMode: r = void 0
+} = {}) {
+  try {
+    r && dt(r);
+  } catch (y) {
+    p.error("clear preload page cache error", { error: y });
+  }
+  const { pages: l, pageIds: n, routeIds: c, routes: f, supportedLocales: b } = t;
+  if (r === "production") {
+    let y = s ?? [], g = null;
+    for (const u of c ?? []) {
+      const I = f?.[u];
+      if (I?.params && I?.params.length > 0 && I?.paramsOptions && I?.paramsOptions.length > 0) {
+        const C = be({
+          basePath: I.path,
+          params: I.params,
+          routeId: I.id,
+          paramsOptions: I.paramsOptions,
+          currentIndex: 0,
+          currentParams: [],
+          currentOptionIds: [],
+          result: []
+        }), O = Object.fromEntries(C.map((w) => [`${u}-${w.paramOptionIds.join("-")}`, w]));
+        g = { ...g || {}, ...O }, s || (y = [...y, ...C.map((w) => `${u}-${w.paramOptionIds.join("-")}`)]);
+      } else s || y.push(u);
+    }
+    p.info("routeIds to be published: ", y);
+    for (const u of y) {
+      let I = u;
+      if (I.includes("-")) {
+        const [w] = I.split("-");
+        I = w;
+      }
+      const C = f?.[I];
+      if (!C) {
+        const w = e.pageIds.indexOf(I);
+        w !== -1 && o && (e.pageIds.splice(w, 1), delete e.pages[I]);
+        for (const D of e.pageIds)
+          D.includes(`${I}-`) && (e.pageIds.splice(e.pageIds.indexOf(D), 1), delete e.pages[D]);
+        p.info("delete main route page", I);
+        continue;
+      }
+      if (u.includes("-") && !g?.[u]) {
+        const w = e.pageIds.indexOf(u);
+        w !== -1 && o && (e.pageIds.splice(w, 1), delete e.pages[u]), p.info("delete page", u);
+        continue;
+      }
+      if (!C.displayTemplateId) {
+        p.info("no display template", u);
+        continue;
+      }
+      const O = l[C.displayTemplateId];
+      if (!O) {
+        p.info("no template page", u);
+        continue;
+      }
+      if (e.pageIds.includes(u)) {
+        if (p.info("has need update page", u), a === "replace")
+          e.pages[u] = me({
+            page: O,
+            route: C,
+            state: t,
+            routeId: u,
+            routePathInfo: g?.[u]
+          }), p.info("replace page", u);
+        else if (a === "byUpdateTime") {
+          const w = e.pages[C.id];
+          (!w || C.updatedAt && C.updatedAt > w.updatedAt) && (e.pages[u] = me({
+            page: O,
+            route: C,
+            state: t,
+            routeId: u,
+            routePathInfo: g?.[u]
+          }), p.info("replace page by update time", u));
+        }
+      } else
+        e.pageIds.push(u), e.pages[u] = me({
+          page: O,
+          route: C,
+          state: t,
+          routeId: u,
+          routePathInfo: g?.[u]
+        }), p.info("add page", u);
+    }
+    if (o && !s)
+      for (const u of e.pageIds)
+        y?.includes(u) || (delete e.pages[u], p.info("delete page", u)), e.pageIds = [...e.pageIds].filter((I) => y?.includes(I));
+  } else {
+    for (const y of n) {
+      const g = l[y];
+      if (g)
+        if (e.pageIds.includes(g.id)) {
+          if (a === "replace")
+            e.pages[g.id] = g;
+          else if (a === "byUpdateTime") {
+            const u = e.pages[g.id];
+            (!u || g.updatedAt && g.updatedAt > u.updatedAt) && (e.pages[g.id] = g);
+          }
+        } else
+          e.pageIds.push(g.id), e.pages[g.id] = g;
+    }
+    for (const y of c) {
+      const g = f[y];
+      if (g)
+        if (e.routeIds.includes(g.id)) {
+          if (a === "replace")
+            e.routes[g.id] = g;
+          else if (a === "byUpdateTime") {
+            const u = e.routes[g.id];
+            (!u || g.updatedAt && g.updatedAt > u.updatedAt) && (e.routes[g.id] = g);
+          }
+        } else
+          e.routeIds.push(g.id), e.routes[g.id] = g;
+    }
+  }
+  if (e.supportedLocales.splice(0, e.supportedLocales.length), e.supportedLocales.push(...Ae(b)), o)
+    for (const y of Object.keys(e.components))
+      delete e.components[y];
+  let R = JSON.parse(JSON.stringify(t.components));
+  R = Object.fromEntries(
+    await Promise.all(
+      Object.entries(R).map(async ([y, g]) => {
+        const u = await st(g?.data);
+        return [
+          y,
+          {
+            ...g,
+            data: u
+          }
+        ];
+      })
+    )
+  ), Object.assign(e.components, R), Object.assign(e.config, JSON.parse(JSON.stringify(t.config))), ke(t.resources.components) || (e.resources.components = JSON.parse(JSON.stringify(t.resources.components || {})));
+}
+const st = lt(
+  async (t) => {
+    if (!ke(t?.properties))
+      return t;
+    if (t?.renderer?.type === "react-component") {
+      const { script: e, PROPERTIES_SCHEMA: s } = t?.renderer || {};
+      if (s || e && e.includes("PROPERTIES_SCHEMA"))
+        try {
+          const a = await pt(
+            e ?? "",
+            "PROPERTIES_SCHEMA",
+            t.id,
+            s
+          );
+          a && a.length > 0 && t && (t.properties = {}, a.forEach((o, r) => {
+            t?.properties && (t.properties[o.id] = {
+              index: r,
+              data: o
+            });
+          }));
+        } catch (a) {
+          p.error("getPropertiesFromCode error", { componentId: t.id, name: t.name }, { error: a });
+        }
+    }
+    return t;
+  },
+  {
+    subdir: "getPropertiesFromCode"
+  }
+);
+let le, Q, pe, ue;
+const at = () => Ct({
+  types: [
+    { did: Ye, type: xe },
+    { did: Jt, type: xe }
+  ]
+}), Is = async () => {
+  const t = at(), e = {};
+  for (const s of t) {
+    const o = (await ye("**/.blocklet/pages/pages.config.yml", {
+      cwd: s.path,
+      absolute: !0
+    }))[0], r = o && A(M(o), "../../chunks");
+    if (r && await G(r)) {
+      const l = await vt(r);
+      for (const n of l)
+        e[n] = A(r, n);
+    }
+  }
+  return e;
+};
+function ot() {
+  return le = (async () => {
+    const t = at();
+    Q = (await Promise.all(
+      t.map(async (s) => {
+        const a = s.path ? await tt(s.path, { importAssets: !1 }) : void 0;
+        return a ? { blockletId: s.did, state: a, blockletTitle: s.title } : void 0;
+      })
+    )).filter((s) => !!s), pe = Q.reduce(
+      (s, a) => Object.assign(
+        s,
+        Object.fromEntries(
+          Object.values(a.state.pages).map((o) => o ? [o?.id, { page: o, blockletId: a.blockletId }] : [])
+        )
+      ),
+      {}
+    );
+    const e = Q.reduce(
+      (s, a) => Object.assign(
+        s,
+        Object.fromEntries(
+          Object.values(a.state.components).map((o) => [o.data.id, { blockletId: a.blockletId, component: o.data }])
+        )
+      ),
+      {}
+    );
+    ue = Object.fromEntries(
+      await Promise.all(
+        Object.entries(e).map(async ([s, a]) => {
+          const o = await st(a.component);
+          return [
+            s,
+            {
+              ...a,
+              component: o
+            }
+          ];
+        })
+      )
+    );
+  })(), le;
+}
+function Ps(t) {
+  const e = Ce(
+    async () => {
+      await ot().catch((s) => {
+        p.error("load resource states error", { error: s });
+      }), await t?.({
+        states: Q,
+        pages: pe,
+        components: ue
+      });
+    },
+    3e3,
+    // 3s
+    { leading: !1, trailing: !0 }
+  );
+  return e(), E.events.on(E.Events.componentAdded, e), E.events.on(E.Events.componentRemoved, e), E.events.on(E.Events.componentStarted, e), E.events.on(E.Events.componentStopped, e), E.events.on(E.Events.componentUpdated, e), E.events.on(we, e), () => {
+    E.events.off(E.Events.componentAdded, e), E.events.off(E.Events.componentRemoved, e), E.events.off(E.Events.componentStarted, e), E.events.off(E.Events.componentStopped, e), E.events.off(E.Events.componentUpdated, e), E.events.off(we, e);
+  };
+}
+const rt = Symbol.for("GLOBAL_RESOURCE_STATES_LISTENER_KEY"), nt = globalThis;
+nt[rt]?.();
+nt[rt] = Ps(async ({ pages: t, components: e }) => {
+  const s = await k.getProjectIds();
+  p.info(`start update resource states projects(${s.length})`, s);
+  const a = Re(10);
+  await Promise.race([
+    new Promise((o) => {
+      setTimeout(() => {
+        o({});
+      }, 30 * 1e3);
+    }),
+    Promise.all(
+      s.map(
+        (o) => a(async () => {
+          it({
+            projectId: o,
+            pages: t,
+            components: e
+          });
+        })
+      )
+    )
+  ]).catch((o) => {
+    p.error("update resource states failed:", o);
+  });
+});
+k.startPeriodicCheck();
+process.on("beforeExit", () => {
+  k.stopPeriodicCheck();
+});
+process.on("SIGINT", () => {
+  k.stopPeriodicCheck(), process.exit(0);
+});
+process.on("SIGTERM", () => {
+  k.stopPeriodicCheck(), process.exit(0);
+});
+async function it({
+  projectId: t,
+  pages: e,
+  components: s
+}) {
+  const a = k.sharedInstances[t];
+  if (!a) {
+    p.info(`projectId: ${t} not found in sharedInstances`);
+    return;
+  }
+  const o = a.syncedStore.resources.pages, r = a.syncedStore.resources.components, l = await U.findByPk(t, {
+    attributes: { exclude: ["productionState", "relatedBlocklets"] }
+  });
+  let n;
+  if (l?.useAllResources)
+    n = s;
+  else {
+    const R = (await De.findAll({ where: { projectId: t } })).map((y) => y.componentId);
+    n = Object.fromEntries(Object.entries(s || {}).filter(([y]) => R.includes(y)));
+  }
+  const c = !Ge(o, e), f = !Ge(r, n);
+  c || f ? a.transact(() => {
+    c && (a.syncedStore.resources.pages = e, p.info(`[${t}] pages resources updated: ${Object.keys(e || {}).length} pages`)), f && (a.syncedStore.resources.components = n, p.info(
+      `[${t}] components resources updated: ${Object.keys(n || {}).length} components`
+    ));
+  }) : p.info(`[${t}] resource states unchanged, skipping update`), p.info(`update [${t}] resource states summary:`, {
+    pages: Object.keys(a.syncedStore.resources.pages || {}).length,
+    components: Object.keys(a.syncedStore.resources.components || {}).length,
+    pagesChanged: c,
+    componentsChanged: f
+  });
+}
+const he = /* @__PURE__ */ new Map();
+async function bs(t) {
+  if (!he.has(t)) {
+    const e = Ce(async (s) => it({
+      projectId: s,
+      pages: pe,
+      components: ue
+    }), 3e3);
+    he.set(t, e);
+  }
+  return he.get(t)(t);
+}
+async function ia() {
+  p.info("trigger reload all project resource"), E.events.emit(we);
+}
+async function ca({
+  ensureLoaded: t = !0
+} = {}) {
+  return t && (le ??= ot(), await le), { states: Q, pages: pe, components: ue };
+}
+export {
+  Ye as C,
+  U as P,
+  xe as R,
+  k as S,
+  K as a,
+  ra as b,
+  oa as c,
+  na as d,
+  gs as e,
+  ys as f,
+  ca as g,
+  Ss as h,
+  tt as i,
+  Ps as j,
+  ia as k,
+  qe as m,
+  ws as t,
+  bs as u
+};