fimo-vite 0.21.0-experimental.1

package/dist/runtime/overlay-hmr.js

@@ -0,0 +1,27 @@
+// Vite HMR build-error bridge.
+//
+// This file is served by vite (not embedded inline) so that vite's plugin
+// pipeline transforms `import.meta.hot` into a real hot-context — inline
+// `<script type="module">` blocks bypass that pipeline and `import.meta.hot`
+// stays `undefined`. The inline overlay runtime (overlay-runtime.ts) exposes
+// its helpers on `window.__fimoOverlay`, which we call here.
+function api() {
+    if (typeof window === 'undefined') {
+        return undefined;
+    }
+    return window.__fimoOverlay;
+}
+if (import.meta && import.meta.hot) {
+    import.meta.hot.on('vite:error', (data) => {
+        const a = api();
+        if (!a)
+            return;
+        const d = a.getErrorDetails(data);
+        a.mount();
+        a.notify('Build Error', d.message, d.stack);
+    });
+    import.meta.hot.on('vite:afterUpdate', () => {
+        api()?.unmount();
+    });
+}
+export {};

package/dist/runtime/overlay-runtime.d.ts

@@ -0,0 +1,24 @@
+declare const ID = "fimo-error-overlay";
+declare function ensureStyles(): void;
+declare function mountBlack(): void;
+declare function unmount(): void;
+declare function getErrorDetails(e: unknown): {
+    message: string;
+    stack: string;
+};
+declare function postToTargets(type: string, payload: {
+    heading: string;
+    message: string;
+    stack: string;
+}): void;
+declare function notify(heading: string, message: string, stack: string): void;
+type FimoOverlayApi = {
+    mount: () => void;
+    unmount: () => void;
+    notify: (heading: string, message: string, stack: string) => void;
+    getErrorDetails: (e: unknown) => {
+        message: string;
+        stack: string;
+    };
+};
+//# sourceMappingURL=overlay-runtime.d.ts.map

package/dist/runtime/overlay-runtime.js

