@blinkk/root 3.0.1 → 3.0.3

package/dist/node/vite-plugin-prune-empty-chunks.d.ts

@@ -0,0 +1,27 @@
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that removes 0-byte JS chunks from the build output and prunes
+ * the import statements that reference them.
+ *
+ * Tree-shaking (via rolldown/esbuild) can reduce a module to nothing — e.g. a
+ * type-only `.ts` file, or an entry whose contents are entirely eliminated.
+ * rolldown still emits a file for every explicit input, so these surface as
+ * 0-byte `.js` files in the build output. Worse, a sibling chunk may keep a
+ * bare side-effect import (`import "./<hash>.js"`) pointing at the empty file.
+ * If that empty file is removed without also removing the import, the import
+ * 404s at runtime and breaks the entire module graph.
+ *
+ * This plugin runs in `generateBundle` (before Vite's manifest plugin) and:
+ *   1. Detects chunks whose generated code is empty.
+ *   2. Skips any that still anchor CSS or asset references, so co-located
+ *      styles are preserved (Vite keeps an empty JS chunk to carry the CSS
+ *      link for a style-only module).
+ *   3. Strips bare side-effect imports of the empty chunks from sibling chunks.
+ *      A 0-byte module exports nothing, so it can only be imported bare.
+ *   4. Deletes the empty chunks from the bundle.
+ *
+ * Because it runs before the manifest is emitted, the resulting
+ * `manifest.json` (consumed by Root's asset map) never references the removed
+ * files.
+ */
+export declare function pruneEmptyChunksPlugin(): Plugin;

package/dist/node/vite-plugin-root-jsx-virtual.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from 'vite';
+export interface PreactToRootJsxPluginOptions {
+    /** Whether Root's JSX renderer mode is enabled. */
+    useRootJsx?: boolean;
+}
+/**
+ * Vite plugin that aliases `preact` imports to `@blinkk/root/jsx` in the SSR
+ * environment only.
+ *
+ * When `jsxRenderer.mode` is configured, the project uses Root's built-in JSX
+ * runtime instead of Preact for server-side rendering. This plugin redirects
+ * `preact` imports (`preact`, `preact/hooks`, `preact/jsx-runtime`, etc.) to
+ * Root's JSX package, but only in the SSR environment. Client-side code (e.g.
+ * islands that depend on real Preact for hydration) is left untouched.
+ */
+export declare function preactToRootJsxPlugin(options?: PreactToRootJsxPluginOptions): Plugin;

package/dist/node/vite.d.ts

@@ -0,0 +1,18 @@
+import { ViteDevServer } from 'vite';
+import { RootConfig } from '../core/config.js';
+export interface CreateViteServerOptions {
+    /** Override HMR settings. */
+    hmr?: boolean;
+    /** The port the server will run on. */
+    port?: number;
+    /** List of files to include in the optimizeDeps.include config. */
+    optimizeDeps?: string[];
+}
+/**
+ * Returns a vite dev server.
+ */
+export declare function createViteServer(rootConfig: RootConfig, options?: CreateViteServerOptions): Promise<ViteDevServer>;
+/**
+ * Shortcut `viteServer.ssrLoadModule()` without starting an actual dev server.
+ */
+export declare function viteSsrLoadModule<T = Record<string, any>>(rootConfig: RootConfig, file: string): Promise<T>;

package/dist/node.js

@@ -10,7 +10,7 @@ import {
   loadRootConfig,
   loadRootConfigWithDeps,
   viteSsrLoadModule
-} from "./chunk-PVBPP5LN.js";
+} from "./chunk-7PSEEE6C.js";
 import "./chunk-XSNCF7WU.js";
 export {
   bundleRootConfig,
@@ -25,4 +25,4 @@ export {
   loadRootConfigWithDeps,
   viteSsrLoadModule
 };
-//# sourceMappingURL=node.js.map
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -1 +1,7 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/render/accept-language.d.ts

@@ -0,0 +1,8 @@
+export declare const ACCEPT_LANG_RE: RegExp;
+export interface AcceptLanguage {
+    code: string;
+    script?: string;
+    region?: string;
+    quality: number;
+}
+export declare function parseAcceptLanguage(value: string): AcceptLanguage[];

package/dist/render/asset-map/asset-map.d.ts

@@ -0,0 +1,25 @@
+export interface Asset {
+    /**
+     * The path to the asset's src file, relative to the project root.
+     */
+    src: string;
+    /**
+     * The serving URL for the asset.
+     */
+    assetUrl: string;
+    /**
+     * Recursively walks all deps and returns a list of CSS asset URLs.
+     */
+    getCssDeps(): Promise<string[]>;
+    /**
+     * Recursively walks all deps and returns a list of JS asset URLs.
+     */
+    getJsDeps(): Promise<string[]>;
+}
+export interface AssetMap {
+    /**
+     * Returns the asset for a given src file. The `src` value should be a path
+     * relative to the project root, e.g. "routes/index.tsx".
+     */
+    get: (src: string) => Promise<Asset | null>;
+}

package/dist/render/asset-map/build-asset-map.d.ts

@@ -0,0 +1,47 @@
+import { Manifest } from 'vite';
+import { RootConfig } from '../../core/config.js';
+import { ElementGraph } from '../../node/element-graph.js';
+import { Asset, AssetMap } from './asset-map.js';
+export type BuildAssetManifest = Record<string, {
+    src: string;
+    assetUrl: string;
+    importedModules: string[];
+    importedCss: string[];
+    isElement: boolean;
+}>;
+export declare class BuildAssetMap implements AssetMap {
+    private rootConfig;
+    private srcToAsset;
+    constructor(rootConfig: RootConfig);
+    get(src: string): Promise<Asset | null>;
+    private add;
+    toJson(): BuildAssetManifest;
+    static fromViteManifest(rootConfig: RootConfig, clientManifest: Manifest, elementsGraph: ElementGraph): BuildAssetMap;
+    static fromRootManifest(rootConfig: RootConfig, rootManifest: BuildAssetManifest): BuildAssetMap;
+}
+export declare class BuildAsset {
+    src: string;
+    assetUrl: string;
+    private assetMap;
+    private importedModules;
+    private importedCss;
+    isElement: boolean;
+    constructor(assetMap: BuildAssetMap, assetData: {
+        src: string;
+        assetUrl: string;
+        importedModules: string[];
+        importedCss: string[];
+        isElement: boolean;
+    });
+    getCssDeps(): Promise<string[]>;
+    getJsDeps(): Promise<string[]>;
+    private collectJs;
+    private collectCss;
+    toJson(): {
+        src: string;
+        assetUrl: string;
+        importedModules: string[];
+        importedCss: string[];
+        isElement: boolean;
+    };
+}

package/dist/render/asset-map/dev-asset-map.d.ts

@@ -0,0 +1,26 @@
+import { ModuleGraph, ModuleNode } from 'vite';
+import { RootConfig } from '../../core/config.js';
+import { Asset, AssetMap } from './asset-map.js';
+export declare class DevServerAssetMap implements AssetMap {
+    private rootConfig;
+    private moduleGraph;
+    constructor(rootConfig: RootConfig, moduleGraph: ModuleGraph);
+    get(src: string): Promise<Asset | null>;
+    filePathToSrc(file: string): string;
+}
+export declare class DevServerAsset implements Asset {
+    src: string;
+    moduleId: string;
+    assetUrl: string;
+    private assetMap;
+    private viteModule;
+    constructor(src: string, options: {
+        assetMap: DevServerAssetMap;
+        viteModule: ModuleNode;
+    });
+    getCssDeps(): Promise<string[]>;
+    getJsDeps(): Promise<string[]>;
+    getImportedModules(): Set<ModuleNode>;
+    private collectJs;
+    private collectCss;
+}

package/dist/render/countrie-language.d.ts

@@ -0,0 +1,13 @@
+interface CountryLanguages {
+    code: string;
+    name: string;
+    languages: Language[];
+    langCultureMs?: Array<{
+        langCultureName: string;
+    }>;
+}
+interface Language {
+    iso639_1: string;
+}
+export declare function getCountryLanguageData(countryCode: string): CountryLanguages | null;
+export {};

package/dist/render/html-minify.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from 'html-minifier-terser';
+export type HtmlMinifyOptions = Options;
+export declare function htmlMinify(html: string, options?: HtmlMinifyOptions): Promise<string>;

package/dist/render/html-pretty.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLBeautifyOptions } from 'js-beautify';
+export type HtmlPrettyOptions = HTMLBeautifyOptions;
+export declare function htmlPretty(html: string, options?: HtmlPrettyOptions): Promise<string>;

package/dist/render/i18n-fallbacks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility functions for handling requests that mimic the Firebase Hosting i18n
+ * fallback logic.
+ * https://firebase.google.com/docs/hosting/i18n-rewrites
+ */
+import { Request } from '../core/types.js';
+export declare const UNKNOWN_COUNTRY = "zz";
+export declare const ES_419_COUNTRIES: string[];
+export declare function getFallbackLocales(req: Request): string[];
+export declare function getCountry(req: Request): string;
+export declare function test419Country(countryCode: string): boolean;

package/dist/render/render.d.ts

@@ -0,0 +1,91 @@
+import { RootConfig } from '../core/config.js';
+import { Request, Response, NextFunction, Route, Sitemap } from '../core/types.js';
+import type { ElementGraph } from '../node/element-graph.js';
+import { AssetMap } from './asset-map/asset-map.js';
+export declare class Renderer {
+    private rootConfig;
+    private assetMap;
+    private elementGraph;
+    private router;
+    constructor(rootConfig: RootConfig, options: {
+        assetMap: AssetMap;
+        elementGraph: ElementGraph;
+    });
+    /** Returns a route from the router. */
+    getRoute(url: string): [Route | undefined, Record<string, string>];
+    handle(req: Request, res: Response, next: NextFunction): Promise<void>;
+    private renderComponent;
+    /** SSG renders a route. */
+    renderRoute(route: Route, options: {
+        routeParams: Record<string, string>;
+    }): Promise<{
+        html?: string;
+        notFound?: boolean;
+    }>;
+    /** Handles the SSR rendering of a route. */
+    handleRoute(req: Request, res: Response, next: NextFunction, route: Route, options?: {
+        defaultStatusCode?: number;
+        /**
+         * URL placeholder params.
+         */
+        routeParams?: Record<string, string>;
+        /**
+         * Handler function that tries the next matching route if multiple routes
+         * match for a given url path.
+         */
+        nextRouteHandler?: () => void | Promise<void>;
+    }): Promise<void>;
+    /**
+     * Constructs and returns the project's sitemap.
+     *
+     * The sitemap is used to:
+     * - determine all paths to build in SSG mode
+     * - display links on the dev server's 404 page
+     * - construct alternates for localized URL paths
+     */
+    getSitemap(): Promise<Sitemap>;
+    private getJsxRenderOptions;
+    /**
+     * Renders JSX via either the `@blinkk/root/jsx` package or
+     * `preact-render-to-string` depending if the `jsxRenderer` config is set up
+     * in `root.config.ts`.
+     */
+    private renderJsx;
+    private getConfiguredStyleEntries;
+    private renderHtml;
+    private ensureNewline;
+    render404(options?: {
+        currentPath?: string;
+    }): Promise<{
+        html: string;
+    }>;
+    renderError(err: any, options?: {
+        currentPath?: string;
+    }): Promise<{
+        html: string;
+    }>;
+    renderDevServer404(req: Request): Promise<{
+        html: string;
+    }>;
+    renderDevServer500(req: Request, error: unknown): Promise<{
+        html: string;
+    }>;
+    /**
+     * Parses rendered HTML for custom element tags used on the page and
+     * automatically adds the JS/CSS deps to the page.
+     */
+    private collectElementDeps;
+    /**
+     * Returns the `security` config value with default values inserted wherever
+     * a user config value is blank or set to `true`.
+     */
+    private getSecurityConfig;
+    /**
+     * Generates a random string that can be used as the "nonce" value for CSP.
+     */
+    private generateNonce;
+    /**
+     * Sets security-related HTTP headers.
+     */
+    private setSecurityHeaders;
+}

package/dist/render/route-trie.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A trie data structure that stores routes. Supports Next-style routing using
+ * [param], [...catchall], and [[...optcatchall]] placeholders.
+ */
+export declare class RouteTrie<T> {
+    private children;
+    private paramNodes?;
+    private catchAllNodes?;
+    private optCatchAllNodes?;
+    private route?;
+    /**
+     * Adds a route to the trie.
+     */
+    add(path: string, route: T): void;
+    /**
+     * Returns a route mapped to the given path and any parameter values from the
+     * URL.
+     */
+    get(path: string): [T | undefined, Record<string, string>];
+    /**
+     * Returns all routes that match the given path and their parameter values.
+     */
+    matchAll(path: string): Array<[T, Record<string, string>]>;
+    /**
+     * Walks the route trie and calls a callback function for each route.
+     */
+    walk(cb: (urlPath: string, route: T) => Promise<void> | void): Promise<void>;
+    /**
+     * Removes all routes from the trie.
+     */
+    clear(): void;
+    private getRoute;
+    private collectRoutes;
+    /**
+     * Normalizes a path for inclusion into the route trie.
+     */
+    private normalizePath;
+    /**
+     * Splits the parent directory from its children, e.g.:
+     *
+     *     splitPath("foo/bar/baz") -> ["foo", "bar/baz"]
+     */
+    private splitPath;
+}

package/dist/render/router.d.ts

@@ -0,0 +1,18 @@
+import { RootConfig } from '../core/config.js';
+import { Route } from '../core/types.js';
+export declare class Router {
+    private rootConfig;
+    private routeTrie;
+    constructor(rootConfig: RootConfig);
+    get(url: string): [Route | undefined, Record<string, string>];
+    matchAll(url: string): [Route, Record<string, string>][];
+    walk(cb: (urlPath: string, route: Route) => void | Promise<void>): Promise<void>;
+    private initRouteTrie;
+    getAllPathsForRoute(urlPathFormat: string, route: Route): Promise<Array<{
+        urlPath: string;
+        params: Record<string, string>;
+    }>>;
+}
+export declare function normalizeUrlPath(urlPath: string, options?: {
+    trailingSlash?: boolean;
+}): string;

package/dist/render.js

@@ -5,7 +5,7 @@ import {
   getTranslations,
   replaceParams,
   testPathHasParams
-} from "./chunk-WAZTR3DX.js";
+} from "./chunk-KW7KTYGC.js";
 import {
   RouteTrie,
   htmlMinify,
@@ -14,12 +14,12 @@ import {
 } from "./chunk-6P3B7ZXL.js";
 import {
   renderJsxToString
-} from "./chunk-M6WGW5VY.js";
-import "./chunk-FQBA5QSG.js";
+} from "./chunk-DU7JUEDY.js";
+import "./chunk-3Z5TNZEP.js";
 
 // src/render/render.tsx
