@jk2908/solas 0.1.0

package/dist/solas.d.ts

@@ -0,0 +1,32 @@
+import type { PluginConfig } from './types';
+export declare namespace Solas {
+    namespace Config {
+        const NAME = "Solas";
+        const SLUG: string;
+        const PKG_NAME: string;
+        const OUT_DIR = "dist";
+        const APP_DIR = "app";
+        const GENERATED_DIR: string;
+        const ENTRY_RSC = "entry.rsc.tsx";
+        const ENTRY_SSR = "entry.ssr.tsx";
+        const ENTRY_BROWSER = "entry.browser.tsx";
+        const ASSETS_DIR = "assets";
+        const $: unique symbol;
+        const REQUEST_META: string;
+        const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
+        const PRERENDER_MODES: readonly ["full", "ppr", false];
+        /**
+         * Validate the plugin configuration object, throwing an error if invalid
+         * @param input - the unvalidated configuration object
+         * @return the typed and validated configuration object
+         */
+        function validate(input: unknown): PluginConfig;
+    }
+    function getVersion(): string;
+    namespace Events {
+        const names: {
+            readonly NAVIGATION: `${string}navigation`;
+            readonly NAVIGATION_ERROR: `${string}navigationerror`;
+        };
+    }
+}

package/dist/solas.js

@@ -0,0 +1,125 @@
+export { Solas };
+var Solas;
+(function (Solas) {
+    let Config;
+    (function (Config) {
+        Config.NAME = 'Solas';
+        Config.SLUG = Config.NAME.toLowerCase();
+        Config.PKG_NAME = `@jk2908/${Config.SLUG}`;
+        Config.OUT_DIR = 'dist';
+        Config.APP_DIR = 'app';
+        Config.GENERATED_DIR = `.${Config.SLUG}`;
+        Config.ENTRY_RSC = 'entry.rsc.tsx';
+        Config.ENTRY_SSR = 'entry.ssr.tsx';
+        Config.ENTRY_BROWSER = 'entry.browser.tsx';
+        Config.ASSETS_DIR = 'assets';
+        Config.$ = Symbol(Config.SLUG);
+        Config.REQUEST_META = `__${Config.SLUG.toUpperCase()}__`;
+        Config.LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
+        Config.PRERENDER_MODES = ['full', 'ppr', false];
+        const CONFIG_KEYS = new Set([
+            'logger',
+            'metadata',
+            'precompress',
+            'prerender',
+            'trailingSlash',
+            'url',
+        ]);
+        const LOGGER_KEYS = new Set(['level']);
+        /**
+         * Validate the plugin configuration object, throwing an error if invalid
+         * @param input - the unvalidated configuration object
+         * @return the typed and validated configuration object
+         */
+        function validate(input) {
+            if (input === undefined)
+                return {};
+            const errors = [];
+            if (!isRecord(input)) {
+                throw new Error(`[${Config.NAME}] Invalid config:\n- Expected plugin config to be an object`);
+            }
+            for (const key of Object.keys(input)) {
+                if (!CONFIG_KEYS.has(key)) {
+                    errors.push(`Unknown config key: ${key}`);
+                }
+            }
+            if ('url' in input && input.url !== undefined) {
+                if (typeof input.url !== 'string') {
+                    errors.push('config.url must be a string');
+                }
+                else {
+                    try {
+                        const url = new URL(input.url);
+                        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                            errors.push('config.url must use http:// or https://');
+                        }
+                    }
+                    catch {
+                        errors.push('config.url must be a valid URL');
+                    }
+                }
+            }
+            if ('precompress' in input && input.precompress !== undefined) {
+                if (typeof input.precompress !== 'boolean') {
+                    errors.push('config.precompress must be a boolean');
+                }
+            }
+            if ('prerender' in input && input.prerender !== undefined) {
+                if (!new Set(Config.PRERENDER_MODES).has(input.prerender)) {
+                    errors.push("config.prerender must be 'full', 'ppr', or false");
+                }
+            }
+            if ('trailingSlash' in input && input.trailingSlash !== undefined) {
+                if (typeof input.trailingSlash !== 'boolean') {
+                    errors.push('config.trailingSlash must be a boolean');
+                }
+            }
+            if ('metadata' in input &&
+                input.metadata !== undefined &&
+                !isRecord(input.metadata)) {
+                errors.push('config.metadata must be an object when provided');
+            }
+            if ('logger' in input && input.logger !== undefined) {
+                if (!isRecord(input.logger)) {
+                    errors.push('config.logger must be an object when provided');
+                }
+                else {
+                    for (const key of Object.keys(input.logger)) {
+                        if (!LOGGER_KEYS.has(key)) {
+                            errors.push(`Unknown config.logger key: ${key}`);
+                        }
+                    }
+                    if ('level' in input.logger && input.logger.level !== undefined) {
+                        if (typeof input.logger.level !== 'string' ||
+                            !new Set(Config.LOG_LEVELS).has(input.logger.level)) {
+                            errors.push('config.logger.level must be one of: debug, info, warn, error, fatal');
+                        }
+                    }
+                }
+            }
+            if (errors.length > 0) {
+                throw new Error(`[${Config.NAME}] Invalid config:\n- ${errors.join('\n- ')}`);
+            }
+            return input;
+        }
+        Config.validate = validate;
+    })(Config = Solas.Config || (Solas.Config = {}));
+    function getVersion() {
+        const value = import.meta.env.SOLAS_VERSION;
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new Error(`[${Config.NAME}] Missing ${Config.NAME} package version`);
+        }
+        return value;
+    }
+    Solas.getVersion = getVersion;
+    let Events;
+    (function (Events) {
+        Events.names = {
+            NAVIGATION: `${Config.SLUG}navigation`,
+            NAVIGATION_ERROR: `${Config.SLUG}navigationerror`,
+        };
+    })(Events = Solas.Events || (Solas.Events = {}));
+})(Solas || (Solas = {}));
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/types.d.ts

