@feeef.dev/cli 0.2.0

package/vendor/template-kit/lib/component-meta.mjs

@@ -0,0 +1,481 @@
+/**
+ * Load component metadata from `export const meta` in a component entry,
+ * with fallback to legacy `component.json`.
+ *
+ * Entries may be:
+ * - Flat file: `components/hero.tsx` (or `.jsx` / `.json`)
+ * - Folder: `components/hero/component.tsx` (+ optional nested slots/children)
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import vm from "node:vm";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { COMPONENT_META_KEYS, rel } from "./paths.mjs";
+
+const require = createRequire(import.meta.url);
+
+/** Flat / folder entry extensions (basename, not `slots.empty.json`). */
+const FLAT_CODE_EXT = new Set([".tsx", ".jsx"]);
+const FLAT_META_EXT = new Set([".tsx", ".jsx", ".json"]);
+
+/**
+ * @returns {typeof import('esbuild') | null}
+ */
+function loadEsbuild() {
+  try {
+    return require("esbuild");
+  } catch {
+    try {
+      const here = path.dirname(fileURLToPath(import.meta.url));
+      const cliRoot = path.resolve(here, "../../..");
+      return createRequire(path.join(cliRoot, "package.json"))("esbuild");
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Component id from an entry path (`hero.tsx` → `hero`, `hero/` → `hero`).
+ * @param {string} entryPath
+ */
+export function componentIdFromPath(entryPath) {
+  const base = path.basename(entryPath);
+  const ext = path.extname(base).toLowerCase();
+  if (FLAT_META_EXT.has(ext)) return base.slice(0, -ext.length);
+  return base;
+}
+
+/**
+ * Whether `root` is a flat component file (not a directory).
+ * @param {string} root
+ */
+export function isFlatComponentFile(root) {
+  try {
+    if (!fs.statSync(root).isFile()) return false;
+  } catch {
+    return false;
+  }
+  const ext = path.extname(root).toLowerCase();
+  return FLAT_META_EXT.has(ext) && path.basename(root) !== "slots.empty.json";
+}
+
+/**
+ * Resolve the TSX/JSX source file for a component root (dir or flat file).
+ * @param {string} root Absolute path to component folder or flat `.tsx`/`.jsx`/`.json`
+ * @returns {string | null}
+ */
+export function resolveComponentEntry(root) {
+  if (isFlatComponentFile(root)) {
+    const ext = path.extname(root).toLowerCase();
+    if (FLAT_CODE_EXT.has(ext)) return root;
+    return null;
+  }
+  const tsx = path.join(root, "component.tsx");
+  const jsx = path.join(root, "component.jsx");
+  if (fs.existsSync(tsx)) return tsx;
+  if (fs.existsSync(jsx)) return jsx;
+  return null;
+}
+
+/**
+ * List component entries under a `components/` (or `children/` / `slots/<id>/`) dir.
+ * Supports flat `name.tsx|jsx|json` and legacy `name/` folders.
+ * Prefer folder when both `name/` and `name.tsx` exist (warn via thrown Error).
+ *
+ * @param {string} componentsDir
+ * @returns {string[]} Absolute entry paths, sorted by meta.order then id
+ */
+export function listComponentEntries(componentsDir) {
+  if (!fs.existsSync(componentsDir)) return [];
+
+  /** @type {Map<string, { id: string; path: string; kind: 'dir' | 'file' }>} */
+  const byId = new Map();
+
+  for (const ent of fs.readdirSync(componentsDir, { withFileTypes: true })) {
+    if (ent.name.startsWith(".")) continue;
+
+    if (ent.isDirectory()) {
+      const id = ent.name;
+      const abs = path.join(componentsDir, id);
+      const prev = byId.get(id);
+      if (prev && prev.kind === "file") {
+        throw new Error(
+          `Component id "${id}" has both ${rel(prev.path)} and folder ${rel(abs)} — keep one`,
+        );
+      }
+      byId.set(id, { id, path: abs, kind: "dir" });
+      continue;
+    }
+
+    if (!ent.isFile()) continue;
+    if (ent.name === "slots.empty.json") continue;
+    const ext = path.extname(ent.name).toLowerCase();
+    if (!FLAT_META_EXT.has(ext)) continue;
+
+    const id = ent.name.slice(0, -ext.length);
+    const abs = path.join(componentsDir, ent.name);
+    const prev = byId.get(id);
+    if (prev) {
+      if (prev.kind === "dir") {
+        throw new Error(
+          `Component id "${id}" has both folder ${rel(prev.path)} and ${rel(abs)} — keep one`,
+        );
+      }
+      // Prefer .tsx > .jsx > .json when duplicates
+      const rank = (p) =>
+        p.endsWith(".tsx") ? 0 : p.endsWith(".jsx") ? 1 : 2;
+      if (rank(abs) < rank(prev.path)) {
+        byId.set(id, { id, path: abs, kind: "file" });
+      }
+      continue;
+    }
+    byId.set(id, { id, path: abs, kind: "file" });
+  }
+
+  /** @type {{ id: string; order: number; path: string }[]} */
+  const entries = [...byId.values()].map(({ id, path: abs }) => {
+    let order = Number.MAX_SAFE_INTEGER;
+    try {
+      const { meta } = loadComponentMeta(abs);
+      if (typeof meta.order === "number") order = meta.order;
+    } catch {
+      // Missing meta — keep at end; readComponentRaw will throw later.
+    }
+    return { id, order, path: abs };
+  });
+
+  entries.sort((a, b) => {
+    if (a.order !== b.order) return a.order - b.order;
+    return a.id.localeCompare(b.id);
+  });
+  return entries.map((e) => e.path);
+}
+
+/**
+ * Strip `export const meta` / `componentMeta` so live compile only keeps App.
+ * @param {string} source
+ */
+export function stripMetaExport(source) {
+  let out = source;
+  out = removeExportedConst(out, "meta");
+  out = removeExportedConst(out, "componentMeta");
+  out = out.replace(
+    /export\s*\{[^}]*\bmeta\b[^}]*\}\s*;?/g,
+    "/* stripped meta re-export */",
+  );
+  // Authoring-only schema binding (used by meta + FeeefLivePropsOf) — not for react-live.
+  out = removeTopLevelConst(out, "propsSchema");
+  return out;
+}
+
+/**
+ * Remove a top-level `const name = …;` (object/array/literal), including `as const`.
+ * @param {string} source
+ * @param {string} name
+ */
+function removeTopLevelConst(source, name) {
+  const re = new RegExp(String.raw`(?:^|\n)const\s+${name}\s*=\s*`);
+  const m = re.exec(source);
+  if (!m || m.index == null) return source;
+  const start = m[0].startsWith("\n") ? m.index + 1 : m.index;
+  let i = m.index + m[0].length;
+  i = skipValue(source, i);
+  i = skipMetaTrailer(source, i);
+  return source.slice(0, start) + source.slice(i);
+}
+
+/**
+ * Remove `export const name = …;` (object/array/literal) via brace scan.
+ * @param {string} source
+ * @param {string} name
+ */
+function removeExportedConst(source, name) {
+  const re = new RegExp(
+    String.raw`export\s+const\s+${name}(?:\s+satisfies\s+[^=]+)?\s*=\s*`,
+  );
+  const m = re.exec(source);
+  if (!m || m.index == null) return source;
+  const start = m.index;
+  let i = m.index + m[0].length;
+  // Skip value
+  i = skipValue(source, i);
+  // trailing `as const` / `satisfies T` / `;` / whitespace
+  i = skipMetaTrailer(source, i);
+  return source.slice(0, start) + source.slice(i);
+}
+
+/**
+ * Skip `as const`, `satisfies Type`, semicolons after a meta value.
+ * @param {string} source
+ * @param {number} i
+ */
+function skipMetaTrailer(source, i) {
+  for (;;) {
+    while (i < source.length && /\s/.test(source[i])) i++;
+    if (source.slice(i, i + 8) === "as const") {
+      i += 8;
+      continue;
+    }
+    if (source.slice(i, i + 9) === "satisfies") {
+      i += 9;
+      while (i < source.length && /\s/.test(source[i])) i++;
+      // skip type expression until `;` or newline before next top-level
+      i = skipTypeExpression(source, i);
+      continue;
+    }
+    if (source[i] === ";") {
+      i++;
+      if (source[i] === "\n") i++;
+      break;
+    }
+    if (source[i] === "\n") {
+      i++;
+      break;
+    }
+    break;
+  }
+  return i;
+}
+
+/**
+ * Skip a TypeScript type expression (identifiers, `.`, `<>`, `[]`, `|`, `&`, `typeof`).
+ * @param {string} source
+ * @param {number} i
+ */
+function skipTypeExpression(source, i) {
+  let depthAngle = 0;
+  let depthParen = 0;
+  let depthBracket = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "<") depthAngle++;
+    else if (c === ">") depthAngle = Math.max(0, depthAngle - 1);
+    else if (c === "(") depthParen++;
+    else if (c === ")") depthParen = Math.max(0, depthParen - 1);
+    else if (c === "[") depthBracket++;
+    else if (c === "]") depthBracket = Math.max(0, depthBracket - 1);
+    else if (
+      (c === ";" || c === "\n") &&
+      depthAngle === 0 &&
+      depthParen === 0 &&
+      depthBracket === 0
+    ) {
+      break;
+    }
+    i++;
+  }
+  return i;
+}
+
+/**
+ * @param {string} source
+ * @param {number} i
+ */
+function skipValue(source, i) {
+  const ch = source[i];
+  if (ch === "{" || ch === "[") {
+    const open = ch;
+    const close = ch === "{" ? "}" : "]";
+    let depth = 0;
+    for (; i < source.length; i++) {
+      const c = source[i];
+      if (c === "'" || c === '"' || c === "`") {
+        const q = c;
+        i++;
+        while (i < source.length) {
+          if (source[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (source[i] === q) break;
+          i++;
+        }
+        continue;
+      }
+      if (c === open) depth++;
+      else if (c === close) {
+        depth--;
+        if (depth === 0) return i + 1;
+      }
+    }
+    return source.length;
+  }
+  // identifier / number / string literal until `;` or newline+`as`
+  while (i < source.length && source[i] !== ";" && source[i] !== "\n") i++;
+  return i;
+}
+
+/**
+ * Evaluate `export const meta` from component source without running App UI.
+ * @param {string} source
+ * @param {string} filePath
+ * @returns {Record<string, any> | null}
+ */
+export function extractMetaFromSource(source, filePath) {
+  if (
+    !/\bexport\s+const\s+(meta|componentMeta)\b/.test(source) &&
+    !/\bexport\s*\{[^}]*\bmeta\b/.test(source)
+  ) {
+    return null;
+  }
+
+  const esbuild = loadEsbuild();
+  if (!esbuild) {
+    throw new Error(
+      `Found export const meta in ${rel(filePath)} but esbuild is not installed`,
+    );
+  }
+
+  const neutralized = stubAppFunction(source);
+  const loader = filePath.endsWith(".tsx") ? "tsx" : "jsx";
+  const transformed = esbuild.transformSync(neutralized, {
+    loader,
+    format: "cjs",
+    target: "es2018",
+    jsx: "transform",
+    logLevel: "silent",
+  });
+
+  const module = { exports: /** @type {Record<string, any>} */ ({}) };
+  const sandbox = {
+    module,
+    exports: module.exports,
+    require: () => ({}),
+    React: {
+      createElement: () => null,
+      Fragment: "Fragment",
+      useState: (v) => [v, () => {}],
+      useEffect: () => {},
+      useRef: (v) => ({ current: v }),
+      useMemo: (fn) => fn(),
+      useCallback: (fn) => fn,
+    },
+    console,
+  };
+
+  try {
+    vm.runInNewContext(
+      `${transformed.code}\n; module.exports = Object.assign({}, module.exports, exports);`,
+      sandbox,
+      { filename: filePath, timeout: 2000 },
+    );
+  } catch (err) {
+    throw new Error(
+      `Failed to evaluate meta export in ${rel(filePath)}: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+  }
+
+  const meta =
+    sandbox.module.exports?.meta ??
+    sandbox.module.exports?.componentMeta ??
+    null;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    return null;
+  }
+  return { ...meta };
+}
+
+/**
+ * Replace `function App(...) { ... }` with a no-op stub (brace-balanced).
+ * @param {string} source
+ */
+function stubAppFunction(source) {
+  const re = /\bfunction\s+App\s*\([^)]*\)\s*\{/;
+  const m = re.exec(source);
+  if (!m || m.index == null) return source;
+  const start = m.index;
+  const bodyStart = m.index + m[0].length - 1; // at '{'
+  let depth = 0;
+  let i = bodyStart;
+  for (; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        i++;
+        break;
+      }
+    } else if (ch === "'" || ch === '"' || ch === "`") {
+      // skip strings
+      const quote = ch;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === quote) break;
+        i++;
+      }
+    }
+  }
+  return (
+    source.slice(0, start) +
+    "function App(){ return null; }\n" +
+    source.slice(i)
+  );
+}
+
+/**
+ * Load meta for a component entry (folder or flat file).
+ * Preference: `export const meta` in .tsx/.jsx → sibling/flat `.json` / `component.json`.
+ * @param {string} root Absolute path to component folder or flat file
+ * @returns {{ meta: Record<string, any>, source: 'tsx' | 'json', entry: string | null, jsonPath: string | null }}
+ */
+export function loadComponentMeta(root) {
+  if (isFlatComponentFile(root)) {
+    const ext = path.extname(root).toLowerCase();
+    if (ext === ".json") {
+      const meta = JSON.parse(fs.readFileSync(root, "utf8"));
+      return { meta, source: "json", entry: null, jsonPath: root };
+    }
+    const source = fs.readFileSync(root, "utf8");
+    const fromTs = extractMetaFromSource(source, root);
+    if (fromTs) {
+      return { meta: fromTs, source: "tsx", entry: root, jsonPath: null };
+    }
+    throw new Error(
+      `Missing export const meta in ${rel(root)} — add meta or use a .json leaf`,
+    );
+  }
+
+  const entry = resolveComponentEntry(root);
+  if (entry) {
+    const source = fs.readFileSync(entry, "utf8");
+    const fromTs = extractMetaFromSource(source, entry);
+    if (fromTs) {
+      return { meta: fromTs, source: "tsx", entry, jsonPath: null };
+    }
+  }
+
+  const jsonPath = path.join(root, "component.json");
+  if (fs.existsSync(jsonPath)) {
+    const meta = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
+    return { meta, source: "json", entry, jsonPath };
+  }
+
+  throw new Error(
+    `Missing component meta in ${rel(root)} — add export const meta in component.tsx / <name>.tsx or component.json`,
+  );
+}
+
+/**
+ * Serialize meta as a TS `export const meta = …` preamble for unpack.
+ * @param {Record<string, any>} meta
+ */
+export function formatMetaExport(meta) {
+  const clean = { ...meta };
+  delete clean.$schema;
+  delete clean.code;
+  // Keep order + COMPONENT_META_KEYS + any extra catalog fields already on meta
+  const json = JSON.stringify(clean, null, 2);
+  return `export const meta = ${json} as const;\n\n`;
+}
+
+export { COMPONENT_META_KEYS };

