@jk2908/solas 0.3.7 → 0.4.0

package/dist/internal/browser-router/shared.d.ts

@@ -0,0 +1,169 @@
+import { Solas } from '../../solas.js';
+export declare namespace BrowserRouter {
+    export type Params = Record<string, string>;
+    export type Query = Record<string, string | number | boolean>;
+    export type Path = keyof Solas.Routes & string;
+    type Replace = {
+        replace?: boolean;
+    };
+    export type GoOptions = {
+        replace?: boolean;
+        query?: Query;
+        params?: Params;
+    };
+    /**
+     * These targets are used as-is. They are not matched against the route table,
+     * so this covers normal external URLs and hash-only links
+     */
+    export type ExternalTarget = `${string}:${string}` | `//${string}` | `#${string}`;
+    export function isHashOnlyTarget(target: string): boolean;
+    export function isExternalTarget(target: string, origin: string): boolean;
+    /**
+     * Turn a route pattern into the real path shape a caller can use. In practice,
+     * every ':param' or '*' part becomes a plain string slot
+     *
+     * @example
+     * ```ts
+     * // '/p/:id' becomes '/p/${string}'
+     * // '/test/*' becomes '/test/${string}'
+     * // '/posts' stays '/posts'
+     * ```
+     *
+     * @example
+     * ```ts
+     * type A = ResolvedPath<'/posts/:id'>
+     * // '/posts/${string}'
+     * ```
+     *
+     * @example
+     * ```ts
+     * type B = ResolvedPath<'/docs/*'>
+     * // '/docs/${string}'
+     * ```
+     */
+    export type ResolvedPath<TPath extends string> = TPath extends `${infer Start}:${string}/${infer Rest}` ? `${Start}${string}/${ResolvedPath<Rest>}` : TPath extends `${infer Start}:${string}` ? `${Start}${string}` : TPath extends `${infer Start}*${infer Rest}` ? `${Start}${string}${ResolvedPath<Rest>}` : TPath;
+    /**
+     * Once we have a real path, also allow the usual query-string and hash forms
+     *
+     * @example
+     * ```ts
+     * type A = TargetSuffix<'/posts/123'>
+     * // '/posts/123' | '/posts/123?${string}' | '/posts/123#${string}' | '/posts/123?${string}#${string}'
+     * ```
+     */
+    export type TargetSuffix<TPath extends string> = TPath | `${TPath}?${string}` | `${TPath}#${string}` | `${TPath}?${string}#${string}`;
+    /**
+     * This is the final string form a caller can navigate to. It can be an external
+     * URL, or a concrete URL that matches one of the  known routes
+     *
+     * @example
+     * ```ts
+     * type A = Target
+     * // 'https://example.com'
+     * // '#intro'
+     * // '/posts/123'
+     * // '/posts/123?draft=true'
+     * ```
+     */
+    export type Target = ExternalTarget | TargetSuffix<ResolvedPath<Path>>;
+    /**
+     * Extra options for callers who already have a finished target string
+     *
+     * @example
+     * ```ts
+     * const a: TargetConfig = { query: { page: 2 } }
+     * // params is rejected here because the path is already complete
+     * ```
+     */
+    type TargetConfig = {
+        params?: never;
+        query?: Query;
+    };
+    /**
+     * Extra options for callers who pass a route pattern and params separately.
+     * If the route definition says that route needs params, this type makes
+     * those params required. If the route has no params, it rejects them
+     *
+     * @example
+     * ```ts
+     * // if Solas.Routes['/posts/:id'] is { params: { id: string } }
+     * type A = PatternConfig<'/posts/:id'>
+     * // { query?: Query } & { params: { id: string } }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // if Solas.Routes['/about'] has no params field
+     * type B = PatternConfig<'/about'>
+     * // { query?: Query } & { params?: never }
+     * ```
+     */
+    type PatternConfig<TPath extends Path> = {
+        query?: Query;
+    } & (Solas.Routes[TPath] extends {
+        params: infer TParams extends Params;
+    } ? {
+        params: TParams;
+    } : {
+        params?: never;
+    });
+    /**
+     * Typed <Link /> props, using `href` instead of the internal `to` name
+     *
+     * `query` is always allowed
+     * `params` are only allowed when `href` is a known route pattern
+     *
+     * @example
+     * ```ts
+     * const a: LinkProps = { href: '/posts/:id', params: { id: '123' } }
+     * const b: LinkProps = { href: '/posts/123?draft=true' }
+     * ```
+     */
+    export type LinkProps = ({
+        href: Target;
+    } & TargetConfig) | (keyof Solas.Routes extends never ? never : {
+        [TPath in Path]: {
+            href: TPath;
+        } & PatternConfig<TPath>;
+    }[Path]);
+    /**
+     * Typed input for router.go(), using the same route rules as <Link />
+     *
+     * @example
+     * ```ts
+     * go('/p/post-2')
+     * go('/?foo=bar', { replace: true })
+     * ```
+     *
+     * @example
+     * ```ts
+     * go('/p/:id', { params: { id: 'post-2' }, replace: true })
+     * ```
+     *
+     * The last overload is the fallback for plain `string` values. The
+     * `string extends TTo` check stops that fallback from taking over
+     * when TypeScript already knows the caller passed a more specific
+     * string literal
+     *
+     * @example
+     * ```ts
+     * declare const dynamicPath: string
+     * go(dynamicPath, { replace: true })
+     * ```
+     */
+    export type Go = {
+        <TTo extends Path>(to: TTo, opts?: PatternConfig<TTo> & Replace): Promise<string>;
+        <TTo extends Target>(to: TTo, opts?: TargetConfig & Replace): Promise<string>;
+        <TTo extends string>(to: string extends TTo ? TTo : never, opts?: GoOptions): Promise<string>;
+    };
+    /**
+     * Convert a route pattern and params into a real path string. This is used internally
+     * to implement <Link /> and router.go
+     */
+    export function toTarget(path: string, params?: Record<string, string>, query?: Query): string;
+    export {};
+}
+/**
+ * Apply the base path to a target string when needed
+ */
+export declare function withBase(target: string): string;

