@feeef.dev/cli 0.2.0

package/vendor/template-kit/bin/feeef-template.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * Feeef Template Kit CLI
+ *
+ *   node template-kit/bin/feeef-template.mjs unpack <data.json> -o <dir> [--force]
+ *   node template-kit/bin/feeef-template.mjs build <srcDir> [-o dist/data.json]
+ *   node template-kit/bin/feeef-template.mjs check <srcDir>
+ *   node template-kit/bin/feeef-template.mjs watch <srcDir> [-o dist/data.json]
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { unpackTemplate } from "../lib/unpack.mjs";
+import { buildTemplate } from "../lib/build.mjs";
+import { resolveFromCwd, rel } from "../lib/paths.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function printHelp() {
+  console.log(`
+Feeef Template Kit — author templates as a folder tree, compile to data.json
+
+Usage:
+  feeef-template unpack <data.json> -o <outDir> [--force]
+  feeef-template build  <srcDir> [-o <data.json>]
+  feeef-template check  <srcDir>
+  feeef-template watch  <srcDir> [-o <data.json>]
+
+Examples (from storefront/):
+  npm run template:unpack
+  npm run template:build
+  npm run template:dev
+`);
+}
+
+/**
+ * @param {string[]} argv
+ */
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const cmd = args[0];
+  /** @type {Record<string, string | boolean>} */
+  const flags = {};
+  /** @type {string[]} */
+  const positional = [];
+
+  for (let i = 1; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--force") {
+      flags.force = true;
+    } else if (a === "-o" || a === "--out") {
+      flags.out = args[++i];
+    } else if (a === "-h" || a === "--help") {
+      flags.help = true;
+    } else if (a.startsWith("-")) {
+      throw new Error(`Unknown flag: ${a}`);
+    } else {
+      positional.push(a);
+    }
+  }
+
+  return { cmd, flags, positional };
+}
+
+function runBuild(srcDir, outPath, { write }) {
+  const result = buildTemplate({
+    srcDir,
+    outPath,
+    write,
+  });
+  for (const w of result.warnings) {
+    console.warn(`warning: [${w.path}] ${w.message}`);
+  }
+  if (write) {
+    console.log(
+      `✓ built ${result.pageCount} pages / ${result.componentCount} components` +
+        (result.sharedCount
+          ? ` (${result.sharedCount} shared, ${result.sharedPlacementCount} placements)`
+          : "") +
+        (result.libraryCount
+          ? ` / ${result.libraryCount} library`
+          : "") +
+        (result.localeCount ? ` / ${result.localeCount} locales` : "") +
+        ` → ${rel(result.outPath)}`,
+    );
+    if (result.libraryOutPath) {
+      console.log(`  library → ${rel(result.libraryOutPath)}`);
+    }
+    if (result.localeCount) {
+      console.log(`  locales → ${rel(path.dirname(result.outPath) + "/locales")}`);
+    }
+  } else {
+    console.log(
+      `✓ check ok — ${result.pageCount} pages / ${result.componentCount} components` +
+        (result.sharedCount ? ` / ${result.sharedCount} shared` : "") +
+        (result.libraryCount ? ` / ${result.libraryCount} library` : ""),
+    );
+  }
+  return result;
+}
+
+async function main() {
+  let parsed;
+  try {
+    parsed = parseArgs(process.argv);
+  } catch (e) {
+    console.error(String(e.message || e));
+    process.exit(1);
+  }
+
+  const { cmd, flags, positional } = parsed;
+
+  if (!cmd || flags.help || cmd === "help") {
+    printHelp();
+    process.exit(cmd && !flags.help ? 1 : 0);
+  }
+
+  try {
+    if (cmd === "unpack") {
+      const input = positional[0];
+      if (!input || !flags.out) {
+        console.error("Usage: unpack <data.json> -o <outDir> [--force]");
+        process.exit(1);
+      }
+      const stats = unpackTemplate({
+        inputPath: resolveFromCwd(input),
+        outDir: resolveFromCwd(String(flags.out)),
+        force: Boolean(flags.force),
+      });
+      console.log(
+        `✓ unpacked ${stats.pages} pages / ${stats.components} root components (${stats.files} files) → ${flags.out}`,
+      );
+      return;
+    }
+
+    if (cmd === "build" || cmd === "check") {
+      const src = positional[0];
+      if (!src) {
+        console.error(`Usage: ${cmd} <srcDir> [-o data.json]`);
+        process.exit(1);
+      }
+      const srcDir = resolveFromCwd(src);
+      const outPath = flags.out
+        ? resolveFromCwd(String(flags.out))
+        : path.join(srcDir, "dist", "data.json");
+      runBuild(srcDir, outPath, { write: cmd === "build" });
+      return;
+    }
+
+    if (cmd === "watch") {
+      const src = positional[0];
+      if (!src) {
+        console.error("Usage: watch <srcDir> [-o data.json]");
+        process.exit(1);
+      }
+      const srcDir = resolveFromCwd(src);
+      const outPath = flags.out
+        ? resolveFromCwd(String(flags.out))
+        : path.join(srcDir, "dist", "data.json");
+
+      const rebuild = () => {
+        try {
+          runBuild(srcDir, outPath, { write: true });
+        } catch (e) {
+          console.error(`build failed: ${e.message || e}`);
+        }
+      };
+
+      rebuild();
+      console.log(`watching ${rel(srcDir)} …`);
+
+      /** @type {ReturnType<typeof setTimeout> | null} */
+      let timer = null;
+      const schedule = () => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(rebuild, 120);
+      };
+
+      // Recursive watch is supported on macOS / Windows; Linux may need polling.
+      try {
+        fs.watch(srcDir, { recursive: true }, (_event, filename) => {
+          if (!filename) {
+            schedule();
+            return;
+          }
+          const norm = filename.replace(/\\/g, "/");
+          if (norm.startsWith("dist/") || norm.includes("/dist/")) return;
+          schedule();
+        });
+      } catch (e) {
+        console.error(
+          `fs.watch(recursive) failed (${e.message}). Rebuild manually with template:build.`,
+        );
+        process.exit(1);
+      }
+
+      // Keep process alive.
+      await new Promise(() => {});
+      return;
+    }
+
+    console.error(`Unknown command: ${cmd}`);
+    printHelp();
+    process.exit(1);
+  } catch (e) {
+    console.error(e.message || e);
+    process.exit(1);
+  }
+}
+
+main();