@blocklet/pages-kit-inner-components 0.6.103 → 0.6.105

package/lib/es/add-component.js

@@ -1,5 +1,5 @@
 import { jsx as o, jsxs as w } from "react/jsx-runtime";
-import { i as D, a as G, h as J, j as Z, k as ee, l as oe, m as te, f as re } from "./chunks/state-DNdwHwty.js";
+import { i as D, a as G, h as J, j as Z, k as ee, l as oe, m as te, f as re } from "./chunks/state-qDCrgEMQ.js";
 import $ from "@arcblock/ux/lib/Empty";
 import { useLocaleContext as F } from "@arcblock/ux/lib/Locale/context";
 import { Icon as L } from "@iconify-icon/react";
@@ -7,7 +7,7 @@ import ie from "@mui/icons-material/Check";
 import { Box as n, styled as H, alpha as ne, Stack as ae, Dialog as se, DialogTitle as le, TextField as pe, IconButton as ce, DialogContent as de, Tabs as me, Tab as ue, Grid as O, Card as fe, CardMedia as be, CardContent as ge, Typography as W, DialogActions as xe, Button as N, Skeleton as he } from "@mui/material";
 import { useReactive as Q } from "ahooks";
 import { createContext as _, useMemo as P, useEffect as M, useRef as E } from "react";
-import { a as ye, R as ve, B as V, c as Ce, T as ke, I as we } from "./chunks/index-DENjTU8O.js";
+import { a as ye, R as ve, B as V, c as Ce, T as ke, I as we } from "./chunks/index-BpP1FqET.js";
 import { styled as g } from "@arcblock/ux/lib/Theme";
 import "@blocklet/pages-kit/builtin/color-picker";
 import "@blocklet/pages-kit/utils/style";

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

