bun-plugin-stx 0.2.316 → 0.2.318

package/dist/{chunk-71hprtbd.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);
@@ -964,6 +979,15 @@ function getRouterScript() {
   // navigation, leaking a listener and an observer each time and resetting the
   // instance registry \u2014 trading a silent missing component for a silent leak.
   var REGISTERS_SCOPE=/window\\.stx\\.mount|_scopes\\s*\\[|\\.initScope\\s*\\(|__stxComponentFactories\\s*\\[/;
+  // The page's module registry (#1957): the bundle every component that
+  // imports a local module reads from, so on navigation it has to run before
+  // any of them. Marked data-stx-modules; the text test also finds it where
+  // only a script's text survives. Its wrapper names __stxModuleBundles, which
+  // no component script does -- they read __stxModules.
+  var REGISTRY_TEXT=/__stxModuleBundles/;
+  function isModuleRegistryScript(s){
+    return !!s&&((s.hasAttribute&&s.hasAttribute('data-stx-modules'))||REGISTRY_TEXT.test(s.textContent||''));
+  }
   function runsAlways(declared, code){
     if(declared==='always')return true;
     if(declared==='once')return false;
@@ -1968,7 +1992,7 @@ else {
           var slot='document-'+(++routedBodyScriptId);
           var setupName=generatedSetupName(text);
           if(setupName)incomingSetupName=setupName;
-          routedBodyScripts.push({text:text,runAlways:true,slot:slot,setupName:setupName,run:s.getAttribute('data-stx-run')||'',owner:s.getAttribute('data-stx-owner')||''});
+          routedBodyScripts.push({text:text,runAlways:true,slot:slot,setupName:setupName,run:s.getAttribute('data-stx-run')||'',owner:s.getAttribute('data-stx-owner')||'',registry:isModuleRegistryScript(s)});
           s.textContent='';
           s.setAttribute('type','application/stx-pending');
           s.setAttribute('data-stx-route-script',slot);
@@ -2050,16 +2074,24 @@ else {
 
       var scripts=routedBodyScripts.slice();
       function addScript(text, runAlways, slot, owner){
-        scripts.push({text:text,runAlways:!!runAlways,slot:slot||'',owner:owner||''});
+        scripts.push({text:text,runAlways:!!runAlways,slot:slot||'',owner:owner||'',registry:REGISTRY_TEXT.test(text)});
       }
       if(isLayoutChange){
-        // Also collect setup functions from <head>
+        // Also collect setup functions from <head>, and the page's module
+        // registry (#1957). The registry is anchored to the signals runtime,
+        // and a layout with its own <head> script (analytics, say) pulls the
+        // runtime -- and the registry with it -- into <head>. Collecting only
+        // setups there dropped it, so every component that imports a local
+        // module threw "is not registered on this page" and its template
+        // hydrated against globals: an <input id="email"> bound to
+        // :model="email" showed "[object HTMLInputElement]".
         doc.querySelectorAll('head script').forEach(function(s){
           var text=s.textContent||'';
           if(s.hasAttribute('src'))return;
           if(!text.trim())return;
           if(isSignalsRuntimeScript(s,text))return;
-          if(text.indexOf('__stx_setup_')!==-1)addScript(text,true);
+          if(isModuleRegistryScript(s))addScript(text,true,'','');
+          else if(text.indexOf('__stx_setup_')!==-1)addScript(text,true);
         });
       } else {
         // Collect page scripts from <head> AND <body> (outside container).
@@ -2107,6 +2139,12 @@ else {
           return aPage-bPage;
         });
       }
+      // The module registry runs before anything that reads it (#1957). The
+      // container's own scripts are collected first and head scripts after,
+      // so without this a component in the page body could run ahead of the
+      // registry it imports from. Stable: the order within each group holds.
+      var registryFirst=scripts.filter(function(e){return e.registry});
+      if(registryFirst.length)scripts=registryFirst.concat(scripts.filter(function(e){return !e.registry}));
 
       // Push history state (before active link updates so location.pathname is current)
       if(pushState!==false)writeHistory(pushState,url+(hash||''));

package/dist/serve.d.ts

@@ -175,6 +175,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 +279,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";
@@ -9084,6 +9084,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 +9284,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;
@@ -9718,19 +9736,20 @@ function __stxOverlay(errs){
         console.error(`Error processing pattern "${pattern}":`, error);
       }
     }
-    sourceFiles = files;
-    rebuildDiscoveredPagePaths(files);
+    const kept = files.filter((f) => !isExcludedPage(f));
+    sourceFiles = kept;
+    rebuildDiscoveredPagePaths(kept);
     pageMiddlewareByPath.clear();
     pageMiddlewarePatterns.length = 0;
-    await Promise.all(files.map((f) => detectPageMiddleware(f)));
+    await Promise.all(kept.map((f) => detectPageMiddleware(f)));
     try {
-      const { Router } = await import("./chunk-71hprtbd.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)
@@ -11185,6 +11204,7 @@ export {
   render404Page,
   publicFileExists,
   projectUsesImageBuiltins,
+  pageExcluder,
   isStaticAssetPath,
   isRenderableCacheCandidate,
   isRenderFailure,

package/package.json

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