@blinkk/root 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/config-872b068d.d.ts

@@ -0,0 +1,343 @@
+import { Express, Request as Request$1, Response as Response$1, NextFunction as NextFunction$1 } from 'express';
+import { ComponentType } from 'preact';
+import { ViteDevServer, PluginOption, UserConfig } from 'vite';
+import { Options } from 'html-minifier-terser';
+import { HTMLBeautifyOptions } from 'js-beautify';
+
+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[]>;
+}
+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>;
+}
+
+interface ElementSourceFile {
+    /** Full file path. */
+    filePath: string;
+    /** Path relative to the root project directory. */
+    relPath: string;
+}
+/**
+ * Dependency graph for element files to capture which other elements are used
+ * by any particular element.
+ */
+declare class ElementGraph {
+    /**
+     * Element tagName => sourceFile.
+     */
+    readonly sourceFiles: {
+        [tagName: string]: ElementSourceFile;
+    };
+    /**
+     * Element tagName => set of element tagName dependencies.
+     */
+    private deps;
+    constructor(sourceFiles: {
+        [tagName: string]: ElementSourceFile;
+    });
+    getDeps(tagName: string, visited?: Set<string>): string[];
+    /**
+     * Parses an element's source file for usage of other custom elements.
+     */
+    private parseDepsFromSource;
+}
+
+declare class Renderer {
+    private rootConfig;
+    private routes;
+    private assetMap;
+    private elementGraph;
+    constructor(rootConfig: RootConfig, options: {
+        assetMap: AssetMap;
+        elementGraph: ElementGraph;
+    });
+    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;
+    }>;
+    getSitemap(): Promise<Record<string, {
+        route: Route;
+        params: Record<string, string>;
+    }>>;
+    private renderHtml;
+    render404(): Promise<{
+        html: string;
+    }>;
+    renderError(err: any): 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;
+}
+
+/**
+ * Param values from the route, e.g. a route like `/route/[slug].tsx` will pass
+ * `{slug: 'foo'}`.
+ */
+declare type RouteParams = Record<string, string>;
+/**
+ * The `getStaticProps()` function is an optional function that routes can
+ * define to fetch and transform props before passing it to the route's
+ * component.
+ */
+declare type GetStaticProps<T = unknown> = (ctx: {
+    rootConfig: RootConfig;
+    params: RouteParams;
+}) => Promise<{
+    /** Props to pass to the component. */
+    props?: T;
+    /**  Set to true if the route should result in a 404 page. */
+    notFound?: boolean;
+}>;
+/**
+ * The `getStaticPaths()` is used by the SSG build to determine all of the
+ * paths that should exist for a given route. This should be used alongside a
+ * parameterized route, e.g. `/routes/blog/[slug].tsx`.
+ */
+declare type GetStaticPaths<T = RouteParams> = () => Promise<{
+    paths: Array<{
+        params: T;
+    }>;
+}>;
+/** Root.js express app. */
+declare type Server = Express;
+/** Root.js express request. */
+declare type Request = Request$1 & {
+    /** The root.js project config. */
+    rootConfig?: RootConfig & {
+        rootDir: string;
+    };
+    /** The vite dev server. This is only available when running `root dev`. */
+    viteServer?: ViteDevServer;
+    /** The root.js renderer, to render routes within middleware. */
+    renderer?: Renderer;
+    /**
+     * Handler context, provided to route files that export a custom `handler()`
+     * function.
+     */
+    handlerContext?: HandlerContext;
+};
+/** Root.js express response. */
+declare type Response = Response$1;
+/** Root.js express next function. */
+declare type NextFunction = NextFunction$1;
+/**
+ * A context variable passed to a route's `handle()` method within the req
+ * object.
+ */
+interface HandlerContext<T = any> {
+    /**
+     * The resolved route.
+     */
+    route: Route;
+    /**
+     * Param values from the route, e.g. a route like `/route/[slug].tsx` will
+     * pass `{slug: 'foo'}`.
+     */
+    params: RouteParams;
+    /** Renders the default exported component from the route. */
+    render: (props: T) => Promise<void>;
+    /** Renders a 404 page. */
+    render404: () => Promise<void>;
+}
+/**
+ * The `handle()` function can be exported by a route to define a custom express
+ * request handler. The `req` object will contain a `handlerContext` which
+ * contains the route's param values and also a `render()` method that can be
+ * used to render the route's default component.
+ */
+declare type Handler = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
+interface RouteModule {
+    default?: ComponentType<unknown>;
+    getStaticPaths?: GetStaticPaths;
+    getStaticProps?: GetStaticProps;
+    handle?: Handler;
+}
+interface Route {
+    /** The relative path to the route file, e.g. `routes/index.tsx`. */
+    src: string;
+    /** The imported route module. */
+    module: RouteModule;
+    /** The locale used for the route. */
+    locale: string;
+    /**
+     * The mapped URL path for the route, e.g.:
+     *
+     *   routes/index.tsx => `/`.
+     *   routes/events.tsx => `/events`.
+     *   routes/blog/[slug].tsx => `/blog/[slug]`.
+     *
+     * Per the example above, this value may contain placeholder params.
+     */
+    routePath: string;
+    /**
+     * The localized URL path for the route, e.g. `/[locale]/blog/[slug]`.
+     * Per the example above, this value contains placeholder params.
+     */
+    localeRoutePath: string;
+}
+
+declare type MaybePromise<T> = T | Promise<T>;
+declare type ConfigureServerHook = (server: Server, options: ConfigureServerOptions) => MaybePromise<void> | MaybePromise<() => void>;
+interface ConfigureServerOptions {
+    type: 'dev' | 'preview' | 'prod';
+    rootConfig: RootConfig;
+}
+interface Plugin {
+    [key: string]: any;
+    /** The name of the plugin. */
+    name?: string;
+    /**
+     * Configures the root.js express server. Any middleware defined by the plugin
+     * will be added to the server first. If a callback fn is returned, it will
+     * be called after the root.js middlewares are added.
+     */
+    configureServer?: ConfigureServerHook;
+    /**
+     * Returns a list of deps to bundle for ssr. The files will be bundled and
+     * output to `dist/server/`. The return value should be a map of
+     * `{output filename => input filepath}`.
+     *
+     * E.g. a value of `{foo: 'path/to/bar.js'}` will output `dist/server/foo.js`.
+     *
+     * @experimental This config is subject to change to be incorporated into a
+     * broader config option called "ssr" or "ssrOptions".
+     */
+    ssrInput?: () => {
+        [entryAlias: string]: string;
+    };
+    /** Adds vite plugins. */
+    vitePlugins?: PluginOption[];
+}
+/**
+ * Runs the pre-hook configureServer method of every plugin, calls a callback
+ * function, and then runs the configureServer's post-hook if provided. Plugins
+ * provide a post-hook by returning a callback function from configureServer.
+ */
+declare function configureServerPlugins(server: Server, callback: () => Promise<void>, plugins: Plugin[], options: ConfigureServerOptions): Promise<void>;
+declare function getVitePlugins(plugins: Plugin[]): PluginOption[];
+
+declare type HtmlMinifyOptions = Options;
+
+declare type HtmlPrettyOptions = HTMLBeautifyOptions;
+
+interface RootUserConfig {
+    /**
+     * Canonical domain the website will serve on. Useful for things like the
+     * sitemap, SEO tags, etc.
+     */
+    domain?: string;
+    /**
+     * Config for auto-injecting custom element dependencies.
+     */
+    elements?: {
+        /**
+         * A list of directories to use to look for custom elements. The dir path
+         * should be relative to the project dir, e.g. "path/to/elements".
+         */
+        include?: string[];
+        /**
+         * A list of RegEx patterns to exclude. The string passed to the RegEx is
+         * the file URL relative to the project root, e.g. "/elements/foo/foo.ts".
+         */
+        exclude?: RegExp[];
+    };
+    /**
+     * Config options for localization and internationalization.
+     */
+    i18n?: RootI18nConfig;
+    /**
+     * Config options for the Root.js express server.
+     */
+    server?: RootServerConfig;
+    /**
+     * Vite config.
+     * @see {@link https://vitejs.dev/config/} for more information.
+     */
+    vite?: UserConfig;
+    /**
+     * Whether to automatically minify HTML output. This is enabled by default,
+     * in order to disable, pass `minifyHtml: false` to root.config.ts.
+     */
+    minifyHtml?: boolean;
+    /**
+     * Options to pass to html-minifier-terser.
+     */
+    minifyHtmlOptions?: HtmlMinifyOptions;
+    /**
+     * Whether to pretty print HTML output.
+     */
+    prettyHtml?: boolean;
+    /**
+     * Options to pass to js-beautify.
+     */
+    prettyHtmlOptions?: HtmlPrettyOptions;
+    /**
+     * Whether to include a sitemap.xml file to the build output.
+     */
+    sitemap?: boolean;
+    /**
+     * Plugins.
+     */
+    plugins?: Plugin[];
+}
+declare type RootConfig = RootUserConfig & {
+    rootDir: string;
+};
+interface RootI18nConfig {
+    /**
+     * Locales enabled for the site.
+     */
+    locales?: string[];
+    /**
+     * The default locale to use. Defaults is `en`.
+     */
+    defaultLocale?: string;
+    /**
+     * URL format for localized content. Default is `/{locale}/{path}`.
+     */
+    urlFormat?: string;
+}
+interface RootServerConfig {
+    /**
+     * An array of middleware to add to the express server. These middleware are
+     * added to the beginning of the express app.
+     */
+    middlewares?: Array<(req: Request, res: Response, next: NextFunction) => void | Promise<void>>;
+}
+declare function defineConfig(config: RootUserConfig): RootUserConfig;
+
+export { ConfigureServerHook as C, GetStaticProps as G, HandlerContext as H, NextFunction as N, Plugin as P, Route as R, Server as S, RootUserConfig as a, RootConfig as b, RootI18nConfig as c, RootServerConfig as d, defineConfig as e, ConfigureServerOptions as f, configureServerPlugins as g, getVitePlugins as h, RouteParams as i, GetStaticPaths as j, Request as k, Response as l, Handler as m, RouteModule as n, Renderer as o };