@@ -0,0 +1,103 @@
+"use strict";
+const ID = 'fimo-error-overlay';
+function ensureStyles() {
+    if (document.getElementById(ID + '-styles')) {
+        return;
+    }
+    const s = document.createElement('style');
+    s.id = ID + '-styles';
+    s.textContent =
+        'vite-error-overlay, #vite-error-overlay, vite-overlay { display: none !important; }' +
+            '#' +
+            ID +
+            ' { position: fixed; inset: 0; background: #000; z-index: 2147483647; display: none; }';
+    document.head.appendChild(s);
+}
+function mountBlack() {
+    ensureStyles();
+    let el = document.getElementById(ID);
+    if (!el) {
+        el = document.createElement('div');
+        el.id = ID;
+        document.body.appendChild(el);
+    }
+    el.style.display = 'block';
+}
+function unmount() {
+    const el = document.getElementById(ID);
+    if (el) {
+        el.style.display = 'none';
+    }
+}
+function getErrorDetails(e) {
+    try {
+        // Preserve the original loose extraction logic but in typed form
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const anyErr = e && e.error ? e.error : e;
+        let err = null;
+        if (!anyErr) {
+            err = null;
+        }
+        else if (anyErr.error) {
+            err = anyErr.error;
+        }
+        else if (anyErr.reason) {
+            err = anyErr.reason;
+        }
+        else if (anyErr.err) {
+            err = anyErr.err;
+        }
+        else {
+            err = anyErr;
+        }
+        const message = typeof err === 'string' ? err : err && err.message ? err.message : String(err || 'Unknown error');
+        const stack = err && err.stack ? String(err.stack) : '';
+        return { message, stack };
+    }
+    catch {
+        return { message: 'Unknown error', stack: '' };
+    }
+}
+function postToTargets(type, payload) {
+    const data = { type, payload };
+    try {
+        if (window.parent && window.parent !== window) {
+            window.parent.postMessage(data, '*');
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        if (window.top && window.top !== window && window.top !== window.parent) {
+            window.top.postMessage(data, '*');
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+function notify(heading, message, stack) {
+    const payload = { heading, message, stack };
+    // First, send a preview-level error so the parent can perform a minimal handshake
+    // and lock onto the sandbox origin in build-error scenarios.
+    postToTargets('preview/error', payload);
+    // Then, send the existing app-level error used by the UI overlay.
+    postToTargets('app/error', payload);
+}
+window.addEventListener('error', (e) => {
+    const d = getErrorDetails(e);
+    mountBlack();
+    notify('Runtime Error', d.message, d.stack);
+});
+window.addEventListener('unhandledrejection', (e) => {
+    const d = getErrorDetails(e);
+    mountBlack();
+    notify('Runtime Error', d.message, d.stack);
+});
+window.__fimoOverlay = {
+    mount: mountBlack,
+    unmount,
+    notify,
+    getErrorDetails,
+};

package/dist/vite.d.ts

@@ -0,0 +1,32 @@
+import type { PluginOption } from 'vite';
+export interface FimoViteOptions {
+    /**
+     * Emit `sitemap.xml` at build (and serve at `/sitemap.xml` in dev). Reads
+     * `seo.url` from `.fimo/config.json` as the base URL.
+     *
+     * Opt-in via `fimo({ sitemap: true })`.
+     */
+    sitemap?: boolean;
+    /**
+     * Emit `robots.txt` at build (and serve at `/robots.txt` in dev). Defaults
+     * to an allow-all robots policy + a `Sitemap:` directive when `seo.url` is
+     * set in `.fimo/config.json`.
+     *
+     * Opt-in via `fimo({ robots: true })`.
+     */
+    robots?: boolean;
+    /**
+     * Inject SEO meta tags into `index.html` via `transformIndexHtml`. Resolves
+     * per-route SEO from `.fimo/config.json#seo` and the matched route.
+     *
+     * Only applies in projects that have an `index.html` (plain Vite). Conflicts
+     * with frameworks that have their own SEO mechanism — React Router's `meta`
+     * export, Astro's frontmatter, Next.js's `generateMetadata`. Use those
+     * instead via the framework adapter's SEO helpers.
+     *
+     * Opt-in via `fimo({ seo: true })` — only documented in the plain-Vite recipe.
+     */
+    seo?: boolean;
+}
+export declare function fimo(opts?: FimoViteOptions): PluginOption[];
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.js

@@ -0,0 +1,98 @@
+import runtimeEnvPlugin from 'fimo/vite/runtime-env';
+import contentSyncPlugin from './plugins/content-sync.js';
+import dataIdPlugin from './plugins/data-id.js';
+import fimoConfigPlugin from './plugins/fimo-config.js';
+import overlayPlugin from './plugins/overlay.js';
+import robotsPlugin from './plugins/robots.js';
+import seoPlugin from './plugins/seo.js';
+import serverConfigPlugin from './plugins/server-config.js';
+import sitemapPlugin from './plugins/sitemap.js';
+import translationsPlugin from './plugins/translations.js';
+// Force-bundle fimo into the SSR build, and let the dev optimizer pre-bundle
+// it for the client. fimo's runtime imports `virtual:fimo-config` /
+// `virtual:translations` / `virtual:fimo-overlay-*` — Vite-only specifiers
+// resolved by sibling plugins — which esbuild can't see.
+//
+// Two places this matters:
+//   1. SSR build: bundle fimo into dist/server (top-level `ssr.noExternal`
+//      + per-environment `configEnvironment` for react-router 7.15+, which
+//      doesn't merge viteUserConfig.environments.ssr for the default
+//      non-serverBundles case). Rollup resolves the virtuals through the
+//      plugin container, so SSR needs no special-casing.
+//   2. Dev dep scan + optimization: esbuild chokes on `virtual:` ("Could not
+//      resolve 'virtual:fimo-config'"). The previous fix excluded the whole
+//      package from optimizeDeps, which served every runtime file as an
+//      individual module request (~34 extra round-trips per cold preview
+//      load through the sandbox proxy). Instead, externalize just the
+//      virtual specifiers — kept BARE (`virtual:fimo-config`, not an
+//      `/@id/`-prefixed URL): vite:import-analysis re-transforms optimized
+//      dep chunks and resolves bare specifiers through the plugin container,
+//      rewriting them to `/@id/` URLs itself. A pre-prefixed path fails that
+//      resolve ("Failed to resolve import '/@id/virtual:fimo-config'").
+//
+// Only `fimo` is named here. A framework package that also imports the
+// virtual modules (fimo-react-router does) contributes its own package names
+// through its own plugin; Vite concatenates the array config both return.
+function bundleFimoIntoSsrPlugin() {
+    return {
+        name: 'vite-plugin-fimo-ssr-bundle',
+        config: () => ({
+            ssr: { noExternal: ['fimo'] },
+            optimizeDeps: {
+                rolldownOptions: {
+                    plugins: [
+                        {
+                            name: 'fimo-externalize-virtuals',
+                            resolveId(id) {
+                                if (id.startsWith('virtual:')) {
+                                    return {
+                                        id,
+                                        external: true,
+                                    };
+                                }
+                            },
+                        },
+                    ],
+                },
+            },
+        }),
+        configEnvironment(name, config) {
+            if (name !== 'ssr')
+                return;
+            const existing = config.resolve?.noExternal;
+            const merged = existing === true
+                ? true
+                : Array.isArray(existing)
+                    ? [...existing, 'fimo']
+                    : existing
+                        ? [existing, 'fimo']
+                        : ['fimo'];
+            return {
+                resolve: { noExternal: merged },
+            };
+        },
+    };
+}
+// NOTE: dataIdPlugin must run before anything else to capture valid line numbers.
+export function fimo(opts = {}) {
+    const plugins = [
+        runtimeEnvPlugin(),
+        bundleFimoIntoSsrPlugin(),
+        contentSyncPlugin(),
+        serverConfigPlugin(),
+        fimoConfigPlugin(),
+        dataIdPlugin(),
+        translationsPlugin(),
+        overlayPlugin(),
+    ];
+    if (opts.sitemap) {
+        plugins.push(sitemapPlugin());
+    }
+    if (opts.robots) {
+        plugins.push(robotsPlugin());
+    }
+    if (opts.seo) {
+        plugins.push(seoPlugin());
+    }
+    return plugins;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "fimo-vite",
+  "version": "0.21.0-experimental.1",
+  "description": "Framework-neutral Fimo Vite plugin. Pairs with the fimo package at the same version.",
+  "files": [
+    "dist/",
+    "!dist/**/*.d.ts.map",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "check:types": "tsc -b tsconfig.json --noEmit",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.1.0",
+    "oxc-parser": "^0.118.0"
+  },
+  "devDependencies": {
+    "@fimo/tsconfig": "0.21.0-experimental.1",
+    "@types/node": "^22.15.29",
+    "fimo": "0.21.0-experimental.1",
+    "typescript": "7.0.2",
+    "vite": "^8.0.13",
+    "vitest": "^4.1.6"
+  },
+  "peerDependencies": {
+    "fimo": ">=0.14.0",
+    "vite": "^7.0.0 || ^8.0.0"
+  },
+  "engines": {
+    "node": ">=20.12.0"
+  }
+}