@kestack/kabuki 0.0.0 → 0.0.2

package/dist/start/vite/vite.js

@@ -0,0 +1,217 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { isRunnableDevEnvironment } from 'vite';
+import { serveHandler } from './dev.js';
+import { BUILD, CLIENT, ENTRY, HANDLER, WORKER, buildModule, clientEntry, devScripts, handlerModule, workerEntry, } from './entries.js';
+import { findFiles } from './files.js';
+import { filesOf } from './manifest.js';
+import { mentionsLazy, withIds } from './lazy.js';
+import { DEV_STYLES, serveStyles } from './styles.js';
+/** A file the client build writes for the Worker to read, and which is never deployed. */
+const MANIFEST = '.vite/kabuki-start.json';
+/** What the client build hands the Worker's, kept on `globalThis`: Vite may make the plugin again for each build. */
+const built = () => {
+    const key = Symbol.for('@kestack/kabuki/start/vite');
+    const global = globalThis;
+    return (global[key] ??= new Map());
+};
+const resolved = (id) => `\0${id}`;
+/** Start's Vite plugin. Put it beside the React plugin: `plugins: [react(), start({ platform: cloudflare() })]`. */
+export const start = (options) => {
+    let root = process.cwd();
+    let base = '/';
+    let server;
+    // 1. Find
+    const files = () => findFiles(root, options);
+    const devBuild = async () => ({
+        id: undefined,
+        base,
+        entry: {
+            script: `${base}@id/__x00__${CLIENT}`,
+            styles: [`${base}${DEV_STYLES}`],
+            preloads: [],
+        },
+        views: null,
+        head: server
+            ? devScripts(await server.transformIndexHtml('/', '<html><head></head><body></body></html>'))
+            : [],
+    });
+    return {
+        name: '@kestack/kabuki/start',
+        enforce: 'pre',
+        // 2. Write
+        config: {
+            order: 'pre',
+            handler(config, { command }) {
+                root = path.resolve(config.root ?? process.cwd());
+                // A Worker's main module may export only its handlers, so the
+                // server build is one file: its lazy imports are inlined.
+                const input = (entry, inline = false) => {
+                    return 'rolldownVersion' in this.meta
+                        ? {
+                            rolldownOptions: {
+                                input: entry,
+                                ...(inline ? { output: { codeSplitting: false } } : {}),
+                            },
+                        }
+                        : {
+                            rollupOptions: {
+                                input: entry,
+                                ...(inline ? { output: { inlineDynamicImports: true } } : {}),
+                            },
+                        };
+                };
+                // Where the Cloudflare plugin puts them too: `dist/client` and `dist/ssr`.
+                const outDir = (name) => config.environments?.[name]?.build?.outDir ??
+                    path.join(config.build?.outDir ?? 'dist', name);
+                const found = findFiles(root, options);
+                return {
+                    appType: 'custom',
+                    // The browser's entry is the plugin's own, which Vite cannot scan:
+                    // scan the app's files, and what the entry imports, so the first
+                    // page in dev does not find new dependencies and reload.
+                    optimizeDeps: {
+                        entries: [found.app],
+                        include: ['react-dom/client'],
+                    },
+                    environments: {
+                        client: {
+                            build: {
+                                manifest: config.environments?.client?.build?.manifest ||
+                                    config.build?.manifest ||
+                                    MANIFEST,
+                                outDir: outDir('client'),
+                                ...input({ [ENTRY]: CLIENT }),
+                            },
+                        },
+                        ssr: {
+                            // A Worker runs alone: built, it carries every dependency, in
+                            // its edge form.
+                            ...(command === 'build'
+                                ? {
+                                    resolve: {
+                                        noExternal: true,
+                                        conditions: [...options.platform.conditions],
+                                    },
+                                }
+                                : {}),
+                            build: {
+                                outDir: outDir('ssr'),
+                                ...input({ index: WORKER }, true),
+                            },
+                        },
+                    },
+                    // 4. Build
+                    ...(config.builder?.buildApp
+                        ? {}
+                        : {
+                            builder: {
+                                buildApp: async (builder) => {
+                                    await builder.build(builder.environments.client);
+                                    for (const environment of Object.values(builder.environments))
+                                        if (!environment.isBuilt)
+                                            await builder.build(environment);
+                                },
+                            },
+                        }),
+                };
+            },
+        },
+        // 5. Dev: a Worker that finds its own dependencies, as workerd under the
+        // Cloudflare plugin does, cannot scan the plugin's entry either: scan the
+        // app's server files, and include what Start's own Worker imports, so
+        // the first page does not find new dependencies and reload. Vite's own
+        // server environment, in Node, finds none and is left as it is.
+        configEnvironment(name, config) {
+            if (name === 'client' || config.optimizeDeps?.noDiscovery !== false)
+                return undefined;
+            const found = files();
+            return {
+                optimizeDeps: {
+                    entries: [found.app, found.loaders].filter((file) => file !== undefined),
+                    include: [
+                        'effect',
+                        'react',
+                        'react/jsx-runtime',
+                        'react/jsx-dev-runtime',
+                        'react-dom/server',
+                    ],
+                },
+            };
+        },
+        configResolved(config) {
+            root = config.root;
+            base = config.base;
+        },
+        resolveId(id) {
+            if ([HANDLER, WORKER, CLIENT, BUILD].includes(id))
+                return resolved(id);
+            return undefined;
+        },
+        async load(id) {
+            if (id === resolved(HANDLER))
+                return handlerModule(files());
+            if (id === resolved(WORKER))
+                return workerEntry(options.platform);
+            if (id === resolved(CLIENT))
+                return clientEntry(files(), this.environment.config.command === 'serve'
+                    ? `${base}${DEV_STYLES}`
+                    : undefined);
+            if (id === resolved(BUILD)) {
+                if (this.environment.config.command === 'serve')
+                    return buildModule(await devBuild());
+                const client = built().get(root);
+                if (!client)
+                    this.error('the client was not built before the Worker: build with `vite build`, which builds the client first');
+                return buildModule({ ...client, head: [] });
+            }
+            return undefined;
+        },
+        // 3. Name
+        async transform(code, id) {
+            if (this.environment.config.consumer === 'client' &&
+                /\.server\.[cm]?[jt]sx?$/.test(id.split('?')[0]))
+                this.error(`${path.relative(root, id)} runs on the server only, and something the browser loads imports it`);
+            if (id.includes('/node_modules/') || !mentionsLazy(code))
+                return undefined;
+            const named = await withIds(code, root, async (specifier) => (await this.resolve(specifier, id))?.id);
+            return named === undefined ? undefined : { code: named, map: null };
+        },
+        // 4. Build: the client's files, for the Worker; the manifest is not deployed.
+        writeBundle: {
+            order: 'post',
+            handler(output) {
+                if (this.environment.name !== 'client')
+                    return;
+                const setting = this.environment.config.build.manifest;
+                const name = typeof setting === 'string' ? setting : '.vite/manifest.json';
+                const dir = output.dir ?? this.environment.config.build.outDir;
+                const file = path.resolve(root, dir, name);
+                const manifest = JSON.parse(readFileSync(file, 'utf8'));
+                built().set(root, {
+                    id: randomUUID(),
+                    base,
+                    ...filesOf(manifest, base),
+                });
+                if (name !== MANIFEST)
+                    return;
+                rmSync(file);
+                const folder = path.dirname(file);
+                if (existsSync(folder) && readdirSync(folder).length === 0)
+                    rmSync(folder, { recursive: true });
+            },
+        },
+        // 5. Dev
+        configureServer(dev) {
+            server = dev;
+            dev.middlewares.use(serveStyles(dev, () => [files().app]));
+            return () => {
+                const ssr = dev.environments.ssr;
+                if (!ssr || !isRunnableDevEnvironment(ssr))
+                    return;
+                dev.middlewares.use(serveHandler(async () => (await ssr.runner.import(HANDLER)).default, (error) => ssr.config.logger.error(error.stack ?? error.message)));
+            };
+        },
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kestack/kabuki",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "private": false,
   "description": "An app as one tree of Actors outside React: each Actor a small state machine driven by Messages, one immutable Snapshot for the whole app, Effect running the work, and React only drawing it.",
   "keywords": [
@@ -30,11 +30,61 @@
     "./react": {
       "types": "./dist/react/index.d.ts",
       "default": "./dist/react/index.js"
+    },
+    "./routing": {
+      "types": "./dist/routing/index.d.ts",
+      "default": "./dist/routing/index.js"
+    },
+    "./routing/adapter": {
+      "types": "./dist/routing/adapter/index.d.ts",
+      "default": "./dist/routing/adapter/index.js"
+    },
+    "./routing/adapter/browser": {
+      "types": "./dist/routing/adapter/browser/index.d.ts",
+      "default": "./dist/routing/adapter/browser/index.js"
+    },
+    "./routing/adapter/tanstack": {
+      "types": "./dist/routing/adapter/tanstack/index.d.ts",
+      "default": "./dist/routing/adapter/tanstack/index.js"
+    },
+    "./start": {
+      "types": "./dist/start/common/common.d.ts",
+      "default": "./dist/start/common/common.js"
+    },
+    "./start/server": {
+      "types": "./dist/start/server/index.d.ts",
+      "default": "./dist/start/server/index.js"
+    },
+    "./start/client": {
+      "types": "./dist/start/client/index.d.ts",
+      "default": "./dist/start/client/index.js"
+    },
+    "./start/platform": {
+      "types": "./dist/start/platform/index.d.ts",
+      "default": "./dist/start/platform/index.js"
+    },
+    "./start/platform/cloudflare": {
+      "types": "./dist/start/platform/cloudflare/index.d.ts",
+      "default": "./dist/start/platform/cloudflare/index.js"
+    },
+    "./start/vite": {
+      "types": "./dist/start/vite/index.d.ts",
+      "default": "./dist/start/vite/index.js"
     }
   },
   "peerDependencies": {
     "effect": "^4.0.0",
-    "react": "^19.0.0"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "vite": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react-dom": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/react": "19.2.18",
@@ -47,7 +97,7 @@
     "typescript": "7.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
     "vitest": "5.0.1",
-    "laymos": "0.0.11"
+    "laymos": "0.0.13"
   },
   "scripts": {
     "build": "rm -rf ./dist && tsc -p tsconfig.build.json",