package/dist/core.d.ts

@@ -1,41 +1,144 @@
-import * as preact from 'preact';
-import { ComponentChildren } from 'preact';
-export { b as GetStaticPaths, G as GetStaticProps, R as RootConfig, a as RootI18nConfig, d as defineConfig } from './types-2af24c42.js';
+import { R as Route } from './config-872b068d.js';
+export { C as ConfigureServerHook, f as ConfigureServerOptions, j as GetStaticPaths, G as GetStaticProps, m as Handler, H as HandlerContext, N as NextFunction, P as Plugin, k as Request, l as Response, b as RootConfig, c as RootI18nConfig, d as RootServerConfig, a as RootUserConfig, R as Route, n as RouteModule, i as RouteParams, S as Server, g as configureServerPlugins, e as defineConfig, h as getVitePlugins } from './config-872b068d.js';
+import * as preact$1 from 'preact';
+import { ComponentChildren, FunctionalComponent } from 'preact';
+import 'express';
 import 'vite';
+import 'html-minifier-terser';
+import 'js-beautify';
 
-interface ErrorPageProps {
-    error: unknown;
-}
-declare function ErrorPage(props: ErrorPageProps): preact.JSX.Element;
+declare type BodyProps = preact.JSX.HTMLAttributes<HTMLBodyElement> & {
+    children?: ComponentChildren;
+};
+/**
+ * The `<Body>` component can be used to update attrs in the `<body>` tag.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * <Body className="body">
+ *   <h1>Hello world</h1>
+ * </Body>
+ * ```
+ *
+ * Output:
+ *
+ * ```html
+ * <body class="body">
+ *   <h1>Hello world</h1>
+ * </body>
+ */
+declare const Body: FunctionalComponent<BodyProps>;
 