-import crypto from "crypto";
-import path2 from "path";
+import crypto from "node:crypto";
+import path2 from "node:path";
 import {
   options as preactOptions
 } from "preact";
@@ -12876,7 +12876,7 @@ function test419Country(countryCode) {
 }
 
 // src/render/router.ts
-import path from "path";
+import path from "node:path";
 import { ROUTE_MODULES, POD_ROUTE_MODULES } from "virtual:root/routes";
 var ROUTES_FILES = ROUTE_MODULES;
 var POD_ROUTES = POD_ROUTE_MODULES || {};
@@ -13125,7 +13125,7 @@ var Renderer = class {
     if (url.includes("%")) {
       try {
         url = decodeURI(url);
-      } catch (e) {
+      } catch {
       }
     }
     const matches = this.router.matchAll(url);
@@ -13172,7 +13172,7 @@ var Renderer = class {
     };
     const vdom = /* @__PURE__ */ jsx4(REQUEST_CONTEXT.Provider, { value: ctx, children: /* @__PURE__ */ jsx4(I18N_CONTEXT.Provider, { value: { locale, translations }, children: /* @__PURE__ */ jsx4(HTML_CONTEXT.Provider, { value: htmlContext, children: /* @__PURE__ */ jsx4(Component, { ...props }) }) }) });
     const preactHook = preactOptions.vnode;
-    let mainHtml = "";
+    let mainHtml;
     try {
       preactOptions.vnode = (vnode) => {
         if (vnode && vnode.type === "script") {
@@ -13793,4 +13793,4 @@ function guessContentType(ext) {
 export {
   Renderer
 };
-//# sourceMappingURL=render.js.map
+//# sourceMappingURL=render.js.map