@webround/editor 0.0.0-stage → 0.3.0

package/dist/vite-plugins/langs.d.ts

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

package/dist/vite-plugins/langs.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+const WR_LANGS_VIRTUAL_ID = 'virtual:wr-langs';
+const WR_LANGS_RESOLVED_ID = '\0' + WR_LANGS_VIRTUAL_ID;
+export function wrLangsPlugin() {
+    const langsPath = path.resolve(process.cwd(), 'src', 'config', 'langs.json');
+    function generate() {
+        if (!fs.existsSync(langsPath)) {
+            return `export const langs = null;\n`;
+        }
+        const langs = JSON.parse(fs.readFileSync(langsPath, 'utf-8'));
+        return `export const langs = ${JSON.stringify(langs)};\n`;
+    }
+    function invalidate(server) {
+        const mod = server.moduleGraph.getModuleById(WR_LANGS_RESOLVED_ID);
+        if (mod) {
+            server.moduleGraph.invalidateModule(mod);
+            server.ws.send({ type: 'full-reload' });
+        }
+    }
+    return {
+        name: 'wr-langs',
+        resolveId(id) {
+            if (id === WR_LANGS_VIRTUAL_ID)
+                return WR_LANGS_RESOLVED_ID;
+        },
+        load(id) {
+            if (id !== WR_LANGS_RESOLVED_ID)
+                return;
+            this.addWatchFile(langsPath);
+            return generate();
+        },
+        configureServer(server) {
+            server.watcher.add(langsPath);
+            const onFsEvent = (file) => {
+                if (path.resolve(file) === langsPath)
+                    invalidate(server);
+            };
+            server.watcher.on('add', onFsEvent);
+            server.watcher.on('change', onFsEvent);
+        },
+    };
+}
+//# sourceMappingURL=langs.js.map

package/dist/vite-plugins/operations.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+/**
+ * The one door of the editor's page into the project: `POST /wr/op/<name>` with the input as JSON runs an operation (see operations/).
+ * Only the page itself may call it (the same-origin guard of every /wr/* route: the editor's parent, another site and anything that is
+ * not a browser on this page are refused) — whoever else works on the project does it through `wr-op` and the container's tools.
+ *   200 { ok: true, data }          the operation's answer
+ *   4xx/5xx { ok: false, code, error }   why not
+ */
+export declare function wrOperationsPlugin(): Plugin;
+//# sourceMappingURL=operations.d.ts.map

package/dist/vite-plugins/operations.js