package/vendor/template-kit/lib/library.mjs

@@ -0,0 +1,168 @@
+/**
+ * Theme component library (`schema.library.json`).
+ *
+ * Author under:
+ *   <theme>/library/components/<id>.tsx   # preferred leaf
+ *   <theme>/library/components/<id>/      # folder when slots/children needed
+ *     component.json / component.tsx
+ *     slots/… children/…
+ *
+ * Entries may never appear in data.json — they exist so the merchant editor
+ * can drag-drop them into pages. Build emits `dist/schema.library.json` and
+ * the same list is embedded on the template schema as `library: [...]`.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  componentIdFromPath,
+  listComponentEntries,
+} from "./component-meta.mjs";
+
+/**
+ * Catalog metadata keys (not part of TemplateDataComponent runtime).
+ */
+const CATALOG_KEYS = new Set([
+  "libraryId",
+  "id",
+  "title",
+  "subtitle",
+  "category",
+  "tags",
+  "imageUrl",
+  "order",
+  "$schema",
+  "$ref",
+  "shared",
+]);
+
+/**
+ * Build schema.library.json document from disk.
+ *
+ * @param {object} opts
+ * @param {string} opts.srcDir
+ * @param {(dir: string, fileStack: string[]) => Record<string, any>} opts.readComponentRaw
+ * @param {(node: any, catalog: Map<string, any>, resolving: Set<string>, hint: string) => any} [opts.resolveSharedInTree]
+ * @param {Map<string, any>} [opts.sharedCatalog]
+ */
+export function buildSchemaLibrary({
+  srcDir,
+  readComponentRaw,
+  resolveSharedInTree,
+  sharedCatalog,
+}) {
+  const libraryRoot = path.join(srcDir, "library", "components");
+  /** @type {any[]} */
+  const components = [];
+
+  if (!fs.existsSync(libraryRoot)) {
+    return {
+      version: "1.0",
+      components: [],
+    };
+  }
+
+  const fileStack = [];
+  const resolving = new Set();
+  const catalog = sharedCatalog || new Map();
+
+  for (const entryPath of listComponentEntries(libraryRoot)) {
+    const folderName = componentIdFromPath(entryPath);
+    let raw = readComponentRaw(entryPath, fileStack);
+
+    if (resolveSharedInTree && catalog.size > 0) {
+      raw = resolveSharedInTree(
+        raw,
+        catalog,
+        resolving,
+        `library/${folderName}`,
+      );
+    }
+
+    const id =
+      (typeof raw.libraryId === "string" && raw.libraryId.trim()) ||
+      (typeof raw.id === "string" && raw.id.trim()) ||
+      folderName;
+
+    const title =
+      (typeof raw.title === "string" && raw.title.trim()) ||
+      id;
+
+    /** @type {Record<string, any>} */
+    const entry = {
+      id,
+      title,
+      subtitle: raw.subtitle ?? null,
+      category: raw.category ?? "library",
+      tags: Array.isArray(raw.tags) ? raw.tags : [],
+      imageUrl: raw.imageUrl ?? null,
+      // Insert type: usually "custom"; may be a built-in registry type.
+      type: typeof raw.type === "string" && raw.type ? raw.type : "custom",
+      code: typeof raw.code === "string" ? raw.code : null,
+      propsSchema:
+        raw.propsSchema && typeof raw.propsSchema === "object"
+          ? raw.propsSchema
+          : null,
+      propsDefault:
+        raw.props && typeof raw.props === "object" ? raw.props : {},
+      slotsSchema:
+        raw.slotsSchema && typeof raw.slotsSchema === "object"
+          ? raw.slotsSchema
+          : null,
+      slotsDefault:
+        raw.slots && typeof raw.slots === "object" ? raw.slots : null,
+      slotsLayout:
+        raw.slotsLayout && typeof raw.slotsLayout === "object"
+          ? raw.slotsLayout
+          : null,
+      children: Array.isArray(raw.children) ? raw.children : null,
+    };
+
+    // Preserve unknown forward-compat fields (except catalog/runtime noise).
+    for (const [k, v] of Object.entries(raw)) {
+      if (CATALOG_KEYS.has(k)) continue;
+      if (
+        [
+          "type",
+          "code",
+          "props",
+          "propsSchema",
+          "slots",
+          "slotsSchema",
+          "slotsLayout",
+          "children",
+          "instanceId",
+          "refId",
+          "refVersion",
+        ].includes(k)
+      ) {
+        continue;
+      }
+      if (v !== undefined && !(k in entry)) entry[k] = v;
+    }
+
+    components.push(entry);
+  }
+
+  // Stable order: optional numeric order on disk via folder order already sorted;
+  // secondary sort by title.
+  components.sort((a, b) => String(a.title).localeCompare(String(b.title)));
+
+  return {
+    version: "1.0",
+    components,
+  };
+}
+
+/**
+ * Embed library list onto a schema document (non-destructive).
+ * @param {Record<string, any>} schema
+ * @param {{ components?: any[] }} libraryDoc
+ */
+export function attachLibraryToSchema(schema, libraryDoc) {
+  const next = { ...schema };
+  next.library = Array.isArray(libraryDoc?.components)
+    ? libraryDoc.components
+    : [];
+  return next;
+}

