@jk2908/solas 0.5.4 → 0.7.0

package/dist/types.js

@@ -1 +1 @@
-import { Solas } from './solas.js';
+import * as Config from './config.js';

package/dist/utils/base-path.d.ts

@@ -1,14 +1,12 @@
-export declare namespace BasePath {
-    /**
-     * Normalise a base path so every check uses the same shape
-     */
-    function normalise(value: string | null | undefined): string;
-    /**
-     * Strip the base path from a request path
-     */
-    function strip(pathname: string, base: string | null | undefined): string | null;
-    /**
-     * Add the base path to a path when needed
-     */
-    function apply(pathname: string, base: string | null | undefined): string;
-}
+/**
+ * Normalise a base path so every check uses the same shape
+ */
+export declare function normaliseBasePath(value: string | null | undefined): string;
+/**
+ * Strip the base path from a request path
+ */
+export declare function stripBasePath(pathname: string, base: string | null | undefined): string | null;
+/**
+ * Add the base path to a path when needed
+ */
+export declare function applyBasePath(pathname: string, base: string | null | undefined): string;

package/dist/utils/base-path.js

@@ -1,85 +1,78 @@
-export { BasePath };
-var BasePath;
-(function (BasePath) {
-    /**
-     * Normalise a base path so every check uses the same shape
-     */
-    function normalise(value) {
-        // no base means the app lives at the site root
-        if (!value)
-            return '/';
-        if (value === '/' || value === '.' || value === './')
-            return '/';
-        let pathname = value.trim();
-        if (!pathname)
-            return '/';
-        // plain path bases are the common case, so keep them cheap
-        if (!pathname.startsWith('http://') && !pathname.startsWith('https://')) {
-            const hashIndex = pathname.indexOf('#');
-            const searchIndex = pathname.indexOf('?');
-            const end = hashIndex === -1
-                ? searchIndex
-                : searchIndex === -1
-                    ? hashIndex
-                    : Math.min(hashIndex, searchIndex);
-            if (end >= 0)
-                pathname = pathname.slice(0, end);
+/**
+ * Normalise a base path so every check uses the same shape
+ */
+export function normaliseBasePath(value) {
+    // no base means the app lives at the site root
+    if (!value)
+        return '/';
+    if (value === '/' || value === '.' || value === './')
+        return '/';
+    let pathname = value.trim();
+    if (!pathname)
+        return '/';
+    // plain path bases are the common case, so keep them cheap
+    if (!pathname.startsWith('http://') && !pathname.startsWith('https://')) {
+        const hashIndex = pathname.indexOf('#');
+        const searchIndex = pathname.indexOf('?');
+        const end = hashIndex === -1
+            ? searchIndex
+            : searchIndex === -1
+                ? hashIndex
+                : Math.min(hashIndex, searchIndex);
+        if (end >= 0)
+            pathname = pathname.slice(0, end);
+    }
+    else {
+        try {
+            // full urls can still show up here, but we only need the path part
+            pathname = new URL(pathname).pathname;
         }
-        else {
-            try {
-                // full urls can still show up here, but we only need the path part
-                pathname = new URL(pathname).pathname;
-            }
-            catch {
-                // if parsing fails, fall back to the raw value below
-            }
+        catch {
+            // if parsing fails, fall back to the raw value below
         }
-        if (!pathname || pathname === '.' || pathname === './')
-            return '/';
-        // keep one stable shape: leading slash, trailing slash
-        if (!pathname.startsWith('/'))
-            pathname = `/${pathname}`;
-        return pathname.endsWith('/') ? pathname : `${pathname}/`;
-    }
-    BasePath.normalise = normalise;
-    /**
-     * Strip the base path from a request path
-     */
-    function strip(pathname, base) {
-        const normalisedBase = normalise(base);
-        // root base means there is nothing to strip
-        if (normalisedBase === '/')
-            return pathname || '/';
-        const basePath = normalisedBase.slice(0, -1);
-        // treat both '/docs' and '/docs/' as the app root
-        if (pathname === basePath || pathname === normalisedBase)
-            return '/';
-        // paths outside the base do not belong to this app
-        if (!pathname.startsWith(`${basePath}/`))
-            return null;
-        // return the path as the app should see it
-        return pathname.slice(basePath.length) || '/';
-    }
-    BasePath.strip = strip;
-    /**
-     * Add the base path to a path when needed
-     */
-    function apply(pathname, base) {
-        const normalisedBase = normalise(base);
-        // always work with a path-like value
-        const target = pathname.startsWith('/') ? pathname : `/${pathname}`;
-        // root base means the path can pass through unchanged
-        if (normalisedBase === '/')
-            return target;
-        const basePath = normalisedBase.slice(0, -1);
-        // leave it alone if the base is already there
-        if (target === basePath || target.startsWith(`${basePath}/`))
-            return target;
-        // the app root maps to the base path itself
-        if (target === '/')
-            return normalisedBase;
-        // everything else sits underneath the base path
-        return `${basePath}${target}`;
     }
-    BasePath.apply = apply;
-})(BasePath || (BasePath = {}));
+    if (!pathname || pathname === '.' || pathname === './')
+        return '/';
+    // keep one stable shape: leading slash, trailing slash
+    if (!pathname.startsWith('/'))
+        pathname = `/${pathname}`;
+    return pathname.endsWith('/') ? pathname : `${pathname}/`;
+}
+/**
+ * Strip the base path from a request path
+ */
+export function stripBasePath(pathname, base) {
+    const normalisedBase = normaliseBasePath(base);
+    // root base means there is nothing to strip
+    if (normalisedBase === '/')
+        return pathname || '/';
+    const basePath = normalisedBase.slice(0, -1);
+    // treat both '/docs' and '/docs/' as the app root
+    if (pathname === basePath || pathname === normalisedBase)
+        return '/';
+    // paths outside the base do not belong to this app
+    if (!pathname.startsWith(`${basePath}/`))
+        return null;
+    // return the path as the app should see it
+    return pathname.slice(basePath.length) || '/';
+}
+/**
+ * Add the base path to a path when needed
+ */
+export function applyBasePath(pathname, base) {
+    const normalisedBase = normaliseBasePath(base);
+    // always work with a path-like value
+    const target = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    // root base means the path can pass through unchanged
+    if (normalisedBase === '/')
+        return target;
+    const basePath = normalisedBase.slice(0, -1);
+    // leave it alone if the base is already there
+    if (target === basePath || target.startsWith(`${basePath}/`))
+        return target;
+    // the app root maps to the base path itself
+    if (target === '/')
+        return normalisedBase;
+    // everything else sits underneath the base path
+    return `${basePath}${target}`;
+}

package/dist/utils/compress.d.ts

@@ -1,11 +1,9 @@
-export declare namespace Compress {
-    /**
-     * Compress a file or directory
-     */
-    function run(input: string, config?: {
-        filter?: (f: string) => boolean;
-    }): AsyncGenerator<{
-        input: string;
-        compressed: Uint8Array;
-    }>;
-}
+/**
+ * Compress a file or directory
+ */
+export declare function run(input: string, config?: {
+    filter?: (f: string) => boolean;
+}): AsyncGenerator<{
+    input: string;
+    compressed: Uint8Array;
+}>;

package/dist/utils/compress.js

@@ -3,74 +3,69 @@ import os from 'node:os';
 import path from 'node:path';
 import { brotliCompress } from 'node:zlib';
 import { Runtime } from '../internal/runtimes/runtime.js';
-export { Compress };
-var Compress;
-(function (Compress) {
-    const DEFAULT_CONCURRENCY = Math.max(1, Math.min(os.cpus().length, 8));
-    async function collect(input, filter, output = []) {
-        const stat = await fs.stat(input);
-        if (!stat.isDirectory()) {
-            if (filter(input))
-                output.push(input);
-            return output;
-        }
-        for (const entry of await fs.readdir(input, { withFileTypes: true })) {
-            const next = path.join(input, entry.name);
-            if (entry.isDirectory()) {
-                await collect(next, filter, output);
-                continue;
-            }
-            if (entry.isFile() && filter(next))
-                output.push(next);
-        }
+const DEFAULT_CONCURRENCY = Math.max(1, Math.min(os.cpus().length, 8));
+async function collect(input, filter, output = []) {
+    const stat = await fs.stat(input);
+    if (!stat.isDirectory()) {
+        if (filter(input))
+            output.push(input);
         return output;
     }
-    async function compress(input) {
-        const buffer = Buffer.from(await Runtime.readBuffer(input));
-        const compressed = await new Promise((fulfill, reject) => {
-            brotliCompress(buffer, (err, res) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    fulfill(res);
-                }
-            });
-        });
-        // return the input path plus a zero-copy Uint8Array view over the
-        // compressed Buffer using its exact offset and length
-        return {
-            input,
-            compressed: new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength),
-        };
+    for (const entry of await fs.readdir(input, { withFileTypes: true })) {
+        const next = path.join(input, entry.name);
+        if (entry.isDirectory()) {
+            await collect(next, filter, output);
+            continue;
+        }
+        if (entry.isFile() && filter(next))
+            output.push(next);
     }
-    /**
-     * Compress a file or directory
-     */
-    async function* run(input, config = {}) {
-        const { filter = f => /\.(js|css|html|svg|json|txt)$/.test(f) } = config;
-        const targets = await collect(input, filter);
-        if (!targets.length)
-            return;
-        let index = 0;
-        const pending = new Map();
-        function enqueue() {
-            while (index < targets.length && pending.size < DEFAULT_CONCURRENCY) {
-                const i = index++;
-                const value = targets[i];
-                pending.set(i, compress(value).then(compressed => ({
-                    index: i,
-                    value: compressed,
-                })));
+    return output;
+}
+async function compress(input) {
+    const buffer = Buffer.from(await Runtime.readBuffer(input));
+    const compressed = await new Promise((fulfill, reject) => {
+        brotliCompress(buffer, (err, res) => {
+            if (err) {
+                reject(err);
             }
+            else {
+                fulfill(res);
+            }
+        });
+    });
+    // return the input path plus a zero-copy Uint8Array view over the
+    // compressed Buffer using its exact offset and length
+    return {
+        input,
+        compressed: new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength),
+    };
+}
+/**
+ * Compress a file or directory
+ */
+export async function* run(input, config = {}) {
+    const { filter = f => /\.(js|css|html|svg|json|txt)$/.test(f) } = config;
+    const targets = await collect(input, filter);
+    if (!targets.length)
+        return;
+    let index = 0;
+    const pending = new Map();
+    function enqueue() {
+        while (index < targets.length && pending.size < DEFAULT_CONCURRENCY) {
+            const i = index++;
+            const value = targets[i];
+            pending.set(i, compress(value).then(compressed => ({
+                index: i,
+                value: compressed,
+            })));
         }
+    }
+    enqueue();
+    while (pending.size > 0) {
+        const settled = await Promise.race(pending.values());
+        pending.delete(settled.index);
+        yield settled.value;
         enqueue();
-        while (pending.size > 0) {
-            const settled = await Promise.race(pending.values());
-            pending.delete(settled.index);
-            yield settled.value;
-            enqueue();
-        }
     }
-    Compress.run = run;
-})(Compress || (Compress = {}));
+}

package/dist/utils/context.d.ts

@@ -1,6 +1,4 @@
-export declare namespace Context {
-    function create<T>(name: string): {
-        use(): NonNullable<T>;
-        write<R>(value: T, fn: () => R | Promise<R>): R | Promise<R>;
-    };
-}
+export declare function create<T>(name: string): {
+    use(): NonNullable<T>;
+    write<R>(value: T, fn: () => R | Promise<R>): R | Promise<R>;
+};

package/dist/utils/context.js

@@ -1,25 +1,20 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { Logger } from './logger.js';
 const logger = new Logger();
-export { Context };
-var Context;
-(function (Context) {
-    function create(name) {
-        const storage = new AsyncLocalStorage();
-        return {
-            use() {
-                const r = storage.getStore();
-                if (!r) {
-                    const error = new Error(`No ${name} context available`);
-                    logger.error(`[Context:create] ${error.message}`, error);
-                    throw error;
-                }
-                return r;
-            },
-            write(value, fn) {
-                return storage.run(value, fn);
-            },
-        };
-    }
-    Context.create = create;
-})(Context || (Context = {}));
+export function create(name) {
+    const storage = new AsyncLocalStorage();
+    return {
+        use() {
+            const r = storage.getStore();
+            if (!r) {
+                const error = new Error(`No ${name} context available`);
+                logger.error(`[Context:create] ${error.message}`, error);
+                throw error;
+            }
+            return r;
+        },
+        write(value, fn) {
+            return storage.run(value, fn);
+        },
+    };
+}

package/dist/utils/logger.js

@@ -1,5 +1,5 @@
+import * as Config from '../config.js';
 import { HttpException } from '../internal/navigation/http-exception.js';
-import { Solas } from '../solas.js';
 const LEVELS = {
     debug: 0,
     info: 1,
@@ -69,7 +69,7 @@ export class Logger {
         if (level === 'error' || level === 'fatal') {
             entry.error = error ? Logger.toError(error) : new Error(message);
         }
-        const line = `[${Solas.Config.NAME}] [${entry.ts}] [${level.toUpperCase()}] ${message}`;
+        const line = `[${Config.NAME}] [${entry.ts}] [${level.toUpperCase()}] ${message}`;
         const extra = entry.error ? `\n${Logger.print(entry.error)}` : '';
         if (level === 'warn') {
             console.warn(line, extra);

package/dist/utils/time.d.ts

@@ -1,4 +1,2 @@
-export declare namespace Time {
-    function debounce<T extends unknown[]>(fn: (...args: T) => void, wait: number): (...args: T) => void;
-    function timeout<T>(task: Promise<T>, timeoutMs: number, label: string): Promise<Awaited<T>>;
-}
+export declare function debounce<T extends unknown[]>(fn: (...args: T) => void, wait: number): (...args: T) => void;
+export declare function timeout<T>(task: Promise<T>, timeoutMs: number, label: string): Promise<Awaited<T>>;

package/dist/utils/time.js

@@ -1,29 +1,23 @@
-export { Time };
-var Time;
-(function (Time) {
-    function debounce(fn, wait) {
-        let timeoutId = null;
-        return (...args) => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            timeoutId = setTimeout(() => {
-                fn.apply(null, args);
-            }, wait);
-        };
-    }
-    Time.debounce = debounce;
-    function timeout(task, timeoutMs, label) {
-        let timer;
-        const timeout = new Promise((_, reject) => {
-            timer = setTimeout(() => {
-                reject(new Error(`Timed out after ${timeoutMs}ms (${label})`));
-            }, timeoutMs);
-        });
-        return Promise.race([task, timeout]).finally(() => {
-            if (timer)
-                clearTimeout(timer);
-        });
-    }
-    Time.timeout = timeout;
-})(Time || (Time = {}));
+export function debounce(fn, wait) {
+    let timeoutId = null;
+    return (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            fn.apply(null, args);
+        }, wait);
+    };
+}
+export function timeout(task, timeoutMs, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error(`Timed out after ${timeoutMs}ms (${label})`));
+        }, timeoutMs);
+    });
+    return Promise.race([task, timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.5.4",
+	"version": "0.7.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",
@@ -33,10 +33,6 @@
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
 		},
-		"./$": {
-			"types": "./dist/solas.d.ts",
-			"import": "./dist/solas.js"
-		},
 		"./env/rsc": {
 			"types": "./dist/internal/env/rsc.d.ts",
 			"import": "./dist/internal/env/rsc.js"
@@ -76,6 +72,10 @@
 	},
 	"scripts": {
 		"build": "rm -rf dist && tsgo",
+		"postbuild": "node scripts/measure.mjs",
+		"test": "vitest run",
+		"test:browser": "vitest run --config vitest.browser.config.ts",
+		"test:watch": "vitest",
 		"lint": "bunx oxlint .",
 		"lint:fix": "bunx oxlint --fix .",
 		"format": "bunx oxfmt --write .",
@@ -85,16 +85,24 @@
 		"prepublishOnly": "npm run build && npm run pack:dry"
 	},
 	"dependencies": {
-		"@vitejs/plugin-rsc": "^0.5.20",
+		"@vitejs/plugin-rsc": "0.5.34",
 		"oxc-parser": "^0.134.0",
+		"oxfmt": "^0.35.0",
 		"path-to-regexp": "^8.3.0"
 	},
 	"devDependencies": {
 		"@prettier/plugin-oxc": "^0.1.3",
 		"@typescript/native-preview": "^7.0.0-dev.20260224.1",
+		"@vitejs/plugin-react": "^5.1.4",
+		"@vitest/browser": "^4.1.8",
+		"@vitest/browser-playwright": "^4.1.8",
+		"happy-dom": "^20.10.2",
 		"network-information-types": "^0.1.1",
 		"oxfmt": "^0.35.0",
-		"typescript": "^5.9.3"
+		"playwright": "^1.58.2",
+		"typescript": "^5.9.3",
+		"vitest": "^4.1.8",
+		"vitest-browser-react": "^2.2.0"
 	},
 	"peerDependencies": {
 		"@types/react": "^19.2.14",
@@ -109,5 +117,7 @@
 			"optional": true
 		}
 	},
