vite-wp 0.1.0

package/dist/live.config.d.ts

@@ -0,0 +1,64 @@
+export declare const collections: {
+    routes: import("astro/content/config").LiveCollectionConfig<import("./content.js").LiveLoader<import("./wordpress/client.js").WpResolvedRoute & Record<string, unknown>, import("./content.js").WpRouteEntryFilter, import("./content.js").WpRouteCollectionFilter>, import("zod/v4").ZodObject<{
+        kind: import("zod/v4").ZodString;
+        postType: import("zod/v4").ZodString;
+        restBase: import("zod/v4").ZodString;
+        slug: import("zod/v4").ZodString;
+    }, import("zod/v4/core").$loose>>;
+    posts: import("astro/content/config").LiveCollectionConfig<import("./content.js").LiveLoader<import("./wordpress/client.js").WpContentItem & Record<string, unknown>, import("./content.js").WpPostEntryFilter, import("./content.js").WpPostCollectionFilter>, import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodNumber;
+        slug: import("zod/v4").ZodString;
+        type: import("zod/v4").ZodString;
+        link: import("zod/v4").ZodString;
+        title: import("zod/v4").ZodObject<{
+            rendered: import("zod/v4").ZodString;
+            protected: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$loose>;
+        content: import("zod/v4").ZodObject<{
+            rendered: import("zod/v4").ZodString;
+            protected: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$loose>;
+        excerpt: import("zod/v4").ZodOptional<import("zod/v4").ZodObject<{
+            rendered: import("zod/v4").ZodString;
+            protected: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$loose>>;
+        date: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        modified: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    }, import("zod/v4/core").$loose>>;
+    pages: import("astro/content/config").LiveCollectionConfig<import("./content.js").LiveLoader<import("./wordpress/client.js").WpContentItem & Record<string, unknown>, import("./content.js").WpPostEntryFilter, import("./content.js").WpPostCollectionFilter>, import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodNumber;
+        slug: import("zod/v4").ZodString;
+        type: import("zod/v4").ZodString;
+        link: import("zod/v4").ZodString;
+        title: import("zod/v4").ZodObject<{
+            rendered: import("zod/v4").ZodString;
+            protected: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$loose>;
+        content: import("zod/v4").ZodObject<{
+            rendered: import("zod/v4").ZodString;
+            protected: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$loose>;
+        excerpt: import("zod/v4").ZodOptional<import("zod/v4").ZodObject<{
+            rendered: import("zod/v4").ZodString;
+            protected: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$loose>>;
+        date: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        modified: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    }, import("zod/v4/core").$loose>>;
+    menus: import("astro/content/config").LiveCollectionConfig<import("./content.js").LiveLoader<import("./wordpress/menus.js").WpMenu & Record<string, unknown>, import("./content.js").WpMenuEntryFilter, import("./content.js").WpMenuCollectionFilter>, import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodNumber;
+        slug: import("zod/v4").ZodString;
+        name: import("zod/v4").ZodString;
+        items: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+            id: import("zod/v4").ZodNumber;
+            parent: import("zod/v4").ZodNumber;
+            title: import("zod/v4").ZodString;
+            url: import("zod/v4").ZodString;
+            target: import("zod/v4").ZodString;
+            classes: import("zod/v4").ZodArray<import("zod/v4").ZodString>;
+            object: import("zod/v4").ZodString;
+            objectId: import("zod/v4").ZodNumber;
+            type: import("zod/v4").ZodString;
+        }, import("zod/v4/core").$loose>>;
+    }, import("zod/v4/core").$loose>>;
+};

package/dist/live.config.js

@@ -0,0 +1,21 @@
+import { defineLiveCollection } from 'astro/content/config';
+import { wpMenuLoader, wpPostTypeLoader, wpRouteLoader } from './content.js';
+import { wpContentItemSchema, wpMenuSchema, wpResolvedRouteSchema } from './wordpress/schemas.js';
+export const collections = {
+    routes: defineLiveCollection({
+        loader: wpRouteLoader(),
+        schema: wpResolvedRouteSchema,
+    }),
+    posts: defineLiveCollection({
+        loader: wpPostTypeLoader({ postType: 'post', restBase: 'posts' }),
+        schema: wpContentItemSchema,
+    }),
+    pages: defineLiveCollection({
+        loader: wpPostTypeLoader({ postType: 'page', restBase: 'pages' }),
+        schema: wpContentItemSchema,
+    }),
+    menus: defineLiveCollection({
+        loader: wpMenuLoader(),
+        schema: wpMenuSchema,
+    }),
+};

package/dist/runtime/astro.d.ts

@@ -0,0 +1,4 @@
+import type { LoadedViteWpConfig } from '../config.js';
+import { type ManagedProcess } from './process.js';
+export declare function stopAstroServer(config: LoadedViteWpConfig): Promise<void>;
+export declare function startAstroServer(config: LoadedViteWpConfig): Promise<ManagedProcess>;

package/dist/runtime/astro.js

@@ -0,0 +1,69 @@
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { spawnManaged } from './process.js';
+const execFileAsync = promisify(execFile);
+export async function stopAstroServer(config) {
+    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    await execFileAsync(npx, ['astro', 'dev', 'stop'], {
+        cwd: config.root,
+        env: process.env,
+    }).catch(() => undefined);
+    await killStaleAstroProcesses(config);
+}
+export async function startAstroServer(config) {
+    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    await stopAstroServer(config);
+    await execFileAsync(npx, [
+        'astro',
+        'dev',
+        '--background',
+        '--host',
+        config.dev.astroHost,
+        '--port',
+        String(config.dev.astroPort),
+    ], {
+        cwd: config.root,
+        env: process.env,
+    });
+    const logs = spawnManaged('astro', npx, ['astro', 'dev', 'logs', '--follow'], config.root, {
+        shouldLogLine: (line) => isVerbose() || !line.includes('Local    http://'),
+    });
+    return {
+        ...logs,
+        critical: false,
+        stop: () => {
+            logs.stop();
+            spawn(npx, ['astro', 'dev', 'stop'], {
+                cwd: config.root,
+                stdio: 'ignore',
+                detached: true,
+            }).unref();
+        },
+    };
+}
+function isVerbose() {
+    return process.env.VITEWP_VERBOSE === '1';
+}
+async function killStaleAstroProcesses(config) {
+    if (process.platform === 'win32')
+        return;
+    const { stdout } = await execFileAsync('ps', ['-Ao', 'pid=,command=']).catch(() => ({ stdout: '' }));
+    const lines = stdout.split('\n');
+    for (const line of lines) {
+        const match = line.trim().match(/^(\d+)\s+(.+)$/);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const command = match[2] ?? '';
+        if (pid !== process.pid
+            && command.includes(`${config.root}/node_modules/astro/bin/astro.mjs`)
+            && command.includes(' dev')) {
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch {
+                // Ignore already-exited processes.
+            }
+        }
+    }
+}

package/dist/runtime/composer.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedViteWpConfig } from '../config.js';
+export declare function ensureComposerInstall(config: LoadedViteWpConfig): Promise<void>;

package/dist/runtime/composer.js

@@ -0,0 +1,36 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+export async function ensureComposerInstall(config) {
+    if (!config.composer.install) {
+        console.log('Composer install disabled by config.');
+        return;
+    }
+    const lockfile = join(config.root, 'composer.lock');
+    const vendor = join(config.root, 'vendor');
+    const wpSettings = join(config.root, config.wordpress.docroot, 'wp-settings.php');
+    if (existsSync(lockfile) && existsSync(vendor) && existsSync(wpSettings)) {
+        console.log('✓ Composer dependencies already installed');
+        return;
+    }
+    console.log('Installing Composer dependencies...');
+    await runComposerInstall(config.root);
+    console.log('✓ Composer dependencies ready');
+}
+function runComposerInstall(cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('composer', ['install'], {
+            cwd,
+            stdio: 'inherit',
+            env: { ...process.env, COMPOSER_ALLOW_SUPERUSER: process.env.COMPOSER_ALLOW_SUPERUSER ?? '1' },
+        });
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`composer install failed with code ${code ?? 'unknown'}.`));
+            }
+        });
+    });
+}

