@stacksjs/stx 0.2.154 → 0.2.156

package/dist/site-builder/build.js

@@ -13,6 +13,8 @@ import {
 import { dirname, join, relative } from "node:path";
 import process from "node:process";
 import stxPlugin from "bun-plugin-stx";
+import { CONVENTIONAL_ASSET_OUTPUT, resolveConventionalAssetRoot } from "../asset-roots.js";
+import { externalizeSharedAssets } from "../build-externalize.js";
 import { injectCrosswindCSS } from "../dev-server/crosswind.js";
 import { injectSeo } from "./seo.js";
 import { generateSitemap } from "./sitemap.js";
@@ -87,8 +89,14 @@ export async function buildStaticSite(options) {
         ;
     }
   }
+  const externalized = externalizeSharedAssets(outDir);
+  if (externalized.assets > 0)
+    console.log(`[stx] externalized ${externalized.assets} asset(s) from ${externalized.pages} page(s) (${(externalized.bytesInlined / 1024).toFixed(1)}KB removed from HTML)`);
   if (existsSync(publicDir))
     cpSync(publicDir, outDir, { recursive: !0 });
+  const conventionalAssets = resolveConventionalAssetRoot();
+  if (conventionalAssets)
+    cpSync(conventionalAssets, join(outDir, CONVENTIONAL_ASSET_OUTPUT), { recursive: !0 });
   const fourOhFourSrc = join(outDir, "404.html");
   if (!existsSync(fourOhFourSrc) && existsSync(join(outDir, "index.html"))) {
     const fallback = readFileSync(join(outDir, "index.html"), "utf8").replace(/<title>[^<]*<\/title>/i, `<title>404 \u2014 ${escapeText(options.name)}</title>`);

package/dist/site-url.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Where the canonical site URL comes from.
+ *
+ * The SSG defaulted `domain` to `http://localhost` and read no config at all,
+ * so an app that declared `url: 'https://example.org'` still shipped a
+ * sitemap.xml in which every entry was `http://localhost/…` — valid XML,
+ * accepted by the build, and useless to a crawler. Nothing warned, because
+ * from the build's point of view nothing failed (stacksjs/stx#1866).
+ *
+ * The URL is looked for in the places apps actually declare it, because there
+ * is more than one: `stx.config.ts` for stx-native apps, `site.config.ts` for
+ * the site-builder path (which has had `site.url` all along — that generator
+ * was never wired to this one), and the deploy-platform env vars, which are the
+ * only source available in CI where neither file knows the preview domain.
+ *
+ * @module site-url
+ */
+/** Where a resolved URL came from, for diagnostics. */
+export type SiteUrlSource = 'option' | 'stx.config' | 'site.config' | 'env' | 'fallback';
+export interface ResolvedSiteUrl {
+    url: string;
+    source: SiteUrlSource;
+    /** The env var or config key it came from, when there is one. */
+    via?: string;
+}
+/** Last resort. Deliberately not a real domain, so it is obvious in output. */
+export declare const SITE_URL_FALLBACK = "http://localhost";
+/**
+ * Resolve the canonical site URL, reporting where it came from so the caller
+ * can warn when it had to fall back.
+ *
+ * Order is explicit-option, then app config, then deploy env, then localhost.
+ */
+export declare function resolveSiteUrl(options?: {
+    explicit?: string;
+    stxConfig?: unknown;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}): Promise<ResolvedSiteUrl>;
+/**
+ * The warning shown when a build produced localhost URLs.
+ *
+ * Loud, and it names the fix — a sitemap full of `http://localhost` is not
+ * something anyone notices by reading build output.
+ */
+export declare function siteUrlFallbackWarning(): string;

package/dist/site-url.js

@@ -0,0 +1,70 @@
+export const SITE_URL_FALLBACK = "http://localhost";
+const ENV_KEYS = ["STX_SITE_URL", "SITE_URL", "URL", "VERCEL_URL", "CF_PAGES_URL"];
+function normalize(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return null;
+  const withScheme = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  try {
+    return new URL(withScheme).origin + new URL(withScheme).pathname.replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function fromEnv(env) {
+  for (const key of ENV_KEYS) {
+    const value = env[key];
+    if (!value)
+      continue;
+    const url = normalize(value);
+    if (url)
+      return { url, source: "env", via: key };
+  }
+  return null;
+}
+function fromConfigObject(config) {
+  if (!config || typeof config !== "object")
+    return null;
+  const record = config, candidate = record.site?.url ?? record.url ?? record.app?.url;
+  return typeof candidate === "string" ? normalize(candidate) : null;
+}
+async function loadSiteConfigFile(cwd) {
+  const { existsSync } = await import("node:fs"), path = await import("node:path");
+  for (const name of ["site.config.ts", "site.config.js", ".config/site.config.ts"]) {
+    const file = path.resolve(cwd, name);
+    if (!existsSync(file))
+      continue;
+    try {
+      const module = await import(file), url = fromConfigObject(module.default ?? module);
+      if (url)
+        return url;
+    } catch {}
+  }
+  return null;
+}
+export async function resolveSiteUrl(options = {}) {
+  const cwd = options.cwd ?? process.cwd(), env = options.env ?? process.env;
+  if (options.explicit) {
+    const url = normalize(options.explicit);
+    if (url)
+      return { url, source: "option" };
+  }
+  const fromStx = fromConfigObject(options.stxConfig);
+  if (fromStx)
+    return { url: fromStx, source: "stx.config", via: "site.url" };
+  const fromSiteFile = await loadSiteConfigFile(cwd);
+  if (fromSiteFile)
+    return { url: fromSiteFile, source: "site.config", via: "url" };
+  const env_ = fromEnv(env);
+  if (env_)
+    return env_;
+  return { url: SITE_URL_FALLBACK, source: "fallback" };
+}
+export function siteUrlFallbackWarning() {
+  return [
+    "No site URL configured \u2014 sitemap.xml and robots.txt will point at http://localhost.",
+    "  Set one in stx.config.ts (site: { url: 'https://example.com' }), in site.config.ts,",
+    "  via --domain, or with SITE_URL in the build environment."
+  ].join(`
+`);
+}

package/dist/slots.d.ts

@@ -1,3 +1,84 @@
+/**
+ * STX Slots Module
+ *
+ * Provides Vue-style named slots and scoped slots support.
+ *
+ * @module slots
+ *
+ * ## Named Slots
+ *
+ * Parent component:
+ * ```html
+ * <Card>
+ *   <template #header>
+ *     <h1>Title</h1>
+ *   </template>
+ *
+ *   <p>Default slot content</p>
+ *
+ *   <template #footer>
+ *     <button>Submit</button>
+ *   </template>
+ * </Card>
+ * ```
+ *
+ * Child component (Card.stx):
+ * ```html
+ * <div class="card">
+ *   <header>
+ *     <slot name="header">Default Header</slot>
+ *   </header>
+ *   <main>
+ *     <slot />
+ *   </main>
+ *   <footer>
+ *     <slot name="footer" />
+ *   </footer>
+ * </div>
+ * ```
+ *
+ * ## Scoped Slots
+ *
+ * Parent component:
+ * ```html
+ * <DataTable :items="users">
+ *   <template #row="{ item, index }">
+ *     <td>{{ index + 1 }}</td>
+ *     <td>{{ item.name }}</td>
+ *   </template>
+ * </DataTable>
+ * ```
+ *
+ * Child component (DataTable.stx):
+ * ```html
+ * <table>
+ *   @foreach (items as item, index)
+ *     <tr>
+ *       <slot name="row" :item="item" :index="index">
+ *         <td>{{ item }}</td>
+ *       </slot>
+ *     </tr>
+ *   @endforeach
+ * </table>
+ * ```
+ */
+export interface SlotDefinition {
+    /** Slot name (empty string for default slot) */
+    name: string;
+    /** Slot content (the template) */
+    content: string;
+    /** Scoped slot props binding (e.g., "{ item, index }") */
+    propsBinding?: string;
+}
+export interface SlotProps {
+    [key: string]: unknown;
+}
+export interface ParsedSlots {
+    /** Default slot content */
+    default: string;
+    /** Named slots */
+    named: Map<string, SlotDefinition>;
+}
 /**
  * Parse slot content from component children.
  *
@@ -14,9 +95,9 @@ export declare function parseSlots(childContent: string): ParsedSlots;
  * Returns: { name: 'row', props: { item: 'item', index: 'index' } }
  */
 export declare function parseSlotElement(slotTag: string): {
-  name: string
-  props: Record<string, string>
-  defaultContent: string
+    name: string;
+    props: Record<string, string>;
+    defaultContent: string;
 };
 /**
  * Render a slot with its content and props.
@@ -38,26 +119,11 @@ export declare function processSlots(template: string, parsedSlots: ParsedSlots,
  * This is called when processing a component to separate slot content.
  */
 export declare function extractSlotContent(childContent: string): {
-  defaultSlot: string
-  namedSlots: Map<string, SlotDefinition>
+    defaultSlot: string;
+    namedSlots: Map<string, SlotDefinition>;
 };
 /**
  * Apply slots to a component template.
  * This replaces <slot> elements with the provided slot content.
  */
 export declare function applySlots(componentTemplate: string, defaultSlotContent: string, namedSlots: Map<string, SlotDefinition>, context: Record<string, unknown>): Promise<string>;
-// =============================================================================
-// Types
-// =============================================================================
-export declare interface SlotDefinition {
-  name: string
-  content: string
-  propsBinding?: string
-}
-export declare interface SlotProps {
-  [key: string]: unknown
-}
-export declare interface ParsedSlots {
-  default: string
-  named: Map<string, SlotDefinition>
-}

package/dist/source-signature.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A cheap fingerprint of a set of source files, so a memoised bundle cannot
+ * outlive its sources.
+ *
+ * The store and composable loaders memoised their built bundle per directory
+ * and nothing ever invalidated it. `clearStoreCache()` and
+ * `clearComposableCache()` existed and were exported, but the only callers in
+ * the entire workspace were tests — so in dev, no edit to a store reached the
+ * browser without restarting the server, including creating the first one
+ * (stacksjs/stx#1877).
+ *
+ * A watcher alone is not enough: it fixes the common case but a missed event
+ * still leaves a stale bundle serving indefinitely, with no symptom other than
+ * an edit that seems not to have happened. Keying the memo on the sources means
+ * the worst a missed event costs is one stale request, not the rest of the
+ * session.
+ *
+ * Statting a handful of files is nothing next to the `Bun.build` it guards, so
+ * this runs on every call rather than being cached itself.
+ *
+ * @module source-signature
+ */
+/**
+ * Fingerprint `files` by path, size and mtime.
+ *
+ * Size is included because mtime resolution is coarse enough on some
+ * filesystems that a fast rewrite of the same length can land in the same
+ * millisecond. Sorted, so directory-scan order cannot change the result.
+ *
+ * A file that cannot be statted contributes a `missing` marker rather than
+ * throwing — it is a difference from the last run either way.
+ */
+export declare function sourceSignature(files: readonly string[]): string;
+/** A memo entry that knows which sources it was built from. */
+export interface SignedCacheEntry<T> {
+    signature: string;
+    value: T;
+}
+/**
+ * Read a memo entry, returning `undefined` when the sources have changed since
+ * it was written.
+ */
+export declare function readSigned<T>(cache: Map<string, SignedCacheEntry<T>>, key: string, signature: string): T | undefined;
+/** Write a memo entry stamped with the signature of its sources. */
+export declare function writeSigned<T>(cache: Map<string, SignedCacheEntry<T>>, key: string, signature: string, value: T): T;

package/dist/source-signature.js

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+export function sourceSignature(files) {
+  return [...files].sort().map((file) => {
+    try {
+      const stat = fs.statSync(file);
+      return `${file}:${stat.size}:${stat.mtimeMs}`;
+    } catch {
+      return `${file}:missing`;
+    }
+  }).join(`
+`);
+}
+export function readSigned(cache, key, signature) {
+  const entry = cache.get(key);
+  return entry !== void 0 && entry.signature === signature ? entry.value : void 0;
+}
+export function writeSigned(cache, key, signature, value) {
+  cache.set(key, { signature, value });
+  return value;
+}