reroute-js 0.0.4 → 0.0.6

package/cli/bin.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 // @bun
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -11,6 +12,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // packages/cli/src/commands/init.ts
 var exports_init = {};
@@ -110,7 +112,7 @@ async function copyTemplateFiles(templatePath, targetPath, variables) {
 }
 function printSuccess(projectName, template) {
   console.log(`
-✅ Project created successfully!
+[✓] Project created successfully!
 `);
   console.log(`Next steps:
 `);
@@ -192,37 +194,220 @@ async function dev(_args) {
   console.log("");
   console.log("For now, please use your own dev server setup or check the examples.");
 }
+// packages/core/src/bundler/transpile.ts
+var init_transpile = () => {};
 
-// packages/cli/src/libs/tailwind.ts
+// packages/core/src/bundler/index.ts
+var init_bundler = __esm(() => {
+  init_transpile();
+});
+
+// packages/core/src/content/builder.ts
+var init_builder = () => {};
+
+// packages/core/src/content/metadata.ts
+var init_metadata = () => {};
+
+// packages/core/src/content/discovery.ts
+var init_discovery = __esm(() => {
+  init_metadata();
+});
+
+// packages/core/src/content/registry.ts
+var init_registry = () => {};
+
+// packages/core/src/content/index.ts
+var init_content = __esm(() => {
+  init_builder();
+  init_discovery();
+  init_metadata();
+  init_registry();
+});
+
+// packages/core/src/ssr/modules.ts
+var init_modules = () => {};
+
+// packages/core/src/ssr/seed.ts
+var init_seed = __esm(() => {
+  init_modules();
+});
+
+// packages/core/src/ssr/data.ts
+var init_data = __esm(() => {
+  init_seed();
+});
+
+// node_modules/dedent/dist/dedent.mjs
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1;i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null)
+    return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object")
+      return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function createDedent(options) {
+  dedent2.withOptions = (newOptions) => createDedent(_objectSpread(_objectSpread({}, options), newOptions));
+  return dedent2;
+  function dedent2(strings, ...values) {
+    const raw = typeof strings === "string" ? [strings] : strings.raw;
+    const {
+      alignValues = false,
+      escapeSpecialCharacters = Array.isArray(strings),
+      trimWhitespace = true
+    } = options;
+    let result = "";
+    for (let i = 0;i < raw.length; i++) {
+      let next = raw[i];
+      if (escapeSpecialCharacters) {
+        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+      }
+      result += next;
+      if (i < values.length) {
+        const value = alignValues ? alignValue(values[i], result) : values[i];
+        result += value;
+      }
+    }
+    const lines = result.split(`
+`);
+    let mindent = null;
+    for (const l of lines) {
+      const m = l.match(/^(\s+)\S+/);
+      if (m) {
+        const indent = m[1].length;
+        if (!mindent) {
+          mindent = indent;
+        } else {
+          mindent = Math.min(mindent, indent);
+        }
+      }
+    }
+    if (mindent !== null) {
+      const m = mindent;
+      result = lines.map((l) => l[0] === " " || l[0] === "\t" ? l.slice(m) : l).join(`
+`);
+    }
+    if (trimWhitespace) {
+      result = result.trim();
+    }
+    if (escapeSpecialCharacters) {
+      result = result.replace(/\\n/g, `
+`);
+    }
+    return result;
+  }
+}
+function alignValue(value, precedingText) {
+  if (typeof value !== "string" || !value.includes(`
+`)) {
+    return value;
+  }
+  const currentLine = precedingText.slice(precedingText.lastIndexOf(`
+`) + 1);
+  const indentMatch = currentLine.match(/^(\s+)/);
+  if (indentMatch) {
+    const indent = indentMatch[1];
+    return value.replace(/\n/g, `
+${indent}`);
+  }
+  return value;
+}
+var dedent;
+var init_dedent = __esm(() => {
+  dedent = createDedent({});
+});
+
+// packages/core/src/template/html.ts
+var init_html = () => {};
+
+// packages/core/src/template/index.ts
+var init_template = __esm(() => {
+  init_html();
+});
+
+// packages/core/src/ssr/render.ts
+import { cloneElement } from "react";
+import { renderToString } from "react-dom/server";
+var init_render = __esm(() => {
+  init_dedent();
+  init_metadata();
+  init_template();
+  init_seed();
+});
+
+// packages/core/src/ssr/index.ts
+var init_ssr = __esm(() => {
+  init_data();
+  init_render();
+  init_seed();
+});
+
+// packages/core/src/tailwind.ts
 import { spawn } from "node:child_process";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 function isTailwindAvailable(cwd) {
-  const packageJsonPath = join2(cwd, "package.json");
-  if (!existsSync2(packageJsonPath)) {
+  const packageJsonPath = join3(cwd, "package.json");
+  if (!existsSync2(packageJsonPath))
     return false;
-  }
   try {
     const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
     const deps = {
       ...packageJson.dependencies,
       ...packageJson.devDependencies
     };
-    return "@tailwindcss/cli" in deps;
+    return !!deps && "@tailwindcss/cli" in deps;
   } catch {
     return false;
   }
 }
 function getTailwindPaths(cwd) {
-  const input = join2(cwd, "src/client/theme.css");
-  const output = join2(cwd, ".reroute/theme.css");
+  const input = join3(cwd, "src/client/theme.css");
+  const output = join3(cwd, ".reroute/theme.css");
   return { input, output };
 }
 function hasTailwindInput(cwd) {
   const { input } = getTailwindPaths(cwd);
-  if (!existsSync2(input)) {
+  if (!existsSync2(input))
     return false;
-  }
   try {
     const content = readFileSync(input, "utf-8");
     return content.includes('@import "tailwindcss"');
@@ -232,57 +417,72 @@ function hasTailwindInput(cwd) {
 }
 function resolveTailwindBin(cwd) {
   const pathsToTry = [
-    join2(cwd, "node_modules/.bin/tailwindcss"),
-    join2(cwd, "../node_modules/.bin/tailwindcss"),
-    join2(cwd, "../../node_modules/.bin/tailwindcss"),
-    join2(cwd, "../../../node_modules/.bin/tailwindcss")
+    join3(cwd, "node_modules/.bin/tailwindcss"),
+    join3(cwd, "../node_modules/.bin/tailwindcss"),
+    join3(cwd, "../../node_modules/.bin/tailwindcss"),
+    join3(cwd, "../../../node_modules/.bin/tailwindcss")
   ];
-  for (const binPath of pathsToTry) {
-    if (existsSync2(binPath)) {
+  for (const binPath of pathsToTry)
+    if (existsSync2(binPath))
       return binPath;
-    }
-  }
-  return join2(cwd, "node_modules/.bin/tailwindcss");
+  return join3(cwd, "node_modules/.bin/tailwindcss");
 }
 async function buildTailwind(cwd) {
   const { input, output } = getTailwindPaths(cwd);
-  return new Promise((resolve, reject) => {
+  if (!isTailwindAvailable(cwd) || !hasTailwindInput(cwd))
+    return;
+  await new Promise((resolve, reject) => {
     const tailwindBin = resolveTailwindBin(cwd);
     const args = ["-i", input, "-o", output];
-    const tailwind = spawn(tailwindBin, args, {
-      cwd,
-      stdio: "inherit"
-    });
-    tailwind.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Tailwind CSS build failed with code ${code}`));
-      }
-    });
-    tailwind.on("error", (error) => {
-      reject(error);
-    });
+    const tailwind = spawn(tailwindBin, args, { cwd, stdio: "inherit" });
+    tailwind.on("close", (code) => code === 0 ? resolve() : reject(new Error(`Tailwind CSS build failed with code ${code}`)));
+    tailwind.on("error", (error) => reject(error));
   });
 }
+var init_tailwind = () => {};
+// packages/core/src/utils/cache.ts
+var init_cache = () => {};
+// packages/core/src/utils/compression.ts
+var init_compression = () => {};
+
+// packages/core/src/utils/index.ts
+var init_utils = __esm(() => {
+  init_cache();
+  init_compression();
+});
+
+// packages/core/src/index.ts
+var init_src = __esm(() => {
+  init_bundler();
+  init_content();
+  init_ssr();
+  init_tailwind();
+  init_template();
+  init_utils();
+});
+
+// packages/core/index.ts
+var init_core = __esm(() => {
+  init_src();
+});
+
+// packages/cli/src/libs/tailwind.ts
 function watchTailwind(cwd) {
   const { input, output } = getTailwindPaths(cwd);
   const tailwindBin = resolveTailwindBin(cwd);
   const args = ["-i", input, "-o", output, "--watch"];
   console.log("[reroute/tailwind] Starting Tailwind CSS v4 in watch mode...");
-  const tailwind = spawn(tailwindBin, args, {
-    cwd,
-    stdio: "inherit"
-  });
-  tailwind.on("error", (error) => {
+  const { spawn: spawn2 } = __require("node:child_process");
+  const tailwind2 = spawn2(tailwindBin, args, { cwd, stdio: "inherit" });
+  tailwind2.on("error", (error) => {
     console.error("[reroute/tailwind] Error:", error);
   });
   const stop = () => {
     console.log("[reroute/tailwind] Stopping Tailwind CSS...");
-    tailwind.kill();
+    tailwind2.kill();
   };
   return {
-    process: tailwind,
+    process: tailwind2,
     stop
   };
 }
@@ -305,7 +505,9 @@ function initTailwind(cwd, watch = false) {
   });
   return null;
 }
-var init_tailwind = () => {};
+var init_tailwind2 = __esm(() => {
+  init_core();
+});
 
 // packages/cli/src/commands/gen.ts
 var exports_gen = {};
@@ -314,21 +516,21 @@ __export(exports_gen, {
 });
 import { watch } from "node:fs";
 import { mkdir as mkdir2, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function cleanupOutputDir(cwd) {
-  const outputPath = join3(cwd, OUTPUT_DIR);
   try {
-    await rm(outputPath, { recursive: true, force: true });
-    console.log(`[reroute/gen] Cleaned up ${outputPath}`);
+    await rm(join4(cwd, OUTPUT_DIR), { force: true });
+    await mkdir2(join4(cwd, OUTPUT_DIR), { recursive: true });
+    console.log("[reroute/gen] Cleaned up generated artifacts in .reroute");
   } catch {}
 }
 async function scanDirectory(dir, base = "") {
   const files = [];
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
-    const relativePath = join3(base, entry.name);
+    const fullPath = join4(dir, entry.name);
+    const relativePath = join4(base, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "content")
         continue;
@@ -349,8 +551,8 @@ async function scan404Files(dir, base = "") {
   const files = [];
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
-    const relativePath = join3(base, entry.name);
+    const fullPath = join4(dir, entry.name);
+    const relativePath = join4(base, entry.name);
     if (entry.isDirectory()) {
       const nested = await scan404Files(fullPath, relativePath);
       files.push(...nested);
@@ -541,15 +743,15 @@ async function listContentFiles(collectionDir) {
   }
 }
 async function sha8(text) {
-  const data = new TextEncoder().encode(text);
-  const buf = await crypto.subtle.digest("SHA-256", data);
+  const data2 = new TextEncoder().encode(text);
+  const buf = await crypto.subtle.digest("SHA-256", data2);
   let hex = "";
   for (const b of new Uint8Array(buf))
     hex += b.toString(16).padStart(2, "0");
   return hex.slice(0, 8);
 }
 async function buildContentChunks(cwd) {
-  const routesRoot = join3(cwd, ROUTES_DIR);
+  const routesRoot = join4(cwd, ROUTES_DIR);
   console.log(`[reroute/content] scan ${routesRoot}`);
   const collections = await readdir2(routesRoot, { withFileTypes: true });
   const results = [];
@@ -557,7 +759,7 @@ async function buildContentChunks(cwd) {
     if (!c.isDirectory())
       continue;
     const collection = c.name;
-    const contentDir = join3(routesRoot, collection, "content");
+    const contentDir = join4(routesRoot, collection, "content");
     console.log(`[reroute/content] collection ${collection} dir ${contentDir}`);
     const files = await listContentFiles(contentDir);
     console.log(`[reroute/content] files ${files.join(",")}`);
@@ -565,7 +767,7 @@ async function buildContentChunks(cwd) {
       continue;
     for (const file of files) {
       const name = file.replace(/\.(tsx|ts)$/, "");
-      const absSrc = join3(contentDir, file);
+      const absSrc = join4(contentDir, file);
       let code = "";
       try {
         console.log(`[reroute/content] build ${absSrc}`);
@@ -585,11 +787,11 @@ async function buildContentChunks(cwd) {
         console.error("[reroute/gen] Failed to build content chunk:", absSrc, e);
         continue;
       }
-      const hash = await sha8(code);
-      const chunkRelDir = join3(".reroute", "chunks", collection);
-      const chunkAbsDir = join3(cwd, chunkRelDir);
-      const outFile = `${name}.${hash}.js`;
-      const absOut = join3(chunkAbsDir, outFile);
+      const hash2 = await sha8(code);
+      const chunkRelDir = join4(".reroute", "chunks", collection);
+      const chunkAbsDir = join4(cwd, chunkRelDir);
+      const outFile = `${name}.${hash2}.js`;
+      const absOut = join4(chunkAbsDir, outFile);
       await mkdir2(chunkAbsDir, { recursive: true });
       try {
         const exists = await Bun.file(absOut).exists();
@@ -639,12 +841,12 @@ async function buildContentChunks(cwd) {
   lines.push("  return m ? (m as Record<string, any>)[name] : undefined;");
   lines.push("}");
   lines.push("");
-  await mkdir2(join3(cwd, ".reroute"), { recursive: true });
-  await writeFile2(join3(cwd, OUTPUT_CONTENT_TS), lines.join(`
+  await mkdir2(join4(cwd, ".reroute"), { recursive: true });
+  await writeFile2(join4(cwd, OUTPUT_CONTENT_TS), lines.join(`
 `), "utf-8");
-  console.log(`[reroute/content] wrote ${join3(cwd, OUTPUT_CONTENT_TS)}`);
+  console.log(`[reroute/content] wrote ${join4(cwd, OUTPUT_CONTENT_TS)}`);
   const collectionsSet = new Set(results.map((r) => r.collection));
-  await mkdir2(join3(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
+  await mkdir2(join4(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
   for (const collection of collectionsSet) {
     const items = results.filter((r) => r.collection === collection);
     const js = [];
@@ -664,31 +866,31 @@ async function buildContentChunks(cwd) {
     js.push("  return byName[name];");
     js.push("}");
     js.push("");
-    await writeFile2(join3(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`), js.join(`
+    await writeFile2(join4(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`), js.join(`
 `), "utf-8");
-    console.log(`[reroute/content] wrote ${join3(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`)}`);
+    console.log(`[reroute/content] wrote ${join4(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`)}`);
   }
 }
 async function generate(cwd) {
   console.log("[reroute/gen] Starting generation...");
   await cleanupOutputDir(cwd);
-  const routesPath = join3(cwd, ROUTES_DIR);
+  const routesPath = join4(cwd, ROUTES_DIR);
   try {
     const files = await scanDirectory(routesPath);
     const nfFiles = await scan404Files(routesPath);
     const all = Array.from(new Set([...files, ...nfFiles]));
     const tree = generateRouteTree(all.map((f) => f.replace(/\\/g, "/")));
     const ts = generateTypeScript(tree);
-    await mkdir2(join3(cwd, ".reroute"), { recursive: true });
-    await writeFile2(join3(cwd, OUTPUT_ROUTES), ts, "utf-8");
-    console.log(`[reroute/gen] Generated routes: ${join3(cwd, OUTPUT_ROUTES)}`);
+    await mkdir2(join4(cwd, ".reroute"), { recursive: true });
+    await writeFile2(join4(cwd, OUTPUT_ROUTES), ts, "utf-8");
+    console.log(`[reroute/gen] Generated routes: ${join4(cwd, OUTPUT_ROUTES)}`);
   } catch (error) {
     console.error("[reroute/gen] Failed to generate routes:", error);
     throw error;
   }
   try {
     await buildContentChunks(cwd);
-    console.log(`[reroute/gen] Generated content: ${join3(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
+    console.log(`[reroute/gen] Generated content: ${join4(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
   } catch (error) {
     console.error("[reroute/gen] Failed to generate content:", error);
     throw error;
@@ -708,9 +910,9 @@ async function generate(cwd) {
   indexLines.push("} as const;");
   indexLines.push("");
   indexLines.push("export type RerouteArtifacts = typeof artifacts;");
-  await writeFile2(join3(cwd, OUTPUT_INDEX), indexLines.join(`
+  await writeFile2(join4(cwd, OUTPUT_INDEX), indexLines.join(`
 `), "utf-8");
-  console.log(`[reroute/gen] Generated index: ${join3(cwd, OUTPUT_INDEX)}`);
+  console.log(`[reroute/gen] Generated index: ${join4(cwd, OUTPUT_INDEX)}`);
   console.log("[reroute/gen] ✅ Generation complete!");
 }
 async function gen(args) {
@@ -720,8 +922,10 @@ async function gen(args) {
     console.log("[reroute/gen] Watch mode enabled");
     console.log("[reroute/gen] Initial generation...");
     await generate(cwd);
-    const tailwindProcess = initTailwind(cwd, true);
-    const routesPath = join3(cwd, ROUTES_DIR);
+    try {
+      await buildTailwind(cwd);
+    } catch {}
+    const routesPath = join4(cwd, ROUTES_DIR);
     console.log(`[reroute/gen] Watching ${routesPath} for changes...`);
     let timeout = null;
     const watcher = watch(routesPath, { recursive: true }, (_eventType, filename) => {
@@ -733,18 +937,37 @@ async function gen(args) {
         console.log("[reroute/gen] Change detected, regenerating...");
         try {
           await generate(cwd);
+          await buildTailwind(cwd);
         } catch (error) {
           console.error("[reroute/gen] Error during regeneration:", error);
         }
-      }, 300);
+      }, 0);
+    });
+    const clientPath = join4(cwd, "src", "client");
+    console.log(`[reroute/gen] Watching ${clientPath} for Tailwind class changes...`);
+    let twTimeout = null;
+    const twWatcher = watch(clientPath, { recursive: true }, (_eventType, filename) => {
+      if (!filename)
+        return;
+      if (filename.includes(".reroute") || filename.includes("node_modules"))
+        return;
+      if (filename.includes("routes/") || filename.includes("routes\\"))
+        return;
+      if (!/\.(tsx|ts|jsx|js|html|md|mdx|css)$/.test(filename))
+        return;
+      if (twTimeout)
+        clearTimeout(twTimeout);
+      twTimeout = setTimeout(async () => {
+        try {
+          await buildTailwind(cwd);
+        } catch {}
+      }, 200);
     });
     process.on("SIGINT", () => {
       console.log(`
 [reroute/gen] Stopping watch mode...`);
       watcher.close();
-      if (tailwindProcess) {
-        tailwindProcess.stop();
-      }
+      twWatcher.close();
       process.exit(0);
     });
   } else {
@@ -754,7 +977,8 @@ async function gen(args) {
 }
 var ROUTES_DIR = "src/client/routes", OUTPUT_DIR = ".reroute", OUTPUT_ROUTES = ".reroute/routes.ts", OUTPUT_CONTENT_TS = ".reroute/content.ts", OUTPUT_COLLECTIONS_DIR = ".reroute/collections", OUTPUT_INDEX = ".reroute/index.ts";
 var init_gen = __esm(() => {
-  init_tailwind();
+  init_core();
+  init_tailwind2();
 });
 
 // packages/cli/src/index.ts
@@ -809,4 +1033,4 @@ function printHelp2() {
 }
 main();
 
-//# debugId=C29E5DC549E7785F64756E2164756E21
+//# debugId=D904E39CF66BD8B664756E2164756E21