package/dist/runtime/php.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedViteWpConfig } from '../config.js';
+import { type ManagedProcess } from './process.js';
+export declare function startPhpServer(config: LoadedViteWpConfig): ManagedProcess;

package/dist/runtime/php.js

@@ -0,0 +1,79 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { spawnManaged } from './process.js';
+export function startPhpServer(config) {
+    const docroot = resolve(config.root, config.wordpress.docroot);
+    const contentDir = resolve(config.root, config.wordpress.contentDir);
+    const router = writePhpRouter(config, docroot, contentDir);
+    return spawnManaged('php', 'php', ['-S', `${config.dev.phpHost}:${config.dev.phpPort}`, '-t', docroot, router], config.root, {
+        shouldLogLine: (line) => isVerbose() || !line.includes('Development Server (http://'),
+    });
+}
+function isVerbose() {
+    return process.env.VITEWP_VERBOSE === '1';
+}
+function writePhpRouter(config, docroot, contentDir) {
+    const runtimeDir = resolve(config.root, '.vitewp');
+    const routerPath = join(runtimeDir, 'php-router.php');
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(routerPath, renderRouter(docroot, contentDir), 'utf8');
+    return relative(config.root, routerPath);
+}
+function renderRouter(docroot, contentDir) {
+    return `<?php
+$path = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH) ?: '/';
+$file = ${phpString(docroot)} . $path;
+$content_dir = ${phpString(contentDir)};
+
+if (str_starts_with($path, '/wp-content/')) {
+    $content_file = $content_dir . substr($path, strlen('/wp-content'));
+
+    if (is_file($content_file)) {
+        $type = vitewp_content_type($content_file);
+
+        if ($type) {
+            header('Content-Type: ' . $type);
+        }
+
+        readfile($content_file);
+        return true;
+    }
+}
+
+if ($path !== '/' && is_file($file)) {
+    return false;
+}
+
+if ($path !== '/' && is_dir($file) && is_file(rtrim($file, '/') . '/index.php')) {
+    $_SERVER['SCRIPT_NAME'] = rtrim($path, '/') . '/index.php';
+    $_SERVER['SCRIPT_FILENAME'] = rtrim($file, '/') . '/index.php';
+    require rtrim($file, '/') . '/index.php';
+    return true;
+}
+
+function vitewp_content_type(string $file): string
+{
+    return match (strtolower(pathinfo($file, PATHINFO_EXTENSION))) {
+        'css' => 'text/css; charset=UTF-8',
+        'js' => 'application/javascript; charset=UTF-8',
+        'json' => 'application/json; charset=UTF-8',
+        'svg' => 'image/svg+xml',
+        'webp' => 'image/webp',
+        'png' => 'image/png',
+        'jpg', 'jpeg' => 'image/jpeg',
+        'gif' => 'image/gif',
+        'woff' => 'font/woff',
+        'woff2' => 'font/woff2',
+        default => mime_content_type($file) ?: 'application/octet-stream',
+    };
+}
+
+$_SERVER['SCRIPT_NAME'] = '/index.php';
+$_SERVER['SCRIPT_FILENAME'] = ${phpString(join(docroot, 'index.php'))};
+require ${phpString(join(docroot, 'index.php'))};
+return true;
+`;
+}
+function phpString(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}

