fimo-vite 0.21.0-experimental.1

package/README.md

@@ -0,0 +1,24 @@
+# fimo-vite
+
+The framework-neutral Fimo integration for projects that build with Vite.
+Install it alongside `fimo` at the same version:
+
+```bash
+npm install fimo fimo-vite
+```
+
+```ts
+import { defineConfig } from 'vite';
+import { fimo } from 'fimo-vite';
+
+export default defineConfig({
+  plugins: [fimo({ seo: true })],
+});
+```
+
+Nothing here depends on React, React Router, Svelte, or any other UI framework:
+it is the config virtual module, the label/content dev bridge, the JSX
+`data-fimo-id` tagger, the dev error overlay, and the opt-in `sitemap` /
+`robots` / `seo` emitters. Framework packages compose it — React Router
+projects use `fimo-react-router/vite`, which adds the router-specific
+dependency-optimization behaviour on top of this plugin set.

package/dist/plugins/content-sync.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+/**
+ * Keeps generated schema + form clients in sync while the Vite dev server is
+ * running.
+ *
+ * Production builds are deliberately read-only. Explicit authoring commands
+ * (`fimo validate`, `fimo schemas push`, and `fimo forms push`) own initial
+ * generation before a build starts.
+ */
+export default function contentSyncPlugin(): Plugin;
+//# sourceMappingURL=content-sync.d.ts.map

package/dist/plugins/content-sync.js

@@ -0,0 +1,40 @@
+import { resolve } from 'path';
+import { syncForms, syncSchemas } from 'fimo/sync';
+/**
+ * Keeps generated schema + form clients in sync while the Vite dev server is
+ * running.
+ *
+ * Production builds are deliberately read-only. Explicit authoring commands
+ * (`fimo validate`, `fimo schemas push`, and `fimo forms push`) own initial
+ * generation before a build starts.
+ */
+export default function contentSyncPlugin() {
+    let rootDir = process.cwd();
+    return {
+        name: 'vite-plugin-fimo-content-sync',
+        enforce: 'pre',
+        configResolved(config) {
+            rootDir = config.root;
+        },
+        configureServer(server) {
+            const schemasGlob = resolve(rootDir, 'src/schemas');
+            const formsGlob = resolve(rootDir, 'src/forms');
+            server.watcher.add([schemasGlob, formsGlob]);
+            server.watcher.on('add', onChange);
+            server.watcher.on('change', onChange);
+            server.watcher.on('unlink', onChange);
+            function onChange(file) {
+                if (!file.endsWith('.json')) {
+                    return;
+                }
+                if (file.startsWith(schemasGlob)) {
+                    syncSchemas({ cwd: rootDir, framework: 'vite', verbose: false });
+                    return;
+                }
+                if (file.startsWith(formsGlob)) {
+                    syncForms({ cwd: rootDir, verbose: false });
+                }
+            }
+        },
+    };
+}

package/dist/plugins/data-id.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export default function dataIdPlugin(): Plugin;
+//# sourceMappingURL=data-id.d.ts.map

package/dist/plugins/data-id.js