-declare const HEAD_CONTEXT: preact.Context<ComponentChildren[]>;
-interface HeadProps {
+declare type HeadProps = preact.JSX.HTMLAttributes<HTMLHeadElement> & {
     children?: ComponentChildren;
-}
+};
 /**
  * The <Head> component can be used for injecting elements into the HTML head
- * tag from any part of a page.
+ * tag from any part of a page. The <Head> can be added via any component or
+ * sub-component and will automatically be hoisted to the `<head>` element.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * <Head>
+ *   <link rel="preconnect" href="https://fonts.googleapis.com" />
+ * </Head>
+ * ```
  */
-declare function Head(props: HeadProps): null;
+declare const Head: FunctionalComponent<HeadProps>;
 
-declare const SCRIPT_CONTEXT: preact.Context<ScriptProps[]>;
-interface ScriptProps {
-    src: string;
-    type?: string;
+interface HtmlContext {
+    htmlAttrs: preact$1.JSX.HTMLAttributes<HTMLHtmlElement>;
+    headAttrs: preact$1.JSX.HTMLAttributes<HTMLHeadElement>;
+    headComponents: ComponentChildren[];
+    bodyAttrs: preact$1.JSX.HTMLAttributes<HTMLBodyElement>;
+    scriptDeps: Array<preact$1.JSX.HTMLAttributes<HTMLScriptElement>>;
 }
+declare const HTML_CONTEXT: preact$1.Context<HtmlContext | null>;
+declare type HtmlProps = preact$1.JSX.HTMLAttributes<HTMLHtmlElement> & {
+    children?: ComponentChildren;
+};
+/**
+ * The `<Html>` component can be used to update attrs in the `<html>` tag.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * <Html lang="en-US">
+ *   <h1>Hello world</h1>
+ * </Html>
+ * ```
+ */
+declare const Html: FunctionalComponent<HtmlProps>;
+
+declare type ScriptProps = preact.JSX.HTMLAttributes<HTMLScriptElement>;
 /**
  * The <Script> component is used for rendering any custom script modules. At
  * the moment, the system only pre-renders and bundles files that are in the
  * `/bundles` folder at the root of the project.
+ *
+ * Usage:
+ *
+ * ```tsx
+ * <Script src="/bundles/main.ts" />
+ * ```
  */
-declare function Script(props: ScriptProps): null;
+declare const Script: FunctionalComponent<ScriptProps>;
 
-declare const I18N_CONTEXT: preact.Context<I18nContext | null>;
+declare const I18N_CONTEXT: preact$1.Context<I18nContext | null>;
 interface I18nContext {
     locale: string;
     translations: Record<string, string>;
 }
+/**
+ * A hook that returns information about the current i18n context, including the
+ * locale for the given route and a map of translations for that locale.
+ */
+declare function useI18nContext(): I18nContext;
 declare function getTranslations(locale: string): Record<string, string>;
+
+interface RequestContext {
+    /** The route file. */
+    route: Route;
+    /**
+     * Route param values. E.g. for a route like `routes/blog/[slug].tsx`,
+     * visiting `/blog/foo` will pass {slug: 'foo'} here.
+     */
+    routeParams: Record<string, string>;
+    /** Props passed to the route's server component. */
+    props: any;
+    /** The current locale. */
+    locale: string;
+    /** Translations map for the current locale. */
+    translations: Record<string, string>;
+}
+declare const REQUEST_CONTEXT: preact$1.Context<RequestContext | null>;
+/**
+ * A hook that returns information about the current route.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const ctx = useRequestContext();
+ * ctx.route.src;
+ * // => 'routes/index.tsx'
+ * ```
+ */
+declare function useRequestContext(): RequestContext;
+
+/**
+ * A hook that returns a function that can be used to translate a string, and
+ * optionally replace any parameterized values that are surrounded in curly
+ * braces.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const t = useTranslations();
+ * t('Hello {name}', {name: 'Bob'});
+ * // => 'Bounjour Bob'
+ */
 declare function useTranslations(): (str: string, params?: Record<string, string>) => string;
 
-export { ErrorPage, ErrorPageProps, HEAD_CONTEXT, Head, HeadProps, I18N_CONTEXT, I18nContext, SCRIPT_CONTEXT, Script, ScriptProps, getTranslations, useTranslations };
+export { Body, BodyProps, HTML_CONTEXT, Head, HeadProps, Html, HtmlContext, HtmlProps, I18N_CONTEXT, I18nContext, REQUEST_CONTEXT, RequestContext, Script, ScriptProps, getTranslations, useI18nContext, useRequestContext, useTranslations };

package/dist/core.js

@@ -1,27 +1,95 @@
 import {
-  ErrorPage,
-  HEAD_CONTEXT,
-  Head,
+  configureServerPlugins,
+  getVitePlugins
+} from "./chunk-DTEQ2AIW.js";
+import {
+  HTML_CONTEXT,
+  Html,
   I18N_CONTEXT,
-  SCRIPT_CONTEXT,
-  Script,
+  REQUEST_CONTEXT,
   getTranslations,
-  useTranslations
-} from "./chunk-ZV52A6YZ.js";
+  useI18nContext,
+  useRequestContext
+} from "./chunk-WTSNW7BB.js";
 
 // src/core/config.ts
 function defineConfig(config) {
   return config;
 }