package/dist/runtime/ports.d.ts

@@ -0,0 +1,3 @@
+export declare function assertPortAvailable(host: string, port: number, label: string): Promise<void>;
+export declare function resolveInternalPort(host: string, port: number): Promise<number>;
+export declare function isPortAvailable(host: string, port: number): Promise<boolean>;

package/dist/runtime/ports.js

@@ -0,0 +1,38 @@
+import net from 'node:net';
+export async function assertPortAvailable(host, port, label) {
+    const available = await isPortAvailable(host, port);
+    if (!available) {
+        throw new Error(`${label} port ${host}:${port} is already in use.`);
+    }
+}
+export async function resolveInternalPort(host, port) {
+    if (port > 0) {
+        const available = await isPortAvailable(host, port);
+        if (available) {
+            return port;
+        }
+    }
+    return findAvailablePort(host);
+}
+function findAvailablePort(host) {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', reject);
+        server.once('listening', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+        server.listen(0, host);
+    });
+}
+export function isPortAvailable(host, port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, host);
+    });
+}

package/dist/runtime/process.d.ts

@@ -0,0 +1,12 @@
+import { type ChildProcess } from 'node:child_process';
+export interface ManagedProcess {
+    name: string;
+    child: ChildProcess;
+    stop: () => void;
+    critical?: boolean;
+}
+export interface SpawnManagedOptions {
+    shouldLogLine?: (line: string) => boolean;
+}
+export declare function spawnManaged(name: string, command: string, args: string[], cwd: string, options?: SpawnManagedOptions): ManagedProcess;
+export declare function waitForExit(processes: ManagedProcess[]): Promise<void>;

