@jk2908/solas 0.1.0

package/dist/index.js

@@ -0,0 +1,235 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import rsc from '@vitejs/plugin-rsc';
+import { Solas } from './solas';
+import { ExportReader } from './utils/export-reader';
+import { Format } from './utils/format';
+import { Logger } from './utils/logger';
+import { Time } from './utils/time';
+import { Build } from './internal/build';
+import { writeConfig } from './internal/codegen/config';
+import { writeBrowserEntry, writeRSCEntry, writeSSREntry, } from './internal/codegen/environments';
+import { writeManifest } from './internal/codegen/manifest';
+import { writeMaps } from './internal/codegen/maps';
+const DEFAULT_CONFIG = {
+    precompress: true,
+    prerender: false,
+    trailingSlash: false,
+};
+function solas(c) {
+    const config = Solas.Config.validate({
+        ...DEFAULT_CONFIG,
+        ...c,
+        url: c.url ?? process.env.VITE_APP_URL?.toString() ?? process.env.APP_URL?.toString(),
+    });
+    if (config.logger?.level)
+        Logger.defaultLevel = config.logger.level;
+    const logger = new Logger();
+    const exportReader = new ExportReader();
+    const buildContext = {
+        prerenderedRoutes: new Set(),
+        exportReader,
+    };
+    // cache for file contents to avoid unnecessary readFile invocations
+    const fileCache = new Map();
+    async function maybeWrite(filePath, content) {
+        try {
+            const cached = fileCache.get(filePath);
+            if (cached === content) {
+                // if content is unchanged and file exists, skip write
+                if (await Bun.file(filePath).exists())
+                    return null;
+                // else, file is missing but cached content is the same as
+                // last time we saw it, write it
+                await Bun.write(filePath, content);
+                fileCache.set(filePath, content);
+                return path.relative(process.cwd(), filePath);
+            }
+            const curr = cached ?? (await fs.readFile(filePath, 'utf-8'));
+            fileCache.set(filePath, curr);
+            // no change, bail
+            if (curr === content)
+                return null;
+            try {
+                await Bun.write(filePath, content);
+                fileCache.set(filePath, content);
+                return path.relative(process.cwd(), filePath);
+            }
+            catch (err) {
+                logger.error(`[maybeWrite] Failed to write file: ${filePath}`, err);
+                return null;
+            }
+        }
+        catch (err) {
+            // file doesn't exist, write it
+            if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+                try {
+                    await Bun.write(filePath, content);
+                    fileCache.set(filePath, content);
+                    return path.relative(process.cwd(), filePath);
+                }
+                catch (err) {
+                    logger.error(`[maybeWrite] Failed to write file: ${filePath}`, err);
+                    return null;
+                }
+            }
+            logger.error(`[maybeWrite] Failed to read file: ${filePath}`, err);
+            return null;
+        }
+    }
+    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);
+        await Promise.all([
+            fs.mkdir(routesDir, { recursive: true }),
+            fs.mkdir(generatedDir, { recursive: true }),
+        ]);
+        const processor = new Build.Finder(buildContext, config);
+        const { manifest, prerenderedRoutes, imports, modules } = await processor.run();
+        // set prerenderable routes in context for use in closeBundle
+        buildContext.prerenderedRoutes = prerenderedRoutes;
+        const files = [
+            ['config.ts', writeConfig(config)],
+            ['manifest.ts', writeManifest(manifest)],
+            ['maps.ts', writeMaps(imports, modules)],
+            [Solas.Config.ENTRY_RSC, writeRSCEntry()],
+            [Solas.Config.ENTRY_SSR, writeSSREntry()],
+            [Solas.Config.ENTRY_BROWSER, writeBrowserEntry()],
+        ];
+        const writes = await Promise.all(files.map(([file, content]) => maybeWrite(path.join(generatedDir, file), content)));
+        const changed = writes.filter(n => n !== null);
+        // early return if nothing has changed
+        if (!changed.length)
+            return;
+        await Promise.all(changed.map(filePath => Format.run(filePath).catch(() => {
+            logger.error(`[build] Failed to format file: ${filePath}`);
+        })));
+        return changed;
+    }
+    let rebuildRunning = false;
+    let rebuildQueued = false;
+    let rebuildReason = 'change';
+    // 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}/`;
+    // 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
+    const toAbsoluteWatchPath = (p) => normaliseWatchPath(path.isAbsolute(p) ? p : path.join(WATCH_CWD, p));
+    // only route changes inside the app directory should trigger a rebuild
+    const inAppDir = (p) => toAbsoluteWatchPath(p).startsWith(WATCH_APP_ROOT);
+    // route graph rebuilds only care about framework route files, with endpoint
+    // 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 queue = () => {
+            void (async () => {
+                // collapse bursts of file events into one active rebuild plus a single
+                // queued rerun when changes land mid-build
+                if (rebuildRunning) {
+                    rebuildQueued = true;
+                    return;
+                }
+                rebuildRunning = true;
+                do {
+                    rebuildQueued = false;
+                    try {
+                        const changed = await build();
+                        if (changed)
+                            logger.info('[watch]', `route graph rebuilt (${rebuildReason})`);
+                    }
+                    catch (err) {
+                        logger.error('[watch] route rebuild failed', err);
+                    }
+                } while (rebuildQueued);
+                rebuildRunning = false;
+            })();
+        };
+        // ignore anything outside the app dir
+        if (!inAppDir(p))
+            return;
+        const file = toAbsoluteWatchPath(p);
+        // directory adds/removals can change route structure immediately
+        if (event === 'addDir' || event === 'unlinkDir') {
+            rebuildReason = `${event}: ${path.relative(WATCH_CWD, file)}`;
+            queue();
+            return;
+        }
+        // non-route files do not affect generated route artifacts
+        if (!routeFile.test(file))
+            return;
+        // content changes only matter for route graph when endpoint verbs change
+        if (event === 'change' && !endpointFile.test(file))
+            return;
+        rebuildReason = `${event}: ${path.relative(WATCH_CWD, file)}`;
+        queue();
+    }, 75);
+    const plugin = {
+        name: Solas.Config.NAME,
+        enforce: 'pre',
+        async config(viteConfig) {
+            await build();
+            const pkg = JSON.parse(fsSync.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+            if (typeof pkg.version !== 'string' || pkg.version.length === 0) {
+                throw new Error(`Missing ${Solas.Config.NAME} package version`);
+            }
+            viteConfig.build ??= {};
+            viteConfig.build.outDir = Solas.Config.OUT_DIR;
+            viteConfig.build.emptyOutDir = true;
+            viteConfig.server ??= {};
+            viteConfig.server.port = config.port ?? viteConfig.server.port ?? 8787;
+            viteConfig.define ??= {};
+            viteConfig.define['import.meta.env.APP_URL'] = JSON.stringify(process.env.APP_URL);
+            viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(process.env.VITE_APP_URL);
+            viteConfig.define['import.meta.env.SOLAS_VERSION'] = JSON.stringify(pkg.version);
+            viteConfig.resolve ??= {};
+            viteConfig.resolve.alias = {
+                ...(viteConfig.resolve.alias ?? {}),
+                '.solas': path.resolve(process.cwd(), Solas.Config.GENERATED_DIR),
+            };
+            viteConfig.optimizeDeps ??= {};
+            viteConfig.optimizeDeps.exclude = [
+                ...(Array.isArray(viteConfig.optimizeDeps.exclude)
+                    ? viteConfig.optimizeDeps.exclude
+                    : []),
+                'react-dom/client',
+            ];
+        },
+        configureServer(server) {
+            logger.info('[configureServer]', `Watching for changes in ./${Solas.Config.APP_DIR}...`);
+            server.watcher
+                .on('add', (p) => rebuild('add', p))
+                .on('change', (p) => rebuild('change', p))
+                .on('unlink', (p) => rebuild('unlink', p))
+                .on('addDir', (p) => rebuild('addDir', p))
+                .on('unlinkDir', (p) => rebuild('unlinkDir', p));
+        },
+        async closeBundle() {
+            if (process.env.NODE_ENV === 'development')
+                return;
+            // write build manifest
+            const generatedDir = path.join(process.cwd(), Solas.Config.GENERATED_DIR);
+            await Bun.write(path.join(generatedDir, 'build.json'), JSON.stringify({
+                prerenderedRoutes: Array.from(buildContext.prerenderedRoutes),
+                precompress: config.precompress,
+            }));
+            logger.info('[closeBundle]', 'vite build complete');
+        },
+    };
+    return [
+        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}`,
+            },
+        }),
+    ];
+}
+export default solas;
+export { Solas } from './solas';

package/dist/internal/build.d.ts

@@ -0,0 +1,104 @@
+import type { BuildContext, Endpoint, PluginConfig, Segment } from '../types';
+export declare namespace Build {
+    type ScanResult = {
+        segments: {
+            dir: string;
+            page?: string;
+            layouts: (string | null)[];
+            shell: string;
+            '401s': (string | null)[];
+            '403s': (string | null)[];
+            '404s': (string | null)[];
+            '500s': (string | null)[];
+            loaders: (string | null)[];
+            middlewares: (string | null)[];
+        }[];
+        endpoints: {
+            file: string;
+            middlewares: (string | null)[];
+        }[];
+    };
+    type Imports = {
+        endpoints: {
+            static: Map<string, string>;
+        };
+        components: {
+            static: Map<string, string>;
+            dynamic: Map<string, string>;
+        };
+        middlewares: {
+            static: Map<string, string>;
+        };
+    };
+    type Modules = Record<string, {
+        shellId?: string;
+        layoutIds?: (string | null)[];
+        pageId?: string;
+        '401Ids'?: (string | null)[];
+        '403Ids'?: (string | null)[];
+        '404Ids'?: (string | null)[];
+        '500Ids'?: (string | null)[];
+        loadingIds?: (string | null)[];
+        middlewareIds?: (string | null)[];
+        endpointId?: string;
+    }>;
+    const EntryKind: {
+        readonly SHELL: "$S";
+        readonly LAYOUT: "$L";
+        readonly PAGE: "$P";
+        readonly 401: "$401";
+        readonly 403: "$403";
+        readonly 404: "$404";
+        readonly 500: "$500";
+        readonly LOADING: "$LOAD";
+        readonly MIDDLEWARE: "$MW";
+        readonly ENDPOINT: "$E";
+    };
+    /**
+     * Finder class to process application routes
+     */
+    class Finder {
+        #private;
+        readonly buildContext: BuildContext;
+        readonly config: PluginConfig;
+        constructor(buildContext: BuildContext, config: PluginConfig);
+        /**
+         * Extracts dynamic parameter names from a file path
+         */
+        static getParams(file: string): string[];
+        /**
+         * Get the depth of a route based on slashes
+         */
+        static getDepth(route: string): number;
+        /**
+         * Convert a file path to a canonical route.
+         */
+        static toCanonicalRoute(file: string): string;
+        /**
+         * Get the import path for a file
+         * This finds the relative path from the generated
+         * directory to the file, removes the extension and
+         * replaces backslashes with forward slashes.
+         */
+        static getImportPath(file: string): string;
+        /**
+         * Run the Finder to get the app route and associated data
+         * needed for codegen
+         */
+        run(): Promise<{
+            manifest: Record<string, (Endpoint | Segment)[] | Endpoint | Segment>;
+            imports: Imports;
+            modules: Modules;
+            prerenderedRoutes: Set<string>;
+        }>;
+        /**
+         * Process the scanned route data
+         */
+        process(res: ScanResult): Promise<{
+            manifest: Record<string, (Endpoint | Segment)[] | Endpoint | Segment>;
+            imports: Imports;
+            modules: Modules;
+            prerenderedRoutes: Set<string>;
+        }>;
+    }
+}