bun-plugin-stx 0.2.413 → 0.2.414

package/dist/{chunk-anqecs1e.js → chunk-18kmm7vg.js}

@@ -33,7 +33,7 @@ function shouldWatch(filePath, options) {
   }
   return true;
 }
-function createWatcher(options = {}) {
+function createWatcher2(options = {}) {
   const watchedPaths = new Set;
   const watchers = new Map;
   let isActive = true;
@@ -127,7 +127,7 @@ function createWatcher(options = {}) {
     isWatching: () => isActive && watchers.size > 0
   };
 }
-async function watchAndBuild(options) {
+async function watchAndBuild2(options) {
   const {
     entrypoints,
     outdir = "./dist",
@@ -145,7 +145,7 @@ async function watchAndBuild(options) {
       const result = await Bun.build({
         entrypoints,
         outdir,
-        plugins: [stxPlugin(stxOptions)],
+        plugins: [stxPlugin2(stxOptions)],
         ...buildConfig
       });
       const duration = Date.now() - startTime;
@@ -193,7 +193,7 @@ async function watchAndBuild(options) {
       dirsToWatch.add(fullPath);
     }
   }
-  const watcher = createWatcher({
+  const watcher = createWatcher2({
     ...watchOptions,
     paths: watchOptions.paths || Array.from(dirsToWatch),
     onChange: async (event) => {
@@ -215,9 +215,9 @@ async function watchAndBuild(options) {
   }
   return watcher;
 }
-async function startWatchMode(args) {
+async function startWatchMode2(args) {
   console.log("\x1B[36m[stx]\x1B[0m Starting watch mode...");
-  const watcher = await watchAndBuild({
+  const watcher = await watchAndBuild2({
     entrypoints: args.entrypoints,
     outdir: args.outdir,
     verbose: args.verbose,
@@ -248,7 +248,7 @@ async function startWatchMode(args) {
 }
 
 // src/index.ts
-import { createMiddleware, createRoute, readMarkdownFile as readMarkdownFile2 } from "@stacksjs/stx";
+import { createMiddleware as createMiddleware2, createRoute as createRoute2, readMarkdownFile as readMarkdownFile2 } from "@stacksjs/stx";
 function escapeHtmlForError(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
@@ -273,7 +273,7 @@ function generateErrorPage(title, message, filePath) {
 </body>
 </html>`;
 }
-function stxPlugin(userOptions) {
+function stxPlugin2(userOptions) {
   return {
     name: "bun-plugin-stx",
     async setup(build) {
@@ -462,6 +462,6 @@ ${scriptsHtml}`;
     }
   };
 }
-var src_default = stxPlugin;
+var src_default = stxPlugin2;
 
-export { createWatcher, watchAndBuild, startWatchMode, stxPlugin, createMiddleware, createRoute, readMarkdownFile2 as readMarkdownFile, src_default };
+export { createWatcher2, watchAndBuild2, startWatchMode2, stxPlugin2, createMiddleware2, createRoute2, readMarkdownFile2, src_default };

package/dist/chunk-jmbnee6y.js

@@ -0,0 +1,286 @@
+// @bun
+// ../router/src/file-router.ts
+import fs3 from "fs";
+import path4 from "path";
+
+// ../router/src/codegen.ts
+import fs from "fs";
+import path from "path";
+
+// ../router/src/page-routes.ts
+var NON_PAGE_DIRS = ["components", "layouts", "partials", "emails"];
+function isNonPageRoutePath(relativePath) {
+  const segments = relativePath.split(/[\\/]/).filter(Boolean);
+  return segments.slice(0, -1).some((segment) => NON_PAGE_DIRS.includes(segment));
+}
+function isNonPageRoutePattern(pattern) {
+  return isNonPageRoutePath(pattern.replace(/^\//, ""));
+}
+
+// ../router/src/codegen.ts
+function generateRouteTypes(routes, outputDir) {
+  const pageRoutes = routes.filter((r) => !isNonPageRoutePattern(r.pattern));
+  const lines = ["// Auto-generated by STX - do not edit"];
+  if (pageRoutes.length === 0) {
+    lines.push("// No page routes found \u2014 route paths stay typed as string.", "export {}", "");
+  } else {
+    lines.push(`declare module '@stacksjs/stx' {`, "  interface KnownRoutes {");
+    for (const route of pageRoutes) {
+      const paramEntries = [];
+      for (const p of route.params) {
+        const optional = route.pattern.includes(`:${p}?`) ? "?" : "";
+        paramEntries.push(`${p}${optional}: string`);
+      }
+      const paramsStr = paramEntries.join("; ");
+      lines.push(`    '${route.pattern}': { ${paramsStr} }`);
+    }
+    lines.push("  }", "}", "", "export {}", "");
+  }
+  const contents = lines.join(`
+`);
+  const target = path.join(outputDir, "route-types.d.ts");
+  try {
+    if (fs.existsSync(target) && fs.readFileSync(target, "utf8") === contents)
+      return;
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(target, contents);
+  } catch {}
+}
+function generateRouteManifest(routes, outputDir, pagesDir) {
+  const cwd = process.cwd();
+  const relativePages = path.relative(cwd, pagesDir);
+  const pageRoutes = routes.filter((r) => !isNonPageRoutePattern(r.pattern));
+  const lines = [
+    "// Auto-generated by stx \u2014 do not edit",
+    `// Source: ${relativePages || "pages"}/`,
+    "",
+    "export const routes = ["
+  ];
+  for (const route of pageRoutes) {
+    const relFile = path.relative(cwd, route.filePath).replace(/\\/g, "/");
+    const params = JSON.stringify(route.params);
+    const layoutStr = route.layout ? `, layout: '${path.relative(cwd, route.layout).replace(/\\/g, "/")}'` : "";
+    lines.push(`  { pattern: '${route.pattern}', filePath: '${relFile}', isDynamic: ${route.isDynamic}, params: ${params}${layoutStr} },`);
+  }
+  lines.push("] as const", "");
+  lines.push("export type RouteName = typeof routes[number]['pattern']", "");
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(path.join(outputDir, "routes.ts"), lines.join(`
+`));
+}
+
+// ../router/src/matcher.ts
+import path2 from "path";
+function filePathToPattern(filePath, pagesDir) {
+  const relativePath = path2.relative(pagesDir, filePath);
+  let route = relativePath.replace(/\.(stx|md)$/, "");
+  route = route.split(path2.sep).join("/");
+  if (route === "index") {
+    return "/";
+  }
+  if (route.endsWith("/index")) {
+    route = route.slice(0, -6);
+  }
+  route = route.replace(/\[\[([^\]]+)\]\]/g, ":$1?");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  route = route.replace(/:\.\.\.([^/]+)/g, ":$1*");
+  return `/${route}`;
+}
+function patternToRegex(pattern) {
+  const params = [];
+  let regexStr = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const rest = pattern.slice(i);
+    const optional = /^\/:([^/?*]+)\?/.exec(rest);
+    if (optional) {
+      params.push(optional[1]);
+      regexStr += "(?:/([^/]+))?";
+      i += optional[0].length;
+      continue;
+    }
+    const catchAll = /^:([^/?*]+)\*/.exec(rest);
+    if (catchAll) {
+      params.push(catchAll[1]);
+      regexStr += "(.+)";
+      i += catchAll[0].length;
+      continue;
+    }
+    const required = /^:([^/?*]+)/.exec(rest);
+    if (required) {
+      params.push(required[1]);
+      regexStr += "([^/]+)";
+      i += required[0].length;
+      continue;
+    }
+    regexStr += pattern[i].replace(/[.+^${}()|[\]\\*?]/g, "\\$&");
+    i += 1;
+  }
+  return { regex: new RegExp(`^${regexStr}$`), params };
+}
+
+// ../router/src/nested-layouts.ts
+import fs2 from "fs";
+import path3 from "path";
+function resolveLayoutChain(routeFilePath, pagesDir) {
+  const layouts = [];
+  let dir = path3.dirname(routeFilePath);
+  while (dir.startsWith(pagesDir) || dir === pagesDir) {
+    const layoutFile = path3.join(dir, "_layout.stx");
+    if (fs2.existsSync(layoutFile)) {
+      layouts.unshift(layoutFile);
+    }
+    if (dir === pagesDir)
+      break;
+    dir = path3.dirname(dir);
+  }
+  return layouts;
+}
+
+// ../router/src/file-router.ts
+function scanDirectory(dir, extensions) {
+  const files = [];
+  if (!fs3.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      if (NON_PAGE_DIRS.includes(entry.name)) {
+        continue;
+      }
+      files.push(...scanDirectory(fullPath, extensions));
+    } else if (entry.isFile()) {
+      const ext = path4.extname(entry.name);
+      if (extensions.includes(ext)) {
+        if (entry.name.startsWith("_") && entry.name !== "_layout.stx") {
+          continue;
+        }
+        if (entry.name === "_layout.stx") {
+          continue;
+        }
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+
+class Router {
+  routes;
+  pagesDir;
+  pagesDirs;
+  config;
+  constructor(baseDir, config = {}) {
+    this.config = config;
+    const rawDirs = config.pagesDirs && config.pagesDirs.length > 0 ? config.pagesDirs : [config.pagesDir || "pages"];
+    this.pagesDirs = rawDirs.map((d) => path4.resolve(baseDir, d));
+    this.pagesDir = this.pagesDirs[0];
+    const extensions = config.extensions || [".stx"];
+    const canonical = (entry) => {
+      const resolved = path4.resolve(baseDir, entry);
+      try {
+        return fs3.realpathSync(resolved);
+      } catch {
+        return resolved;
+      }
+    };
+    const excluded = (config.exclude ?? []).filter((entry) => typeof entry === "string" && entry.trim() !== "").map(canonical);
+    const isExcluded = (file) => {
+      if (excluded.length === 0)
+        return false;
+      const real = canonical(file);
+      return excluded.some((root) => real === root || real.startsWith(`${root}${path4.sep}`));
+    };
+    const seenPatterns = new Set;
+    this.routes = [];
+    for (const dir of this.pagesDirs) {
+      const files = scanDirectory(dir, extensions).filter((file) => !isExcluded(file));
+      const localPatterns = new Map;
+      for (const filePath of files) {
+        const pattern = filePathToPattern(filePath, dir);
+        const identity = config.pagesDirs ? pattern.replace(/:[\w]+/g, ":param") : pattern;
+        if (config.pagesDirs && localPatterns.has(identity))
+          throw new Error(`Conflicting layer pages for ${pattern}: ${localPatterns.get(identity)} and ${filePath}`);
+        localPatterns.set(identity, filePath);
+        if (seenPatterns.has(identity))
+          continue;
+        seenPatterns.add(identity);
+        const { regex, params } = patternToRegex(pattern);
+        const layouts = config.layouts !== false ? resolveLayoutChain(filePath, dir) : [];
+        this.routes.push({
+          pattern,
+          regex,
+          params,
+          filePath,
+          isDynamic: params.length > 0,
+          layout: layouts.length > 0 ? layouts[layouts.length - 1] : undefined
+        });
+      }
+    }
+    this.routes.sort((a, b) => {
+      if (!a.isDynamic && b.isDynamic)
+        return -1;
+      if (a.isDynamic && !b.isDynamic)
+        return 1;
+      const aSegments = a.pattern.split("/").length;
+      const bSegments = b.pattern.split("/").length;
+      if (aSegments !== bSegments)
+        return bSegments - aSegments;
+      return a.pattern.localeCompare(b.pattern);
+    });
+    if (config.emit !== false) {
+      const stxDir = path4.resolve(baseDir, config.stateDir || process.env.STX_DIR?.trim() || ".stx");
+      generateRouteTypes(this.routes, stxDir);
+      generateRouteManifest(this.routes, stxDir, this.pagesDir);
+    }
+  }
+  match(pathname) {
+    const normalizedPath = pathname === "" ? "/" : pathname;
+    for (const route of this.routes) {
+      const m = normalizedPath.match(route.regex);
+      if (m) {
+        const params = {};
+        route.params.forEach((name, index) => {
+          params[name] = m[index + 1];
+        });
+        return { route, params };
+      }
+    }
+    return null;
+  }
+  resolve(name, params) {
+    const route = this.routes.find((r) => r.pattern === name || r.filePath.includes(name));
+    if (!route)
+      return "#not-found";
+    let resolved = route.pattern;
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        resolved = resolved.replace(`:${key}`, encodeURIComponent(value));
+      }
+    }
+    return resolved;
+  }
+  addRoute(route) {
+    this.routes.push(route);
+    this.routes.sort((a, b) => {
+      if (!a.isDynamic && b.isDynamic)
+        return -1;
+      if (a.isDynamic && !b.isDynamic)
+        return 1;
+      return a.pattern.localeCompare(b.pattern);
+    });
+  }
+  getLayout(route) {
+    return route.layout ?? null;
+  }
+}
+// ../router/src/middleware.ts
+var middlewareRegistry = new Map;
+export {
+  Router
+};

package/dist/{chunk-93ete56h.js → chunk-qcdy1k88.js}

@@ -20,4 +20,4 @@ function extractLayoutMetadata(html) {
   };
 }
 
-export { deriveLayoutGroup, extractLayoutMetadata };
+export { extractLayoutMetadata };

package/dist/client.js

@@ -1,6 +1,4 @@
 // @bun
-import"./chunk-2mx7fq49.js";
-
 // src/client.ts
 var version = "1.0.0";
 var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
@@ -110,8 +108,8 @@ function initIslands(handlers, config = {}) {
   }
 }
 export {
-  version,
-  preloadIslandHandlers,
+  hydrateIslands,
   initIslands,
-  hydrateIslands
+  preloadIslandHandlers,
+  version
 };

package/dist/index.js

@@ -1,22 +1,21 @@
 // @bun
 import {
-  createMiddleware,
-  createRoute,
-  createWatcher,
-  readMarkdownFile,
-  src_default,
-  startWatchMode,
-  stxPlugin,
-  watchAndBuild
-} from "./chunk-anqecs1e.js";
-import"./chunk-2mx7fq49.js";
+  createWatcher2,
+  watchAndBuild2,
+  startWatchMode2,
+  stxPlugin2,
+  createMiddleware2,
+  createRoute2,
+  readMarkdownFile2,
+  src_default
+} from "./chunk-18kmm7vg.js";
 export {
-  watchAndBuild,
-  stxPlugin,
-  startWatchMode,
-  readMarkdownFile,
+  createMiddleware2 as createMiddleware,
+  createRoute2 as createRoute,
+  createWatcher2 as createWatcher,
   src_default as default,
-  createWatcher,
-  createRoute,
-  createMiddleware
+  readMarkdownFile2 as readMarkdownFile,
+  startWatchMode2 as startWatchMode,
+  stxPlugin2 as stxPlugin,
+  watchAndBuild2 as watchAndBuild
 };

package/dist/preload.js

@@ -1,8 +1,7 @@
 // @bun
 import {
   src_default
-} from "./chunk-anqecs1e.js";
-import"./chunk-2mx7fq49.js";
+} from "./chunk-18kmm7vg.js";
 
 // src/preload.ts
 var {plugin } = globalThis.Bun;