package/dist/internal/browser-router/shared.js

@@ -0,0 +1,71 @@
+import { BasePath } from '../../utils/base-path.js';
+const BASE_PATH = BasePath.normalise(import.meta.env.BASE_URL);
+export { BrowserRouter };
+var BrowserRouter;
+(function (BrowserRouter) {
+    function isHashOnlyTarget(target) {
+        return target.startsWith('#');
+    }
+    BrowserRouter.isHashOnlyTarget = isHashOnlyTarget;
+    function isExternalTarget(target, origin) {
+        if (isHashOnlyTarget(target))
+            return false;
+        try {
+            return new URL(target, origin).origin !== origin;
+        }
+        catch {
+            return false;
+        }
+    }
+    BrowserRouter.isExternalTarget = isExternalTarget;
+    /**
+     * Convert a route pattern and params into a real path string. This is used internally
+     * to implement <Link /> and router.go
+     */
+    function toTarget(path, params, query) {
+        const used = new Set();
+        let to = path.replaceAll(/:([A-Za-z0-9_]+)/g, (_, key) => {
+            const value = params?.[key];
+            if (value == null) {
+                throw new Error(`[Link]: missing route param: ${key}`);
+            }
+            used.add(key);
+            return encodeURIComponent(value);
+        });
+        if (to.includes('*')) {
+            const remaining = Object.entries(params ?? {}).filter(([key]) => !used.has(key));
+            if (remaining.length !== 1) {
+                throw new Error('[Link]: wildcard routes require exactly one unmatched param');
+            }
+            to = to.replace('*', remaining[0][1].split('/').map(encodeURIComponent).join('/'));
+        }
+        if (!query)
+            return withBase(to);
+        const hashIndex = to.indexOf('#');
+        const hash = hashIndex >= 0 ? to.slice(hashIndex) : '';
+        const pathWithSearch = hashIndex >= 0 ? to.slice(0, hashIndex) : to;
+        const searchIndex = pathWithSearch.indexOf('?');
+        const pathname = searchIndex >= 0 ? pathWithSearch.slice(0, searchIndex) : pathWithSearch;
+        const currentSearch = searchIndex >= 0 ? pathWithSearch.slice(searchIndex + 1) : '';
+        const search = new URLSearchParams(currentSearch);
+        for (const [key, value] of Object.entries(query)) {
+            search.set(key, String(value));
+        }
+        const value = search.toString();
+        return withBase(`${pathname}${value.length > 0 ? `?${value}` : ''}${hash}`);
+    }
+    BrowserRouter.toTarget = toTarget;
+})(BrowserRouter || (BrowserRouter = {}));
+/**
+ * Apply the base path to a target string when needed
+ */
+export function withBase(target) {
+    if (BrowserRouter.isHashOnlyTarget(target))
+        return target;
+    if (target.startsWith('//') || /^[A-Za-z][A-Za-z\d+.-]*:/.test(target))
+        return target;
+    const suffixIndex = target.search(/[?#]/);
+    const pathname = suffixIndex === -1 ? target : target.slice(0, suffixIndex);
+    const suffix = suffixIndex === -1 ? '' : target.slice(suffixIndex);
+    return `${BasePath.apply(pathname || '/', BASE_PATH)}${suffix}`;
+}

package/dist/internal/browser-router/use-router.d.ts

@@ -1,5 +1,5 @@
 export declare function useRouter(): {
-    go: import("./router.js").BrowserRouter.Go;
+    go: import("./shared.js").BrowserRouter.Go;
     prefetch: (path: string) => void;
     isNavigating: boolean;
     url: {

package/dist/internal/build.js

@@ -324,7 +324,7 @@ var Build;
                 try {
                     if (!this.buildContext || !this.config)
                         continue;
-                    const { shell: shellPath, layouts: layoutPaths, '401s': unauthorizedPaths, '403s': forbiddenPaths, page: pagePath, '404s': notFoundPaths, '500s': serverErrorPaths, loaders: loaderPaths, middlewares: middlewarePaths, dir, } = segment;
+                    const { shell: shellPath, layouts: layoutPaths, '401s': unauthorisedPaths, '403s': forbiddenPaths, page: pagePath, '404s': notFoundPaths, '500s': serverErrorPaths, loaders: loaderPaths, middlewares: middlewarePaths, dir, } = segment;
                     // derive the route pattern from the directory path, falling
                     // back to a synthetic +page.tsx when this is
                     // a layout-only segment
@@ -347,7 +347,7 @@ var Build;
                     const shellImport = Finder.getImportPath(shellPath);
                     const shellId = `${Build.EntryKind.SHELL}${Bun.hash(shellImport)}`;
                     const layoutIds = [];
-                    const unauthorizedIds = [];
+                    const unauthorisedIds = [];
                     const forbiddenIds = [];
                     const notFoundIds = [];
                     const serverErrorIds = [];
@@ -375,17 +375,17 @@ var Build;
                         applyPrerenderMode(prerenderCache.get(layoutPath));
                         layoutIds.push(layoutId);
                     }
-                    for (const unauthorizedPath of unauthorizedPaths) {
-                        if (!unauthorizedPath) {
-                            unauthorizedIds.push(null);
+                    for (const unauthorisedPath of unauthorisedPaths) {
+                        if (!unauthorisedPath) {
+                            unauthorisedIds.push(null);
                             continue;
                         }
-                        const unauthorizedImport = Finder.getImportPath(unauthorizedPath);
-                        const unauthorizedId = `${Build.EntryKind['401']}${Bun.hash(unauthorizedImport)}`;
-                        unauthorizedIds.push(unauthorizedId);
-                        if (!processed.has(unauthorizedPath)) {
-                            imports.components.dynamic.set(unauthorizedId, unauthorizedImport);
-                            processed.add(unauthorizedPath);
+                        const unauthorisedImport = Finder.getImportPath(unauthorisedPath);
+                        const unauthorisedId = `${Build.EntryKind['401']}${Bun.hash(unauthorisedImport)}`;
+                        unauthorisedIds.push(unauthorisedId);
+                        if (!processed.has(unauthorisedPath)) {
+                            imports.components.dynamic.set(unauthorisedId, unauthorisedImport);
+                            processed.add(unauthorisedPath);
                         }
                     }
                     for (const forbiddenPath of forbiddenPaths) {
@@ -475,7 +475,7 @@ var Build;
                         processed.add(pagePath);
                     }
                     // resolve final prerender mode after shell → layout → page overrides
-                    const shouldPrerender = currentPrerenderMode !== false;
+                    const shouldPrerender = currentPrerenderMode !== false && this.buildContext.command === 'build';
                     const prerenderMode = shouldPrerender
                         ? currentPrerenderMode
                         : false;
@@ -506,7 +506,7 @@ var Build;
                         method: 'get',
                         paths: {
                             layouts: [shellPath, ...layoutPaths].map(layout => layout ? Finder.getImportPath(layout) : null),
-                            '401s': unauthorizedPaths.map(unauthorized => unauthorized ? Finder.getImportPath(unauthorized) : null),
+                            '401s': unauthorisedPaths.map(unauthorised => unauthorised ? Finder.getImportPath(unauthorised) : null),
                             '403s': forbiddenPaths.map(forbidden => forbidden ? Finder.getImportPath(forbidden) : null),
                             '404s': notFoundPaths.map(notFound => notFound ? Finder.getImportPath(notFound) : null),
                             '500s': serverErrorPaths.map(serverError => serverError ? Finder.getImportPath(serverError) : null),
@@ -533,7 +533,7 @@ var Build;
                         shellId,
                         layoutIds,
                         pageId: pagePath ? entryId : undefined,
-                        '401Ids': unauthorizedIds,
+                        '401Ids': unauthorisedIds,
                         '403Ids': forbiddenIds,
                         '404Ids': notFoundIds,
                         '500Ids': serverErrorIds,

package/dist/internal/codegen/environments.js

@@ -8,18 +8,19 @@ export function writeRSCEntry() {
 		${AUTOGEN_MSG}
 
 		import { createHandler } from '${Solas.Config.PKG_NAME}/env/rsc'
-		import { Prerender } from '${Solas.Config.PKG_NAME}/prerender'
 		import { Solas } from '${Solas.Config.PKG_NAME}'
 
 		import { manifest } from './manifest.js'
 		import { importMap } from './maps.js'
 		import { config } from './config.js'
 
-		const artifactManifest = await Prerender.Artifact.loadManifest(Solas.Config.OUT_DIR)
+		const runtimeManifest = await Solas.Runtime.loadManifest(Solas.Config.OUT_DIR)
 
-		export default createHandler(config, manifest, importMap, artifactManifest)
+		export default createHandler(config, manifest, importMap, runtimeManifest)
 
-		import.meta.hot?.accept()
+		if (import.meta.hot) {
+			import.meta.hot.accept()
+		}
 	`;
 }
 /**

package/dist/internal/env/browser.js

@@ -50,13 +50,15 @@ export async function browser() {
     hydrateRoot(document, _jsx(StrictMode, { children: _jsx(A, {}) }), {
         formState: payload.formState,
     });
-    import.meta.hot?.on?.('rsc:update', async () => {
-        try {
-            const p = await createFromFetch(fetch(window.location.href, { headers: { Accept: 'text/x-component' } }));
-            payloadSetter.current(p);
-        }
-        catch (err) {
-            console.error('[hmr] failed to refresh rsc payload', err);
-        }
-    });
+    if (import.meta.hot) {
+        import.meta.hot.on?.('rsc:update', async () => {
+            try {
+                const p = await createFromFetch(fetch(window.location.href, { headers: { Accept: 'text/x-component' } }));
+                payloadSetter.current(p);
+            }
+            catch (err) {
+                console.error('[hmr] failed to refresh rsc payload', err);
+            }
+        });
+    }
 }

package/dist/internal/env/rsc.d.ts

@@ -1,7 +1,7 @@
 import type { ReactFormState } from 'react-dom/client';
 import type { ImportMap, Manifest, RuntimeConfig } from '../../types.js';
+import { Solas } from '../../solas.js';
 import { Metadata } from '../metadata.js';
-import { Prerender } from '../prerender.js';
 export type RscPayload = {
     returnValue?: {
         ok: boolean;
@@ -20,6 +20,6 @@ export type RscPayload = {
  * route manifest, and import map to build the router once, then returns an object
  * with a fetch method that handles requests
  */
-export declare function createHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap, artifactManifest?: Prerender.Artifact.Manifest | null): {
+export declare function createHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap, runtimeManifest?: Solas.Runtime.Manifest | null): {
     fetch(req: Request): Promise<Response>;
 };