@@ -0,0 +1,93 @@
+type BunRequest = Request & {
+    params?: Record<string, string | string[]>;
+};
+import { Solas } from './solas';
+import { ExportReader } from './utils/export-reader';
+import type { Build } from './internal/build';
+import type { Metadata } from './internal/metadata';
+import type { HttpException } from './internal/navigation/http-exception';
+import type { Router } from './internal/router/router';
+export type LogLevel = (typeof Solas.Config.LOG_LEVELS)[number];
+export type PluginConfig = {
+    url?: `http://${string}` | `https://${string}`;
+    port?: number;
+    precompress?: boolean;
+    prerender?: Route.Prerender;
+    metadata?: Metadata.Item;
+    trailingSlash?: boolean;
+    readonly logger?: {
+        level?: LogLevel;
+    };
+};
+export type RuntimeConfig = PluginConfig & {
+    precompress: NonNullable<PluginConfig['precompress']>;
+    trailingSlash: NonNullable<PluginConfig['trailingSlash']>;
+};
+export type BuildContext = {
+    prerenderedRoutes: Set<string>;
+    exportReader: ExportReader;
+};
+export type SolasRequest = Request & {};
+export type Segment = {
+    __id: string;
+    __path: string;
+    __params: string[];
+    __kind: typeof Build.EntryKind.PAGE;
+    __depth: number;
+    method: 'get';
+    paths: {
+        layouts: (string | null)[];
+        '401s': (string | null)[];
+        '403s': (string | null)[];
+        '404s': (string | null)[];
+        '500s': (string | null)[];
+        loaders: (string | null)[];
+        middlewares: (string | null)[];
+        page?: string | null;
+    };
+    error?: HttpException | Error;
+    prerender: Route.Prerender;
+    dynamic: boolean;
+    wildcard: boolean;
+};
+export type Endpoint = {
+    __id: string;
+    __path: string;
+    __params: string[];
+    __kind: typeof Build.EntryKind.ENDPOINT;
+    method: Lowercase<HttpMethod>;
+    middlewares: (string | null)[];
+};
+export type ManifestEntry = Segment | Endpoint;
+export type Manifest = Awaited<ReturnType<typeof Build.Finder.prototype.process>>['manifest'];
+export type View<TProps> = React.ComponentType<TProps> | React.LazyExoticComponent<React.ComponentType<TProps>>;
+export type StaticImport = Record<string, unknown>;
+export type DynamicImport<T = Record<string, unknown>> = () => Promise<T>;
+export type MapEntry = {
+    shell?: StaticImport;
+    page?: DynamicImport;
+    layouts?: readonly (DynamicImport | null)[];
+    '401s'?: readonly (DynamicImport | null)[];
+    '403s'?: readonly (DynamicImport | null)[];
+    '404s'?: readonly (DynamicImport | null)[];
+    '500s'?: readonly (DynamicImport | null)[];
+    loaders?: readonly (DynamicImport | null)[];
+    middlewares?: readonly (Router.Middleware | null)[];
+    endpoint?: (req?: BunRequest) => unknown;
+};
+export type ImportMap = Record<string, MapEntry>;
+export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS';
+export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+export type LooseNumber<T extends number> = T | (number & {});
+export type BuildManifest = {
+    prerenderedRoutes: string[];
+    precompress: boolean;
+};
+export declare namespace Route {
+    type Metadata = Metadata.Item | ((input: Metadata.Input<Router.Params>) => Promise<Metadata.Item> | Metadata.Item);
+    type Prerender = (typeof Solas.Config.PRERENDER_MODES)[number];
+}
+export type BoundaryError = Error & {
+    digest?: string;
+};
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+import { Solas } from './solas';

