@jk2908/solas 0.1.0

package/dist/internal/navigation/link.js

@@ -0,0 +1,63 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef } from 'react';
+import { useRouter } from '../router/use-router';
+/**
+ * A link component that navigates to a given href
+ * @param href - the href to navigate to
+ * @param prefetch - when to prefetch the linked page, defaults to 'intent'
+ * @param rest - other props to pass to the underlying anchor element
+ * @returns a link element that navigates to the given href
+ */
+export function Link({ children, href, prefetch = 'intent', ...rest }) {
+    const { go, prefetch: prefetcher } = useRouter();
+    const timer = useRef(null);
+    return (_jsx("a", { ...rest, href: href, onClick: e => {
+            rest.onClick?.(e);
+            if (e.defaultPrevented)
+                return;
+            // only intercept plain left-click same-origin navigations
+            if (e.button !== 0)
+                return;
+            if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)
+                return;
+            if (rest.target && rest.target !== '_self')
+                return;
+            if (rest.download)
+                return;
+            const to = new URL(href, window.location.origin);
+            if (to.origin !== window.location.origin)
+                return;
+            e.preventDefault();
+            go(to.pathname + to.search + to.hash);
+        }, onFocus: e => {
+            rest.onFocus?.(e);
+            if (e.defaultPrevented)
+                return;
+            if (prefetch !== 'intent')
+                return;
+            prefetcher(href);
+        }, onTouchStart: e => {
+            rest.onTouchStart?.(e);
+            if (e.defaultPrevented)
+                return;
+            if (prefetch !== 'intent')
+                return;
+            prefetcher(href);
+        }, onMouseEnter: e => {
+            rest.onMouseEnter?.(e);
+            if (e.defaultPrevented)
+                return;
+            if (prefetch !== 'hover')
+                return;
+            timer.current = setTimeout(() => {
+                prefetcher(href);
+            }, 100);
+        }, onMouseLeave: e => {
+            rest.onMouseLeave?.(e);
+            if (timer.current) {
+                clearTimeout(timer.current);
+                timer.current = null;
+            }
+        }, children: children }));
+}

package/dist/internal/navigation/redirect-boundary.d.ts

