@gracile/engine 0.9.0 → 0.9.1

package/dist/vite/plugin-serve.js

@@ -0,0 +1,61 @@
+/**
+ * Vite plugin: development server middleware.
+ *
+ * Sets up the Gracile request handler, route watcher, and dev-time
+ * logging for `vite dev`.
+ *
+ * @internal
+ */
+import { getVersion } from '@gracile/internal-utils/version';
+import c from 'picocolors';
+import { createDevelopmentHandler } from '../dev/development.js';
+import { nodeAdapter } from '../server/adapters/node.js';
+export function gracileServePlugin({ state, config, logger, resetClientBuiltFlag, }) {
+    return {
+        name: 'vite-plugin-gracile-serve-middleware',
+        apply: 'serve',
+        config(_, environment) {
+            if (environment.isPreview)
+                return null;
+            return {
+                // NOTE: Supresses message: `Could not auto-determine entry point from rollupOptions or html files…`
+                // FIXME: It's not working when reloading the Vite config.
+                // Is user config, putting `optimizeDeps: { include: [] }` solve this.
+                optimizeDeps: { include: [] },
+                // NOTE: Useful? It breaks preview (expected)
+                appType: 'custom',
+            };
+        },
+        async configureServer(server) {
+            // Reset so dev-mode config hot-reloads don't hit the guard.
+            resetClientBuiltFlag();
+            const version = getVersion();
+            logger.info(`${c.cyan(c.italic(c.underline('🧚 Gracile')))}` +
+                ` ${c.dim(`~`)} ${c.green(`v${version ?? 'X'}`)}`);
+            const { handler } = await createDevelopmentHandler({
+                routes: state.routes,
+                vite: server,
+                gracileConfig: state.gracileConfig,
+            });
+            logger.info(c.dim('Vite development server is starting…'), {
+                timestamp: true,
+            });
+            server.watcher.on('ready', () => {
+                setTimeout(() => {
+                    logger.info('');
+                    logger.info(c.green('Watching for file changes…'), {
+                        timestamp: true,
+                    });
+                    logger.info('');
+                    // NOTE: We want it to show after the Vite intro stuff
+                }, 100);
+            });
+            return () => {
+                server.middlewares.use((request, response, next) => {
+                    const locals = config?.dev?.locals?.({ nodeRequest: request });
+                    Promise.resolve(nodeAdapter(handler, { logger })(request, response, locals)).catch((error) => next(error));
+                });
+            };
+        },
+    };
+}