package/dist/utils/compress.d.ts

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

package/dist/utils/compress.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { brotliCompress } from 'node:zlib';
+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);
+        }
+        return output;
+    }
+    async function compress(input) {
+        const file = Bun.file(input);
+        const buffer = Buffer.from(await file.arrayBuffer());
+        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
+     */
+    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();
+        }
+    }
+    Compress.run = run;
+})(Compress || (Compress = {}));

package/dist/utils/context.d.ts

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

package/dist/utils/context.js

@@ -0,0 +1,25 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Logger } from './logger';
+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 = {}));

package/dist/utils/cookies.d.ts

@@ -0,0 +1,3 @@
+export declare namespace Cookies {
+    function parse(header: string | null | undefined): Map<string, string>;
+}

package/dist/utils/cookies.js

@@ -0,0 +1,35 @@
+export { Cookies };
+var Cookies;
+(function (Cookies) {
+    function decode(value) {
+        try {
+            // some clients encode spaces as '+'
+            return decodeURIComponent(value.replace(/\+/g, ' '));
+        }
+        catch {
+            // keep raw value if decoding fails
+            return value;
+        }
+    }
+    function parse(header) {
+        const out = new Map();
+        if (!header)
+            return out;
+        for (const part of header.split(';')) {
+            // cookie values may contain =, so only split on the
+            // first separator
+            const separator = part.indexOf('=');
+            const raw = separator === -1 ? part : part.slice(0, separator);
+            const key = raw.trim();
+            if (!key)
+                continue;
+            // later duplicates are ignored so the first cookie value wins
+            if (out.has(key))
+                continue;
+            const value = separator === -1 ? '' : part.slice(separator + 1).trim();
+            out.set(key, decode(value));
+        }
+        return out;
+    }
+    Cookies.parse = parse;
+})(Cookies || (Cookies = {}));

package/dist/utils/export-reader.d.ts

@@ -0,0 +1,29 @@
+export declare class ExportReader {
+    #private;
+    /**
+     * Read the raw text content of a file
+     */
+    raw(filePath: string): Promise<string>;
+    /**
+     * Get the names of all exports from a file
+     */
+    exports(filePath: string): Promise<string[]>;
+    /**
+     * Check if a file exports a specific name
+     */
+    has(filePath: string, name: string): Promise<boolean>;
+    /**
+     * Read a simple literal export from a file without executing it
+     * @description supports string, number, boolean, and null literals.
+     * The export must be in the form of `export const|let|var name = <literal>`
+     */
+    literal<T>(filePath: string, name: string, validate?: ExportReader.Validator<T>): Promise<T | undefined>;
+    /**
+     * Read an export from a file by executing the module
+     */
+    value<T>(filePath: string, name: string, validate?: ExportReader.Validator<T>): Promise<T | undefined>;
+}
+export declare namespace ExportReader {
+    type Loader = 'js' | 'jsx' | 'ts' | 'tsx';
+    type Validator<T> = (value: unknown) => value is T;
+}

package/dist/utils/export-reader.js

