@jk2908/solas 0.5.3 → 0.6.0

package/dist/index.js

@@ -5,10 +5,12 @@ import { createServer, loadConfigFromFile, } from 'vite';
 import rsc from '@vitejs/plugin-rsc';
 import { ExportReader } from './utils/export-reader.js';
 import { Logger } from './utils/logger.js';
-import { Time } from './utils/time.js';
-import { Build } from './internal/build.js';
+import { debounce } from './utils/time.js';
+import * as Config from './config.js';
+import * as Build from './internal/build.js';
 import { writeConfig } from './internal/codegen/config.js';
 import { writeBrowserEntry, writeRSCEntry, writeSSREntry, } from './internal/codegen/environments.js';
+import { format as formatSource } from './internal/codegen/format.js';
 import { writeManifest } from './internal/codegen/manifest.js';
 import { writeMaps } from './internal/codegen/maps.js';
 import { writeTypes } from './internal/codegen/types.js';
@@ -16,7 +18,6 @@ import { postbuild } from './internal/postbuild.js';
 import { collect as collectPublicFiles } from './internal/public-files.js';
 import { createRuntime } from './internal/runtimes/create.js';
 import { Runtime } from './internal/runtimes/runtime.js';
-import { Solas } from './solas.js';
 const DEFAULT_CONFIG = {
     runtime: 'auto',
     precompress: false,
@@ -25,15 +26,14 @@ const DEFAULT_CONFIG = {
     trailingSlash: 'never',
 };
 function solas(c) {
-    const validatedConfig = Solas.Config.validate({
-        ...c,
-        url: c?.url ?? process.env.VITE_APP_URL?.toString(),
-    });
+    const validatedConfig = Config.validate(c);
     const config = {
         ...DEFAULT_CONFIG,
         ...validatedConfig,
         runtime: validatedConfig.runtime ?? DEFAULT_CONFIG.runtime,
     };
+    const envUrl = process.env.VITE_APP_URL?.toString();
+    let resolvedUrl = c?.url ?? (envUrl && envUrl.length > 0 ? envUrl : undefined);
     Runtime.runtime = createRuntime(config.runtime);
     if (config.logger?.level)
         Logger.defaultLevel = config.logger.level;
@@ -93,8 +93,8 @@ function solas(c) {
     }
     async function build() {
         const cwd = process.cwd();
-        const routesDir = path.join(cwd, Solas.Config.APP_DIR);
-        const generatedDir = path.join(cwd, Solas.Config.GENERATED_DIR);
+        const routesDir = path.join(cwd, Config.APP_DIR);
+        const generatedDir = path.join(cwd, Config.GENERATED_DIR);
         await Promise.all([
             fs.mkdir(routesDir, { recursive: true }),
             fs.mkdir(generatedDir, { recursive: true }),
@@ -107,12 +107,27 @@ function solas(c) {
             ['config.ts', writeConfig(config)],
             ['manifest.ts', writeManifest(manifest)],
             ['maps.ts', writeMaps(imports, modules)],
-            [`${Solas.Config.SLUG}.d.ts`, writeTypes(manifest)],
-            [Solas.Config.ENTRY_RSC, writeRSCEntry(config)],
-            [Solas.Config.ENTRY_SSR, writeSSREntry()],
-            [Solas.Config.ENTRY_BROWSER, writeBrowserEntry()],
+            [`${Config.SLUG}.d.ts`, writeTypes(manifest)],
+            [Config.ENTRY_RSC, writeRSCEntry(config)],
+            [Config.ENTRY_SSR, writeSSREntry()],
+            [Config.ENTRY_BROWSER, writeBrowserEntry()],
         ];
-        const writes = await Promise.all(files.map(([file, content]) => maybeWrite(path.join(generatedDir, file), content)));
+        // remove generated files no longer emitted by the current codegen, so
+        // old artifacts don't linger and break module resolution. keep
+        // closeBundle's build.json, which lives in the same directory
+        const currentFiles = new Set(files.map(([file]) => file));
+        const existing = await fs
+            .readdir(generatedDir, { withFileTypes: true })
+            .catch(() => []);
+        await Promise.all(existing
+            .filter(entry => entry.isFile() &&
+            entry.name !== 'build.json' &&
+            !currentFiles.has(entry.name))
+            .map(entry => fs.rm(path.join(generatedDir, entry.name), { force: true })));
+        const writes = await Promise.all(files.map(async ([file, content]) => {
+            const formatted = await formatSource(file, content);
+            return maybeWrite(path.join(generatedDir, file), formatted);
+        }));
         const changed = writes.filter(n => n !== null);
         // early return if nothing has changed
         if (!changed.length)
@@ -125,7 +140,7 @@ function solas(c) {
     // normalise all watcher paths to forward slashes so path checks behave the
     // same on Windows and POSIX
     const WATCH_CWD = process.cwd().replace(/\\/g, '/');
-    const WATCH_APP_ROOT = `${WATCH_CWD}/${Solas.Config.APP_DIR}/`;
+    const WATCH_APP_ROOT = `${WATCH_CWD}/${Config.APP_DIR}/`;
     // convert watcher paths to a consistent slash format before comparing them
     const normaliseWatchPath = (p) => p.replace(/\\/g, '/');
     // resolve relative watcher paths against the project root so prefix checks are reliable
@@ -136,7 +151,7 @@ function solas(c) {
     // edits needing special treatment because verb exports can change in-place
     const routeFile = /\/\+(layout|page|401|403|404|500|loading|middleware|endpoint)\.(t|j)sx?$/;
     const endpointFile = /\/\+endpoint\.(t|j)sx?$/;
-    const rebuild = Time.debounce((event, p) => {
+    const rebuild = debounce((event, p) => {
         const queue = () => {
             void (async () => {
                 // collapse bursts of file events into one active rebuild plus a single
@@ -197,9 +212,7 @@ function solas(c) {
                 return [];
             if (Array.isArray(plugin))
                 return plugin.flatMap(flatten);
-            if (typeof plugin === 'object' &&
-                'name' in plugin &&
-                plugin.name === Solas.Config.NAME) {
+            if (typeof plugin === 'object' && 'name' in plugin && plugin.name === Config.NAME) {
                 return [];
             }
             return [plugin];
@@ -219,26 +232,35 @@ function solas(c) {
         return utilityServer;
     }
     const plugin = {
-        name: Solas.Config.NAME,
+        name: Config.NAME,
         async config(viteConfig) {
             const pkg = JSON.parse(fsSync.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
             if (typeof pkg.name !== 'string' || pkg.name.length === 0) {
-                throw new Error(`Missing ${Solas.Config.NAME} package name`);
+                throw new Error(`Missing ${Config.NAME} package name`);
             }
             if (typeof pkg.version !== 'string' || pkg.version.length === 0) {
-                throw new Error(`Missing ${Solas.Config.NAME} package version`);
+                throw new Error(`Missing ${Config.NAME} package version`);
             }
             viteConfig.build ??= {};
-            viteConfig.build.outDir = Solas.Config.OUT_DIR;
+            viteConfig.build.outDir = Config.OUT_DIR;
             // keep framework files under one reserved url prefix
-            viteConfig.build.assetsDir = Solas.Config.ASSETS_DIR;
+            viteConfig.build.assetsDir = Config.ASSETS_DIR;
             viteConfig.build.emptyOutDir = true;
             // let users move the source public folder if they want
-            viteConfig.publicDir ??= Solas.Config.PUBLIC_DIR;
+            viteConfig.publicDir ??= Config.PUBLIC_DIR;
             viteConfig.server ??= {};
-            viteConfig.server.port = config.port ?? viteConfig.server.port ?? 8787;
+            viteConfig.server.port ??= 8787;
+            // derive the public url from vite's dev server settings when no
+            // origin was set explicitly via the url option or VITE_APP_URL
+            if (resolvedUrl === undefined) {
+                const { host, port } = viteConfig.server;
+                const hostname = typeof host === 'string' && host.length > 0 && host !== '0.0.0.0'
+                    ? host
+                    : 'localhost';
+                resolvedUrl = `http://${hostname}:${port}`;
+            }
             viteConfig.define ??= {};
-            viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(config.url);
+            viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(resolvedUrl);
             viteConfig.define['import.meta.env.SOLAS_VERSION'] = JSON.stringify(pkg.version);
             viteConfig.optimizeDeps ??= {};
             viteConfig.optimizeDeps.exclude = [
@@ -255,12 +277,12 @@ function solas(c) {
                     ...viteConfig.resolve.alias,
                     {
                         find: '.solas',
-                        replacement: path.resolve(process.cwd(), Solas.Config.GENERATED_DIR),
+                        replacement: path.resolve(process.cwd(), Config.GENERATED_DIR),
                     },
                 ]
                 : {
                     ...viteConfig.resolve.alias,
-                    '.solas': path.resolve(process.cwd(), Solas.Config.GENERATED_DIR),
+                    '.solas': path.resolve(process.cwd(), Config.GENERATED_DIR),
                 };
         },
         configResolved(resolvedConfig) {
@@ -268,7 +290,7 @@ function solas(c) {
             buildContext.command = resolvedConfig.command;
         },
         configureServer(server) {
-            logger.info('[configureServer]', `Watching for changes in ./${Solas.Config.APP_DIR}...`);
+            logger.info('[configureServer]', `Watching for changes in ./${Config.APP_DIR}...`);
             server.watcher
                 .on('add', (p) => rebuild('add', p))
                 .on('change', (p) => rebuild('change', p))
@@ -294,7 +316,7 @@ function solas(c) {
             }
             // resolve sitemap routes
             let sitemapRoutes = [];
-            if (config.sitemap && config.url) {
+            if (config.sitemap && resolvedUrl) {
                 const auto = [
                     ...new Set([...buildContext.knownRoutes, ...buildContext.prerenderRoutes]),
                 ];
@@ -306,7 +328,7 @@ function solas(c) {
                 }
             }
             // write build manifest
-            const generatedDir = path.join(process.cwd(), Solas.Config.GENERATED_DIR);
+            const generatedDir = path.join(process.cwd(), Config.GENERATED_DIR);
             await Runtime.write(path.join(generatedDir, 'build.json'), JSON.stringify({
                 base: resolvedViteConfig?.base ?? '/',
                 publicFiles: await collectPublicFiles(resolvedViteConfig?.publicDir),
@@ -314,7 +336,7 @@ function solas(c) {
                 sitemapRoutes,
                 precompress: config.precompress,
                 trailingSlash: config.trailingSlash,
-                url: config.url,
+                url: resolvedUrl,
             }));
         },
         buildApp: {
@@ -328,12 +350,12 @@ function solas(c) {
         plugin,
         rsc({
             entries: {
-                rsc: `./${Solas.Config.GENERATED_DIR}/${Solas.Config.ENTRY_RSC}`,
-                ssr: `./${Solas.Config.GENERATED_DIR}/${Solas.Config.ENTRY_SSR}`,
-                client: `./${Solas.Config.GENERATED_DIR}/${Solas.Config.ENTRY_BROWSER}`,
+                rsc: `./${Config.GENERATED_DIR}/${Config.ENTRY_RSC}`,
+                ssr: `./${Config.GENERATED_DIR}/${Config.ENTRY_SSR}`,
+                client: `./${Config.GENERATED_DIR}/${Config.ENTRY_BROWSER}`,
             },
         }),
     ];
 }
 export default solas;
-export { Solas } from './solas.js';
+export * as Solas from './solas.js';

package/dist/internal/boundary-error.d.ts

@@ -0,0 +1,4 @@
+export declare class BoundaryError extends Error {
+    digest?: string;
+    constructor(digest?: string);
+}

package/dist/internal/boundary-error.js

@@ -0,0 +1,8 @@
+export class BoundaryError extends Error {
+    digest;
+    constructor(digest) {
+        super();
+        if (digest)
+            this.digest = digest;
+    }
+}

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

@@ -0,0 +1,46 @@
+import * as BrowserRouter from './shared.js';
+/**
+ * A small in-memory mirror of browser history used by BrowserRouter.
+ * It keeps local entries/index in sync with push/replace/go and
+ * popstate updates
+ */
+export declare class BrowserRouterHistory {
+    #private;
+    constructor(url: {
+        pathname: string;
+        search?: string;
+        hash?: string;
+    });
+    /**
+     * Returns a copy of tracked entries
+     */
+    get entries(): BrowserRouter.HistoryEntry[];
+    /**
+     * Returns the tracked history index
+     */
+    get index(): number;
+    /**
+     * Returns the tracked history length
+     */
+    get length(): number;
+    /**
+     * Returns the current tracked entry
+     */
+    get current(): BrowserRouter.HistoryEntry;
+    /**
+     * Pushes a new history entry and advances the index
+     */
+    pushState(path: string): BrowserRouter.HistoryEntry;
+    /**
+     * Replaces the current history entry without changing length
+     */
+    replaceState(path: string): BrowserRouter.HistoryEntry;
+    /**
+     * Applies relative history movement and updates local index
+     */
+    go(delta: number): BrowserRouter.HistoryEntry;
+    /**
+     * Syncs local index and entry from a popstate event
+     */
+    onPopState(): BrowserRouter.HistoryEntry;
+}

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

@@ -0,0 +1,131 @@
+/**
+ * A small in-memory mirror of browser history used by BrowserRouter.
+ * It keeps local entries/index in sync with push/replace/go and
+ * popstate updates
+ */
+export class BrowserRouterHistory {
+    #entries;
+    #index;
+    constructor(url) {
+        const entry = {
+            pathname: url.pathname,
+            search: url.search ?? '',
+            hash: url.hash ?? '',
+        };
+        this.#entries = [entry];
+        this.#index = 0;
+    }
+    /**
+     * Returns a copy of tracked entries
+     */
+    get entries() {
+        return [...this.#entries];
+    }
+    /**
+     * Returns the tracked history index
+     */
+    get index() {
+        return this.#index;
+    }
+    /**
+     * Returns the tracked history length
+     */
+    get length() {
+        return this.#entries.length;
+    }
+    /**
+     * Returns the current tracked entry
+     */
+    get current() {
+        return this.#entries[this.#index] ?? null;
+    }
+    /**
+     * Pushes a new history entry and advances the index
+     */
+    pushState(path) {
+        if (this.#index < this.#entries.length - 1) {
+            // drop forward entries when pushing from the middle
+            this.#entries = this.#entries.slice(0, this.#index + 1);
+        }
+        window.history.pushState(null, '', path);
+        const entry = {
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash,
+        };
+        this.#entries.push(entry);
+        this.#index++;
+        return entry;
+    }
+    /**
+     * Replaces the current history entry without changing length
+     */
+    replaceState(path) {
+        window.history.replaceState(null, '', path);
+        const entry = {
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash,
+        };
+        if (this.#entries.length === 0) {
+            this.#entries = [entry];
+            this.#index = 0;
+            return entry;
+        }
+        this.#entries[this.#index] = entry;
+        return entry;
+    }
+    /**
+     * Applies relative history movement and updates local index
+     */
+    go(delta) {
+        if (!Number.isInteger(delta) || delta === 0) {
+            return this.current;
+        }
+        const nextIndex = Math.max(0, Math.min(this.#index + delta, this.#entries.length - 1));
+        if (nextIndex !== this.#index)
+            this.#index = nextIndex;
+        window.history.go(delta);
+        return this.current;
+    }
+    /**
+     * Syncs local index and entry from a popstate event
+     */
+    onPopState() {
+        const current = {
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash,
+        };
+        const prev = this.#entries[this.#index - 1];
+        const next = this.#entries[this.#index + 1];
+        if (prev &&
+            prev.pathname === current.pathname &&
+            prev.search === current.search &&
+            prev.hash === current.hash) {
+            this.#index--;
+            this.#entries[this.#index] = current;
+            return current;
+        }
+        if (next &&
+            next.pathname === current.pathname &&
+            next.search === current.search &&
+            next.hash === current.hash) {
+            this.#index++;
+            this.#entries[this.#index] = current;
+            return current;
+        }
+        // fallback: locate an existing matching entry
+        const index = this.#entries.findIndex(entry => entry.pathname === current.pathname &&
+            entry.search === current.search &&
+            entry.hash === current.hash);
+        if (index >= 0) {
+            this.#index = index;
+            this.#entries[index] = current;
+            return current;
+        }
+        this.#entries.push(current);
+        this.#index = this.#entries.length - 1;
+        return current;
+    }
+}

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

@@ -1,4 +1,4 @@
-import { BrowserRouter } from './shared.js';
+import * as BrowserRouter from './shared.js';
 type AnchorProps = React.ComponentPropsWithRef<'a'> & {
     href: string;
 };

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

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useRef } from 'react';
-import { BrowserRouter } from './shared.js';
+import * as BrowserRouter from './shared.js';
 import { useRouter } from './use-router.js';
 function guard(path, prefetcher) {
     const connection = window.navigator.connection;

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

@@ -1,22 +1,14 @@
 import type { RscPayload } from '../env/rsc.js';
-import { BrowserRouter } from './shared.js';
-export { BrowserRouter } from './shared.js';
-export declare const BrowserRouterContext: import("react").Context<{
-    go: BrowserRouter.Go;
-    prefetch: (path: string) => void;
-    refresh: BrowserRouter.Refresh;
-    isNavigating: boolean;
-    url: {
-        pathname?: string | undefined;
-        search?: string | undefined;
-    };
-}>;
+import * as BrowserRouter from './shared.js';
+export * as BrowserRouter from './shared.js';
+export declare const BrowserRouterContext: import("react").Context<BrowserRouter.Context>;
 export declare function BrowserRouterProvider({ children, setPayload, isNavigating, url }: {
     children: React.ReactNode;
     setPayload?: (payload: RscPayload) => void;
     isNavigating?: boolean;
-    url?: {
-        pathname?: string;
+    url: {
+        pathname: string;
         search?: string;
+        hash?: string;
     };
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -3,16 +3,25 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useEffect, useMemo, useRef } from 'react';
 import { createFromFetch } from '@vitejs/plugin-rsc/browser';
 import { Logger } from '../../utils/logger.js';
-import { Solas } from '../../solas.js';
+import * as Events from '../../events.js';
+import { BrowserRouterHistory } from './history.js';
 import { ResponseCache } from './response-cache.js';
-import { BrowserRouter } from './shared.js';
-export { BrowserRouter } from './shared.js';
+import * as BrowserRouter from './shared.js';
+export * as BrowserRouter from './shared.js';
 export const BrowserRouterContext = createContext({
     go: async () => '',
     prefetch: () => { },
     refresh: async () => '',
     isNavigating: false,
-    url: {},
+    url: {
+        pathname: '',
+        search: '',
+        hash: '',
+    },
+    history: {
+        entries: [],
+        index: -1,
+    },
 });
 const DEFAULT_GO_CONFIG = {
     replace: false,
@@ -22,6 +31,7 @@ const responseCache = new ResponseCache();
 export function BrowserRouterProvider({ children, setPayload, isNavigating = false, url, }) {
     const id = useRef(0);
     const controller = useRef(null);
+    const history = useRef(new BrowserRouterHistory(url));
     /**
      * Navigates to a given path
      *
@@ -35,6 +45,13 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
         const navigationId = id.current;
         const currentPath = window.location.pathname + window.location.search;
         let path = currentPath;
+        // support numeric relative navigation like router.go(-1) to go back,
+        // or router.go(1) to go forward. Will trigger a popstate event which
+        // is intercepted
+        if (typeof to === 'number') {
+            const entry = history.current.go(to);
+            return `${entry.pathname}${entry.search}`;
+        }
         const replace = opts?.replace ?? DEFAULT_GO_CONFIG.replace;
         controller.current?.abort();
         controller.current = null;
@@ -51,10 +68,10 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             path = key;
             if (path !== currentPath) {
                 if (replace) {
-                    window.history.replaceState(null, '', path);
+                    history.current.replaceState(path);
                 }
                 else {
-                    window.history.pushState(null, '', path);
+                    history.current.pushState(path);
                 }
             }
             let promise = responseCache.get(path);
@@ -78,10 +95,10 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             if (navigationId !== id.current)
                 return resolvedPath;
             if (resolvedPath !== path) {
-                window.history.replaceState(null, '', resolvedPath);
+                history.current.replaceState(resolvedPath);
             }
             setPayload?.(payload);
-            window.dispatchEvent(new CustomEvent(Solas.Events.names.NAVIGATION, {
+            window.dispatchEvent(new CustomEvent(Events.names.NAVIGATION, {
                 detail: { path: resolvedPath },
             }));
             return resolvedPath;
@@ -90,7 +107,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             if (err instanceof Error && err.name === 'AbortError') {
                 return path;
             }
-            window.dispatchEvent(new CustomEvent(Solas.Events.names.NAVIGATION_ERROR, {
+            window.dispatchEvent(new CustomEvent(Events.names.NAVIGATION_ERROR, {
                 detail: {
                     path,
                     error: err instanceof Error ? err.message : Logger.print(err),
@@ -138,9 +155,13 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
         });
     }, [go]);
     useEffect(() => {
-        const handler = () => go(BrowserRouter.toTarget(window.location.pathname + window.location.search), {
-            replace: true,
-        });
+        const h = history.current;
+        function handler() {
+            h.onPopState();
+            void go(BrowserRouter.toTarget(window.location.pathname + window.location.search), {
+                replace: true,
+            });
+        }
         window.addEventListener('popstate', handler);
         return () => {
             controller.current?.abort();
@@ -154,8 +175,13 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
         refresh,
         isNavigating,
         url: {
-            pathname: url?.pathname,
+            pathname: url.pathname,
             search: url?.search,
+            hash: url?.hash,
+        },
+        history: {
+            entries: history.current.entries,
+            index: history.current.index,
         },
     }), [go, prefetch, refresh, isNavigating, url]);
     return _jsx(BrowserRouterContext, { value: value, children: children });