@@ -0,0 +1,12 @@
+import type { BoundaryError } from '../../types';
+export type Props = {
+    fallback: ((error: BoundaryError) => React.ReactNode) | React.ReactNode;
+    children: React.ReactNode;
+};
+/**
+ * A component that catches redirect errors in its child component tree and performs
+ * a client-side redirect using a meta refresh tag
+ */
+export declare function RedirectBoundary({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/internal/navigation/redirect-boundary.js

@@ -0,0 +1,39 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Component } from 'react';
+import { isRedirect, REDIRECT_DIGEST_PREFIX } from './redirect';
+class Boundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = { error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    render() {
+        const { error } = this.state;
+        if (!error)
+            return this.props.children;
+        return typeof this.props.fallback === 'function'
+            ? this.props.fallback(error)
+            : this.props.fallback;
+    }
+}
+/**
+ * A component that catches redirect errors in its child component tree and performs
+ * a client-side redirect using a meta refresh tag
+ */
+export function RedirectBoundary({ children }) {
+    return (_jsx(Boundary, { fallback: err => {
+            if (!isRedirect(err))
+                throw err;
+            if ('digest' in err && typeof err.digest === 'string') {
+                const [type, ...rest] = err.digest.split(':');
+                if (type === REDIRECT_DIGEST_PREFIX) {
+                    const [, url] = rest;
+                    return _jsx("meta", { httpEquiv: "refresh", content: `0;url=${url}` });
+                }
+            }
+            return null;
+        }, children: children }));
+}

package/dist/internal/navigation/redirect.d.ts

@@ -0,0 +1,21 @@
+export type RedirectStatusCode = 301 | 302 | 307 | 308;
+/**
+ * Redirect exception class to signal a redirect
+ */
+export declare class Redirect extends Error {
+    readonly url: string;
+    readonly status: RedirectStatusCode;
+    digest?: string;
+    constructor(url: string, status?: RedirectStatusCode);
+}
+export declare const REDIRECT_DIGEST_PREFIX = "REDIRECT";
+/**
+ * Check if an error is a Redirect error
+ */
+export declare function isRedirect(err: unknown): err is Redirect;
+/**
+ * Throws a Redirect exc`eption to signal a redirect
+ * @param url - the application-relative URL or absolute http/https URL to redirect to
+ * @param status - the HTTP status code for the redirect, defaults to 307
+ */
+export declare function redirect(url: string, status?: RedirectStatusCode): never;

package/dist/internal/navigation/redirect.js

@@ -0,0 +1,63 @@
+import { Solas } from '../../solas';
+/**
+ * Redirect exception class to signal a redirect
+ */
+export class Redirect extends Error {
+    url;
+    status;
+    digest;
+    constructor(url, status = 307) {
+        super(`Redirecting to ${url} with status ${status}`);
+        this.url = url;
+        this.status = status;
+        this.name = 'Redirect';
+        this.digest = `${REDIRECT_DIGEST_PREFIX}:${status}:${url}`;
+    }
+}
+export const REDIRECT_DIGEST_PREFIX = 'REDIRECT';
+/**
+ * Validate a url for use in the redirect() function
+ */
+function validate(url) {
+    if (url.startsWith('//')) {
+        throw new TypeError(`[${Solas.Config.NAME}] redirect() does not allow protocol-relative urls`);
+    }
+    // reject urls with control characters to prevent header injection
+    for (const char of url) {
+        if (char === '\r' || char === '\n') {
+            throw new TypeError(`[${Solas.Config.NAME}] redirect() does not allow control characters`);
+        }
+    }
+    // good
+    if (url.startsWith('/'))
+        return;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new TypeError(`[${Solas.Config.NAME}] redirect() only supports relative paths or absolute http/https urls`);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new TypeError(`[${Solas.Config.NAME}] redirect() only supports http:// and https:// urls`);
+    }
+}
+/**
+ * Check if an error is a Redirect error
+ */
+export function isRedirect(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        'digest' in err &&
+        typeof err.digest === 'string' &&
+        err.digest.startsWith(REDIRECT_DIGEST_PREFIX));
+}
+/**
+ * Throws a Redirect exc`eption to signal a redirect
+ * @param url - the application-relative URL or absolute http/https URL to redirect to
+ * @param status - the HTTP status code for the redirect, defaults to 307
+ */
+export function redirect(url, status = 307) {
+    validate(url);
+    throw new Redirect(url, status);
+}

package/dist/internal/navigation/use-search-params.d.ts

@@ -0,0 +1 @@
+export declare function useSearchParams(): URLSearchParams;

package/dist/internal/navigation/use-search-params.js

@@ -0,0 +1,13 @@
+import { useMemo, useSyncExternalStore } from 'react';
+import { Solas } from '../../solas';
+export function useSearchParams() {
+    const search = useSyncExternalStore(fn => {
+        window.addEventListener('popstate', fn);
+        window.addEventListener(Solas.Events.names.NAVIGATION, fn);
+        return () => {
+            window.removeEventListener('popstate', fn);
+            window.removeEventListener(Solas.Events.names.NAVIGATION, fn);
+        };
+    }, () => window.location.search, () => '');
+    return useMemo(() => new URLSearchParams(search), [search]);
+}

package/dist/internal/prerender.d.ts