package/dist/runtime/process.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+export function spawnManaged(name, command, args, cwd, options = {}) {
+    const child = spawn(command, args, {
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    child.stdout?.on('data', (chunk) => writeLines(name, chunk, options));
+    child.stderr?.on('data', (chunk) => writeLines(name, chunk, options));
+    return {
+        name,
+        child,
+        stop: () => {
+            if (!child.killed) {
+                child.kill('SIGTERM');
+            }
+        },
+    };
+}
+export function waitForExit(processes) {
+    return new Promise((resolve) => {
+        let shuttingDown = false;
+        const stopAll = () => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            for (const process of processes) {
+                process.stop();
+            }
+            resolve();
+        };
+        process.once('SIGINT', stopAll);
+        process.once('SIGTERM', stopAll);
+        for (const managed of processes) {
+            managed.child.once('exit', (code) => {
+                if (!shuttingDown && managed.critical !== false) {
+                    console.log(`\n${managed.name} exited with code ${code ?? 'unknown'}. Stopping ViteWP dev runtime.`);
+                    stopAll();
+                }
+            });
+        }
+    });
+}
+function writeLines(name, chunk, options) {
+    const lines = chunk.toString().split(/\r?\n/);
+    for (const line of lines) {
+        if (line.length > 0 && (options.shouldLogLine?.(line) ?? true)) {
+            console.log(`[${name}] ${line}`);
+        }
+    }
+}

package/dist/runtime/proxy.d.ts

@@ -0,0 +1,6 @@
+import type { LoadedViteWpConfig } from '../config.js';
+export interface ProxyServer {
+    url: string;
+    stop: () => Promise<void>;
+}
+export declare function startUnifiedProxy(config: LoadedViteWpConfig): Promise<ProxyServer>;

package/dist/runtime/proxy.js

@@ -0,0 +1,204 @@
+import { createReadStream, statSync } from 'node:fs';
+import http from 'node:http';
+import { extname, normalize, resolve, sep } from 'node:path';
+import { URL } from 'node:url';
+const wordpressPrefixes = [
+    '/wp-admin',
+    '/wp-content',
+    '/wp-includes',
+    '/wp-json',
+];
+const wordpressFiles = [
+    '/index.php',
+    '/wp-login.php',
+    '/wp-cron.php',
+    '/wp-comments-post.php',
+    '/wp-trackback.php',
+    '/xmlrpc.php',
+    '/favicon.ico',
+];
+export async function startUnifiedProxy(config) {
+    const publicUrl = new URL(config.wordpress.url);
+    const phpUrl = new URL(`http://${config.dev.phpHost}:${config.dev.phpPort}`);
+    const astroUrl = new URL(`http://${config.dev.astroHost}:${config.dev.astroPort}`);
+    const contentDir = resolve(config.root, config.wordpress.contentDir);
+    const server = http.createServer((request, response) => {
+        if (serveWpContentAsset(request, response, contentDir)) {
+            return;
+        }
+        proxyHttpRequest(request, response, selectTarget(request.url ?? '/', phpUrl, astroUrl), publicUrl);
+    });
+    server.on('upgrade', (request, socket, head) => {
+        proxyUpgrade(request, socket, head, selectTarget(request.url ?? '/', phpUrl, astroUrl), publicUrl);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(Number(publicUrl.port || 3000), publicUrl.hostname, () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    return {
+        url: publicUrl.toString().replace(/\/$/, ''),
+        stop: () => new Promise((resolve) => {
+            server.close(() => resolve());
+        }),
+    };
+}
+function selectTarget(path, phpUrl, astroUrl) {
+    return isWordPressRequest(path) ? phpUrl : astroUrl;
+}
+function isWordPressRequest(path) {
+    const pathname = path.split('?')[0] ?? '/';
+    return wordpressPrefixes.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`))
+        || wordpressFiles.includes(pathname)
+        || pathname.endsWith('.php');
+}
+function serveWpContentAsset(request, response, contentDir) {
+    const pathname = new URL(request.url ?? '/', 'http://vitewp.local').pathname;
+    if (!pathname.startsWith('/wp-content/')) {
+        return false;
+    }
+    const relativePath = decodeURIComponent(pathname.slice('/wp-content/'.length));
+    const file = resolve(contentDir, normalize(relativePath));
+    if (!isInside(contentDir, file)) {
+        response.writeHead(403, { 'content-type': 'text/plain; charset=utf-8' });
+        response.end('Forbidden');
+        return true;
+    }
+    try {
+        const stats = statSync(file);
+        if (!stats.isFile()) {
+            return false;
+        }
+        response.writeHead(200, {
+            'content-type': contentType(file),
+            'content-length': stats.size,
+            'cache-control': 'no-cache',
+        });
+        if (request.method === 'HEAD') {
+            response.end();
+            return true;
+        }
+        createReadStream(file).pipe(response);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isInside(root, file) {
+    const normalizedRoot = root.endsWith(sep) ? root : `${root}${sep}`;
+    return file.startsWith(normalizedRoot);
+}
+function rewriteTargetPath(path, target, publicUrl) {
+    if (target.origin === publicUrl.origin)
+        return path;
+    const url = new URL(path, publicUrl);
+    if (url.pathname === '/wp-json' || url.pathname.startsWith('/wp-json/')) {
+        const restRoute = url.pathname.replace(/^\/wp-json\/?/, '/');
+        url.pathname = '/index.php';
+        url.searchParams.set('rest_route', restRoute || '/');
+        return `${url.pathname}${url.search}`;
+    }
+    return path;
+}
+function proxyHttpRequest(request, response, target, publicUrl) {
+    const targetRequest = http.request({
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port,
+        method: request.method,
+        path: rewriteTargetPath(request.url ?? '/', target, publicUrl),
+        headers: rewriteRequestHeaders(request, publicUrl),
+    }, (targetResponse) => {
+        response.writeHead(targetResponse.statusCode ?? 502, targetResponse.statusMessage, rewriteResponseHeaders(targetResponse.headers, target, publicUrl));
+        targetResponse.pipe(response);
+    });
+    targetRequest.on('error', (error) => {
+        response.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' });
+        response.end(`ViteWP proxy could not reach ${target.origin}: ${error.message}\n`);
+    });
+    request.pipe(targetRequest);
+}
+function proxyUpgrade(request, socket, head, target, publicUrl) {
+    socket.on('error', () => undefined);
+    const targetRequest = http.request({
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port,
+        method: request.method,
+        path: rewriteTargetPath(request.url ?? '/', target, publicUrl),
+        headers: rewriteRequestHeaders(request, publicUrl),
+    });
+    targetRequest.on('upgrade', (targetResponse, targetSocket, targetHead) => {
+        targetSocket.on('error', () => socket.destroy());
+        socket.write(`HTTP/${targetResponse.httpVersion} ${targetResponse.statusCode} ${targetResponse.statusMessage}\r\n${rawHeaders(rewriteResponseHeaders(targetResponse.headers, target, publicUrl))}\r\n\r\n`);
+        if (targetHead.length > 0)
+            socket.write(targetHead);
+        if (head.length > 0)
+            targetSocket.write(head);
+        targetSocket.pipe(socket);
+        socket.pipe(targetSocket);
+    });
+    targetRequest.on('error', () => socket.destroy());
+    targetRequest.on('socket', (targetSocket) => {
+        targetSocket.on('error', () => socket.destroy());
+    });
+    targetRequest.end();
+}
+function rewriteRequestHeaders(request, publicUrl) {
+    return {
+        ...request.headers,
+        host: publicUrl.host,
+        'x-forwarded-host': publicUrl.host,
+        'x-forwarded-proto': publicUrl.protocol.replace(':', ''),
+    };
+}
+function rewriteResponseHeaders(headers, target, publicUrl) {
+    const rewritten = { ...headers };
+    const location = headers.location;
+    if (typeof location === 'string') {
+        rewritten.location = location.replace(target.origin, publicUrl.origin);
+    }
+    delete rewritten['content-length'];
+    return rewritten;
+}
+function rawHeaders(headers) {
+    return Object.entries(headers)
+        .flatMap(([key, value]) => {
+        if (value === undefined)
+            return [];
+        if (Array.isArray(value))
+            return value.map((item) => `${key}: ${item}`);
+        return [`${key}: ${value}`];
+    })
+        .join('\r\n');
+}
+function contentType(file) {
+    switch (extname(file).toLowerCase()) {
+        case '.css':
+            return 'text/css; charset=UTF-8';
+        case '.js':
+            return 'application/javascript; charset=UTF-8';
+        case '.json':
+            return 'application/json; charset=UTF-8';
+        case '.svg':
+            return 'image/svg+xml';
+        case '.webp':
+            return 'image/webp';
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.gif':
+            return 'image/gif';
+        case '.woff':
+            return 'font/woff';
+        case '.woff2':
+            return 'font/woff2';
+        default:
+            return 'application/octet-stream';
+    }
+}

package/dist/runtime/wp-config.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedViteWpConfig } from '../config.js';
+export declare function writeWordPressConfig(config: LoadedViteWpConfig): void;
+export declare function phpServerUrl(config: LoadedViteWpConfig): string;