package/vendor/template-kit/lib/locales.mjs

@@ -0,0 +1,68 @@
+/**
+ * Theme locale files (`locales/*.json`) → TemplateData.i18n + dist/locales/.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * @param {string} srcDir
+ * @param {{ defaultLocale?: string }} [opts]
+ * @returns {{
+ *   defaultLocale: string,
+ *   locales: string[],
+ *   messages: Record<string, Record<string, any>>,
+ * } | null}
+ */
+export function buildThemeI18n(srcDir, opts = {}) {
+  const localesDir = path.join(srcDir, "locales");
+  if (!fs.existsSync(localesDir)) return null;
+
+  /** @type {Record<string, Record<string, any>>} */
+  const messages = {};
+  const locales = fs
+    .readdirSync(localesDir)
+    .filter((name) => name.endsWith(".json") && !name.startsWith("."))
+    .map((name) => name.replace(/\.json$/i, ""))
+    .sort();
+
+  for (const locale of locales) {
+    const filePath = path.join(localesDir, `${locale}.json`);
+    try {
+      messages[locale] = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch (err) {
+      throw new Error(
+        `Invalid locale file ${path.relative(process.cwd(), filePath)}: ${err}`,
+      );
+    }
+  }
+
+  if (locales.length === 0) return null;
+
+  const defaultLocale =
+    (typeof opts.defaultLocale === "string" && opts.defaultLocale) ||
+    (locales.includes("en") ? "en" : locales[0]);
+
+  return {
+    defaultLocale,
+    locales,
+    messages,
+  };
+}
+
+/**
+ * Write per-locale JSON next to data.json.
+ * @param {string} distDir
+ * @param {{ messages: Record<string, Record<string, any>> }} i18n
+ */
+export function writeLocaleFiles(distDir, i18n) {
+  const outDir = path.join(distDir, "locales");
+  fs.mkdirSync(outDir, { recursive: true });
+  for (const [locale, tree] of Object.entries(i18n.messages || {})) {
+    fs.writeFileSync(
+      path.join(outDir, `${locale}.json`),
+      `${JSON.stringify(tree, null, 2)}\n`,
+      "utf8",
+    );
+  }
+}