@blocklet/pages-kit-inner-components 0.6.7 → 0.6.9

package/lib/es/chunks/components-BWQM8y6L.js

@@ -0,0 +1,608 @@
+import { getComponentMountPoint as Q } from "@blocklet/pages-kit/builtin/utils";
+import { PreloadComponentScriptModule as P } from "@blocklet/pages-kit/types";
+import { componentUMDName as z, RenderNestedComponent as j, mergeComponent as Z } from "@blocklet/pages-kit/utils/property";
+import { memoize as X, BuiltinModules as I } from "@blocklet/quickjs";
+import { BuiltinModules as M } from "@blocklet/pages-kit/utils/builtin";
+import h from "@blocklet/sdk/lib/config";
+import { LRUCache as Y } from "lru-cache";
+import q, { Headers as ee } from "node-fetch";
+import { joinURL as A, getQuery as te, withQuery as oe, parseURL as D, withHttps as ne } from "ufo";
+import re from "lodash/isEmpty";
+import { createHash as se } from "crypto";
+import { promises as g } from "fs";
+import U, { join as b } from "path";
+import ce from "lodash/isNil";
+import ae from "@blocklet/logger";
+import { isRelativeModule as ie, createBuiltinModuleTransformer as pe } from "@blocklet/pages-kit/utils/typescript/builtin-module-transformer";
+import "@blocklet/sdk/lib/component";
+h.env.mode;
+h.env.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+h.env.OPENAI_BASE_URL || process.env.OPENAI_BASE_URL;
+h.env.TRANSLATE_ADDITIONAL_PROMPT || process.env.TRANSLATE_ADDITIONAL_PROMPT;
+h.env.PAGE_CONTENT_ADDITIONAL_PROMPT || process.env.PAGE_CONTENT_ADDITIONAL_PROMPT;
+const qe = "image-bin";
+h.env.INIT_TEMPLATE_PATH;
+const et = process.env.DATABASE_URL || U.join(h.env.dataDir, "db/pages-kit.db"), L = h, tt = () => h.env.tenantMode === "multiple", ot = () => (ce(L.env.preferences.multiTenantAllProjectAccessPassports) ? [] : L.env.preferences.multiTenantAllProjectAccessPassports?.split(",")) || [], le = U.join(h.env.dataDir, "fs-memoize-cache"), ue = h.env.FS_MEMOIZE_CACHE_VERSION || "v1.0.0", w = ae("pages-kit"), de = le, me = ue, _ = 30 * 24 * 60 * 60 * 1e3, fe = 24 * 60 * 60 * 1e3, B = async (e = "") => {
+  const t = b(de, e);
+  try {
+    if (!(await g.stat(t)).isDirectory())
+      throw new Error(`${t} is not a directory`);
+  } catch {
+    await g.mkdir(t, { recursive: !0 });
+  }
+  return t;
+}, $ = (e, ...t) => e.keyGenerator ? e.keyGenerator(...t) : JSON.stringify([e.subdir || "", ...t]), he = (e, t) => {
+  const o = se("md5").update(t).digest("hex");
+  return b(e, `${me}-${o}.json`);
+}, we = async (e = "") => {
+  const t = await B(e), o = Date.now();
+  try {
+    const n = await g.readdir(t);
+    await Promise.all(
+      n.filter((c) => c.endsWith(".json")).map(async (c) => {
+        const r = b(t, c);
+        try {
+          const u = await g.readFile(r, "utf-8"), p = JSON.parse(u);
+          p.createdAt && o - p.createdAt > _ && await g.unlink(r);
+        } catch {
+          try {
+            const p = await g.stat(r);
+            o - p.mtimeMs > _ && await g.unlink(r);
+          } catch {
+          }
+        }
+      })
+    );
+  } catch (n) {
+    console.error(`Failed to cleanup cache in ${t}:`, n);
+  }
+}, ge = (() => {
+  const e = /* @__PURE__ */ new Set();
+  return setInterval(async () => {
+    await Promise.all(Array.from(e).map((n) => we(n)));
+  }, fe).unref(), (n) => {
+    e.add(n);
+  };
+})();
+function O(e, t) {
+  return t.subdir && ge(t.subdir), X(
+    async (...n) => {
+      const c = await B(t.subdir || ""), r = $(t, ...n), u = he(c, r);
+      try {
+        const p = await g.readFile(u, "utf-8"), { value: d, createdAt: l } = JSON.parse(p);
+        if (l && Date.now() - l > _)
+          throw await g.unlink(u).catch(() => {
+          }), new Error("Cache expired");
+        return d;
+      } catch {
+        const d = await e(...n), l = JSON.stringify({ value: d, createdAt: Date.now() });
+        return g.writeFile(u, l, "utf-8").catch((m) => {
+          console.error("Failed to write fs cache:", m);
+        }), d;
+      }
+    },
+    {
+      keyGenerator: (...n) => $(t, ...n),
+      lruOptions: t.lruOptions || {
+        max: 100,
+        ttl: _
+      }
+    }
+  );
+}
+const H = async () => await import("typescript"), ye = async () => await import("esbuild"), Ee = async () => (await import("postcss")).default, Se = async () => (await import("tailwindcss")).default, xe = async () => (await import("autoprefixer")).default, Ce = !1, Pe = async (e, { componentId: t }) => {
+  const o = `@tailwind components;
+@tailwind utilities;
+`, n = `.CustomComponent_${t}`, c = await Ee(), r = await Se(), u = await xe();
+  return (await c([
+    r({ content: [{ raw: e, extension: "tsx" }] }),
+    u({
+      overrideBrowserslist: ["> 1%", "last 2 versions"],
+      stats: {}
+    }),
+    (d) => {
+      d.walkRules((l) => {
+        l.selectors = l.selectors.map((m) => m.replace(/\.(.+)/g, `${n}.$1,${n} .$1`));
+      });
+    }
+    // FIXME: cssnano use browserslist, it is not working with the fs isolation
+    // cssnano({ preset: 'default' }),
+  ]).process(o)).css;
+}, Te = async (e, { componentId: t }) => {
+  const o = await Pe(e, { componentId: t });
+  return `export const __PagesKit_CSS__ = ${JSON.stringify(o)};
+
+${e}
+`;
+}, k = O(
+  async (e, t) => {
+    let o = await H();
+    try {
+      let n = o.transpileModule(e, {
+        compilerOptions: {
+          jsx: o.JsxEmit.React,
+          target: o.ScriptTarget.ES2016,
+          module: o.ModuleKind.ESNext
+        },
+        transformers: {
+          before: [pe(o)]
+        }
+      }).outputText;
+      if (t.tailwind && (n = await Te(n, { componentId: t.componentId })), t.module === P.ESM) return n;
+      const c = o.transpileModule(n, {
+        compilerOptions: {
+          jsx: o.JsxEmit.React,
+          target: o.ScriptTarget.ES2016,
+          module: o.ModuleKind.CommonJS,
+          moduleResolution: o.ModuleResolutionKind.Node16
+        }
+      }).outputText;
+      return t.module === P.CJS ? c : J(t.moduleName, c);
+    } catch (n) {
+      throw new Error(n);
+    } finally {
+      o = null;
+    }
+  },
+  {
+    subdir: "transpileModule"
+  }
+), _e = async (e, t) => {
+  let { build: o } = await ye(), n = null;
+  try {
+    const r = (await o({
+      entryPoints: ["index.tsx"],
+      external: Object.keys(M),
+      format: "esm",
+      target: "esnext",
+      bundle: !0,
+      write: !1,
+      plugins: [
+        {
+          name: "vfs",
+          setup(d) {
+            d.onResolve({ filter: /.*/ }, (l) => l.path === "index.tsx" ? { path: "index.tsx", namespace: "vfs" } : l.path === "./component" ? { path: "component.tsx", namespace: "vfs" } : null), d.onLoad({ filter: /.*/, namespace: "vfs" }, async (l) => {
+              if (l.path === "index.tsx")
+                return { contents: `export { ${t} } from './component'`, loader: "tsx" };
+              if (l.path === "component.tsx")
+                return { contents: e, loader: "tsx" };
+              if (ie(l.path)) {
+                const m = l.path.split("/").pop();
+              }
+              return null;
+            });
+          }
+        }
+      ]
+    })).outputFiles?.[0]?.contents;
+    if (!r) throw new Error("Failed to build server code");
+    const u = Buffer.from(r).toString();
+    return n = await H(), n.transpileModule(u, {
+      compilerOptions: { module: n.ModuleKind.ESNext, target: n.ScriptTarget.ES2020 }
+    }).outputText;
+  } catch (c) {
+    throw new Error(c);
+  } finally {
+    o = null, n = null;
+  }
+}, ve = (e, t) => new RegExp(
+  `export\\s+\\{[^}]*(?:\\w+\\s+as\\s+${t}\\b|\\b${t}\\b)[^}]*\\}`,
+  "m"
+).test(e) ? e : void 0, K = O(
+  async (e, t) => {
+    const o = await _e(e, t);
+    return ve(o, t);
+  },
+  {
+    subdir: "extractExportValueSchema"
+  }
+), J = (e, t) => `// GENERATED FILE. DO NOT EDIT.
+var ${e} = async function () {
+
+  const exports = {};
+  let moduleExports = null;
+  
+  // add commonjs module compatibility layer
+  const module = { exports: moduleExports };
+  
+  // execute component code
+  ${t}
+  
+  // handle possible module.exports
+  if (module.exports && module.exports !== moduleExports) {
+    // if module.exports is used, use it first
+    return typeof module.exports === 'object' ? module.exports : { default: module.exports };
+  }
+  
+  // ensure a default export
+  if (!('default' in exports) && Object.keys(exports).length === 0) {
+    // module has no exports, return null to indicate invalid
+    return null;
+  }
+  
+  return exports;
+};
+`, G = async () => {
+  const { Sandbox: e } = await import("@blocklet/quickjs");
+  return e;
+};
+function Ie(e) {
+  return e?.type === "react-component";
+}
+const x = new Y({
+  max: 100,
+  ttl: 1e3 * 60 * 60 * 24
+  // 24 hours
+}), Ae = 60 * 60, F = 10;
+function V(e) {
+  w.info("clear preload components cache", { cacheKey: e }), x.delete(e);
+}
+function nt(e) {
+  for (const t of x.keys())
+    t.includes(e) && (w.info("clear preload components cache", { cacheKey: t }), V(t));
+}
+function rt(e) {
+  for (const t of x.keys())
+    t.includes(e) && (w.info("clear preload components cache", { cacheKey: t }), V(t));
+}
+function Me({
+  mode: e,
+  instanceId: t,
+  componentId: o,
+  locale: n
+}) {
+  return ["getPreloadComponents", e, t, o, n].join("-");
+}
+async function st({
+  mode: e,
+  req: t,
+  state: o,
+  locale: n,
+  instances: c,
+  module: r
+}) {
+  const {
+    supportedLocales: u,
+    config: { defaultLocale: p }
+  } = o;
+  if (!p) return null;
+  const d = (await Promise.all(
+    c.map(async (s) => {
+      try {
+        const a = Me({
+          mode: e,
+          instanceId: s.id,
+          componentId: s.componentId,
+          locale: n
+        });
+        if (e !== "draft" && s.useCache && x.has(a))
+          return w.info(`get preload component from cache: ${a}`), x.get(a);
+        const f = v({ state: o, componentId: s.componentId });
+        if (!f) return null;
+        const S = await be({
+          req: t,
+          state: o,
+          componentId: f.id,
+          locale: n,
+          defaultLocale: p,
+          properties: s.properties
+        });
+        if (!S) return null;
+        const C = { instanceId: s.id, preload: S };
+        if (e !== "draft" && s.useCache) {
+          let E = Ae;
+          s.cacheDuration && (E = s.cacheDuration), w.info(`set preload component to cache(${E}s): ${a}`), x.set(a, C, {
+            ttl: E * 1e3
+          });
+        }
+        return C;
+      } catch (a) {
+        return w.error("get preload component error", { instanceId: s.id, componentId: s.componentId }, { error: a }), null;
+      }
+    })
+  )).filter((s) => !!s), l = Object.values(
+    d.reduce((s, a) => ({ ...s, ...a.preload.components }), {})
+  );
+  async function m() {
+    const s = await Promise.all(
+      l.map(async (a) => {
+        const f = r === P.ESM, S = r === P.UMD_FN, C = r === P.CJS, E = f ? "" : z({ componentId: a.component.id }), N = je(a.component);
+        let T = {
+          module: r,
+          script: "",
+          moduleName: E
+        };
+        if (N && a.component.renderer?.type === "react-component" && f && a.component.renderer?.script)
+          T.script = a.component.renderer?.script;
+        else if (N && a.component.renderer?.type === "react-component" && (C || S) && a.component.renderer?.cjsScript) {
+          const R = a.component.renderer.cjsScript;
+          T.script = C ? R : J(E, R);
+        } else
+          T = f ? {
+            // ESM
+            module: r,
+            script: await k(a.script, {
+              componentId: a.component.id,
+              module: r,
+              tailwind: e !== "draft"
+            })
+          } : {
+            // CJS OR UMD
+            module: r,
+            script: await k(a.script, {
+              componentId: a.component.id,
+              module: r,
+              moduleName: E,
+              tailwind: e !== "draft"
+            }),
+            moduleName: E
+          };
+        return [a.component.id, { component: a.component, script: T }];
+      })
+    );
+    return Object.fromEntries(s);
+  }
+  const y = await m();
+  return {
+    config: { defaultLocale: p, supportedLocales: u },
+    components: y,
+    instances: d.map((s) => ({
+      id: s.instanceId,
+      componentId: s.preload.component.id,
+      locales: { [s.preload.locale]: { props: s.preload.props } }
+    }))
+  };
+}
+async function be({
+  req: e,
+  state: t,
+  componentId: o,
+  locale: n,
+  defaultLocale: c,
+  properties: r
+}) {
+  const { supportedLocales: u } = t, p = v({ state: t, componentId: o });
+  if (!p) return null;
+  const d = u.some((m) => m.locale === n) ? n : c;
+  if (!d) return null;
+  const l = await W({ req: e, state: t, componentId: o, locale: d, defaultLocale: c, properties: r });
+  return l ? {
+    component: p,
+    ...l
+  } : null;
+}
+const Oe = 20;
+async function W({
+  req: e,
+  depth: t = 0,
+  state: o,
+  componentId: n,
+  locale: c,
+  defaultLocale: r,
+  properties: u
+}) {
+  if (t > Oe) throw new RangeError("max component depth exceeded");
+  const p = Ne({ state: o, componentId: n, properties: u, locale: c });
+  if (!p) return null;
+  const { props: d, component: l } = p, m = {
+    locale: c || r,
+    components: { [p.component.id]: { component: p.component, script: p.script } },
+    props: { ...d }
+  };
+  try {
+    const y = Ie(l.renderer) ? l.renderer.getServerSideProps : void 0, i = await Re({ ...p, req: e, getServerSideProps: y });
+    i?.props && Object.assign(m.props, i.props);
+  } catch (y) {
+    w.error("preload data at server side error", { componentId: n, name: p.component.name }, { error: y });
+  }
+  return await Promise.all(
+    Object.entries(d).map(async ([y, i]) => {
+      if (i?.type === j) {
+        const s = await W({
+          req: e,
+          depth: t + 1,
+          state: o,
+          componentId: i.componentId,
+          locale: c,
+          defaultLocale: r,
+          properties: i.properties
+        });
+        s && (Object.assign(m.components, s.components), Object.assign(m.props, {
+          [y]: {
+            type: j,
+            componentId: i.componentId,
+            props: s.props
+          }
+        }));
+      }
+    })
+  ), m;
+}
+function Ne({
+  state: e,
+  componentId: t,
+  locale: o,
+  properties: n
+}) {
+  const c = v({ state: e, componentId: t });
+  if (!c) return null;
+  const r = Z({
+    componentId: t,
+    getComponent: (u) => v({ state: e, componentId: u }),
+    locale: o,
+    defaultLocale: e.config.defaultLocale,
+    properties: n
+  });
+  return r ? { component: c, script: r.script, props: { locale: o, ...r.props } } : null;
+}
+function v({ state: e, componentId: t }) {
+  return e.components[t]?.data ?? e.resources.components?.[t]?.component;
+}
+function ct({ state: e, name: t }) {
+  const o = t.toLowerCase();
+  return Object.values(e.components).find((n) => n.data.name?.toLowerCase() === o)?.data ?? (e.resources.components && Object.values(e.resources.components).find((n) => n.component.name?.toLowerCase() === o))?.component;
+}
+async function Re({
+  component: e,
+  script: t,
+  props: o,
+  req: n,
+  getServerSideProps: c
+}) {
+  if (!c && !t?.includes("getServerSideProps"))
+    return null;
+  const r = c ?? await K(t, "getServerSideProps");
+  if (!r) return null;
+  const p = (r.match(/export\s*{\s*(\w+)\s+as\s+getServerSideProps\s*}/) || r.match(/export\s*{\s*getServerSideProps\s*}/))?.[1] || "getServerSideProps", d = new Promise((i) => {
+    setTimeout(() => {
+      i({});
+    }, F * 1e3);
+  });
+  let l = await G();
+  const m = {
+    componentMountPoints: h.components
+  };
+  return await Promise.race([
+    d,
+    l.callFunction({
+      code: `${r}
+
+export async function getServerSidePropsWrapper(props) {
+const { location, fetch, props: componentProps } = props;
+// 使用局部变量而不是全局变量
+const originalLocation = typeof window !== 'undefined' ? window.location : undefined;
+const originalFetch = globalThis.fetch;
+
+try {
+  globalThis.location = location;
+  globalThis.fetch = fetch;
+  return await ${p}(componentProps);
+} finally {
+  // 清理全局状态
+  if (originalLocation) globalThis.location = originalLocation;
+  if (originalFetch) globalThis.fetch = originalFetch;
+}
+}`,
+      filename: `${e.name || e.id}.js`,
+      moduleLoader: (i) => {
+        if (i === "@blocklet/pages-kit/builtin/utils")
+          return `          const { joinURL, withQuery, getQuery, getComponentMountPoint } = globalThis
+          export { joinURL, withQuery, getQuery, getComponentMountPoint }
+        `;
+        if (i === "@blocklet/pages-kit/builtin/dayjs")
+          return I.dayjs;
+        if (i in I)
+          return I[i];
+        if (i in M) {
+          const s = M[i];
+          return re(s) ? void 0 : s;
+        }
+      },
+      global: {
+        console: {
+          // NOTE: do not return logger.xxx result, it will cause memory leak
+          // eslint-disable-next-line prettier/prettier
+          log: (...i) => {
+            w.info(...i);
+          },
+          warn: (...i) => {
+            w.warn(...i);
+          },
+          error: (...i) => {
+            w.error(...i);
+          }
+        },
+        getComponentMountPoint: Q,
+        joinURL: A,
+        withQuery: oe,
+        getQuery: te,
+        window: {
+          blocklet: m
+        },
+        blocklet: m
+      },
+      functionName: "getServerSidePropsWrapper",
+      args: [
+        {
+          // NOTE: IMPORTANT! place location and fetch (has side effect) at the args not global
+          // because the global is shared between all runtime and just init once
+          location: { href: A(ne(n.hostname), n.originalUrl) },
+          fetch: (i, { ...s } = {}) => {
+            const a = typeof i == "string" && i.startsWith("/") ? A(h.env.appUrl, i) : i;
+            if (typeof a == "string" && D(a).host === D(h.env.appUrl).host) {
+              const f = n.get("cookie");
+              if (f) {
+                const S = new ee(s.headers);
+                S.set("cookie", f), s.headers = S;
+              }
+            }
+            return q(a, {
+              ...s,
+              timeout: F * 1e3
+            }).then((f) => ({
+              ok: f.ok,
+              status: f.status,
+              statusText: f.statusText,
+              headers: Object.fromEntries(f.headers.entries()),
+              json: () => f.json()
+            }));
+          },
+          props: o
+        }
+      ]
+    }).finally(() => {
+      l = null;
+    })
+  ]);
+}
+const at = O(
+  async (e, t, o, n) => {
+    if (!e?.includes(t) && !n)
+      return null;
+    const c = n ?? await K(e, t);
+    if (c)
+      try {
+        let r = await G();
+        return await r.callFunction({
+          cache: !0,
+          code: `
+            ${c}
+
+            export function get${t}SchemaWrapper() {
+              return ${t};
+            }
+          `,
+          filename: `${o}.js`,
+          functionName: `get${t}SchemaWrapper`
+        }).finally(() => {
+          r = null;
+        });
+      } catch (r) {
+        return w.error(`获取 ${t} 失败`, { componentId: o, error: r }), null;
+      }
+    return null;
+  },
+  {
+    subdir: "getExportSchemaValueFromCode"
+  }
+), je = (e) => !!(e.renderer?.type === "react-component" && e.version && e.version >= 2);
+export {
+  Ae as C,
+  F as G,
+  qe as I,
+  ot as a,
+  at as b,
+  nt as c,
+  et as d,
+  V as e,
+  rt as f,
+  st as g,
+  Me as h,
+  tt as i,
+  be as j,
+  v as k,
+  w as l,
+  O as m,
+  ct as n,
+  je as s
+};