-	"engines": {}
+	"engines": {
+		"node": "^20.19.0 || >=22.12.0"
+	}
 }

package/dist/internal/runtimes/bun.d.ts

@@ -1,9 +0,0 @@
-import { RuntimeBase } from './runtime.js';
-export declare class RuntimeBun extends RuntimeBase {
-    exists(filePath: string): Promise<boolean>;
-    readText(filePath: string): Promise<string>;
-    readBuffer(filePath: string): Promise<ArrayBuffer>;
-    mimeType(filePath: string): string;
-    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
-    hash(value: string): string;
-}

package/dist/internal/runtimes/bun.js

@@ -1,33 +0,0 @@
-import { RuntimeBase } from './runtime.js';
-export class RuntimeBun extends RuntimeBase {
-    async exists(filePath) {
-        return Bun.file(filePath).exists();
-    }
-    readText(filePath) {
-        return Bun.file(filePath).text();
-    }
-    readBuffer(filePath) {
-        return Bun.file(filePath).arrayBuffer();
-    }
-    mimeType(filePath) {
-        return Bun.file(filePath).type || 'application/octet-stream';
-    }
-    async write(filePath, content) {
-        // normalise wider arraybuffer views into a shape Bun.write accepts directly
-        await Bun.write(filePath, typeof content === 'string'
-            ? content
-            : content instanceof Uint8Array
-                ? content
-                : new Uint8Array(content.buffer, content.byteOffset, content.byteLength));
-    }
-    hash(value) {
-        const hash = Bun.hash(value);
-        // Bun.hash returns an integer-like value, so keep it in BigInt space and avoid
-        // precision loss. Clamp it to an unsigned 64-bit value before hex
-        // formatting. Pad to 16 chars to match the Node runtime
-        // output shape
-        return BigInt.asUintN(64, typeof hash === 'bigint' ? hash : BigInt(hash))
-            .toString(16)
-            .padStart(16, '0');
-    }
-}