+
+// src/core/components/Body.tsx
+import { useContext } from "preact/hooks";
+import { Fragment, jsx } from "preact/jsx-runtime";
+var Body = ({ children, ...attrs }) => {
+  const context = useContext(HTML_CONTEXT);
+  if (!context) {
+    throw new Error(
+      "HTML_CONTEXT not found, double-check usage of the <Body> component"
+    );
+  }
+  context.bodyAttrs = attrs;
+  return /* @__PURE__ */ jsx(Fragment, {
+    children
+  });
+};
+
+// src/core/components/Head.ts
+import { useContext as useContext2 } from "preact/hooks";
+var Head = ({ children, ...attrs }) => {
+  const context = useContext2(HTML_CONTEXT);
+  if (!context) {
+    throw new Error(
+      "HTML_CONTEXT not found, double-check usage of the <Head> component"
+    );
+  }
+  context.headComponents.push(children);
+  context.headAttrs = attrs;
+  return null;
+};
+
+// src/core/components/Script.ts
+import { useContext as useContext3 } from "preact/hooks";
+var Script = (props) => {
+  const context = useContext3(HTML_CONTEXT);
+  if (!context) {
+    throw new Error(
+      "HTML_CONTEXT not found, double-check usage of the <Script> component"
+    );
+  }
+  context.scriptDeps.push(props);
+  return null;
+};
+
+// src/core/hooks/useTranslations.ts
+function useTranslations() {
+  const context = useI18nContext();
+  const translations = context.translations || {};
+  const t = (str, params) => {
+    let translation = translations[str] ?? str ?? "";
+    if (params) {
+      for (const key of Object.keys(params)) {
+        const val = String(params[key] ?? "");
+        translation = translation.replaceAll(`{${key}}`, val);
+      }
+    }
+    return translation;
+  };
+  return t;
+}
 export {
-  ErrorPage,
-  HEAD_CONTEXT,
+  Body,
+  HTML_CONTEXT,
   Head,
+  Html,
   I18N_CONTEXT,
-  SCRIPT_CONTEXT,
+  REQUEST_CONTEXT,
   Script,
+  configureServerPlugins,
   defineConfig,
   getTranslations,
+  getVitePlugins,
+  useI18nContext,
+  useRequestContext,
   useTranslations
 };
 //# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/core/config.ts"],"sourcesContent":["import {UserConfig as ViteUserConfig} from 'vite';\n\nexport interface RootConfig {\n  /**\n   * Configuration for auto-injecting custom element dependencies.\n   */\n  elements?: {\n    /**\n     * A list of directories to use to look for custom elements. The dir path\n     * should be relative to the project dir, e.g. \"path/to/elements\" or\n     * \"node_modules/my-package\".\n     */\n    include?: string[];\n\n    /**\n     * A list of RegEx patterns to exclude. The string passed to the RegEx is\n     * the file URL relative to the project root, e.g. \"/elements/foo/foo.ts\".\n     */\n    exclude?: RegExp[];\n  };\n\n  /**\n   * Configuration options for localization and internationalization.\n   */\n  i18n?: RootI18nConfig;\n\n  /**\n   * Vite configuration.\n   * @see {@link https://vitejs.dev/config/} for more information.\n   */\n  vite?: ViteUserConfig;\n\n  /**\n   * Whether to automatically minify HTML output.\n   */\n  minifyHtml?: boolean;\n\n  /**\n   * Whether to include a sitemap.xml file to the build output.\n   */\n  sitemap?: boolean;\n}\n\nexport interface RootI18nConfig {\n  /**\n   * Locales enabled for the site.\n   */\n  locales?: string[];\n\n  /**\n   * The default locale to use. Defaults is `en`.\n   */\n  defaultLocale?: string;\n\n  /**\n   * URL format for localized content. Default is `/{locale}/{path}`.\n   */\n  urlFormat?: string;\n}\n\nexport function defineConfig(config: RootConfig): RootConfig {\n  return config;\n}\n"],"mappings":";;;;;;;;;;;;AA4DO,SAAS,aAAa,QAAgC;AAC3D,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/core/config.ts","../src/core/components/Body.tsx","../src/core/components/Head.ts","../src/core/components/Script.ts","../src/core/hooks/useTranslations.ts"],"sourcesContent":["import {Request, Response, NextFunction} from './types';\nimport {Plugin} from './plugin';\nimport {UserConfig as ViteUserConfig} from 'vite';\nimport {HtmlMinifyOptions} from '../render/html-minify';\nimport {HtmlPrettyOptions} from '../render/html-pretty';\n\nexport interface RootUserConfig {\n  /**\n   * Canonical domain the website will serve on. Useful for things like the\n   * sitemap, SEO tags, etc.\n   */\n  domain?: string;\n\n  /**\n   * Config for auto-injecting custom element dependencies.\n   */\n  elements?: {\n    /**\n     * A list of directories to use to look for custom elements. The dir path\n     * should be relative to the project dir, e.g. \"path/to/elements\".\n     */\n    include?: string[];\n\n    /**\n     * A list of RegEx patterns to exclude. The string passed to the RegEx is\n     * the file URL relative to the project root, e.g. \"/elements/foo/foo.ts\".\n     */\n    exclude?: RegExp[];\n  };\n\n  /**\n   * Config options for localization and internationalization.\n   */\n  i18n?: RootI18nConfig;\n\n  /**\n   * Config options for the Root.js express server.\n   */\n  server?: RootServerConfig;\n\n  /**\n   * Vite config.\n   * @see {@link https://vitejs.dev/config/} for more information.\n   */\n  vite?: ViteUserConfig;\n\n  /**\n   * Whether to automatically minify HTML output. This is enabled by default,\n   * in order to disable, pass `minifyHtml: false` to root.config.ts.\n   */\n  minifyHtml?: boolean;\n\n  /**\n   * Options to pass to html-minifier-terser.\n   */\n  minifyHtmlOptions?: HtmlMinifyOptions;\n\n  /**\n   * Whether to pretty print HTML output.\n   */\n  prettyHtml?: boolean;\n\n  /**\n   * Options to pass to js-beautify.\n   */\n  prettyHtmlOptions?: HtmlPrettyOptions;\n\n  /**\n   * Whether to include a sitemap.xml file to the build output.\n   */\n  sitemap?: boolean;\n\n  /**\n   * Plugins.\n   */\n  plugins?: Plugin[];\n}\n\nexport type RootConfig = RootUserConfig & {\n  rootDir: string;\n};\n\nexport interface RootI18nConfig {\n  /**\n   * Locales enabled for the site.\n   */\n  locales?: string[];\n\n  /**\n   * The default locale to use. Defaults is `en`.\n   */\n  defaultLocale?: string;\n\n  /**\n   * URL format for localized content. Default is `/{locale}/{path}`.\n   */\n  urlFormat?: string;\n}\n\nexport interface RootServerConfig {\n  /**\n   * An array of middleware to add to the express server. These middleware are\n   * added to the beginning of the express app.\n   */\n  middlewares?: Array<\n    (req: Request, res: Response, next: NextFunction) => void | Promise<void>\n  >;\n}\n\nexport function defineConfig(config: RootUserConfig): RootUserConfig {\n  return config;\n}\n","import {ComponentChildren, FunctionalComponent} from 'preact';\nimport {useContext} from 'preact/hooks';\nimport {HTML_CONTEXT} from './Html';\n\nexport type BodyProps = preact.JSX.HTMLAttributes<HTMLBodyElement> & {\n  children?: ComponentChildren;\n};\n\n/**\n * The `<Body>` component can be used to update attrs in the `<body>` tag.\n *\n * Usage:\n *\n * ```tsx\n * <Body className=\"body\">\n *   <h1>Hello world</h1>\n * </Body>\n * ```\n *\n * Output:\n *\n * ```html\n * <body class=\"body\">\n *   <h1>Hello world</h1>\n * </body>\n */\nexport const Body: FunctionalComponent<BodyProps> = ({children, ...attrs}) => {\n  const context = useContext(HTML_CONTEXT);\n  if (!context) {\n    throw new Error(\n      'HTML_CONTEXT not found, double-check usage of the <Body> component'\n    );\n  }\n  context.bodyAttrs = attrs;\n  return <>{children}</>;\n};\n","import {ComponentChildren, FunctionalComponent} from 'preact';\nimport {useContext} from 'preact/hooks';\nimport {HTML_CONTEXT} from './Html';\n\nexport type HeadProps = preact.JSX.HTMLAttributes<HTMLHeadElement> & {\n  children?: ComponentChildren;\n};\n\n/**\n * The <Head> component can be used for injecting elements into the HTML head\n * tag from any part of a page. The <Head> can be added via any component or\n * sub-component and will automatically be hoisted to the `<head>` element.\n *\n * Usage:\n *\n * ```tsx\n * <Head>\n *   <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n * </Head>\n * ```\n */\nexport const Head: FunctionalComponent<HeadProps> = ({children, ...attrs}) => {\n  const context = useContext(HTML_CONTEXT);\n  if (!context) {\n    throw new Error(\n      'HTML_CONTEXT not found, double-check usage of the <Head> component'\n    );\n  }\n  context.headComponents.push(children);\n  context.headAttrs = attrs;\n  return null;\n};\n","import {FunctionalComponent} from 'preact';\nimport {useContext} from 'preact/hooks';\nimport {HTML_CONTEXT} from './Html';\n\nexport type ScriptProps = preact.JSX.HTMLAttributes<HTMLScriptElement>;\n\n/**\n * The <Script> component is used for rendering any custom script modules. At\n * the moment, the system only pre-renders and bundles files that are in the\n * `/bundles` folder at the root of the project.\n *\n * Usage:\n *\n * ```tsx\n * <Script src=\"/bundles/main.ts\" />\n * ```\n */\nexport const Script: FunctionalComponent<ScriptProps> = (props) => {\n  const context = useContext(HTML_CONTEXT);\n  if (!context) {\n    throw new Error(\n      'HTML_CONTEXT not found, double-check usage of the <Script> component'\n    );\n  }\n  context.scriptDeps.push(props);\n  return null;\n};\n","import {useI18nContext} from './useI18nContext';\n\n/**\n * A hook that returns a function that can be used to translate a string, and\n * optionally replace any parameterized values that are surrounded in curly\n * braces.\n *\n * Usage:\n *\n * ```ts\n * const t = useTranslations();\n * t('Hello {name}', {name: 'Bob'});\n * // => 'Bounjour Bob'\n */\nexport function useTranslations() {\n  const context = useI18nContext();\n  const translations = context.translations || {};\n  const t = (str: string, params?: Record<string, string>) => {\n    let translation = translations[str] ?? str ?? '';\n    if (params) {\n      for (const key of Object.keys(params)) {\n        const val = String(params[key] ?? '');\n        translation = translation.replaceAll(`{${key}}`, val);\n      }\n    }\n    return translation;\n  };\n  return t;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA6GO,SAAS,aAAa,QAAwC;AACnE,SAAO;AACT;;;AC9GA,SAAQ,kBAAiB;AAiChB;AARF,IAAM,OAAuC,CAAC,EAAC,aAAa,MAAK,MAAM;AAC5E,QAAM,UAAU,WAAW,YAAY;AACvC,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,UAAQ,YAAY;AACpB,SAAO;AAAA,IAAG;AAAA,GAAS;AACrB;;;AClCA,SAAQ,cAAAA,mBAAiB;AAoBlB,IAAM,OAAuC,CAAC,EAAC,aAAa,MAAK,MAAM;AAC5E,QAAM,UAAUC,YAAW,YAAY;AACvC,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,UAAQ,eAAe,KAAK,QAAQ;AACpC,UAAQ,YAAY;AACpB,SAAO;AACT;;;AC9BA,SAAQ,cAAAC,mBAAiB;AAgBlB,IAAM,SAA2C,CAAC,UAAU;AACjE,QAAM,UAAUC,YAAW,YAAY;AACvC,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,UAAQ,WAAW,KAAK,KAAK;AAC7B,SAAO;AACT;;;ACZO,SAAS,kBAAkB;AAChC,QAAM,UAAU,eAAe;AAC/B,QAAM,eAAe,QAAQ,gBAAgB,CAAC;AAC9C,QAAM,IAAI,CAAC,KAAa,WAAoC;AAC1D,QAAI,cAAc,aAAa,QAAQ,OAAO;AAC9C,QAAI,QAAQ;AACV,iBAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,cAAM,MAAM,OAAO,OAAO,QAAQ,EAAE;AACpC,sBAAc,YAAY,WAAW,IAAI,QAAQ,GAAG;AAAA,MACtD;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;","names":["useContext","useContext","useContext","useContext"]}