bun-plugin-stx 0.2.318 → 0.2.320

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

package/dist/serve.js

@@ -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);
 }
@@ -9491,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);
@@ -9739,9 +9762,7 @@ function __stxOverlay(errs){
     const kept = files.filter((f) => !isExcludedPage(f));
     sourceFiles = kept;
     rebuildDiscoveredPagePaths(kept);
-    pageMiddlewareByPath.clear();
-    pageMiddlewarePatterns.length = 0;
-    await Promise.all(kept.map((f) => detectPageMiddleware(f)));
+    await indexPageMiddleware(kept);
     try {
       const { Router } = await import("./chunk-37vp8yms.js");
       const pagesDirs = patterns.map((p) => p.replace(/\/$/, "")).filter(Boolean);
@@ -10111,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) {
@@ -11204,7 +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.318",
+  "version": "0.2.320",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",