bun-plugin-stx 0.2.674 → 0.2.675

package/dist/image-warmup-scope.d.ts

@@ -0,0 +1,13 @@
+import type { StxOptions } from '@stacksjs/stx';
+/**
+ * Walk literal template dependencies, not cwd. No template code is executed:
+ * conditional includes count conservatively; runtime-computed paths need
+ * imageWarmup: true. Unused resource definitions are never entry points.
+ */
+export declare function servedTemplatesUseImageBuiltins(root: string, scope: ImageTemplateScope): Promise<boolean>;
+export declare const IMAGE_BUILTIN_PATTERN: boolean;
+export declare interface ImageTemplateScope {
+  pages: readonly string[]
+  options: Partial<StxOptions>
+  pluginComponentDirs?: readonly string[]
+}

package/dist/serve.d.ts

@@ -1,6 +1,7 @@
 import { serve as bunServe } from 'bun';
 import { compileDomainRoutes, describeDomainRoutes, requestHost, resolveDomainElsewhere, resolveDomainRoute } from './domain-routes';
 import type { DomainRoutesOption } from './domain-routes';
+import type { ImageTemplateScope } from './image-warmup-scope';
 import type { MiddlewareContext, MiddlewareHandler, MiddlewareRequest, PageMiddleware, PrepareMiddlewareRequest } from './page-middleware';
 export type { DomainRoute, DomainRoutesOption } from './domain-routes';
 export type { MiddlewareContext, MiddlewareDefinition, MiddlewareHandler, MiddlewareRequest, PageMiddleware, PrepareMiddlewareRequest } from './page-middleware';
@@ -274,8 +275,12 @@ export declare function serve(options: ServeOptions): Promise<void>;
  * plain `<img>` tags spent over seven minutes of each cold boot encoding
  * 213MB of variants that no page could ask for. A use is followed through
  * wrappers of wrappers, and a page, layout or partial using one counts.
+ *
+ * serve() supplies a scope of discovered pages and their resource directories
+ * so unserved templates do not count. Omitting it retains the legacy project
+ * scan for callers that explicitly want to inspect a whole directory tree.
  */