@@ -0,0 +1,98 @@
+import { createFilter } from '@rollup/pluginutils';
+import { getLineColumn } from 'fimo/vite/data-id';
+import { parseSync } from 'oxc-parser';
+export default function dataIdPlugin() {
+    let config;
+    return {
+        name: 'vite-plugin-data-id',
+        enforce: 'pre',
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
+        async transform(code, id) {
+            if (config?.command === 'build') {
+                return null;
+            }
+            const filter = createFilter(/\.(jsx|tsx)$/);
+            if (!filter(id)) {
+                return null;
+            }
+            if (id.includes('components/ui/') || id.includes('.fimo/ui/')) {
+                return null;
+            }
+            try {
+                const result = parseSync(id, code);
+                const ast = result.program;
+                const insertions = [];
+                function visit(node) {
+                    if (!node || typeof node !== 'object') {
+                        return;
+                    }
+                    if (node.type === 'JSXOpeningElement') {
+                        const attributes = node.attributes || [];
+                        const hasId = attributes.some((attr) => attr.type === 'JSXAttribute' &&
+                            attr.name?.type === 'JSXIdentifier' &&
+                            attr.name?.name === 'data-fimo-id');
+                        if (!hasId && node.start != null) {
+                            const line = getLineColumn(code, node.start);
+                            const relativePath = id.replace(process.cwd() + '/', '');
+                            const fimoId = `${relativePath}#${line.line}-${line.column}`;
+                            const nameEnd = getNameEnd(node);
+                            insertions.push({
+                                offset: nameEnd,
+                                value: ` data-fimo-id="${fimoId}"`,
+                            });
+                        }
+                    }
+                    for (const key of Object.keys(node)) {
+                        if (key === 'parent') {
+                            continue;
+                        }
+                        const child = node[key];
+                        if (Array.isArray(child)) {
+                            for (const item of child) {
+                                visit(item);
+                            }
+                        }
+                        else if (typeof child === 'object' && child !== null) {
+                            visit(child);
+                        }
+                    }
+                }
+                visit(ast);
+                if (insertions.length === 0) {
+                    return null;
+                }
+                insertions.sort((a, b) => b.offset - a.offset);
+                let transformed = code;
+                for (const insertion of insertions) {
+                    transformed = transformed.slice(0, insertion.offset) + insertion.value + transformed.slice(insertion.offset);
+                }
+                return {
+                    code: transformed,
+                    map: null,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+/**
+ * Offset just past the element's name (or its type arguments), which is where
+ * an extra attribute can be spliced in without shifting any other token.
+ *
+ * The `<path>#<line>-<column>` id itself comes from `fimo/vite/data-id`, shared
+ * with the SvelteKit plugin, so the convention cannot drift between them.
+ */
+function getNameEnd(openingElement) {
+    const name = openingElement.name;
+    if (name?.end != null) {
+        if (openingElement.typeParameters?.end != null) {
+            return openingElement.typeParameters.end;
+        }
+        return name.end;
+    }
+    return openingElement.start;
+}

package/dist/plugins/fimo-config.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that exposes the user's `.fimo/config.json`:
+ * - As a virtual module `virtual:fimo-config` that browser-running package
+ *   code (fimo/seo, fimo/app) imports to read `seo`, `routes`, etc. without
+ *   relying on `readFileSync` at runtime.
+ *
+ * Edits to the project config invalidate the virtual module so HMR picks up
+ * the new values without a full reload.
+ */
+export default function fimoConfigPlugin(): Plugin;
+//# sourceMappingURL=fimo-config.d.ts.map

package/dist/plugins/fimo-config.js

@@ -0,0 +1,68 @@
+import { readFileSync } from 'fs';
+import { resolveFimoConfigPath } from 'fimo/config';
+const VIRTUAL_ID = 'virtual:fimo-config';
+const RESOLVED_ID = '\0' + VIRTUAL_ID;
+/**
+ * Vite plugin that exposes the user's `.fimo/config.json`:
+ * - As a virtual module `virtual:fimo-config` that browser-running package
+ *   code (fimo/seo, fimo/app) imports to read `seo`, `routes`, etc. without
+ *   relying on `readFileSync` at runtime.
+ *
+ * Edits to the project config invalidate the virtual module so HMR picks up
+ * the new values without a full reload.
+ */
+export default function fimoConfigPlugin() {
+    let configPath = resolveFimoConfigPath(process.cwd());
+    return {
+        name: 'vite-plugin-fimo-config',
+        config(userConfig) {
+            const root = typeof userConfig.root === 'string' ? userConfig.root : process.cwd();
+            configPath = resolveFimoConfigPath(root);
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_ID) {
+                return RESOLVED_ID;
+            }
+            return null;
+        },
+        load(id) {
+            if (id !== RESOLVED_ID) {
+                return null;
+            }
+            this.addWatchFile(configPath);
+            try {
+                const raw = readFileSync(configPath, 'utf-8');
+                return `export default ${raw};`;
+            }
+            catch {
+                return 'export default {};';
+            }
+        },
+        transformIndexHtml(html) {
+            const lang = readHtmlLang(configPath);
+            if (/<html\b[^>]*\blang=/.test(html)) {
+                return html.replace(/(<html\b[^>]*\blang=["'])[^"']*(["'])/i, `$1${lang}$2`);
+            }
+            return html.replace(/<html\b([^>]*)>/i, `<html$1 lang="${lang}">`);
+        },
+        handleHotUpdate(ctx) {
+            if (ctx.file !== configPath) {
+                return;
+            }
+            const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_ID);
+            if (mod) {
+                ctx.server.moduleGraph.invalidateModule(mod);
+                return [mod];
+            }
+        },
+    };
+}
+function readHtmlLang(configPath) {
+    try {
+        const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+        return (raw.i18n?.defaultLocale ?? 'en').replace('_', '-');
+    }
+    catch {
+        return 'en';
+    }
+}

package/dist/plugins/overlay.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export default function overlayPlugin(): Plugin;
+//# sourceMappingURL=overlay.d.ts.map

package/dist/plugins/overlay.js

@@ -0,0 +1,153 @@
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+// Compiled overlay runtime lives at `dist/runtime/*.js` once this package is
+// built. The plugin lives at `dist/plugins/overlay.js`, so it walks back to
+// `dist` and then into the sibling runtime directory.
+function resolveRuntimeDir() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return resolve(here, '..', 'runtime');
+}
+// Two virtual modules so a framework's script connector can wire both halves
+// of the overlay:
+//
+//   `virtual:fimo-overlay-runtime` — exports the runtime source as a string,
+//      to be embedded inline. Handles window.error + unhandledrejection + DOM
+//      overlay. Inline because we want it loaded as early as possible.
+//
+//   `virtual:fimo-overlay-hmr` — a real ES module (side-effect import).
+//      Handles vite:error / vite:afterUpdate. Must be vite-transformed so
+//      `import.meta.hot` is defined; inline scripts bypass vite's transform.
+//
+// In production both resolve to no-ops so the overlay machinery is dev-only.
+// The previous `transformIndexHtml` approach only fired when vite served an
+// `index.html`, which react-router framework mode bypasses entirely.
+const VIRTUAL_RUNTIME = 'virtual:fimo-overlay-runtime';
+const VIRTUAL_HMR = 'virtual:fimo-overlay-hmr';
+// When the user's code has a parse / load error at the time of a full page
+// request (e.g. hard reload while the file is broken, or cold-loading the
+// preview iframe against a broken sandbox), vite serves a 500 HTML response
+// containing the structured error as a JS object literal:
+//
+//   <script type="module">
+//     const error = { message, stack, id, frame, pluginCode, ... };
+//     const { ErrorOverlay } = await import("/@vite/client");
+//     document.body.appendChild(new ErrorOverlay(error));
+//   </script>
+//
+// In framework mode, none of the user's modules — including the inline
+// overlay-runtime and the side-effect HMR import — ever load on this kind of
+// response, so the parent UI is left blind. We extract that object literal
+// and append a script that postMessages it to `window.parent` using the same
+// `preview/error` + `app/error` shape the runtime uses, so the dashboard's
+// overlay state machine fires identically to the HMR path.
+function injectErrorForwarder(html) {
+    // Vite's error page structure:
+    //   const error = { ...escaped JSON including the whole source as
+    //   `pluginCode` (which contains its own `};` sequences) }
+    //   <newline + spaces>try {
+    // Anchor on `try {` (which always immediately follows) so the lazy
+    // matcher backtracks past `}` sequences embedded inside the source.
+    // The trailing `;` is optional — vite relies on ASI here.
+    const match = html.match(/const error = (\{[\s\S]*?\})\s*;?\s*try\s*\{/);
+    if (!match)
+        return html;
+    const errorLiteral = match[1];
+    const script = '<script>(function(){try{var e=' +
+        errorLiteral +
+        ';if(window.parent&&window.parent!==window){' +
+        'var p={heading:"Build Error",message:(e&&e.message)||"",stack:(e&&e.stack)||""};' +
+        'window.parent.postMessage({type:"preview/error",payload:p},"*");' +
+        'window.parent.postMessage({type:"app/error",payload:p},"*");' +
+        '}}catch(_){}}());</script>';
+    if (html.includes('</body>'))
+        return html.replace('</body>', script + '</body>');
+    return html + script;
+}
+export default function overlayPlugin() {
+    let isDev = false;
+    return {
+        name: 'vite-plugin-overlay',
+        config(_, env) {
+            isDev = env.command === 'serve';
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_RUNTIME || id === VIRTUAL_HMR)
+                return id;
+            return undefined;
+        },
+        load(id) {
+            if (id === VIRTUAL_RUNTIME) {
+                if (!isDev)
+                    return 'export default "";';
+                try {
+                    const runtime = readFileSync(resolve(resolveRuntimeDir(), 'overlay-runtime.js'), 'utf-8');
+                    return `export default ${JSON.stringify(runtime)};`;
+                }
+                catch {
+                    return 'export default "";';
+                }
+            }
+            if (id === VIRTUAL_HMR) {
+                if (!isDev)
+                    return 'export {};';
+                try {
+                    return readFileSync(resolve(resolveRuntimeDir(), 'overlay-hmr.js'), 'utf-8');
+                }
+                catch {
+                    return 'export {};';
+                }
+            }
+            return undefined;
+        },
+        configureServer(server) {
+            server.middlewares.use((_req, res, next) => {
+                const chunks = [];
+                const origWrite = res.write.bind(res);
+                const origEnd = res.end.bind(res);
+                let capturing = false;
+                // Capture every 500 response; sniff by body content in
+                // `injectErrorForwarder` since vite emits its error page without a
+                // Content-Type at the moment res.end() is called.
+                const shouldCapture = () => res.statusCode === 500;
+                // The Connect / Node response.write & end signatures accept Buffer
+                // | string | Uint8Array; we accept everything and normalise to Buffer
+                // so concat works regardless of how vite chose to emit the chunks.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                res.write = function (chunk, ...rest) {
+                    if (!capturing && shouldCapture())
+                        capturing = true;
+                    if (capturing) {
+                        if (chunk)
+                            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                        return true;
+                    }
+                    return origWrite(chunk, ...rest);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                res.end = function (chunk, ...rest) {
+                    if (!capturing && shouldCapture())
+                        capturing = true;
+                    if (!capturing)
+                        return origEnd(chunk, ...rest);
+                    if (chunk)
+                        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                    const html = injectErrorForwarder(Buffer.concat(chunks).toString('utf8'));
+                    const body = Buffer.from(html, 'utf8');
+                    // Vite sets Content-Length before us; rewrite to match the new body.
+                    try {
+                        res.setHeader('content-length', String(body.byteLength));
+                    }
+                    catch {
+                        // Headers already sent — ignore, content-length will be wrong but
+                        // browsers tolerate trailing data on HTTP/1.1 keep-alive.
+                    }
+                    return origEnd(body, ...rest);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
+                next();
+            });
+        },
+    };
+}

package/dist/plugins/robots.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+/**
+ * Emit a minimal `robots.txt` (allow-all + Sitemap reference if `seo.url` is
+ * set in `.fimo/config.json`). Serves at `/robots.txt` in dev; emits as a
+ * static asset at build time.
+ *
+ * Opt-in via `fimo({ robots: true })` in your `vite.config.ts`.
+ */
+export default function robotsPlugin(): Plugin;
+//# sourceMappingURL=robots.d.ts.map

package/dist/plugins/robots.js

@@ -0,0 +1,56 @@
+import { readFileSync } from 'fs';
+import { resolveFimoConfigPath } from 'fimo/config';
+function readSeoUrl() {
+    try {
+        const raw = readFileSync(resolveFimoConfigPath(process.cwd()), 'utf-8');
+        const config = JSON.parse(raw);
+        return config.seo?.url;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildRobotsTxt(baseUrl) {
+    const lines = ['User-agent: *', 'Allow: /'];
+    if (baseUrl) {
+        try {
+            const sitemapUrl = new URL('/sitemap.xml', baseUrl).toString();
+            lines.push('', `Sitemap: ${sitemapUrl}`);
+        }
+        catch {
+            // Invalid baseUrl — skip the Sitemap directive.
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+/**
+ * Emit a minimal `robots.txt` (allow-all + Sitemap reference if `seo.url` is
+ * set in `.fimo/config.json`). Serves at `/robots.txt` in dev; emits as a
+ * static asset at build time.
+ *
+ * Opt-in via `fimo({ robots: true })` in your `vite.config.ts`.
+ */
+export default function robotsPlugin() {
+    return {
+        name: 'fimo:robots',
+        configureServer(server) {
+            server.middlewares.use((req, res, next) => {
+                if (req.url?.split('?')[0] !== '/robots.txt') {
+                    next();
+                    return;
+                }
+                const baseUrl = readSeoUrl();
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+                res.end(buildRobotsTxt(baseUrl));
+            });
+        },
+        generateBundle() {
+            const baseUrl = readSeoUrl();
+            this.emitFile({
+                type: 'asset',
+                fileName: 'robots.txt',
+                source: buildRobotsTxt(baseUrl),
+            });
+        },
+    };
+}

package/dist/plugins/seo.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export default function seoPlugin(): Plugin;
+//# sourceMappingURL=seo.d.ts.map

package/dist/plugins/seo.js

@@ -0,0 +1,112 @@
+import { getConfigServer } from 'fimo/config';
+import { normalizePathname, resolveSeoForPath } from 'fimo/seo';
+class HtmlTag {
+    tags = [];
+    addMeta(name, content) {
+        this.tags.push({ tag: 'meta', attrs: { name, content } });
+    }
+    addProperty(property, content) {
+        this.tags.push({ tag: 'meta', attrs: { property, content } });
+    }
+    addLink(rel, href) {
+        this.tags.push({ tag: 'link', attrs: { rel, href } });
+    }
+    list() {
+        return this.tags;
+    }
+}
+export default function seoPlugin() {
+    let rootDir;
+    return {
+        name: 'vite-plugin-seo',
+        configResolved(config) {
+            rootDir = config.root;
+        },
+        transformIndexHtml(html, ctx) {
+            try {
+                const config = getConfigServer(rootDir);
+                const pathname = normalizePathname(ctx?.path ?? '/');
+                const seo = resolveSeoForPath(pathname, config);
+                if (!seo) {
+                    return html;
+                }
+                let nextHtml = html;
+                if (seo.title) {
+                    if (/<title>[\s\S]*?<\/title>/.test(nextHtml)) {
+                        nextHtml = nextHtml.replace(/<title>[\s\S]*?<\/title>/, `<title>${seo.title}</title>`);
+                    }
+                    else {
+                        nextHtml = nextHtml.replace('<head>', `<head>\n    <title>${seo.title}</title>`);
+                    }
+                }
+                // Remove existing meta/link tags that we will re-inject to avoid duplication
+                // (e.g. when the source index.html already contains og:/twitter: tags from the user's original site)
+                nextHtml = nextHtml
+                    .replace(/<meta\b[^>]*\bname=["']description["'][^>]*>/gi, '')
+                    .replace(/<meta\b[^>]*\bname=["']robots["'][^>]*>/gi, '')
+                    .replace(/<meta\b[^>]*\bname=["']theme-color["'][^>]*>/gi, '')
+                    .replace(/<meta\b[^>]*\b(?:name|property)=["']og:[^"']*["'][^>]*>/gi, '')
+                    .replace(/<meta\b[^>]*\b(?:name|property)=["']twitter:[^"']*["'][^>]*>/gi, '')
+                    .replace(/<link\b[^>]*\brel=["']canonical["'][^>]*>/gi, '');
+                if (seo.favicon) {
+                    nextHtml = nextHtml.replace(/<link\b[^>]*\brel=(?:"[^"]*icon[^"]*"|'[^']*icon[^']*'|[^>\s]*icon[^>\s]*)[^>]*>/gi, '');
+                }
+                const tags = new HtmlTag();
+                if (seo.description) {
+                    tags.addMeta('description', seo.description);
+                }
+                if (seo.robots) {
+                    tags.addMeta('robots', seo.robots);
+                }
+                if (seo.themeColor) {
+                    tags.addMeta('theme-color', seo.themeColor);
+                }
+                if (seo.url) {
+                    tags.addLink('canonical', seo.url);
+                }
+                if (seo.favicon) {
+                    tags.addLink('icon', seo.favicon);
+                    tags.addLink('apple-touch-icon', seo.favicon);
+                }
+                // Open Graph (must use property attribute, not name)
+                if (seo.title) {
+                    tags.addProperty('og:title', seo.title);
+                }
+                if (seo.description) {
+                    tags.addProperty('og:description', seo.description);
+                }
+                tags.addProperty('og:type', 'website');
+                if (seo.url) {
+                    tags.addProperty('og:url', seo.url);
+                }
+                if (seo.siteName) {
+                    tags.addProperty('og:site_name', seo.siteName);
+                }
+                if (seo.locale) {
+                    tags.addProperty('og:locale', seo.locale);
+                }
+                if (seo.image) {
+                    tags.addProperty('og:image', seo.image);
+                }
+                // Twitter
+                tags.addMeta('twitter:card', 'summary_large_image');
+                if (seo.twitterSite) {
+                    tags.addMeta('twitter:site', seo.twitterSite);
+                }
+                if (seo.title) {
+                    tags.addMeta('twitter:title', seo.title);
+                }
+                if (seo.description) {
+                    tags.addMeta('twitter:description', seo.description);
+                }
+                if (seo.image) {
+                    tags.addMeta('twitter:image', seo.image);
+                }
+                return { html: nextHtml, tags: tags.list() };
+            }
+            catch {
+                return html;
+            }
+        },
+    };
+}

package/dist/plugins/server-config.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export default function serverConfigPlugin(): Plugin;
+//# sourceMappingURL=server-config.d.ts.map

package/dist/plugins/server-config.js

@@ -0,0 +1,36 @@
+const PREVIEW_ORIGINS_ENV = 'FIMO_PREVIEW_ALLOWED_ORIGINS';
+function readPreviewHosts() {
+    return (process.env[PREVIEW_ORIGINS_ENV] ?? '')
+        .split(',')
+        .map((origin) => origin.trim())
+        .filter(Boolean)
+        .map((origin) => (origin.startsWith('**.') ? `.${origin.slice(3)}` : origin));
+}
+export default function serverConfigPlugin() {
+    return {
+        name: 'fimo:server-config',
+        config(config) {
+            const configuredHosts = config.server?.allowedHosts;
+            const previewHosts = readPreviewHosts();
+            const allowedHosts = configuredHosts === true
+                ? true
+                : [...(configuredHosts ?? []), ...previewHosts].filter((host, index, hosts) => hosts.indexOf(host) === index);
+            return {
+                server: {
+                    ...(allowedHosts === true || allowedHosts.length > 0 ? { allowedHosts } : {}),
+                    hmr: {
+                        overlay: false,
+                    },
+                    watch: {
+                        ignored: ['**/.worktrees/**', '**/.fimo/config.json', '**/fimo-config.json'],
+                    },
+                },
+                build: {},
+                optimizeDeps: {
+                    include: [],
+                    exclude: [],
+                },
+            };
+        },
+    };
+}

package/dist/plugins/sitemap.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export default function sitemapPlugin(): Plugin;
+//# sourceMappingURL=sitemap.d.ts.map