package/dist/vite/plugin-server-build.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Vite plugins: server-side build pipeline.
+ *
+ * Uses the Vite Environment API (`builder.buildApp()`) to coordinate
+ * client and SSR builds instead of a nested `build()` call.
+ *
+ * Includes:
+ * - Client asset filename collector (client env writeBundle)
+ * - Virtual entrypoint codegen (SSR env only)
+ * - Server-to-client asset mover (SSR env only)
+ *
+ * @internal
+ */
+import type { PluginOption } from 'vite';
+import type { PluginSharedState } from './plugin-shared-state.js';
+/**
+ * Tracks client bundle assets so the server build can reference them
+ * with their hashed filenames.
+ */
+export declare function gracileCollectClientAssetsPlugin({ state, }: {
+    state: PluginSharedState;
+}): PluginOption;
+/**
+ * Generates the virtual `entrypoint.js` module for the server build.
+ * This is the server's main entry: it imports routes and creates the
+ * Gracile handler.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export declare function gracileEntrypointPlugin({ state, }: {
+    state: PluginSharedState;
+}): PluginOption;
+/**
+ * After the server build writes its bundle, move any assets from
+ * `dist/server/assets/` into `dist/client/assets/` so the client
+ * can serve them.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export declare function gracileMoveServerAssetsPlugin({ state, }: {
+    state: PluginSharedState;
+}): PluginOption;
+//# sourceMappingURL=plugin-server-build.d.ts.map

package/dist/vite/plugin-server-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-server-build.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-server-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,EAChD,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,CAgBf;AAID;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,EACvC,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,CAsCf;AAID;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,EAC7C,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,YAAY,CA2Bf"}

package/dist/vite/plugin-server-build.js

@@ -0,0 +1,108 @@
+/**
+ * Vite plugins: server-side build pipeline.
+ *
+ * Uses the Vite Environment API (`builder.buildApp()`) to coordinate
+ * client and SSR builds instead of a nested `build()` call.
+ *
+ * Includes:
+ * - Client asset filename collector (client env writeBundle)
+ * - Virtual entrypoint codegen (SSR env only)
+ * - Server-to-client asset mover (SSR env only)
+ *
+ * @internal
+ */
+import { join } from 'node:path';
+import { rename, rm } from 'node:fs/promises';
+// ── Client asset collector ───────────────────────────────────────────
+/**
+ * Tracks client bundle assets so the server build can reference them
+ * with their hashed filenames.
+ */
+export function gracileCollectClientAssetsPlugin({ state, }) {
+    return {
+        name: 'vite-plugin-gracile-collect-client-assets-for-server',
+        applyToEnvironment(environment) {
+            return environment.name !== 'ssr';
+        },
+        writeBundle(_, bundle) {
+            if (state.outputMode === 'static')
+                return;
+            for (const file of Object.values(bundle))
+                if (file.type === 'asset' && file.name)
+                    state.clientAssets[file.name] = file.fileName;
+        },
+    };
+}
+// ── Virtual entrypoint ───────────────────────────────────────────────
+/**
+ * Generates the virtual `entrypoint.js` module for the server build.
+ * This is the server's main entry: it imports routes and creates the
+ * Gracile handler.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export function gracileEntrypointPlugin({ state, }) {
+    return {
+        name: 'vite-plugin-gracile-entry',
+        apply: 'build',
+        applyToEnvironment(environment) {
+            return environment.name === 'ssr';
+        },
+        resolveId(id) {
+            if (id === 'entrypoint.js') {
+                return id;
+            }
+            return null;
+        },
+        load(id) {
+            if (id === 'entrypoint.js' && state.routes && state.renderedRoutes) {
+                return `
+import { routeAssets, routeImports, routes } from 'gracile:routes';
+import { createGracileHandler } from '@gracile/gracile/_internals/server-runtime';
+import { createLogger } from '@gracile/gracile/_internals/logger';
+
+createLogger();
+
+export const handler = createGracileHandler({
+	root: process.cwd(),
+	routes,
+	routeImports,
+	routeAssets,
+	serverMode: true,
+	gracileConfig: ${JSON.stringify(state.gracileConfig, null, 2)}
+});
+`;
+            }
+            return null;
+        },
+    };
+}
+// ── Server asset mover ───────────────────────────────────────────────
+/**
+ * After the server build writes its bundle, move any assets from
+ * `dist/server/assets/` into `dist/client/assets/` so the client
+ * can serve them.
+ *
+ * Scoped to the SSR environment via `applyToEnvironment`.
+ */
+export function gracileMoveServerAssetsPlugin({ state, }) {
+    return {
+        name: 'gracile-move-server-assets',
+        apply: 'build',
+        applyToEnvironment(environment) {
+            return environment.name === 'ssr';
+        },
+        async writeBundle(_, bundle) {
+            const cwd = state.root || process.cwd();
+            await Promise.all(Object.entries(bundle).map(async ([file]) => {
+                if (file.startsWith('assets/') === false)
+                    return;
+                await rename(join(cwd, `/dist/server/${file}`), join(cwd, `/dist/client/${file}`));
+            }));
+            // NOTE: Disabled for now, because it conflict with test's folder comparer
+            await rm(join(cwd, `/dist/server/assets`), {
+                recursive: true,
+            }).catch(() => null);
+        },
+    };
+}

package/dist/vite/plugin-shared-state.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared mutable state passed between the Gracile Vite plugin phases.
+ *
+ * This exists because Vite plugins in the same array share data through
+ * closures. Making the shared state explicit (instead of ad-hoc `let`
+ * variables) makes the data flow between plugins visible and auditable.
+ *
+ * @internal
+ */
+import type { RenderedRouteDefinition } from '../routes/render.js';
+import type { RoutesManifest } from '../routes/route.js';
+import type { GracileConfig } from '../user-config.js';
+export interface PluginSharedState {
+    /** Collected file-system routes (populated during dev and build). */
+    routes: RoutesManifest;
+    /** Rendered route definitions from the client build phase. */
+    renderedRoutes: RenderedRouteDefinition[] | null;
+    /** Rollup input list for the client build (populated by route renderer). */
+    clientBuildInputList: string[] | null;
+    /** Maps original asset names → hashed filenames from the client bundle. */
+    clientAssets: Record<string, string>;
+    /** Vite `root` captured during build config. */
+    root: string | null;
+    /** The resolved Gracile configuration. */
+    gracileConfig: GracileConfig;
+    /** The output mode: 'static' or 'server'. */
+    outputMode: 'static' | 'server';
+}
+/**
+ * Create a fresh shared state object.
+ */
+export declare function createPluginSharedState(config: GracileConfig | undefined): PluginSharedState;
+//# sourceMappingURL=plugin-shared-state.d.ts.map

