bun-plugin-stx 0.2.317 → 0.2.319

package/dist/{chunk-9gb1t22q.js → chunk-37vp8yms.js}

@@ -205,10 +205,25 @@ class Router {
     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);
+      const files = scanDirectory(dir, extensions).filter((file) => !isExcluded(file));
       const localPatterns = new Map;
       for (const filePath of files) {
         const pattern = filePathToPattern(filePath, dir);

package/dist/serve.d.ts

@@ -60,6 +60,27 @@ export declare function buildDynamicRouteRegexes(fileRouteBase: string): RegExp[
  *   - `[...rest]` catch-all → -10000 (always last)
  */
 export declare function routeSpecificity(fileRouteBase: string): number;
+/**
+ * A discovered page's path relative to the page root holding it, and that
+ * root's position in `patterns`.
+ *
+ * Specificity has to be measured on the relative path. Measured on the whole
+ * path, a root's own directory segments count as static segments, so a page
+ * under a deeper root outranks the same route under a shallower one: Stacks
+ * passes `['resources/views', '<framework>/defaults/resources/views']`, and a
+ * framework default `password/reset/[token].stx` beat the app's own file at
+ * the same path purely because its root sits more directories down.
+ */
+export declare function pageRootOf(filePath: string, patterns: string[]): { relative: string, root: number };
+/**
+ * Order dynamic route files the way `getRoute` tries them: most specific
+ * route first (see {@link routeSpecificity}), and between equally specific
+ * routes, the earlier page root first. Earlier roots are the overrides - an
+ * app's own views are listed before the framework defaults they replace - so
+ * a tie must never go to the later root. Discovery order breaks any remaining
+ * tie, which keeps the order deterministic.
+ */
+export declare function orderDynamicRouteFiles(files: string[], patterns: string[]): string[];
 /**
  * True when a request path is for a STATIC ASSET (a non-page file extension like
  * `.jpg`/`.css`/`.js`) rather than a page. Used so a catch-all page can never
@@ -175,6 +196,14 @@ export declare function boundedCache<T>(limit: number): {
   clear: () => void
   readonly size: number
 };
+/**
+ * A predicate over discovered page files for {@link ServeOptions.exclude}.
+ *
+ * Paths are compared resolved, because patterns and exclusions reach serve()
+ * spelled however the caller built them - relative, absolute, with a trailing
+ * slash - and a spelling mismatch must not quietly put a page back.
+ */
+export declare function pageExcluder(exclude: readonly string[] | undefined, cwd?: string): (file: string) => boolean;
 export declare function resolveServeOpenUrl(port: number, openPath?: string): string;
 /**
  * Did rendering fail?
@@ -271,6 +300,7 @@ export declare interface ServeRequestContext {
 }
 export declare interface ServeOptions {
   patterns: string[]
+  exclude?: string[]
   port?: number
   openPath?: string
   componentsDir?: string

package/dist/serve.js

@@ -9,7 +9,7 @@ import {
 
 // src/serve.ts
 var {serve: bunServe, Glob } = globalThis.Bun;
-import { existsSync as existsSync2, watch as fsWatch, statSync as statSync3 } from "fs";
+import { existsSync as existsSync2, watch as fsWatch, realpathSync, statSync as statSync3 } from "fs";
 import nodeFs from "fs/promises";
 import nodePath from "path";
 import process19 from "process";
@@ -8919,6 +8919,18 @@ function routeSpecificity(fileRouteBase) {
   }
   return score;
 }
+function pageRootOf(filePath, patterns) {
+  const normalized = filePath.replace(/^\.\//, "").replace(/\\/g, "/");
+  for (let root = 0;root < patterns.length; root++) {
+    const base = patterns[root].replace(/\\/g, "/").replace(/\/$/, "");
+    if (normalized.startsWith(`${base}/`))
+      return { relative: normalized.slice(base.length + 1), root };
+  }
+  return { relative: normalized, root: patterns.length };
+}
+function orderDynamicRouteFiles(files, patterns) {
+  return files.map((file, index) => ({ file, index, ...pageRootOf(file, patterns) })).sort((a, b) => routeSpecificity(b.relative) - routeSpecificity(a.relative) || a.root - b.root || a.index - b.index).map((entry) => entry.file);
+}
 function isStaticAssetPath(requestPath) {
   return /\.[a-z0-9]+$/i.test(requestPath) && !/\.(?:stx|md|html)$/i.test(requestPath);
 }
@@ -9084,6 +9096,23 @@ function boundedCache(limit) {
     }
   };
 }
+function pageExcluder(exclude, cwd = process19.cwd()) {
+  const canonical = (entry) => {
+    const resolved = nodePath.resolve(cwd, entry);
+    try {
+      return realpathSync(resolved);
+    } catch {
+      return resolved;
+    }
+  };
+  const roots = (exclude ?? []).filter((entry) => typeof entry === "string" && entry.trim() !== "").map(canonical);
+  if (roots.length === 0)
+    return () => false;
+  return (file) => {
+    const resolved = canonical(file);
+    return roots.some((root) => resolved === root || resolved.startsWith(`${root}${nodePath.sep}`));
+  };
+}
 function resolveServeOpenUrl(port, openPath = "/") {
   const baseUrl = `http://localhost:${port}`;
   try {
@@ -9267,6 +9296,7 @@ After installing: bun add bun-plugin-stx`);
     throw new Error("No file patterns provided");
   }
   let sourceFiles = null;
+  const isExcludedPage = pageExcluder(options.exclude);
   let discoveredPagePaths = null;
   let assetsInitialized = false;
   const htmlCache = new Map;
@@ -9473,21 +9503,32 @@ function __stxOverlay(errs){
       const src = await nodeFs.readFile(file, "utf-8");
       const meta = src.match(/definePageMeta\s*\(\s*\{[\s\S]*?\}\s*\)/);
       if (!meta)
-        return;
+        return [];
       const mw = meta[0].match(/middleware\s*:\s*(\[[^\]]*\]|['"][^'"]+['"])/);
       if (!mw)
-        return;
-      const names = mw[1].startsWith("[") ? Array.from(mw[1].matchAll(/['"]([^'"]+)['"]/g)).map((m) => m[1]) : [mw[1].replace(/['"]/g, "")];
-      if (names.length === 0)
-        return;
+        return [];
+      return mw[1].startsWith("[") ? Array.from(mw[1].matchAll(/['"]([^'"]+)['"]/g)).map((m) => m[1]) : [mw[1].replace(/['"]/g, "")];
+    } catch {
+      return [];
+    }
+  }
+  async function indexPageMiddleware(files) {
+    pageMiddlewareByPath.clear();
+    pageMiddlewarePatterns.length = 0;
+    const detected = await Promise.all(files.map((f) => detectPageMiddleware(f)));
+    const middlewareOf = new Map(files.map((f, i) => [f, detected[i]]));
+    const dynamic = [];
+    for (const file of files) {
       const urlPath = urlPathFromFile(file);
-      if (urlPath.includes("[")) {
-        const { re, names: paramNames } = compileRoutePattern(urlPath);
-        pageMiddlewarePatterns.push({ re, names: paramNames, middleware: names });
-      } else {
-        pageMiddlewareByPath.set(urlPath, names);
-      }
-    } catch {}
+      if (urlPath.includes("["))
+        dynamic.push(file);
+      else if (!pageMiddlewareByPath.has(urlPath))
+        pageMiddlewareByPath.set(urlPath, middlewareOf.get(file) ?? []);
+    }
+    for (const file of orderDynamicRouteFiles(dynamic, patterns)) {
+      const { re, names } = compileRoutePattern(urlPathFromFile(file));
+      pageMiddlewarePatterns.push({ re, names, middleware: middlewareOf.get(file) ?? [] });
+    }
   }
   function resolveRouteMiddleware(path) {
     const exact = pageMiddlewareByPath.get(path);
@@ -9718,19 +9759,18 @@ function __stxOverlay(errs){
         console.error(`Error processing pattern "${pattern}":`, error);
       }
     }
-    sourceFiles = files;
-    rebuildDiscoveredPagePaths(files);
-    pageMiddlewareByPath.clear();
-    pageMiddlewarePatterns.length = 0;
-    await Promise.all(files.map((f) => detectPageMiddleware(f)));
+    const kept = files.filter((f) => !isExcludedPage(f));
+    sourceFiles = kept;
+    rebuildDiscoveredPagePaths(kept);
+    await indexPageMiddleware(kept);
     try {
-      const { Router } = await import("./chunk-9gb1t22q.js");
+      const { Router } = await import("./chunk-37vp8yms.js");
       const pagesDirs = patterns.map((p) => p.replace(/\/$/, "")).filter(Boolean);
-      const router = new Router(process19.cwd(), { pagesDirs, stateDir: stateDirName() });
+      const router = new Router(process19.cwd(), { pagesDirs, stateDir: stateDirName(), exclude: options.exclude });
       if (!options.quiet)
         console.log(`[stx] Generated ${router.routes.length} routes \u2192 ${nodePath.join(stateDirName(), "routes.ts")}`);
     } catch (e) {}
-    return files;
+    return kept;
   }
   async function ensureAssets() {
     if (assetsInitialized)
@@ -10092,8 +10132,8 @@ function __stxOverlay(errs){
       if (isAssetRequest)
         return false;
       return true;
-    }).sort((a, b) => routeSpecificity(b) - routeSpecificity(a));
-    for (const filePath of dynamicFiles) {
+    });
+    for (const filePath of orderDynamicRouteFiles(dynamicFiles, patterns)) {
       const normalizedFilePath = filePath.replace(/^\.\//, "").replace(/\\/g, "/");
       let relativeFilePath = normalizedFilePath;
       for (const pattern of patterns) {
@@ -11185,6 +11225,9 @@ export {
   render404Page,
   publicFileExists,
   projectUsesImageBuiltins,
+  pageRootOf,
+  pageExcluder,
+  orderDynamicRouteFiles,
   isStaticAssetPath,
   isRenderableCacheCandidate,
   isRenderFailure,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.317",
+  "version": "0.2.319",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",