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

package/lib/es/_chunks/components-BVBbxiyS.js

@@ -0,0 +1,453 @@
+import { getComponentMountPoint as v } from "@blocklet/pages-kit/builtin/utils";
+import { PreloadComponentScriptModule as N } from "@blocklet/pages-kit/types";
+import { componentUMDName as L, RenderNestedComponent as P, mergeComponent as U } from "@blocklet/pages-kit/utils/property";
+import { memoize as b, Sandbox as _, BuiltinModules as D } from "@blocklet/quickjs";
+import M from "@blocklet/sdk/lib/config";
+import { LRUCache as F } from "lru-cache";
+import B, { Headers as G } from "node-fetch";
+import { joinURL as S, getQuery as J, withQuery as K, parseURL as T, withHttps as Q } from "ufo";
+import W from "@blocklet/logger";
+import { BuiltinModules as A } from "@blocklet/pages-kit/utils/builtin";
+import { createBuiltinModuleTransformer as V, isRelativeModule as j } from "@blocklet/pages-kit/utils/typescript/builtin-module-transformer";
+import { call as H } from "@blocklet/sdk/lib/component";
+import z from "autoprefixer";
+import * as X from "esbuild";
+import Y from "postcss";
+import Z from "tailwindcss";
+import d from "typescript";
+const h = W("pages-kit"), q = async (e, { componentId: t }) => {
+  const o = `@tailwind components;
+@tailwind utilities;
+`, r = `.CustomComponent_${t}`;
+  return (await Y([
+    Z({ content: [{ raw: e, extension: "tsx" }] }),
+    z({
+      overrideBrowserslist: ["> 1%", "last 2 versions"],
+      stats: {}
+    }),
+    (i) => {
+      i.walkRules((n) => {
+        n.selectors = n.selectors.map((c) => c.replace(/\.(.+)/g, `${r}.$1,${r} .$1`));
+      });
+    }
+    // FIXME: cssnano use browserslist, it is not working with the fs isolation
+    // cssnano({ preset: 'default' }),
+  ]).process(o)).css;
+}, ee = async (e, { componentId: t }) => {
+  const o = await q(e, { componentId: t });
+  return `export const __PagesKit_CSS__ = ${JSON.stringify(o)};
+
+${e}
+`;
+}, I = b(
+  async (e, t) => {
+    let o = d.transpileModule(e, {
+      compilerOptions: {
+        jsx: d.JsxEmit.React,
+        target: d.ScriptTarget.ES2016,
+        module: d.ModuleKind.ESNext
+      },
+      transformers: {
+        before: [V(d)]
+      }
+    }).outputText;
+    if (t.tailwind && (o = await ee(o, { componentId: t.componentId })), t.module === N.ESM) return o;
+    const r = d.transpileModule(o, {
+      compilerOptions: {
+        jsx: d.JsxEmit.React,
+        target: d.ScriptTarget.ES2016,
+        module: d.ModuleKind.CommonJS,
+        moduleResolution: d.ModuleResolutionKind.Node16
+      }
+    }).outputText;
+    return oe(t.moduleName, r);
+  },
+  { keyGenerator: (e, t) => JSON.stringify(["transpileModule", e, t]) }
+), te = async (e, t) => {
+  var n, c;
+  const r = (c = (n = (await X.build({
+    entryPoints: ["index.tsx"],
+    external: Object.keys(A),
+    format: "esm",
+    target: "es2020",
+    bundle: !0,
+    write: !1,
+    plugins: [
+      {
+        name: "vfs",
+        setup(m) {
+          m.onResolve({ filter: /.*/ }, (s) => s.path === "index.tsx" ? { path: "index.tsx", namespace: "vfs" } : s.path === "./component" ? { path: "component.tsx", namespace: "vfs" } : j(s.path) ? { path: s.path, namespace: "vfs" } : null), m.onLoad({ filter: /.*/, namespace: "vfs" }, async (s) => {
+            if (s.path === "index.tsx")
+              return { contents: `export { ${t} } from './component'`, loader: "tsx" };
+            if (s.path === "component.tsx")
+              return { contents: e, loader: "tsx" };
+            if (j(s.path)) {
+              const l = s.path.split("/").pop(), f = S("chunks", l), { data: g } = await H({
+                name: "pages-kit",
+                method: "GET",
+                path: f
+              });
+              return { contents: g, loader: "js" };
+            }
+            return null;
+          });
+        }
+      }
+    ]
+  })).outputFiles) == null ? void 0 : n[0]) == null ? void 0 : c.contents;
+  if (!r) throw new Error("Failed to build server code");
+  const a = Buffer.from(r).toString();
+  return d.transpileModule(a, {
+    compilerOptions: { module: d.ModuleKind.ESNext, target: d.ScriptTarget.ES2020 }
+  }).outputText;
+}, k = b(
+  async (e, t) => {
+    const o = await te(e, t);
+    return new RegExp(`export\\s+\\{\\s+${t}\\s+\\}`, "m").test(o) ? o : void 0;
+  },
+  { keyGenerator: (e, t) => JSON.stringify(["extractExportValueSchema", e, t]) }
+), oe = (e, t) => {
+  const o = /\bawait\b/.test(t);
+  return `// GENERATED FILE. DO NOT EDIT.
+var ${e} = ${o ? "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;
+};
+`;
+}, w = new F({
+  max: 100
+}), ne = 60 * 60, $ = 60;
+function re(e) {
+  h.info("clear preload components cache", { cacheKey: e }), w.delete(e);
+}
+function Me(e) {
+  for (const t of w.keys())
+    t.includes(e) && (h.info("clear preload components cache", { cacheKey: t }), re(t));
+}
+function se({
+  mode: e,
+  instanceId: t,
+  componentId: o,
+  locale: r
+}) {
+  return ["getPreloadComponents", e, t, o, r].join("-");
+}
+async function Te({
+  mode: e,
+  req: t,
+  state: o,
+  locale: r,
+  instances: a,
+  module: i
+}) {
+  const {
+    supportedLocales: n,
+    config: { defaultLocale: c }
+  } = o;
+  if (!c) return null;
+  const m = (await Promise.all(
+    a.map(async (p) => {
+      try {
+        const u = se({
+          mode: e,
+          instanceId: p.id,
+          componentId: p.componentId,
+          locale: r
+        });
+        if (e !== "draft" && p.useCache && w.has(u))
+          return h.info(`get preload component from cache: ${u}`), w.get(u);
+        const x = C({ state: o, componentId: p.componentId });
+        if (!x) return null;
+        const y = await ce({
+          req: t,
+          state: o,
+          componentId: x.id,
+          locale: r,
+          defaultLocale: c,
+          properties: p.properties
+        });
+        if (!y) return null;
+        const O = { instanceId: p.id, preload: y };
+        if (e !== "draft" && p.useCache) {
+          let E = ne;
+          p.cacheDuration && (E = p.cacheDuration), h.info(`set preload component to cache(${E}s): ${u}`), w.set(u, O, {
+            ttl: E * 1e3
+          });
+        }
+        return O;
+      } catch (u) {
+        return h.error("get preload component error", { instanceId: p.id, componentId: p.componentId }, { error: u }), null;
+      }
+    })
+  )).filter((p) => !!p), s = Object.values(
+    m.reduce((p, u) => ({ ...p, ...u.preload.components }), {})
+  );
+  async function l() {
+    const p = await Promise.all(
+      s.map(async (u) => {
+        const x = L({ componentId: u.component.id }), y = i === N.ESM ? {
+          module: i,
+          script: await I(u.script, {
+            componentId: u.component.id,
+            module: i,
+            tailwind: e !== "draft"
+          })
+        } : {
+          module: i,
+          script: await I(u.script, {
+            componentId: u.component.id,
+            module: i,
+            moduleName: x,
+            tailwind: e !== "draft"
+          }),
+          moduleName: x
+        };
+        return [u.component.id, { component: u.component, script: y }];
+      })
+    );
+    return Object.fromEntries(p);
+  }
+  const f = await l();
+  return {
+    config: { defaultLocale: c, supportedLocales: n },
+    components: f,
+    instances: m.map((p) => ({
+      id: p.instanceId,
+      componentId: p.preload.component.id,
+      locales: { [p.preload.locale]: { props: p.preload.props } }
+    }))
+  };
+}
+async function ce({
+  req: e,
+  state: t,
+  componentId: o,
+  locale: r,
+  defaultLocale: a,
+  properties: i
+}) {
+  const { supportedLocales: n } = t, c = C({ state: t, componentId: o });
+  if (!c) return null;
+  const m = n.some((l) => l.locale === r) ? r : a;
+  if (!m) return null;
+  const s = await R({ req: e, state: t, componentId: o, locale: m, defaultLocale: a, properties: i });
+  return s ? {
+    component: c,
+    ...s
+  } : null;
+}
+const ae = 20;
+async function R({
+  req: e,
+  depth: t = 0,
+  state: o,
+  componentId: r,
+  locale: a,
+  defaultLocale: i,
+  properties: n
+}) {
+  if (t > ae) throw new RangeError("max component depth exceeded");
+  const c = ie({ state: o, componentId: r, properties: n, locale: a });
+  if (!c) return null;
+  const { props: m } = c, s = {
+    locale: a || i,
+    components: { [c.component.id]: { component: c.component, script: c.script } },
+    props: { ...m }
+  };
+  try {
+    const l = await pe({ ...c, req: e });
+    l != null && l.props && Object.assign(s.props, l.props);
+  } catch (l) {
+    h.error("preload data at server side error", { componentId: r, name: c.component.name }, { error: l });
+  }
+  return await Promise.all(
+    Object.entries(m).map(async ([l, f]) => {
+      if ((f == null ? void 0 : f.type) === P) {
+        const g = await R({
+          req: e,
+          depth: t + 1,
+          state: o,
+          componentId: f.componentId,
+          locale: a,
+          defaultLocale: i,
+          properties: f.properties
+        });
+        g && (Object.assign(s.components, g.components), Object.assign(s.props, {
+          [l]: {
+            type: P,
+            componentId: f.componentId,
+            props: g.props
+          }
+        }));
+      }
+    })
+  ), s;
+}
+function ie({
+  state: e,
+  componentId: t,
+  locale: o,
+  properties: r
+}) {
+  const a = C({ state: e, componentId: t });
+  if (!a) return null;
+  const i = U({
+    componentId: t,
+    getComponent: (n) => C({ state: e, componentId: n }),
+    locale: o,
+    defaultLocale: e.config.defaultLocale,
+    properties: r
+  });
+  return i ? { component: a, script: i.script, props: { locale: o, ...i.properties } } : null;
+}
+function C({ state: e, componentId: t }) {
+  var o, r, a;
+  return ((o = e.components[t]) == null ? void 0 : o.data) ?? ((a = (r = e.resources.components) == null ? void 0 : r[t]) == null ? void 0 : a.component);
+}
+function je({ state: e, name: t }) {
+  var r, a;
+  const o = t.toLowerCase();
+  return ((r = Object.values(e.components).find((i) => {
+    var n;
+    return ((n = i.data.name) == null ? void 0 : n.toLowerCase()) === o;
+  })) == null ? void 0 : r.data) ?? ((a = e.resources.components && Object.values(e.resources.components).find((i) => {
+    var n;
+    return ((n = i.component.name) == null ? void 0 : n.toLowerCase()) === o;
+  })) == null ? void 0 : a.component);
+}
+async function pe({
+  component: e,
+  script: t,
+  props: o,
+  req: r
+}) {
+  const a = await k(t, "getServerSideProps");
+  if (!a) return null;
+  const i = new Promise((n, c) => {
+    setTimeout(() => c(new Error("getServerSideProps timeout in promise race")), $ * 1e3);
+  });
+  return Promise.race([
+    i,
+    _.callFunction({
+      code: `${a}
+
+export async function getServerSidePropsWrapper({ location, fetch, props}) {
+  globalThis.location = location
+  globalThis.fetch = fetch
+
+  return getServerSideProps(props);
+}
+`,
+      filename: `${e.name || e.id}.js`,
+      moduleLoader: (n) => {
+        if (n === "@blocklet/pages-kit/builtin/utils")
+          return `const { joinURL, withQuery, getQuery, getComponentMountPoint } = globalThis
+export { joinURL, withQuery, getQuery, getComponentMountPoint }
+`;
+        if (n === "@blocklet/pages-kit/builtin/dayjs")
+          return D.dayjs;
+      },
+      global: {
+        console: {
+          // NOTE: do not return logger.xxx result, it will cause memory leak
+          // eslint-disable-next-line prettier/prettier
+          log: (...n) => {
+            h.info(...n);
+          },
+          warn: (...n) => {
+            h.warn(...n);
+          },
+          error: (...n) => {
+            h.error(...n);
+          }
+        },
+        getComponentMountPoint: v,
+        joinURL: S,
+        withQuery: K,
+        getQuery: J
+      },
+      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: S(Q(r.hostname), r.originalUrl) },
+          fetch: (n, { ...c } = {}) => {
+            const m = typeof n == "string" && n.startsWith("/") ? S(M.env.appUrl, n) : n;
+            if (typeof m == "string" && T(m).host === T(M.env.appUrl).host) {
+              const s = r.get("cookie");
+              if (s) {
+                const l = new G(c.headers);
+                l.set("cookie", s), c.headers = l;
+              }
+            }
+            return B(m, {
+              ...c,
+              timeout: $ * 1e3
+            }).then((s) => ({
+              ok: s.ok,
+              status: s.status,
+              statusText: s.statusText,
+              headers: Object.fromEntries(s.headers.entries()),
+              json: () => s.json()
+            }));
+          },
+          props: o
+        }
+      ]
+    })
+  ]);
+}
+const Ie = b(
+  async (e, t, o) => {
+    const r = await k(e, t);
+    return r ? await _.callFunction({
+      code: `
+            ${r}
+
+            export function get${t}SchemaWrapper() {
+              return ${t};
+            }
+          `,
+      filename: `${o}.js`,
+      functionName: `get${t}SchemaWrapper`
+    }) : null;
+  },
+  {
+    keyGenerator: (e, t, o) => JSON.stringify(["getExportSchemaValueFromCode", e, t, o])
+  }
+);
+export {
+  ne as C,
+  $ as G,
+  Te as a,
+  re as b,
+  Me as c,
+  se as d,
+  ce as e,
+  C as f,
+  Ie as g,
+  je as h,
+  h as l
+};