package/dist/vite/plugin-shared-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-shared-state.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-shared-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,MAAM,WAAW,iBAAiB;IACjC,qEAAqE;IACrE,MAAM,EAAE,cAAc,CAAC;IAEvB,8DAA8D;IAC9D,cAAc,EAAE,uBAAuB,EAAE,GAAG,IAAI,CAAC;IAEjD,4EAA4E;IAC5E,oBAAoB,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAEtC,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErC,gDAAgD;IAChD,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpB,0CAA0C;IAC1C,aAAa,EAAE,aAAa,CAAC;IAE7B,6CAA6C;IAC7C,UAAU,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAChC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,aAAa,GAAG,SAAS,GAC/B,iBAAiB,CAUnB"}

package/dist/vite/plugin-shared-state.js

@@ -0,0 +1,23 @@
+/**
+ * Shared mutable state passed between the Gracile Vite plugin phases.
+ *
+ * This exists because Vite plugins in the same array share data through
+ * closures. Making the shared state explicit (instead of ad-hoc `let`
+ * variables) makes the data flow between plugins visible and auditable.
+ *
+ * @internal
+ */
+/**
+ * Create a fresh shared state object.
+ */
+export function createPluginSharedState(config) {
+    return {
+        routes: new Map(),
+        renderedRoutes: null,
+        clientBuildInputList: null,
+        clientAssets: {},
+        root: null,
+        gracileConfig: config || {},
+        outputMode: config?.output || 'static',
+    };
+}

package/dist/vite/virtual-routes.d.ts

@@ -1,13 +1,16 @@
 import { type Plugin } from 'vite';
-import type { RenderedRouteDefinition } from '../routes/render.js';
 import type { RoutesManifest } from '../routes/route.js';
 import type { GracileConfig } from '../user-config.js';
+import type { PluginSharedState } from './plugin-shared-state.js';
 /**
- * @todo Client-side testing, docs.
+ * Server-side routes virtual module (`gracile:routes`).
+ *
+ * Scoped to the SSR build environment via `applyToEnvironment`.
+ * Reads from shared state lazily so `renderedRoutes` is available
+ * (populated during the client build).
  */