package/dist/internal/runtimes/create.d.ts

@@ -1,4 +0,0 @@
-import type { Runtime } from '../../types.js';
-import { RuntimeBun } from './bun.js';
-import { RuntimeNode } from './node.js';
-export declare function createRuntime(runtime: Runtime): RuntimeBun | RuntimeNode;

package/dist/internal/runtimes/create.js

@@ -1,9 +0,0 @@
-import { RuntimeBun } from './bun.js';
-import { RuntimeNode } from './node.js';
-export function createRuntime(runtime) {
-    if (runtime === 'bun' ||
-        (runtime === 'auto' && typeof globalThis.Bun !== 'undefined')) {
-        return new RuntimeBun();
-    }
-    return new RuntimeNode();
-}

package/dist/internal/runtimes/node.d.ts

@@ -1,9 +0,0 @@
-import { RuntimeBase } from './runtime.js';
-export declare class RuntimeNode extends RuntimeBase {
-    exists(filePath: string): Promise<boolean>;
-    readText(filePath: string): Promise<string>;
-    readBuffer(filePath: string): Promise<ArrayBuffer>;
-    mimeType(filePath: string): string;
-    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
-    hash(value: string): string;
-}

package/dist/internal/runtimes/node.js

@@ -1,31 +0,0 @@
-import { createHash } from 'node:crypto';
-import fs from 'node:fs/promises';
-import { getMimeTypeFromPath } from './mime.js';
-import { RuntimeBase } from './runtime.js';
-export class RuntimeNode extends RuntimeBase {
-    async exists(filePath) {
-        try {
-            await fs.access(filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    readText(filePath) {
-        return fs.readFile(filePath, 'utf-8');
-    }
-    async readBuffer(filePath) {
-        const buffer = await fs.readFile(filePath);
-        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-    }
-    mimeType(filePath) {
-        return getMimeTypeFromPath(filePath);
-    }
-    async write(filePath, content) {
-        await fs.writeFile(filePath, content);
-    }
-    hash(value) {
-        return createHash('sha256').update(value).digest('hex').slice(0, 16);
-    }
-}