package/lib/es/_chunks/{site-state-CD7ipvhF.js → site-state-DH2gSYZG.js}

@@ -1,4 +1,4 @@
-import { l as D, c as Me, g as $e } from "./components-k4kCJg_V.js";
+import { l as D, c as Me, g as $e } from "./components-BVBbxiyS.js";
 import { memoize as Be } from "@blocklet/quickjs";
 import { getComponentWebEndpoint as xe, getResources as Ve, call as Ge } from "@blocklet/sdk/lib/component";
 import h from "@blocklet/sdk/lib/config";

package/lib/es/components.js

@@ -6,7 +6,7 @@ import "@blocklet/sdk/lib/config";
 import "lru-cache";
 import "node-fetch";
 import "ufo";
-import { C as S, G as _, a as E, c as d, f as i, h as l, g as N, e as O, d as P, b as c } from "./_chunks/components-k4kCJg_V.js";
+import { C as S, G as _, b as E, c as d, f as i, h as l, g as N, e as O, a as P, d as c } from "./_chunks/components-BVBbxiyS.js";
 export {
   S as CUSTOM_COMPONENT_CACHE_DURATION_IN_SECONDS,
   _ as GET_SERVER_SIDE_PROPS_TIMEOUT_IN_SECONDS,

package/lib/es/project-html.js

@@ -0,0 +1,148 @@
+import { a as W, l as y } from "./_chunks/components-BVBbxiyS.js";
+import { initCronCrawlBlocklet as B, cancelCronCrawlBlocklet as J, initSEOMiddleware as N } from "@blocklet/crawler/middlewares";
+import { PreloadComponentScriptModule as G } from "@blocklet/pages-kit/types";
+import { injectPreloadComponents as K } from "@blocklet/pages-kit/utils/preload";
+import { getComponentMountPoint as Q } from "@blocklet/sdk/lib/component";
+import l, { getBlockletJs as z } from "@blocklet/sdk/lib/config";
+import * as A from "cheerio";
+import { Router as V } from "express";
+import { readFileSync as j } from "fs";
+import X from "mustache";
+import { resolve as D } from "path";
+import { withQuery as Y, joinURL as Z } from "ufo";
+const F = ["/assets/"], M = () => [!0, "true"].includes(l.env.preferences.allowCrawler);
+function O() {
+  M() ? B({
+    time: "30 30 */12 * * *",
+    options: {}
+  }) : J();
+}
+O();
+l.events.on(l.Events.envUpdate, O);
+function de({
+  app: p,
+  viteDevServer: E,
+  projectId: R,
+  state: t
+}) {
+  let g;
+  if (E) {
+    const o = j(D(process.cwd(), "./index.html"), "utf-8");
+    p.use(async (_, T, k) => {
+      const P = _.originalUrl;
+      g = await E.transformIndexHtml(P, o), k();
+    });
+  } else
+    g = j(D(process.env.BLOCKLET_APP_DIR, "dist/index.html"), "utf-8");
+  const C = V();
+  C.use(
+    N({
+      autoReturnHtml: !1,
+      allowCrawler: M
+    })
+  ), C.get("/:path(*)?", async (o, _, T) => {
+    var S, b, I;
+    if (F.some((n) => o.path.startsWith(n))) {
+      T();
+      return;
+    }
+    const k = performance.now(), P = () => Math.round(performance.now() - k), U = "production";
+    let r, m, w = g;
+    if (o.path.startsWith("/pages")) {
+      const n = o.params.lang, h = o.cookies.nf_lang, u = /* @__PURE__ */ new Set([...l.env.languages.map((a) => a.code)]);
+      let s = (n && u.has(n) ? n : void 0) || (u.has(h) ? h : void 0) || [...u][0];
+      if ((!s || !((S = t.supportedLocales) != null && S.find((a) => a.locale === s))) && (s = ((I = (b = t.supportedLocales) == null ? void 0 : b[0]) == null ? void 0 : I.locale) || ""), s) {
+        const a = [];
+        Object.values(t.pages).forEach((i) => {
+          const v = Object.values((i == null ? void 0 : i.sections) ?? {}).filter(
+            (c) => {
+              var f;
+              return c.component === "custom-component" && ((f = c.config) == null ? void 0 : f.componentId);
+            }
+          ).map((c) => {
+            var f, L;
+            return {
+              id: c.id,
+              componentId: c.config.componentId,
+              useCache: c.config.useCache,
+              cacheDuration: c.config.cacheDuration,
+              properties: (L = (f = c.locales) == null ? void 0 : f[s]) == null ? void 0 : L.properties
+            };
+          });
+          a.push(...v);
+        });
+        const H = new Promise((i, v) => {
+          setTimeout(() => {
+            v(new Error("getPreloadComponents timeout in promise race, skip it"));
+          }, 90 * 1e3);
+        });
+        try {
+          await Promise.race([
+            H,
+            W({
+              mode: U,
+              req: o,
+              state: t,
+              locale: s,
+              instances: a,
+              module: G.UMD_FN
+            }).then((i) => {
+              i && (m = K(i));
+            })
+          ]);
+        } catch (i) {
+          y.warn("getPreloadComponents timeout in promise race, skip inject html elements"), y.warn(i);
+        }
+      }
+    }
+    try {
+      const n = (r == null ? void 0 : r.title) || l.env.appName, h = (r == null ? void 0 : r.description) || l.env.appDescription, u = Y(Z(l.env.appUrl, "/.well-known/service/blocklet/og.png"), {
+        title: n,
+        description: h
+      });
+      w = X.render(g, {
+        ogTitle: n,
+        ogDescription: h,
+        ogImage: q(r == null ? void 0 : r.image) || u,
+        pagesPublishedAt: (t == null ? void 0 : t.config.publishedAt) || (/* @__PURE__ */ new Date()).getTime()
+      });
+    } catch {
+    }
+    const e = t == null ? void 0 : t.config.fontFamily, x = o.query.mode === "draft" || o.url.includes("preview"), d = A.load(w);
+    d("head").find("#injected-head-elements").replaceWith(`
+        
+        ${e != null && e.title ? `<link rel="preload" as="style" href="https://fonts.googleapis.com/css?family=${e.title}&display=swap">` : ""}
+        ${e != null && e.description && (e == null ? void 0 : e.description) !== (e == null ? void 0 : e.title) ? `<link rel="preload" as="style" href="https://fonts.googleapis.com/css?family=${e.description}&display=swap">` : ""}
+        <script>
+        window.__PROJECT_ID__ = "${R}"
+        window.__PAGE_STATE__ = ${JSON.stringify(t)}
+
+        document.querySelectorAll('link[rel="preload"][as="style"]').forEach(function (link) {
+          const l = document.createElement('link');
+          l.rel = 'stylesheet';
+          l.href = link.href;
+          document.head.appendChild(l);
+        });
+        <\/script>
+
+        ${x ? `<script src="https://cdn.tailwindcss.com"><\/script>
+<script>
+  window.tailwind.config = {
+    darkMode: "class",
+  };
+<\/script>` : ""}
+    `);
+    const $ = z();
+    if ($ && d('script[src="__blocklet__.js"]').replaceWith(`<script>${$}<\/script>`), m != null && m.html && d("head").find("#injected-html-elements").replaceWith(m.html), o.cachedHtml) {
+      const n = A.load(o.cachedHtml);
+      d("body").html(n("body").html() || "");
+    }
+    w = d.html(), _.send(w), y.info(`[html] render: ${o.path}, ${P()}ms`);
+  }), p.use(C);
+}
+function q(p) {
+  return Q("image-bin"), p;
+}
+export {
+  de as default
+};

package/lib/es/resources.js

@@ -1,5 +1,5 @@
-import { P as S, i as b, g as M, C as J, R as X, S as x, t as W, a as G } from "./_chunks/site-state-CD7ipvhF.js";
-import { l as N } from "./_chunks/components-k4kCJg_V.js";
+import { P as S, i as b, g as M, C as J, R as X, S as x, t as W, a as G } from "./_chunks/site-state-DH2gSYZG.js";
+import { l as N } from "./_chunks/components-BVBbxiyS.js";
 import { AsyncLocalStorage as K } from "async_hooks";
 import { Router as Y } from "express";
 import d from "fs";

package/lib/es/site-state.js

@@ -1,5 +1,5 @@
-import "./_chunks/components-k4kCJg_V.js";
-import { d as x, b as D, c as H, S as M, f as O, a as b, e as h, m as j, n as B, t as L, h as U } from "./_chunks/site-state-CD7ipvhF.js";
+import "./_chunks/components-BVBbxiyS.js";
+import { d as x, b as D, c as H, S as M, f as O, a as b, e as h, m as j, n as B, t as L, h as U } from "./_chunks/site-state-DH2gSYZG.js";
 import "@blocklet/quickjs";
 import "@blocklet/sdk/lib/component";
 import "@blocklet/sdk/lib/config";