package/lib/es/chunks/{draft-data-CafrGKeh.js → draft-data-BiayOfQz.js}

@@ -1,5 +1,5 @@
 import { jsx as e } from "react/jsx-runtime";
-import { u as a, S as o, g as s, a as n } from "./state-0gvZF3k2.js";
+import { u as a, S as o, g as s, a as n } from "./state-C3hsEhCe.js";
 function d({ children: t }) {
   const r = a();
   return /* @__PURE__ */ e(o, { url: s(r ?? ""), name: "root", waitingSynced: !0, children: /* @__PURE__ */ e(i, { children: t }) });

package/lib/es/chunks/{home-DW8SdyfO.js → home-DBc-g4K0.js}

@@ -1,5 +1,5 @@
 import { jsx as e, jsxs as R } from "react/jsx-runtime";
-import { u as z, c as U, d as re, e as ae, f as se, b as ie } from "./state-0gvZF3k2.js";
+import { u as z, c as U, d as re, e as ae, f as se, b as ie } from "./state-C3hsEhCe.js";
 import { useLocaleContext as V } from "@arcblock/ux/lib/Locale/context";
 import G from "@arcblock/ux/lib/Result";
 import { styled as M, useTheme as ce } from "@arcblock/ux/lib/Theme";
@@ -21,7 +21,7 @@ import { Helmet as ke } from "react-helmet";
 import { useSearchParams as ee, Routes as Se, Route as S, Navigate as Ce, ScrollRestoration as Ie } from "react-router-dom";
 import { useAsync as te } from "react-use";
 import { joinURL as w } from "ufo";
-import { S as Te, P as je, a as Re, B as Oe, g as Ee } from "./index-D5gXPe_7.js";
+import { S as Te, P as je, a as Re, B as Oe, g as Ee } from "./index-DaF8ujCZ.js";
 import Me from "@blocklet/ui-react/lib/Footer";
 import "webfontloader";
 import { u as Ae, a as Be } from "./session-C72Dq8zg.js";
@@ -114,7 +114,7 @@ function ze({ mode: t }) {
   }
   return /* @__PURE__ */ e(Ve, { children: ({ state: o }) => /* @__PURE__ */ e(F, { mode: t, state: o }) });
 }
-const Ue = X(() => import("./publish-button-XSZrDaTQ.js")), Ve = X(() => import("./draft-data-CafrGKeh.js"));
+const Ue = X(() => import("./publish-button-DiKDLFU8.js")), Ve = X(() => import("./draft-data-BiayOfQz.js"));
 function Ge({
   mode: t,
   children: o