-export declare function virtualRoutes({ routes, renderedRoutes, }: {
-    routes: RoutesManifest;
-    renderedRoutes: RenderedRouteDefinition[];
+export declare function virtualRoutes({ state, }: {
+    state: PluginSharedState;
 }): Plugin[];
 export declare function virtualRoutesClient({ routes: routesMap, mode, gracileConfig, }: {
     routes: RoutesManifest;

package/dist/vite/virtual-routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-routes.d.ts","sourceRoot":"","sources":["../../src/vite/virtual-routes.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAEjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAE7B,MAAM,EACN,cAAc,GACd,EAAE;IAEF,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,EAAE,uBAAuB,EAAE,CAAC;CAC1C,GAAG,MAAM,EAAE,CAyEX;AAKD,wBAAgB,mBAAmB,CAAC,EACnC,MAAM,EAAE,SAAS,EACjB,IAAe,EACf,aAAa,GACb,EAAE;IACF,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,aAAa,EAAE,aAAa,CAAC;CAC7B,GAAG,MAAM,EAAE,CA4DX"}
+{"version":3,"file":"virtual-routes.d.ts","sourceRoot":"","sources":["../../src/vite/virtual-routes.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAC7B,KAAK,GACL,EAAE;IACF,KAAK,EAAE,iBAAiB,CAAC;CACzB,GAAG,MAAM,EAAE,CAwEX;AAKD,wBAAgB,mBAAmB,CAAC,EACnC,MAAM,EAAE,SAAS,EACjB,IAAe,EACf,aAAa,GACb,EAAE;IACF,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,aAAa,EAAE,aAAa,CAAC;CAC7B,GAAG,MAAM,EAAE,CA4DX"}

package/dist/vite/virtual-routes.js

@@ -1,25 +1,22 @@
 import { normalizeToPosix } from '@gracile/internal-utils/paths';
 import { createFilter } from 'vite';
 /**
- * @todo Client-side testing, docs.
+ * Server-side routes virtual module (`gracile:routes`).
+ *
+ * Scoped to the SSR build environment via `applyToEnvironment`.
+ * Reads from shared state lazily so `renderedRoutes` is available
+ * (populated during the client build).
  */
-export function virtualRoutes({ 
-// root,
-routes, renderedRoutes, }) {
+export function virtualRoutes({ state, }) {
     const virtualModuleId = 'gracile:routes';
     const resolvedVirtualModuleId = `\0${virtualModuleId}`;
-    // TODO: Remove handler when prerendering route
-    const routesWithoutPrerender = [...routes];
-    const renderedRoutesWithoutPrerender = renderedRoutes;
-    // const routesWithoutPrerender = [...routes].filter(
-    // 	([, r]) => r.prerender !== true,
-    // );
-    // const renderedRoutesWithoutPrerender = renderedRoutes.filter(
-    // 	(r) => r.savePrerender !== true,
-    // );
     return [
         {
             name: 'gracile-server-routes',
+            apply: 'build',
+            applyToEnvironment(environment) {
+                return environment.name === 'ssr';
+            },
             resolveId(id) {
                 if (id === virtualModuleId) {
                     return resolvedVirtualModuleId;
@@ -27,39 +24,43 @@ routes, renderedRoutes, }) {
                 return null;
             },
             load(id) {
-                if (id === resolvedVirtualModuleId) {
-                    return `
+                if (id !== resolvedVirtualModuleId)
+                    return null;
+                const routes = state.routes;
+                const renderedRoutes = state.renderedRoutes;
+                if (!routes || routes.size === 0 || !renderedRoutes)
+                    return null;
+                const routesArray = [...routes];
+                return `
 import { URLPattern } from '@gracile/gracile/url-pattern';
 
 const routes = new Map(${
-                    //
-                    JSON.stringify(routesWithoutPrerender, null, 2).replaceAll(
-                    // NOTE: Not strictly necessary, but just in case.
-                    '"pattern": {}', '"pattern": null')})
+                //
+                JSON.stringify(routesArray, null, 2).replaceAll(
+                // NOTE: Not strictly necessary, but just in case.
+                '"pattern": {}', '"pattern": null')})
 routes.forEach((route, pattern) => {
 	route.pattern = new URLPattern(pattern, 'http://gracile');
 });
 
 const routeImports = new Map(
 	[
-		${routesWithoutPrerender
-                        .map(([pattern, route]) => `['${pattern}', () => import('/${normalizeToPosix(route.filePath)}')],`)
-                        .join('\n		')}
+		${routesArray
+                    .map(([pattern, route]) => `['${pattern}', () => import('/${normalizeToPosix(route.filePath)}')],`)
+                    .join('\n		')}
 	]
 );
 
-const routeAssets = new Map(${JSON.stringify(renderedRoutesWithoutPrerender.map((r) => [
-                        `/${r.name
-                            //
-                            .replace(/index\.html$/, '')
-                            .replace(/* Error pages */ /\.html$/, '/')}`,
-                        r.handlerAssets,
-                    ]), null, 2)});
+const routeAssets = new Map(${JSON.stringify(renderedRoutes.map((r) => [
+                    `/${r.name
+                        //
+                        .replace(/index\.html$/, '')
+                        .replace(/* Error pages */ /\.html$/, '/')}`,
+                    r.handlerAssets,
+                ]), null, 2)});
 
 export { routes, routeImports, routeAssets };
 `;
-                }
-                return null;
             },
         },
     ];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gracile/engine",
-  "version": "0.9.0",
-  "description": "A thin, full-stack, web framework",
+  "version": "0.9.1",
+  "description": "Vite-powered build and dev server engine for the Gracile framework",
   "keywords": [
     "custom-elements",
     "full-stack",
@@ -43,8 +43,8 @@
     "!/dist/typedoc-entrypoint.*"
   ],
   "dependencies": {
-    "@gracile-labs/better-errors": "^0.2.0",
-    "@gracile/internal-utils": "^0.6.0",
+    "@gracile-labs/better-errors": "^0.3.1",
+    "@gracile/internal-utils": "^0.6.2",
     "@whatwg-node/server": "^0.10.18",
     "fdir": "^6.5.0",
     "picocolors": "^1.1.1",
@@ -60,5 +60,5 @@
     "access": "public",
     "provenance": true
   },
-  "gitHead": "06fa858cfdda41d1888e1f8f5c64da272c68f2d2"
+  "gitHead": "09d4bbc63796acf03a9c9f3be45737871ed95d9a"
 }