@@ -0,0 +1,66 @@
+import { createOperationContext } from '../operations/context.js';
+import { OperationError } from '../operations/define.js';
+import { createRegistry } from '../operations/registry.js';
+import { wrRoute } from './guard.js';
+const BODY_MAX_BYTES = 4 * 1024 * 1024;
+/**
+ * The one door of the editor's page into the project: `POST /wr/op/<name>` with the input as JSON runs an operation (see operations/).
+ * Only the page itself may call it (the same-origin guard of every /wr/* route: the editor's parent, another site and anything that is
+ * not a browser on this page are refused) — whoever else works on the project does it through `wr-op` and the container's tools.
+ *   200 { ok: true, data }          the operation's answer
+ *   4xx/5xx { ok: false, code, error }   why not
+ */
+export function wrOperationsPlugin() {
+    const registry = createRegistry();
+    const ctx = createOperationContext(process.cwd());
+    return {
+        name: 'wr-operations',
+        configureServer(server) {
+            wrRoute(server, '/wr/op', (req, res) => {
+                const send = (status, payload) => {
+                    res.statusCode = status;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify(payload));
+                };
+                const name = /^\/([a-z][a-z0-9-]*)\/?$/.exec((req.url ?? '').split('?')[0])?.[1];
+                if (req.method !== 'POST' || !name) {
+                    res.statusCode = req.method === 'POST' ? 404 : 405;
+                    res.end();
+                    return;
+                }
+                const chunks = [];
+                let size = 0;
+                req.on('data', (chunk) => {
+                    size += chunk.length;
+                    if (size <= BODY_MAX_BYTES)
+                        chunks.push(chunk);
+                });
+                req.on('end', async () => {
+                    if (size > BODY_MAX_BYTES) {
+                        send(413, { ok: false, code: 'too-large', error: 'body too large' });
+                        return;
+                    }
+                    try {
+                        const body = Buffer.concat(chunks).toString('utf-8');
+                        const input = body.trim() ? JSON.parse(body) : {};
+                        const data = await registry.run(name, input, ctx);
+                        send(200, { ok: true, data });
+                    }
+                    catch (err) {
+                        if (err instanceof OperationError) {
+                            send(err.status, { ok: false, code: err.code, error: err.message });
+                            return;
+                        }
+                        if (err instanceof SyntaxError) {
+                            send(400, { ok: false, code: 'invalid-input', error: 'the body is not JSON' });
+                            return;
+                        }
+                        console.error(`[wr-op] ${name} failed:`, err);
+                        send(500, { ok: false, code: 'internal', error: err instanceof Error ? err.message : String(err) });
+                    }
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=operations.js.map

package/dist/vite-plugins/pages-api.d.ts

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

package/dist/vite-plugins/pages-api.js

@@ -0,0 +1,112 @@
+import fs from 'fs';
+import path from 'path';
+import { SRC_ROOT, isSafePageName, isSafeComponentName, wrRoute } from './guard.js';
+export function wrPagesApiPlugin() {
+    return {
+        name: 'wr-pages-api',
+        configureServer(server) {
+            wrRoute(server, '/wr/pages', (req, res) => {
+                const routesPath = path.join(SRC_ROOT, 'config', 'routes.json');
+                if (req.method === 'GET') {
+                    const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify(routes));
+                    return;
+                }
+                if (req.method === 'DELETE' || req.method === 'PATCH') {
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        try {
+                            const payload = body ? JSON.parse(body) : {};
+                            const { pageName } = payload;
+                            if (!isSafePageName(pageName)) {
+                                res.statusCode = 400;
+                                res.end(JSON.stringify({ error: 'invalid pageName' }));
+                                return;
+                            }
+                            const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+                            const entry = routes[pageName];
+                            if (!entry) {
+                                res.statusCode = 404;
+                                res.end(JSON.stringify({ error: 'page not found' }));
+                                return;
+                            }
+                            if (!isSafeComponentName(entry.component)) {
+                                res.statusCode = 500;
+                                res.end(JSON.stringify({ error: 'invalid component in routes.json' }));
+                                return;
+                            }
+                            const pagePath = path.join(SRC_ROOT, 'config', 'pages', `${pageName}.json`);
+                            const componentPath = path.join(SRC_ROOT, 'pages', `${entry.component}.tsx`);
+                            if (req.method === 'DELETE') {
+                                if (fs.existsSync(pagePath))
+                                    fs.unlinkSync(pagePath);
+                                if (fs.existsSync(componentPath))
+                                    fs.unlinkSync(componentPath);
+                                delete routes[pageName];
+                                fs.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+                                res.end(JSON.stringify({ ok: true }));
+                                return;
+                            }
+                            // PATCH: rename route key e/o component
+                            const { newPageName, newComponent, lazy, header, footer } = payload;
+                            const finalPageName = newPageName ?? pageName;
+                            const finalComponent = newComponent ?? entry.component;
+                            if (!isSafePageName(finalPageName) || !isSafeComponentName(finalComponent)) {
+                                res.statusCode = 400;
+                                res.end(JSON.stringify({ error: 'invalid newPageName or newComponent' }));
+                                return;
+                            }
+                            if (finalPageName !== pageName && routes[finalPageName]) {
+                                res.statusCode = 409;
+                                res.end(JSON.stringify({ error: 'target page name already exists' }));
+                                return;
+                            }
+                            const newPagePath = path.join(SRC_ROOT, 'config', 'pages', `${finalPageName}.json`);
+                            const newComponentPath = path.join(SRC_ROOT, 'pages', `${finalComponent}.tsx`);
+                            if (fs.existsSync(pagePath) && pagePath !== newPagePath) {
+                                fs.mkdirSync(path.dirname(newPagePath), { recursive: true });
+                                fs.renameSync(pagePath, newPagePath);
+                            }
+                            if (fs.existsSync(componentPath) && componentPath !== newComponentPath) {
+                                fs.mkdirSync(path.dirname(newComponentPath), { recursive: true });
+                                fs.renameSync(componentPath, newComponentPath);
+                            }
+                            delete routes[pageName];
+                            // La voce si conserva (header/footer e quello che verrà): si cambia solo ciò che la richiesta dice.
+                            // `true` è il default di header e footer e non si scrive.
+                            const next = { ...entry, component: finalComponent };
+                            if (lazy !== undefined) {
+                                if (lazy)
+                                    next.lazy = true;
+                                else
+                                    delete next.lazy;
+                            }
+                            for (const [key, value] of [['header', header], ['footer', footer]]) {
+                                if (value === undefined)
+                                    continue;
+                                if (value === false)
+                                    next[key] = false;
+                                else
+                                    delete next[key];
+                            }
+                            routes[finalPageName] = next;
+                            fs.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+                            res.end(JSON.stringify({ ok: true, pageName: finalPageName }));
+                        }
+                        catch (err) {
+                            console.error('[wr-pages-api] failed:', err);
+                            res.statusCode = 500;
+                            res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                        }
+                    });
+                    return;
+                }
+                res.statusCode = 405;
+                res.end();
+            });
+        }
+    };
+}
+//# sourceMappingURL=pages-api.js.map

package/dist/vite-plugins/pages.d.ts

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

package/dist/vite-plugins/pages.js

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+const WR_PAGES_VIRTUAL_ID = 'virtual:wr-pages';
+const WR_PAGES_RESOLVED_ID = '\0' + WR_PAGES_VIRTUAL_ID;
+export function wrPagesPlugin() {
+    const routesPath = path.resolve(process.cwd(), 'src', 'config', 'routes.json');
+    function generate() {
+        const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+        const eagerImports = [];
+        const eagerEntries = [];
+        const lazyEntries = [];
+        // The modules are by component: two routes that show the same component (`shop` and `shop/[slug]`) are one module
+        const seen = new Set();
+        for (const entry of Object.values(routes)) {
+            if (seen.has(entry.component))
+                continue;
+            seen.add(entry.component);
+            if (entry.lazy) {
+                lazyEntries.push(`  ${JSON.stringify(entry.component)}: () => import('/src/pages/${entry.component}.tsx'),`);
+            }
+            else {
+                const varName = `Page_${entry.component}`;
+                eagerImports.push(`import * as ${varName} from '/src/pages/${entry.component}.tsx';`);
+                eagerEntries.push(`  ${JSON.stringify(entry.component)}: ${varName},`);
+            }
+        }
+        return `${eagerImports.join('\n')}
+
+export const eagerModules = {
+${eagerEntries.join('\n')}
+};
+
+export const lazyModules = {
+${lazyEntries.join('\n')}
+};
+`;
+    }
+    return {
+        name: 'wr-pages',
+        resolveId(id) {
+            if (id === WR_PAGES_VIRTUAL_ID)
+                return WR_PAGES_RESOLVED_ID;
+        },
+        load(id) {
+            if (id !== WR_PAGES_RESOLVED_ID)
+                return;
+            this.addWatchFile(routesPath);
+            return generate();
+        },
+        configureServer(server) {
+            server.watcher.add(routesPath);
+            server.watcher.on('change', (file) => {
+                if (path.resolve(file) === routesPath) {
+                    const mod = server.moduleGraph.getModuleById(WR_PAGES_RESOLVED_ID);
+                    if (mod) {
+                        server.moduleGraph.invalidateModule(mod);
+                        server.ws.send({ type: 'full-reload' });
+                    }
+                }
+            });
+        },
+    };
+}
+//# sourceMappingURL=pages.js.map

package/dist/vite-plugins/read.d.ts

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

package/dist/vite-plugins/read.js

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import { resolveInSrc, wrRoute } from './guard.js';
+export function wrReadPlugin() {
+    return {
+        name: 'wr-read',
+        configureServer(server) {
+            wrRoute(server, '/wr/read', (req, res) => {
+                if (req.method !== 'GET') {
+                    res.statusCode = 405;
+                    res.end();
+                    return;
+                }
+                try {
+                    const url = new URL(req.url ?? '', 'http://localhost');
+                    const file = url.searchParams.get('file');
+                    if (!file) {
+                        res.statusCode = 400;
+                        res.end(JSON.stringify({ error: 'file query param required' }));
+                        return;
+                    }
+                    const filePath = resolveInSrc(file);
+                    if (!filePath) {
+                        res.statusCode = 400;
+                        res.end(JSON.stringify({ error: 'invalid file path' }));
+                        return;
+                    }
+                    if (!fs.existsSync(filePath)) {
+                        res.setHeader('Content-Type', 'application/json');
+                        res.end(JSON.stringify(null));
+                        return;
+                    }
+                    const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify(content));
+                }
+                catch (err) {
+                    console.error('[wr-read] failed:', err);
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                }
+            });
+        }
+    };
+}
+//# sourceMappingURL=read.js.map

package/dist/vite-plugins/seo-files.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'vite';
+/**
+ * Keeps `public/robots.txt`, `sitemap-index.xml` and `sitemap-pages.xml` true: written when the dev server starts and again whenever the
+ * pages, the languages or the SEO data change — from the editor, from VS Code, from `wr`, from anywhere. The user never has to think
+ * about them. What to write is `wrSeoFiles` (core); this only decides when.
+ */
+export declare function wrSeoFilesPlugin(): Plugin;
+//# sourceMappingURL=seo-files.d.ts.map

package/dist/vite-plugins/seo-files.js

@@ -0,0 +1,42 @@
+import path from 'path';
+import { createOperationContext } from '../operations/context.js';
+import { writeSeoFiles } from '../operations/ops/seo.js';
+const DEBOUNCE_MS = 250;
+/**
+ * Keeps `public/robots.txt`, `sitemap-index.xml` and `sitemap-pages.xml` true: written when the dev server starts and again whenever the
+ * pages, the languages or the SEO data change — from the editor, from VS Code, from `wr`, from anywhere. The user never has to think
+ * about them. What to write is `wrSeoFiles` (core); this only decides when.
+ */
+export function wrSeoFilesPlugin() {
+    const ctx = createOperationContext(process.cwd());
+    const configDir = path.join(ctx.srcRoot, 'config') + path.sep;
+    const sync = () => {
+        try {
+            const { written } = writeSeoFiles(ctx);
+            if (written.length > 0)
+                console.log(`[wr-seo] wrote ${written.join(', ')}`);
+        }
+        catch (err) {
+            // A file half-saved in VS Code: the next change tries again
+            console.warn('[wr-seo] could not update the SEO files:', err instanceof Error ? err.message : err);
+        }
+    };
+    return {
+        name: 'wr-seo-files',
+        configureServer(server) {
+            sync();
+            let timer;
+            const onFsEvent = (file) => {
+                const resolved = path.resolve(file);
+                if (!resolved.startsWith(configDir) || !resolved.endsWith('.json'))
+                    return;
+                clearTimeout(timer);
+                timer = setTimeout(sync, DEBOUNCE_MS);
+            };
+            for (const event of ['add', 'change', 'unlink'])
+                server.watcher.on(event, onFsEvent);
+            server.httpServer?.once('close', () => clearTimeout(timer));
+        },
+    };
+}
+//# sourceMappingURL=seo-files.js.map

package/dist/vite-plugins/theme.d.ts

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

package/dist/vite-plugins/theme.js

@@ -0,0 +1,207 @@
+import fs from 'fs';
+import path from 'path';
+import postcss from 'postcss';
+import { SRC_ROOT, wrRoute } from './guard.js';
+function themeFilePath() {
+    return path.join(SRC_ROOT, 'theme.css');
+}
+function readTheme() {
+    const filePath = themeFilePath();
+    const content = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+    return postcss.parse(content);
+}
+function writeTheme(root) {
+    fs.writeFileSync(themeFilePath(), root.toString());
+}
+function stripQuotes(value) {
+    return value.trim().replace(/^['"]|['"]$/g, '');
+}
+function findGoogleImport(root) {
+    let found;
+    root.walkAtRules('import', (rule) => {
+        if (rule.params.includes('fonts.googleapis.com'))
+            found = rule;
+    });
+    return found;
+}
+function parseGoogleImport(rule) {
+    if (!rule)
+        return [];
+    const urlMatch = rule.params.match(/url\(['"]?([^'")]+)['"]?\)/);
+    if (!urlMatch)
+        return [];
+    const url = new URL(urlMatch[1]);
+    const entries = [];
+    for (const family of url.searchParams.getAll('family')) {
+        const [name, rest] = family.split(':');
+        const weights = rest?.startsWith('wght@') ? rest.slice('wght@'.length) : rest;
+        entries.push({ family: name.replace(/\+/g, ' '), weights });
+    }
+    return entries;
+}
+function buildGoogleImportRule(entries) {
+    const params = entries
+        .map(({ family, weights }) => `family=${family.replace(/ /g, '+')}${weights ? `:wght@${weights}` : ''}`)
+        .join('&');
+    return `url('https://fonts.googleapis.com/css2?${params}&display=swap')`;
+}
+function getThemeItems(root) {
+    const items = [];
+    root.walkRules(':root', (rule) => {
+        rule.walkDecls(/^--wr-/, (decl) => {
+            items.push({ kind: 'property', key: decl.prop, value: stripQuotes(decl.value) });
+        });
+    });
+    for (const { family, weights } of parseGoogleImport(findGoogleImport(root))) {
+        items.push({ kind: 'google-font', key: family, weights });
+    }
+    const customByFamily = new Map();
+    root.walkAtRules('font-face', (rule) => {
+        let family = '';
+        const face = { src: '' };
+        rule.walkDecls((decl) => {
+            const value = stripQuotes(decl.value);
+            if (decl.prop === 'font-family')
+                family = value;
+            else if (decl.prop === 'src')
+                face.src = decl.value;
+            else if (decl.prop === 'font-weight')
+                face.weight = decl.value;
+            else if (decl.prop === 'font-style')
+                face.style = decl.value;
+            else if (decl.prop === 'font-stretch')
+                face.stretch = decl.value;
+        });
+        if (!family)
+            return;
+        const faces = customByFamily.get(family) ?? [];
+        faces.push(face);
+        customByFamily.set(family, faces);
+    });
+    for (const [family, faces] of customByFamily) {
+        items.push({ kind: 'custom-font', key: family, faces });
+    }
+    return items;
+}
+function setProperty(root, key, value) {
+    let rootRule = root.nodes.find((n) => n.type === 'rule' && n.selector === ':root');
+    if (!rootRule) {
+        rootRule = postcss.rule({ selector: ':root' });
+        root.append(rootRule);
+    }
+    const existing = rootRule.nodes.find((n) => n.type === 'decl' && n.prop === key);
+    if (existing && existing.type === 'decl') {
+        existing.value = value;
+    }
+    else {
+        rootRule.append({ prop: key, value });
+    }
+}
+function setGoogleFont(root, family, weights) {
+    const importRule = findGoogleImport(root);
+    const entries = parseGoogleImport(importRule);
+    const idx = entries.findIndex((e) => e.family === family);
+    if (idx >= 0)
+        entries[idx] = { family, weights };
+    else
+        entries.push({ family, weights });
+    if (importRule) {
+        importRule.params = buildGoogleImportRule(entries);
+    }
+    else {
+        const newRule = postcss.atRule({ name: 'import', params: buildGoogleImportRule(entries) });
+        root.prepend(newRule); // @import deve stare in cima al file
+    }
+}
+function removeCustomFontBlocks(root, family) {
+    root.walkAtRules('font-face', (rule) => {
+        let ruleFamily = '';
+        rule.walkDecls('font-family', (decl) => { ruleFamily = stripQuotes(decl.value); });
+        if (ruleFamily === family)
+            rule.remove();
+    });
+}
+function setCustomFont(root, family, faces) {
+    removeCustomFontBlocks(root, family); // edit = replace, niente blocchi duplicati/stale
+    for (const face of faces) {
+        const rule = postcss.atRule({ name: 'font-face' });
+        rule.append({ prop: 'font-family', value: `'${family}'` });
+        rule.append({ prop: 'src', value: face.src });
+        if (face.weight)
+            rule.append({ prop: 'font-weight', value: face.weight });
+        if (face.style)
+            rule.append({ prop: 'font-style', value: face.style });
+        if (face.stretch)
+            rule.append({ prop: 'font-stretch', value: face.stretch });
+        root.append(rule);
+    }
+}
+function removeProperty(root, key) {
+    root.walkRules(':root', (rule) => {
+        rule.walkDecls(key, (decl) => { decl.remove(); });
+    });
+}
+function removeGoogleFont(root, family) {
+    const importRule = findGoogleImport(root);
+    if (!importRule)
+        return;
+    const entries = parseGoogleImport(importRule).filter((e) => e.family !== family);
+    if (entries.length === 0)
+        importRule.remove();
+    else
+        importRule.params = buildGoogleImportRule(entries);
+}
+export function wrThemePlugin() {
+    return {
+        name: 'wr-theme',
+        configureServer(server) {
+            wrRoute(server, '/wr/theme', (req, res) => {
+                if (req.method === 'GET') {
+                    const root = readTheme();
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ items: getThemeItems(root) }));
+                    return;
+                }
+                let body = '';
+                req.on('data', (chunk) => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const root = readTheme();
+                        const payload = JSON.parse(body);
+                        if (req.method === 'PUT') {
+                            const item = payload.item;
+                            if (item.kind === 'property')
+                                setProperty(root, item.key, item.value);
+                            else if (item.kind === 'google-font')
+                                setGoogleFont(root, item.key, item.weights);
+                            else if (item.kind === 'custom-font')
+                                setCustomFont(root, item.key, item.faces);
+                            writeTheme(root);
+                            res.end(JSON.stringify({ kind: item.kind, key: item.key, ok: true }));
+                            return;
+                        }
+                        if (req.method === 'DELETE') {
+                            const { kind, key } = payload;
+                            if (kind === 'property')
+                                removeProperty(root, key);
+                            else if (kind === 'google-font')
+                                removeGoogleFont(root, key);
+                            else if (kind === 'custom-font')
+                                removeCustomFontBlocks(root, key);
+                            writeTheme(root);
+                            res.end(JSON.stringify({ kind, key, ok: true }));
+                            return;
+                        }
+                        res.statusCode = 405;
+                        res.end();
+                    }
+                    catch (err) {
+                        res.statusCode = 500;
+                        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                    }
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=theme.js.map

package/dist/vite-plugins/update.d.ts

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