@@ -0,0 +1,117 @@
+import path from 'node:path';
+export class ExportReader {
+    #transpilers = new Map();
+    /**
+     * Pick the Bun loader that matches the source file extension
+     */
+    static #getLoader(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext === '.js' || ext === '.mjs' || ext === '.cjs')
+            return 'js';
+        if (ext === '.jsx')
+            return 'jsx';
+        if (ext === '.ts' || ext === '.mts' || ext === '.cts')
+            return 'ts';
+        if (ext === '.tsx')
+            return 'tsx';
+        throw new Error(`Unsupported module extension: ${ext || '(none)'} in ${filePath}`);
+    }
+    /**
+     * Reuse one transpiler per supported loader so scans match the module syntax
+     */
+    #getTranspiler(filePath) {
+        const loader = ExportReader.#getLoader(filePath);
+        const cached = this.#transpilers.get(loader);
+        if (cached)
+            return cached;
+        const transpiler = new Bun.Transpiler({ loader });
+        this.#transpilers.set(loader, transpiler);
+        return transpiler;
+    }
+    /**
+     * Parse a literal value from a string
+     */
+    static #parse(value) {
+        const trimmed = value.trim();
+        // keep quoted literals as strings without evaluating the
+        // source text
+        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+            (trimmed.startsWith('`') && trimmed.endsWith('`'))) {
+            return trimmed.slice(1, -1);
+        }
+        if (trimmed === 'true')
+            return true;
+        if (trimmed === 'false')
+            return false;
+        if (trimmed === 'null')
+            return null;
+        const n = Number(trimmed);
+        if (Number.isFinite(n))
+            return n;
+    }
+    /**
+     * Read the raw text content of a file
+     */
+    async raw(filePath) {
+        return Bun.file(filePath).text();
+    }
+    /**
+     * Get the names of all exports from a file
+     */
+    async exports(filePath) {
+        // use Bun's transpiler scan so we can inspect export names
+        // without loading the module
+        return this.#getTranspiler(filePath).scan(await this.raw(filePath)).exports;
+    }
+    /**
+     * Check if a file exports a specific name
+     */
+    async has(filePath, name) {
+        const names = await this.exports(filePath);
+        return names.includes(name);
+    }
+    /**
+     * Read a simple literal export from a file without executing it
+     * @description supports string, number, boolean, and null literals.
+     * The export must be in the form of `export const|let|var name = <literal>`
+     */
+    async literal(filePath, name, validate) {
+        const code = await this.raw(filePath);
+        // build the matcher from escaped plain-text pieces so arbitrary export names
+        // cannot change the regex shape
+        const source = 
+        // match: `export const|let|var `
+        '\\bexport\\s+(?:const|let|var)\\s+' +
+            // treat export name as plain text in regex
+            name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+            // capture one supported literal value (string, number, boolean, null)
+            '\\s*=\\s*(?<value>(?:"(?:[^"\\\\]|\\\\.)*"|\'(?:[^\'\\\\]|\\\\.)*\'|\\x60(?:[^\\x60\\\\]|\\\\.)*\\x60|true|false|null|-?\\d+(?:\\.\\d+)?))(?=\\s|;|$)';
+        const text = code.match(new RegExp(source))?.groups?.value;
+        if (!text)
+            return;
+        // only support cheap literal parsing here. Anything richer should go through
+        // value() so module semantics stay correct
+        const value = ExportReader.#parse(text);
+        if (value === undefined)
+            return;
+        if (!validate || validate(value))
+            return value;
+    }
+    /**
+     * Read an export from a file by executing the module
+     */
+    async value(filePath, name, validate) {
+        if (!(await this.has(filePath, name)))
+            return;
+        // resolve from the project root so generated/build-time callers can pass the
+        // same workspace-relative paths used elsewhere in the route graph
+        const abs = path.resolve(process.cwd(), filePath);
+        const mod = (await import(/* @vite-ignore */ abs));
+        const value = mod[name];
+        if (value === undefined)
+            return;
+        if (!validate || validate(value))
+            return value;
+    }
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,6 @@
+export declare namespace Format {
+    /**
+     * Format a file in-place using oxfmt with our preferred code style
+     */
+    function run(filePath: string): Promise<void>;
+}

package/dist/utils/format.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import { format } from 'oxfmt';
+import { Logger } from './logger';
+const logger = new Logger();
+const BASE_OPTIONS = {
+    useTabs: true,
+    tabWidth: 2,
+    printWidth: 90,
+    singleQuote: true,
+    jsxSingleQuote: false,
+    quoteProps: 'as-needed',
+    trailingComma: 'all',
+    semi: false,
+    arrowParens: 'avoid',
+    bracketSameLine: true,
+    bracketSpacing: true,
+    endOfLine: 'lf',
+};
+const SUPPORTED_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+    '.json',
+    '.jsonc',
+    '.json5',
+    '.css',
+    '.scss',
+    '.less',
+    '.md',
+    '.mdx',
+    '.html',
+    '.yml',
+    '.yaml',
+    '.toml',
+]);
+export { Format };
+var Format;
+(function (Format) {
+    /**
+     * Format a file in-place using oxfmt with our preferred code style
+     */
+    async function run(filePath) {
+        try {
+            const ext = path.extname(filePath).toLowerCase();
+            if (!SUPPORTED_EXTENSIONS.has(ext)) {
+                logger.warn(`[format] Skipping unsupported file type: ${filePath}`);
+                return;
+            }
+            const file = Bun.file(filePath);
+            const source = await file.text();
+            const options = ext === '.json' ? { ...BASE_OPTIONS, trailingComma: 'none' } : BASE_OPTIONS;
+            const result = await format(filePath, source, options);
+            if (result.errors.length > 0) {
+                logger.warn(`[format] oxfmt failed for ${filePath}: ${result.errors[0]?.message}`);
+                return;
+            }
+            if (result.code === source)
+                return;
+            await Bun.write(filePath, result.code);
+            logger.info(`[format] Formatted file: ${filePath}`);
+        }
+        catch (err) {
+            logger.error(`[format] Failed to format file: ${filePath}`, err);
+        }
+    }
+    Format.run = run;
+})(Format || (Format = {}));