@@ -0,0 +1,615 @@
+import { memoize as X, BuiltinModules as I } from "@blocklet/quickjs";
+import { createHash as Y } from "crypto";
+import { promises as y } from "fs";
+import J, { join as N } from "path";
+import h from "@blocklet/sdk/lib/config";
+import q from "lodash/isNil";
+import { getComponentMountPoint as tt } from "@blocklet/pages-kit/builtin/utils";
+import { PreloadComponentScriptModule as P } from "@blocklet/pages-kit/types";
+import { BuiltinModules as A } from "@blocklet/pages-kit/utils/builtin";
+import { componentUMDName as et, RenderNestedComponent as L, mergeComponent as ot } from "@blocklet/pages-kit/utils/property";
+import nt from "lodash/isEmpty";
+import { LRUCache as rt } from "lru-cache";
+import st, { Headers as ct } from "node-fetch";
+import $ from "p-limit";
+import { joinURL as O, getQuery as at, withQuery as it, parseURL as k, withHttps as pt } from "ufo";
+import lt from "@blocklet/logger";
+import { isRelativeModule as ut, createBuiltinModuleTransformer as dt } from "@blocklet/pages-kit/utils/typescript/builtin-module-transformer";
+import "@blocklet/sdk/lib/component";
+h.env.mode;
+h.env.TRANSLATE_ADDITIONAL_PROMPT || process.env.TRANSLATE_ADDITIONAL_PROMPT;
+h.env.PAGE_CONTENT_ADDITIONAL_PROMPT || process.env.PAGE_CONTENT_ADDITIONAL_PROMPT;
+const ne = "image-bin";
+h.env.INIT_TEMPLATE_PATH;
+const re = process.env.DATABASE_URL || J.join(h.env.dataDir, "db/pages-kit.db"), F = h, se = () => h.env.tenantMode === "multiple", ce = () => (q(F.env.preferences.multiTenantAllProjectAccessPassports) ? [] : F.env.preferences.multiTenantAllProjectAccessPassports?.split(",")) || [], mt = J.join(h.env.dataDir, "fs-memoize-cache"), ft = h.env.FS_MEMOIZE_CACHE_VERSION || "v1.0.0", g = lt("pages-kit"), ht = mt, wt = ft, v = 30 * 24 * 60 * 60 * 1e3, gt = 24 * 60 * 60 * 1e3, K = async (t = "") => {
+  const e = N(ht, t);
+  try {
+    if (!(await y.stat(e)).isDirectory())
+      throw new Error(`${e} is not a directory`);
+  } catch {
+    await y.mkdir(e, { recursive: !0 });
+  }
+  return e;
+}, U = (t, ...e) => t.keyGenerator ? t.keyGenerator(...e) : JSON.stringify([t.subdir || "", ...e]), yt = (t, e) => {
+  const o = Y("md5").update(e).digest("hex");
+  return N(t, `${wt}-${o}.json`);
+}, xt = async (t = "") => {
+  const e = await K(t), o = Date.now();
+  try {
+    const n = await y.readdir(e);
+    await Promise.all(
+      n.filter((s) => s.endsWith(".json")).map(async (s) => {
+        const r = N(e, s);
+        try {
+          const l = await y.readFile(r, "utf-8"), a = JSON.parse(l);
+          a.createdAt && o - a.createdAt > v && await y.unlink(r);
+        } catch {
+          try {
+            const a = await y.stat(r);
+            o - a.mtimeMs > v && await y.unlink(r);
+          } catch {
+          }
+        }
+      })
+    );
+  } catch (n) {
+    console.error(`Failed to cleanup cache in ${e}:`, n);
+  }
+}, St = (() => {
+  const t = /* @__PURE__ */ new Set();
+  return setInterval(async () => {
+    await Promise.all(Array.from(t).map((n) => xt(n)));
+  }, gt).unref(), (n) => {
+    t.add(n);
+  };
+})();
+function j(t, e) {
+  return e.subdir && St(e.subdir), X(
+    async (...n) => {
+      const s = await K(e.subdir || ""), r = U(e, ...n), l = yt(s, r);
+      try {
+        const a = await y.readFile(l, "utf-8"), { value: m, createdAt: i } = JSON.parse(a);
+        if (i && Date.now() - i > v)
+          throw await y.unlink(l).catch(() => {
+          }), new Error("Cache expired");
+        return m;
+      } catch {
+        const m = await t(...n), i = JSON.stringify({ value: m, createdAt: Date.now() });
+        return y.writeFile(l, i, "utf-8").catch((f) => {
+          console.error("Failed to write fs cache:", f);
+        }), m;
+      }
+    },
+    {
+      keyGenerator: (...n) => U(e, ...n),
+      lruOptions: e.lruOptions || {
+        max: 100,
+        ttl: v
+      }
+    }
+  );
+}
+const G = async () => await import("typescript"), Ct = async () => await import("esbuild"), Et = async () => (await import("postcss")).default, Pt = async () => (await import("tailwindcss")).default, Tt = async () => (await import("autoprefixer")).default, Mt = !1, bt = async (t, { componentId: e }) => {
+  const o = `@tailwind components;
+@tailwind utilities;
+`, n = `.CustomComponent_${e}`, s = await Et(), r = await Pt(), l = await Tt();
+  return (await s([
+    r({ content: [{ raw: t, extension: "tsx" }] }),
+    l({
+      overrideBrowserslist: ["> 1%", "last 2 versions"],
+      stats: {}
+    }),
+    (m) => {
+      m.walkRules((i) => {
+        i.selectors = i.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;
+}, vt = async (t, { componentId: e }) => {
+  const o = await bt(t, { componentId: e });
+  return `export const __PagesKit_CSS__ = ${JSON.stringify(o)};
+
+${t}
+`;
+}, H = j(
+  async (t, e) => {
+    let o = await G();
+    try {
+      let n = o.transpileModule(t, {
+        compilerOptions: {
+          jsx: o.JsxEmit.React,
+          target: o.ScriptTarget.ES2016,
+          module: o.ModuleKind.ESNext
+        },
+        transformers: {
+          before: [dt(o)]
+        }
+      }).outputText;
+      if (e.tailwind && (n = await vt(n, { componentId: e.componentId })), e.module === P.ESM) return n;
+      const s = o.transpileModule(n, {
+        compilerOptions: {
+          jsx: o.JsxEmit.React,
+          target: o.ScriptTarget.ES2016,
+          module: o.ModuleKind.CommonJS,
+          moduleResolution: o.ModuleResolutionKind.Node16
+        }
+      }).outputText;
+      return e.module === P.CJS ? s : W(e.moduleName, s);
+    } catch (n) {
+      throw new Error(n);
+    } finally {
+      o = null;
+    }
+  },
+  {
+    subdir: "transpileModule"
+  }
+), _t = async (t, e) => {
+  let { build: o } = await Ct(), n = null;
+  try {
+    const r = (await o({
+      entryPoints: ["index.tsx"],
+      external: Object.keys(A),
+      format: "esm",
+      target: "esnext",
+      bundle: !0,
+      write: !1,
+      plugins: [
+        {
+          name: "vfs",
+          setup(m) {
+            m.onResolve({ filter: /.*/ }, (i) => i.path === "index.tsx" ? { path: "index.tsx", namespace: "vfs" } : i.path === "./component" ? { path: "component.tsx", namespace: "vfs" } : null), m.onLoad({ filter: /.*/, namespace: "vfs" }, async (i) => {
+              if (i.path === "index.tsx")
+                return { contents: `export { ${e} } from './component'`, loader: "tsx" };
+              if (i.path === "component.tsx")
+                return { contents: t, loader: "tsx" };
+              if (ut(i.path)) {
+                const f = i.path.split("/").pop();
+              }
+              return null;
+            });
+          }
+        }
+      ]
+    })).outputFiles?.[0]?.contents;
+    if (!r) throw new Error("Failed to build server code");
+    const l = Buffer.from(r).toString();
+    return n = await G(), n.transpileModule(l, {
+      compilerOptions: { module: n.ModuleKind.ESNext, target: n.ScriptTarget.ES2020 }
+    }).outputText;
+  } catch (s) {
+    throw new Error(s);
+  } finally {
+    o = null, n = null;
+  }
+}, It = (t, e) => new RegExp(
+  `export\\s+\\{[^}]*(?:\\w+\\s+as\\s+${e}\\b|\\b${e}\\b)[^}]*\\}`,
+  "m"
+).test(t) ? t : void 0, V = j(
+  async (t, e) => {
+    const o = await _t(t, e);
+    return It(o, e);
+  },
+  {
+    subdir: "extractExportValueSchema"
+  }
+), W = (t, e) => `// GENERATED FILE. DO NOT EDIT.
+var ${t} = async function () {
+
+  const exports = {};
+  let moduleExports = null;
+  
+  // add commonjs module compatibility layer
+  const module = { exports: moduleExports };
+  
+  // execute component code
+  ${e}
+  
+  // 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;
+};
+`, Q = async () => {
+  const { Sandbox: t } = await import("@blocklet/quickjs");
+  return t;
+};
+function Ot(t) {
+  return t?.type === "react-component";
+}
+const E = new rt({
+  max: 600,
+  ttl: 1e3 * 60 * 60 * 24 * 7
+  //  default ttl is 7 days
+}), At = 60 * 60, B = 10;
+function z(t) {
+  g.info("clear preload components cache", { cacheKey: t }), E.delete(t);
+}
+function ae(t) {
+  for (const e of E.keys())
+    e.includes(t) && (g.info("clear preload components cache", { cacheKey: e }), z(e));
+}
+function ie(t) {
+  for (const e of E.keys())
+    e.includes(t) && (g.info("clear preload components cache", { cacheKey: e }), z(e));
+}
+function Nt({
+  mode: t,
+  instanceId: e,
+  componentId: o,
+  locale: n
+}) {
+  return ["getPreloadComponents", t, e, o, n].join("-");
+}
+async function pe({
+  mode: t,
+  req: e,
+  state: o,
+  locale: n,
+  instances: s,
+  module: r
+}) {
+  const {
+    supportedLocales: l,
+    config: { defaultLocale: a }
+  } = o;
+  if (!a) return null;
+  const m = $(10), i = (await Promise.all(
+    s.map(
+      (p) => m(async () => {
+        try {
+          const u = Nt({
+            mode: t,
+            instanceId: p.id,
+            componentId: p.componentId,
+            locale: n
+          });
+          if (t !== "draft" && p.useCache && E.has(u))
+            return g.info(`get preload component from cache: ${u}`), E.get(u);
+          const d = _({ state: o, componentId: p.componentId });
+          if (!d) return null;
+          const S = await jt({
+            req: e,
+            state: o,
+            componentId: d.id,
+            locale: n,
+            defaultLocale: a,
+            properties: p.properties
+          });
+          if (!S) return null;
+          const T = { instanceId: p.id, preload: S };
+          if (t !== "draft" && p.useCache) {
+            let C = At;
+            p.cacheDuration && (C = p.cacheDuration), g.info(`set preload component to cache(${C}s): ${u}`), E.set(u, T, {
+              ttl: C * 1e3
+            });
+          }
+          return T;
+        } catch (u) {
+          return g.error(
+            "get preload component error",
+            { instanceId: p.id, componentId: p.componentId },
+            { error: u }
+          ), null;
+        }
+      })
+    )
+  )).filter((p) => !!p), f = Object.values(
+    i.reduce((p, u) => ({ ...p, ...u.preload.components }), {})
+  );
+  async function x() {
+    const p = $(10), u = await Promise.all(
+      f.map(
+        (d) => p(async () => {
+          const S = r === P.ESM, T = r === P.UMD_FN, C = r === P.CJS, M = S ? "" : et({ componentId: d.component.id }), D = $t(d.component);
+          let b = {
+            module: r,
+            script: "",
+            moduleName: M
+          };
+          if (D && d.component.renderer?.type === "react-component" && S && d.component.renderer?.script)
+            b.script = d.component.renderer?.script;
+          else if (D && d.component.renderer?.type === "react-component" && (C || T) && d.component.renderer?.cjsScript) {
+            const R = d.component.renderer.cjsScript;
+            b.script = C ? R : W(M, R);
+          } else
+            b = S ? {
+              // ESM
+              module: r,
+              script: await H(d.script, {
+                componentId: d.component.id,
+                module: r,
+                tailwind: t !== "draft"
+              })
+            } : {
+              // CJS OR UMD
+              module: r,
+              script: await H(d.script, {
+                componentId: d.component.id,
+                module: r,
+                moduleName: M,
+                tailwind: t !== "draft"
+              }),
+              moduleName: M
+            };
+          return [d.component.id, { component: d.component, script: b }];
+        })
+      )
+    );
+    return Object.fromEntries(u);
+  }
+  const c = await x();
+  return {
+    config: { defaultLocale: a, supportedLocales: l },
+    components: c,
+    instances: i.map((p) => ({
+      id: p.instanceId,
+      componentId: p.preload.component.id,
+      locales: { [p.preload.locale]: { props: p.preload.props } }
+    }))
+  };
+}
+async function jt({
+  req: t,
+  state: e,
+  componentId: o,
+  locale: n,
+  defaultLocale: s,
+  properties: r
+}) {
+  const { supportedLocales: l } = e, a = _({ state: e, componentId: o });
+  if (!a) return null;
+  const m = l.some((f) => f.locale === n) ? n : s;
+  if (!m) return null;
+  const i = await Z({ req: t, state: e, componentId: o, locale: m, defaultLocale: s, properties: r });
+  return i ? {
+    component: a,
+    ...i
+  } : null;
+}
+const Dt = 20;
+async function Z({
+  req: t,
+  depth: e = 0,
+  state: o,
+  componentId: n,
+  locale: s,
+  defaultLocale: r,
+  properties: l
+}) {
+  if (e > Dt) throw new RangeError("max component depth exceeded");
+  const a = Rt({ state: o, componentId: n, properties: l, locale: s });
+  if (!a) return null;
+  const { props: m, component: i } = a, f = {
+    locale: s || r,
+    components: { [a.component.id]: { component: a.component, script: a.script } },
+    props: { ...m }
+  };
+  try {
+    const x = Ot(i.renderer) ? i.renderer.getServerSideProps : void 0, c = await Lt({ ...a, req: t, getServerSideProps: x });
+    c?.props && Object.assign(f.props, c.props);
+  } catch (x) {
+    g.error("preload data at server side error", { componentId: n, name: a.component.name }, { error: x });
+  }
+  return await Promise.all(
+    Object.entries(m).map(async ([x, c]) => {
+      if (c?.type === L) {
+        const w = await Z({
+          req: t,
+          depth: e + 1,
+          state: o,
+          componentId: c.componentId,
+          locale: s,
+          defaultLocale: r,
+          properties: c.properties
+        });
+        w && (Object.assign(f.components, w.components), Object.assign(f.props, {
+          [x]: {
+            type: L,
+            componentId: c.componentId,
+            props: w.props
+          }
+        }));
+      }
+    })
+  ), f;
+}
+function Rt({
+  state: t,
+  componentId: e,
+  locale: o,
+  properties: n
+}) {
+  const s = _({ state: t, componentId: e });
+  if (!s) return null;
+  const r = ot({
+    componentId: e,
+    getComponent: (l) => _({ state: t, componentId: l }),
+    locale: o,
+    defaultLocale: t.config.defaultLocale,
+    properties: n
+  });
+  return r ? { component: s, script: r.script, props: { locale: o, ...r.props } } : null;
+}
+function _({ state: t, componentId: e }) {
+  return t.components[e]?.data ?? t.resources.components?.[e]?.component;
+}
+function le({ state: t, name: e }) {
+  const o = e.toLowerCase();
+  return Object.values(t.components).find((n) => n.data.name?.toLowerCase() === o)?.data ?? (t.resources.components && Object.values(t.resources.components).find((n) => n.component.name?.toLowerCase() === o))?.component;
+}
+async function Lt({
+  component: t,
+  script: e,
+  props: o,
+  req: n,
+  getServerSideProps: s
+}) {
+  if (!s && !e?.includes("getServerSideProps"))
+    return null;
+  const r = s ?? await V(e, "getServerSideProps");
+  if (!r) return null;
+  const a = (r.match(/export\s*{\s*(\w+)\s+as\s+getServerSideProps\s*}/) || r.match(/export\s*{\s*getServerSideProps\s*}/))?.[1] || "getServerSideProps", m = new Promise((c) => {
+    setTimeout(() => {
+      c({});
+    }, B * 1e3);
+  });
+  let i = await Q();
+  const f = {
+    componentMountPoints: h.components
+  };
+  return await Promise.race([
+    m,
+    i.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 ${a}(componentProps);
+} finally {
+  // 清理全局状态
+  if (originalLocation) globalThis.location = originalLocation;
+  if (originalFetch) globalThis.fetch = originalFetch;
+}
+}`,
+      filename: `${t.name || t.id}.js`,
+      moduleLoader: (c) => {
+        if (c === "@blocklet/pages-kit/builtin/utils")
+          return `          const { joinURL, withQuery, getQuery, getComponentMountPoint } = globalThis
+          export { joinURL, withQuery, getQuery, getComponentMountPoint }
+        `;
+        if (c === "@blocklet/pages-kit/builtin/dayjs")
+          return I.dayjs;
+        if (c in I)
+          return I[c];
+        if (c in A) {
+          const w = A[c];
+          return nt(w) ? void 0 : w;
+        }
+      },
+      global: {
+        console: {
+          // NOTE: do not return logger.xxx result, it will cause memory leak
+          // eslint-disable-next-line prettier/prettier
+          log: (...c) => {
+            g.info(...c);
+          },
+          warn: (...c) => {
+            g.warn(...c);
+          },
+          error: (...c) => {
+            g.error(...c);
+          }
+        },
+        getComponentMountPoint: tt,
+        joinURL: O,
+        withQuery: it,
+        getQuery: at,
+        window: {
+          blocklet: f
+        },
+        blocklet: f
+      },
+      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: O(pt(n.hostname), n.originalUrl) },
+          fetch: (c, { ...w } = {}) => {
+            const p = typeof c == "string" && c.startsWith("/") ? O(h.env.appUrl, c) : c;
+            if (typeof p == "string" && k(p).host === k(h.env.appUrl).host) {
+              const u = n.get("cookie");
+              if (u) {
+                const d = new ct(w.headers);
+                d.set("cookie", u), w.headers = d;
+              }
+            }
+            return st(p, {
+              ...w,
+              timeout: B * 1e3
+            }).then((u) => ({
+              ok: u.ok,
+              status: u.status,
+              statusText: u.statusText,
+              headers: Object.fromEntries(u.headers.entries()),
+              json: () => u.json()
+            }));
+          },
+          props: o
+        }
+      ]
+    }).finally(() => {
+      i = null;
+    })
+  ]);
+}
+const ue = j(
+  async (t, e, o, n) => {
+    if (!t?.includes(e) && !n)
+      return null;
+    const s = n ?? await V(t, e);
+    if (s)
+      try {
+        let r = await Q();
+        return await r.callFunction({
+          cache: !0,
+          code: `
+            ${s}
+
+            export function get${e}SchemaWrapper() {
+              return ${e};
+            }
+          `,
+          filename: `${o}.js`,
+          functionName: `get${e}SchemaWrapper`
+        }).finally(() => {
+          r = null;
+        });
+      } catch (r) {
+        return g.error(`获取 ${e} 失败`, { componentId: o, error: r }), null;
+      }
+    return null;
+  },
+  {
+    subdir: "getExportSchemaValueFromCode"
+  }
+), $t = (t) => !!(t.renderer?.type === "react-component" && t.version && t.version >= 2);
+export {
+  At as C,
+  B as G,
+  ne as I,
+  ce as a,
+  ue as b,
+  ae as c,
+  re as d,
+  z as e,
+  ie as f,
+  pe as g,
+  Nt as h,
+  se as i,
+  jt as j,
+  _ as k,
+  g as l,
+  j as m,
+  le as n,
+  $t as s
+};

package/lib/es/chunks/{draft-data-BOoVhbon.js → draft-data-DRdPzuGm.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-DNdwHwty.js";
+import { u as a, S as o, g as s, a as n } from "./state-qDCrgEMQ.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 }) });