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

package/lib/es/chunks/components-B8AH-ivu.js

@@ -0,0 +1,596 @@
+import { getComponentMountPoint as W } from "@blocklet/pages-kit/builtin/utils";
+import { PreloadComponentScriptModule as x } from "@blocklet/pages-kit/types";
+import { componentUMDName as Q, RenderNestedComponent as j, mergeComponent as z } from "@blocklet/pages-kit/utils/property";
+import { memoize as Z, BuiltinModules as A } from "@blocklet/quickjs";
+import { BuiltinModules as M } from "@blocklet/pages-kit/utils/builtin";
+import h from "@blocklet/sdk/lib/config";
+import { LRUCache as X } from "lru-cache";
+import Y, { Headers as q } from "node-fetch";
+import { joinURL as I, getQuery as ee, withQuery as te, parseURL as D, withHttps as oe } from "ufo";
+import ne from "lodash/isEmpty";
+import { createHash as re } from "crypto";
+import { promises as w } from "fs";
+import U, { join as O } from "path";
+import se from "lodash/isNil";
+import ce from "@blocklet/logger";
+import { isRelativeModule as ae, createBuiltinModuleTransformer as ie } 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 = () => (se(L.env.preferences.multiTenantAllProjectAccessPassports) ? [] : L.env.preferences.multiTenantAllProjectAccessPassports?.split(",")) || [], pe = U.join(h.env.dataDir, "fs-memoize-cache"), le = h.env.FS_MEMOIZE_CACHE_VERSION || "v1.0.0", g = ce("pages-kit"), ue = pe, de = le, _ = 30 * 24 * 60 * 60 * 1e3, me = 24 * 60 * 60 * 1e3, B = async (e = "") => {
+  const t = O(ue, e);
+  try {
+    if (!(await w.stat(t)).isDirectory())
+      throw new Error(`${t} is not a directory`);
+  } catch {
+    await w.mkdir(t, { recursive: !0 });
+  }
+  return t;
+}, $ = (e, ...t) => e.keyGenerator ? e.keyGenerator(...t) : JSON.stringify([e.subdir || "", ...t]), fe = (e, t) => {
+  const o = re("md5").update(t).digest("hex");
+  return O(e, `${de}-${o}.json`);
+}, he = async (e = "") => {
+  const t = await B(e), o = Date.now();
+  try {
+    const n = await w.readdir(t);
+    await Promise.all(
+      n.filter((c) => c.endsWith(".json")).map(async (c) => {
+        const r = O(t, c);
+        try {
+          const u = await w.readFile(r, "utf-8"), i = JSON.parse(u);
+          i.createdAt && o - i.createdAt > _ && await w.unlink(r);
+        } catch {
+          try {
+            const i = await w.stat(r);
+            o - i.mtimeMs > _ && await w.unlink(r);
+          } catch {
+          }
+        }
+      })
+    );
+  } catch (n) {
+    console.error(`Failed to cleanup cache in ${t}:`, n);
+  }
+}, we = (() => {
+  const e = /* @__PURE__ */ new Set();
+  return setInterval(async () => {
+    await Promise.all(Array.from(e).map((n) => he(n)));
+  }, me).unref(), (n) => {
+    e.add(n);
+  };
+})();
+function b(e, t) {
+  return t.subdir && we(t.subdir), Z(
+    async (...n) => {
+      const c = await B(t.subdir || ""), r = $(t, ...n), u = fe(c, r);
+      try {
+        const i = await w.readFile(u, "utf-8"), { value: d, createdAt: l } = JSON.parse(i);
+        if (l && Date.now() - l > _)
+          throw await w.unlink(u).catch(() => {
+          }), new Error("Cache expired");
+        return d;
+      } catch {
+        const d = await e(...n), l = JSON.stringify({ value: d, createdAt: Date.now() });
+        return w.writeFile(u, l, "utf-8").catch((f) => {
+          console.error("Failed to write fs cache:", f);
+        }), d;
+      }
+    },
+    {
+      keyGenerator: (...n) => $(t, ...n),
+      lruOptions: t.lruOptions || {
+        max: 100,
+        ttl: _
+      }
+    }
+  );
+}
+const H = async () => await import("typescript"), ge = async () => await import("esbuild"), Ee = async () => (await import("postcss")).default, ye = async () => (await import("tailwindcss")).default, Se = async () => (await import("autoprefixer")).default, xe = !1, Ce = async (e, { componentId: t }) => {
+  const o = `@tailwind components;
+@tailwind utilities;
+`, n = `.CustomComponent_${t}`, c = await Ee(), r = await ye(), u = await Se();
+  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((f) => f.replace(/\.(.+)/g, `${n}.$1,${n} .$1`));
+      });
+    }
+    // FIXME: cssnano use browserslist, it is not working with the fs isolation
+    // cssnano({ preset: 'default' }),
+  ]).process(o)).css;
+}, Pe = async (e, { componentId: t }) => {
+  const o = await Ce(e, { componentId: t });
+  return `export const __PagesKit_CSS__ = ${JSON.stringify(o)};
+
+${e}
+`;
+}, k = b(
+  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: [ie(o)]
+        }
+      }).outputText;
+      if (t.tailwind && (n = await Pe(n, { componentId: t.componentId })), t.module === x.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 === x.CJS ? c : J(t.moduleName, c);
+    } catch (n) {
+      throw new Error(n);
+    } finally {
+      o = null;
+    }
+  },
+  {
+    subdir: "transpileModule"
+  }
+), Te = async (e, t) => {
+  let { build: o } = await ge(), 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 (ae(l.path)) {
+                const f = 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;
+  }
+}, _e = (e, t) => new RegExp(
+  `export\\s+\\{[^}]*(?:\\w+\\s+as\\s+${t}\\b|\\b${t}\\b)[^}]*\\}`,
+  "m"
+).test(e) ? e : void 0, K = b(
+  async (e, t) => {
+    const o = await Te(e, t);
+    return _e(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 ve(e) {
+  return e?.type === "react-component";
+}
+const C = new X({
+  max: 100,
+  ttl: 1e3 * 60 * 60 * 24
+  // 24 hours
+}), Ae = 60 * 60, F = 10;
+function Ie(e) {
+  g.info("clear preload components cache", { cacheKey: e }), C.delete(e);
+}
+function nt(e) {
+  for (const t of C.keys())
+    t.includes(e) && (g.info("clear preload components cache", { cacheKey: t }), Ie(t));
+}
+function Me({
+  mode: e,
+  instanceId: t,
+  componentId: o,
+  locale: n
+}) {
+  return ["getPreloadComponents", e, t, o, n].join("-");
+}
+async function rt({
+  mode: e,
+  req: t,
+  state: o,
+  locale: n,
+  instances: c,
+  module: r
+}) {
+  const {
+    supportedLocales: u,
+    config: { defaultLocale: i }
+  } = o;
+  if (!i) return null;
+  const d = (await Promise.all(
+    c.map(async (a) => {
+      try {
+        const s = Me({
+          mode: e,
+          instanceId: a.id,
+          componentId: a.componentId,
+          locale: n
+        });
+        if (e !== "draft" && a.useCache && C.has(s))
+          return g.info(`get preload component from cache: ${s}`), C.get(s);
+        const E = v({ state: o, componentId: a.componentId });
+        if (!E) return null;
+        const P = await Oe({
+          req: t,
+          state: o,
+          componentId: E.id,
+          locale: n,
+          defaultLocale: i,
+          properties: a.properties
+        });
+        if (!P) return null;
+        const S = { instanceId: a.id, preload: P };
+        if (e !== "draft" && a.useCache) {
+          let y = Ae;
+          a.cacheDuration && (y = a.cacheDuration), g.info(`set preload component to cache(${y}s): ${s}`), C.set(s, S, {
+            ttl: y * 1e3
+          });
+        }
+        return S;
+      } catch (s) {
+        return g.error("get preload component error", { instanceId: a.id, componentId: a.componentId }, { error: s }), null;
+      }
+    })
+  )).filter((a) => !!a), l = Object.values(
+    d.reduce((a, s) => ({ ...a, ...s.preload.components }), {})
+  );
+  async function f() {
+    const a = await Promise.all(
+      l.map(async (s) => {
+        const E = r === x.ESM, P = r === x.UMD_FN, S = r === x.CJS, y = E ? "" : Q({ componentId: s.component.id }), N = je(s.component);
+        let T = {
+          module: r,
+          script: "",
+          moduleName: y
+        };
+        if (N && s.component.renderer?.type === "react-component" && E && s.component.renderer?.script)
+          T.script = s.component.renderer?.script;
+        else if (N && s.component.renderer?.type === "react-component" && (S || P) && s.component.renderer?.cjsScript) {
+          const R = s.component.renderer.cjsScript;
+          T.script = S ? R : J(y, R);
+        } else
+          T = E ? {
+            // ESM
+            module: r,
+            script: await k(s.script, {
+              componentId: s.component.id,
+              module: r,
+              tailwind: e !== "draft"
+            })
+          } : {
+            // CJS OR UMD
+            module: r,
+            script: await k(s.script, {
+              componentId: s.component.id,
+              module: r,
+              moduleName: y,
+              tailwind: e !== "draft"
+            }),
+            moduleName: y
+          };
+        return [s.component.id, { component: s.component, script: T }];
+      })
+    );
+    return Object.fromEntries(a);
+  }
+  const p = await f();
+  return {
+    config: { defaultLocale: i, supportedLocales: u },
+    components: p,
+    instances: d.map((a) => ({
+      id: a.instanceId,
+      componentId: a.preload.component.id,
+      locales: { [a.preload.locale]: { props: a.preload.props } }
+    }))
+  };
+}
+async function Oe({
+  req: e,
+  state: t,
+  componentId: o,
+  locale: n,
+  defaultLocale: c,
+  properties: r
+}) {
+  const { supportedLocales: u } = t, i = v({ state: t, componentId: o });
+  if (!i) return null;
+  const d = u.some((f) => f.locale === n) ? n : c;
+  if (!d) return null;
+  const l = await V({ req: e, state: t, componentId: o, locale: d, defaultLocale: c, properties: r });
+  return l ? {
+    component: i,
+    ...l
+  } : null;
+}
+const be = 20;
+async function V({
+  req: e,
+  depth: t = 0,
+  state: o,
+  componentId: n,
+  locale: c,
+  defaultLocale: r,
+  properties: u
+}) {
+  if (t > be) throw new RangeError("max component depth exceeded");
+  const i = Ne({ state: o, componentId: n, properties: u, locale: c });
+  if (!i) return null;
+  const { props: d, component: l } = i, f = {
+    locale: c || r,
+    components: { [i.component.id]: { component: i.component, script: i.script } },
+    props: { ...d }
+  };
+  try {
+    const p = ve(l.renderer) ? l.renderer.getServerSideProps : void 0, m = await Re({ ...i, req: e, getServerSideProps: p });
+    m?.props && Object.assign(f.props, m.props);
+  } catch (p) {
+    g.error("preload data at server side error", { componentId: n, name: i.component.name }, { error: p });
+  }
+  return await Promise.all(
+    Object.entries(d).map(async ([p, m]) => {
+      if (m?.type === j) {
+        const a = await V({
+          req: e,
+          depth: t + 1,
+          state: o,
+          componentId: m.componentId,
+          locale: c,
+          defaultLocale: r,
+          properties: m.properties
+        });
+        a && (Object.assign(f.components, a.components), Object.assign(f.props, {
+          [p]: {
+            type: j,
+            componentId: m.componentId,
+            props: a.props
+          }
+        }));
+      }
+    })
+  ), f;
+}
+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 st({ 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 i = (r.match(/export\s*{\s*(\w+)\s+as\s+getServerSideProps\s*}/) || r.match(/export\s*{\s*getServerSideProps\s*}/))?.[1] || "getServerSideProps", d = new Promise((p) => {
+    setTimeout(() => {
+      p({});
+    }, F * 1e3);
+  });
+  let l = await G();
+  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 ${i}(componentProps);
+} finally {
+  // 清理全局状态
+  if (originalLocation) globalThis.location = originalLocation;
+  if (originalFetch) globalThis.fetch = originalFetch;
+}
+}`,
+      filename: `${e.name || e.id}.js`,
+      moduleLoader: (p) => {
+        if (p === "@blocklet/pages-kit/builtin/utils")
+          return `          const { joinURL, withQuery, getQuery, getComponentMountPoint } = globalThis
+          export { joinURL, withQuery, getQuery, getComponentMountPoint }
+        `;
+        if (p === "@blocklet/pages-kit/builtin/dayjs")
+          return A.dayjs;
+        if (p in A)
+          return A[p];
+        if (p in M) {
+          const m = M[p];
+          return ne(m) ? void 0 : m;
+        }
+      },
+      global: {
+        console: {
+          // NOTE: do not return logger.xxx result, it will cause memory leak
+          // eslint-disable-next-line prettier/prettier
+          log: (...p) => {
+            g.info(...p);
+          },
+          warn: (...p) => {
+            g.warn(...p);
+          },
+          error: (...p) => {
+            g.error(...p);
+          }
+        },
+        getComponentMountPoint: W,
+        joinURL: I,
+        withQuery: te,
+        getQuery: ee
+      },
+      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: I(oe(n.hostname), n.originalUrl) },
+          fetch: (p, { ...m } = {}) => {
+            const a = typeof p == "string" && p.startsWith("/") ? I(h.env.appUrl, p) : p;
+            if (typeof a == "string" && D(a).host === D(h.env.appUrl).host) {
+              const s = n.get("cookie");
+              if (s) {
+                const E = new q(m.headers);
+                E.set("cookie", s), m.headers = E;
+              }
+            }
+            return Y(a, {
+              ...m,
+              timeout: F * 1e3
+            }).then((s) => ({
+              ok: s.ok,
+              status: s.status,
+              statusText: s.statusText,
+              headers: Object.fromEntries(s.headers.entries()),
+              json: () => s.json()
+            }));
+          },
+          props: o
+        }
+      ]
+    }).finally(() => {
+      l = null;
+    })
+  ]);
+}
+const ct = b(
+  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 g.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,
+  ct as b,
+  nt as c,
+  et as d,
+  Ie as e,
+  Me as f,
+  rt as g,
+  Oe as h,
+  tt as i,
+  v as j,
+  st as k,
+  g as l,
+  b as m,
+  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