-export declare function projectUsesImageBuiltins(root: string): Promise<boolean>;
+export declare function projectUsesImageBuiltins(root: string, scope?: ImageTemplateScope): Promise<boolean>;
 /**
  * Stands in for a dynamic route's params in a cached shell. Not valid
  * JavaScript on its own, so a shell that escaped without being filled fails

package/dist/serve.js

@@ -8861,6 +8861,165 @@ function resolveDomainElsewhere(host, pathname, search, routes, isAsset) {
 function describeDomainRoutes(routes) {
   return routes.map((route) => `${route.pattern}/ \u2192 ${route.to}${route.elsewhere ? ` (other pages: ${route.elsewhere})` : ""}`).join(", ");
 }
+
+// src/image-warmup-scope.ts
+import path from "path";
+import { readdir as readdir4, readFile, stat as stat4 } from "fs/promises";
+import { componentImportCandidates, pascalToKebab } from "@stacksjs/stx/component-resolution";
+import { splitTopLevelArgs } from "@stacksjs/stx/directive-arguments";
+import { extractParenthesizedExpression } from "@stacksjs/stx/parser/directive-parser";
+import { resolveTemplatePath } from "@stacksjs/stx/utils";
+var IMAGE_BUILTIN_PATTERN = /<(?:StxImage|Image|stx-image|stx-img)[\s/>]|@image\s*\(/;
+async function servedTemplatesUseImageBuiltins(root, scope) {
+  const options = { ...scope.options, root };
+  const absolute = (file) => path.resolve(root, file);
+  for (const key of ["componentsDir", "layoutsDir", "fallbackLayoutsDir", "fallbackComponentsDir", "partialsDir"]) {
+    if (options[key])
+      options[key] = absolute(options[key]);
+  }
+  const directories = new Map;
+  const sources = new Map;
+  async function firstFile(candidates) {
+    for (const candidate of candidates) {
+      const file = absolute(candidate);
+      if (await stat4(file).then((result) => result.isFile(), () => false))
+        return file;
+    }
+  }
+  function componentDirectories(directory) {
+    const dir = absolute(directory);
+    let files = directories.get(dir);
+    if (!files) {
+      files = (async () => {
+        const result = [];
+        const pending = [{ dir, depth: 0 }];
+        while (pending.length) {
+          const current = pending.pop();
+          if (current.depth >= 8)
+            continue;
+          const entries = await readdir4(current.dir, { withFileTypes: true }).catch(() => []);
+          for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+              const child = path.join(current.dir, entry.name);
+              result.push(child);
+              pending.push({ dir: child, depth: current.depth + 1 });
+            }
+          }
+        }
+        return result;
+      })();
+      directories.set(dir, files);
+    }
+    return files;
+  }
+  async function component(name, file, page, imported) {
+    const pascal = name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+    for (const alias of [name, name.toLowerCase(), pascal, pascalToKebab(name)]) {
+      if (imported.has(alias))
+        return imported.get(alias);
+    }
+    if (name.startsWith("./") || name.startsWith("../"))
+      return firstFile([path.resolve(path.dirname(file), name.endsWith(".stx") ? name : `${name}.stx`)]);
+    const names = [...new Set([name, pascal, pascalToKebab(name)].map((value) => `${value.replace(/\.stx$/, "")}.stx`))];
+    const dirs = [
+      path.join(path.dirname(page), "components"),
+      options.componentsDir,
+      path.join(path.dirname(file), "components"),
+      path.join(root, "resources/views/components"),
+      path.join(root, "resources/components"),
+      path.join(root, "src/components"),
+      path.join(root, "components"),
+      ...scope.pluginComponentDirs ?? [],
+      options.fallbackComponentsDir
+    ].filter((dir) => typeof dir === "string" && dir.length > 0);
+    for (const dir of new Set(dirs)) {
+      const direct = await firstFile(names.map((name) => path.join(dir, name)));
+      if (direct)
+        return direct;
+      for (const child of await componentDirectories(dir)) {
+        const nested = await firstFile(names.map((name) => path.join(child, name)));
+        if (nested)
+          return nested;
+      }
+    }
+  }
+  for (const entry of scope.pages) {
+    const page = absolute(entry);
+    const pending = [page];
+    const visited = new Set;
+    const imported = new Map;
+    while (pending.length) {
+      const file = pending.pop();
+      if (visited.has(file))
+        continue;
+      visited.add(file);
+      let reading = sources.get(file);
+      if (!reading) {
+        reading = readFile(file, "utf8").catch(() => "");
+        sources.set(file, reading);
+      }
+      const source = await reading;
+      if (IMAGE_BUILTIN_PATTERN.test(source))
+        return true;
+      const references = [];
+      const directives = /@(import|component|extends|layout|include|partial|includeIf|includeWhen|includeUnless|includeFirst)\s*\(/g;
+      let match;
+      while ((match = directives.exec(source)) !== null) {
+        const parsed = extractParenthesizedExpression(source, directives.lastIndex - 1);
+        if (!parsed)
+          continue;
+        references.push({ kind: match[1], args: splitTopLevelArgs(parsed.expression) });
+        directives.lastIndex = parsed.endPos;
+      }
+      const literal = (arg = "") => /^(['"])([^'"\r\n]+)\1$/.exec(arg.trim())?.[2];
+      for (const ref of references.filter((ref) => ref.kind === "import")) {
+        for (const arg of ref.args) {
+          const name = literal(arg);
+          if (!name)
+            continue;
+          const resolved = await firstFile(componentImportCandidates(name, file, options));
+          if (resolved) {
+            const base = path.basename(name, ".stx");
+            const pascal = base.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+            for (const alias of [base, base.toLowerCase(), pascal, pascalToKebab(pascal)])
+              imported.set(alias, resolved);
+          }
+        }
+      }
+      for (const ref of references) {
+        const arg = ref.args[ref.kind === "includeWhen" || ref.kind === "includeUnless" ? 1 : 0];
+        const names = ref.kind === "includeFirst" && arg?.trim().startsWith("[") ? splitTopLevelArgs(arg.trim().slice(1, -1)).map(literal) : [literal(arg)];
+        for (const name of names) {
+          if (!name)
+            continue;
+          let resolved;
+          if (ref.kind === "component")
+            resolved = await component(name, file, page, imported);
+          else if (ref.kind === "extends" || ref.kind === "layout")
+            resolved = await resolveTemplatePath(name, file, options);
+          else if (ref.kind !== "import") {
+            const base = name.startsWith(".") ? path.dirname(file) : options.partialsDir || "partials";
+            resolved = await firstFile([path.resolve(absolute(base), name.endsWith(".stx") ? name : `${name}.stx`)]);
+          }
+          if (resolved)
+            pending.push(absolute(resolved));
+          if (resolved && ref.kind === "includeFirst")
+            break;
+        }
+      }
+      const tags = /<([A-Z][\w.-]*|[a-z][\w.]*-[\w.-]+)(?=[\s/>])/g;
+      const names = new Set;
+      while ((match = tags.exec(source)) !== null)
+        names.add(match[1]);
+      for (const name of names) {
+        const resolved = await component(name, file, page, imported);
+        if (resolved)
+          pending.push(resolved);
+      }
+    }
+  }
+  return false;
+}
 // src/page-middleware.ts
 var DEFAULT_PRIORITY = 10;
 function middlewarePriority(middleware) {
@@ -10629,7 +10788,22 @@ ${block}`;
       console.warn(`\x1B[2m${error.stack}\x1B[0m`);
   }
   async function runImageWarmup() {
-    const imageWarmupEnabled = imageWarmupSetting === "auto" ? await projectUsesImageBuiltins(process20.cwd()) : imageWarmupSetting !== false;
+    let imageWarmupEnabled = imageWarmupSetting !== false;
+    if (imageWarmupSetting === "auto") {
+      const seen = new Set;
+      const pages = (await discoverFiles()).filter((file) => {
+        const relative = pageRootOf(file, patterns).relative;
+        if (seen.has(relative))
+          return false;
+        seen.add(relative);
+        return true;
+      });
+      imageWarmupEnabled = await projectUsesImageBuiltins(process20.cwd(), {
+        pages,
+        options: { componentsDir, layoutsDir, fallbackLayoutsDir, fallbackComponentsDir, partialsDir },
+        pluginComponentDirs: stxConfig._pluginComponentDirs
+      });
+    }
     if (!imageWarmupEnabled) {
       placeholdersAreReady = true;
       markPlaceholdersReady();
@@ -11588,7 +11762,6 @@ async function main() {
 if (import.meta.main) {
   main().catch(console.error);
 }
-var IMAGE_BUILTIN_PATTERN = /<(?:StxImage|Image|stx-image|stx-img)[\s/>]|@image\s*\(/;
 var TEMPLATE_SCAN_SKIP = new Set(["node_modules", "dist", "build", "coverage", "vendor"]);
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -11601,7 +11774,9 @@ function usesComponent(source, name) {
   const spellings = (kebab.includes("-") ? [name, kebab] : [name]).map(escapeRegExp).join("|");
   return new RegExp(`<(?:${spellings})[\\s/>]|@component\\(\\s*['"](?:${spellings})['"]`).test(source);
 }
-async function projectUsesImageBuiltins(root) {
+async function projectUsesImageBuiltins(root, scope) {
+  if (scope)
+    return servedTemplatesUseImageBuiltins(root, scope);
   const { readdir, readFile } = await import("fs/promises");
   const templates = [];
   const pending = [root];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.674",
+  "version": "0.2.675",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -74,7 +74,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/stx": "0.2.674",
+    "@stacksjs/stx": "0.2.675",
     "stx-router": "0.2.674"
   }
 }