@@ -0,0 +1,151 @@
+import type { BuildContext } from '../types';
+export declare namespace Prerender {
+    namespace Artifact {
+        type Mode = 'full' | 'ppr';
+        type File = 'html' | 'prelude' | 'postponed' | 'metadata';
+        type Value = {
+            schema: string;
+            route: string;
+            createdAt: number;
+            mode: Mode;
+            html: string;
+            postponed?: unknown;
+        };
+        type Metadata = Pick<Value, 'schema' | 'route' | 'createdAt' | 'mode'>;
+        type ManifestEntry = {
+            mode: Mode;
+            createdAt: number;
+            files?: File[];
+        };
+        type Manifest = {
+            generatedAt: number;
+            routes: Record<string, ManifestEntry>;
+        };
+        /**
+         * Get the root directory path where prerender artifacts are stored,
+         * based on the output directory specified in the configuration
+         */
+        function getRootPath(outDir: string): string;
+        /**
+         * Get the file system path for the prerender artifact manifest, which
+         * contains metadata about all prerendered routes and their artifacts
+         */
+        function getManifestPath(outDir: string): string;
+        /**
+         * Get the file system path for storing prerender artifacts for a given route
+         */
+        function getPath(outDir: string, pathname: string): string;
+        /**
+         * Load the prerender artifact manifest for faster runtime route mode checks
+         */
+        function loadManifest(outDir: string): Promise<Manifest | null>;
+        /**
+         * Load the postponed state for a given route from the file system, if it exists
+         */
+        function loadPostponedState(outDir: string, pathname: string): Promise<any>;
+        /**
+         * Load the prelude HTML for a given route from the file system, if it exists
+         */
+        function loadPrelude(outDir: string, pathname: string): Promise<string | null>;
+        /**
+         * Load the prerender artifact metadata for a given route from the file system, if it exists and is valid
+         */
+        function loadMetadata(outDir: string, pathname: string): Promise<{
+            schema: string;
+            route: string;
+            createdAt: number;
+            mode: "full" | "ppr";
+        } | null>;
+        /**
+         * Check if a prerender artifact is compatible with the current application version and route,
+         * based on its metadata
+         */
+        function isCompatible(artifactMetadata: Metadata, pathname: string, mode: Mode): boolean;
+        /**
+         * Compose the prelude HTML and the resume stream into a single HTML stream, by injecting the resume stream
+         * into the prelude at the appropriate location (before </body> or </html>)
+         */
+        function composePreludeAndResume(prelude: string, resumeStream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array<ArrayBufferLike>>;
+    }
+    type Result = {
+        route: string;
+        artifact: Artifact.Value;
+    } | {
+        route: string;
+        status: number;
+    } | {
+        route: string;
+        error: unknown;
+    };
+    namespace Runtime {
+        /**
+         * Custom error class to indicate that prerendering has been postponed to request-time
+         */
+        class Postponed extends Error {
+            constructor(message?: string);
+        }
+        /**
+         * Type guard to check if an error is a Postponed error, including wrapped errors like
+         * AbortError or TimeoutError
+         */
+        function isPostponed(error: unknown): boolean;
+    }
+    namespace Build {
+        /**
+         * Get the prerender timeout value from the environment variable, or return the default
+         * if it's not set or invalid
+         */
+        function getTimeout(): number;
+        /**
+         * Get the prerender concurrency value from the environment variable, or return the default
+         * if it's not set or invalid
+         */
+        function getConcurrency(): number;
+        /**
+         * Extract the prerendering mode ('full', 'ppr', or false) from the source code of a route module, by
+         * looking for an exported `prerender` binding and validating its value
+         */
+        function getStaticFlag(filePath: string, buildContext: BuildContext): Promise<"full" | "ppr" | false | undefined>;
+        /**
+         * Get the list of static parameters for a dynamic route, by looking for an exported `params` function
+         * in the route module and calling it to get the list of parameter objects
+         */
+        function getStaticParams(filePath: string, buildContext: BuildContext): Promise<Record<string, string | number | (string | number)[]>[]>;
+        /**
+         * Generate the list of prerenderable routes for a dynamic route, by combining the static parameters obtained from
+         * the route module with the route pattern, and filtering out any routes that still contain dynamic segments
+         */
+        function getDynamicRouteList(route: string, paramNames: string[], staticParams: Record<string, string | number | (string | number)[]>[]): string[];
+        /**
+         * Function to prerender a single route by making a request to the route with special headers, and returning the
+         * result which includes either the prerender artifact or an error/status code if the prerendering failed or was
+         * postponed to request-time
+         */
+        function get(app: {
+            fetch: (req: Request) => Promise<Response>;
+        }, route: string, opts: {
+            timeout: number;
+            origin?: string;
+        }): Promise<{
+            route: string;
+            status: number;
+            artifact?: undefined;
+        } | {
+            status?: undefined;
+            route: string;
+            artifact: any;
+        }>;
+        /**
+         * Run the prerendering process for a list of routes, with a specified concurrency limit and timeout for
+         * each route, by calling the 'get' function for each route and yielding the results as they
+         * become available
+         */
+        function run(app: {
+            fetch: (req: Request) => Promise<Response>;
+        }, routes: string[], opts: {
+            timeout: number;
+            concurrency?: number;
+            origin?: string;
+        }): AsyncGenerator<Result, void, unknown>;
+    }
+}