Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

6.6 KB
Raw Blame
import type { Plugin } from 'vite';
import { spawn } from 'node:child_process';
import process from 'node:process';
import { fileURLToPath } from 'node:url';
import { defineConfig } from 'vite';

const DEV_LOCALE_ENDPOINT = '/__univer_examples_locale';
const DEV_LOCALE_EXPORT_SCRIPT = fileURLToPath(new URL('./scripts/export-locale.mts', import.meta.url));
const DEV_LOCALE_PRODUCTS = new Set(['docs', 'sheets']);
const DEV_TSX_IMPORT = import.meta.resolve('tsx');
const DEV_LOCALE_TAGS = new Set([
    'ar-SA',
    'ca-ES',
    'de-DE',
    'en-US',
    'es-ES',
    'fa-IR',
    'fr-FR',
    'id-ID',
    'it-IT',
    'ja-JP',
    'ko-KR',
    'pl-PL',
    'pt-BR',
    'ru-RU',
    'sk-SK',
    'vi-VN',
    'zh-CN',
    'zh-HK',
    'zh-TW',
]);
type DevLocaleProduct = 'docs' | 'sheets';

const VIRTUAL_LOCALE_MODULES = {
    'virtual:univer-examples-document-locale': {
        development: fileURLToPath(new URL('./src/docs/locale-loader.dev.ts', import.meta.url)),
        exportName: 'loadDocumentLocale',
        production: fileURLToPath(new URL('./src/docs/locale-loader.ts', import.meta.url)),
    },
    'virtual:univer-examples-sheet-locale': {
        development: fileURLToPath(new URL('./src/sheets/locale-loader.dev.ts', import.meta.url)),
        exportName: 'loadSheetLocale',
        production: fileURLToPath(new URL('./src/sheets/locale-loader.ts', import.meta.url)),
    },
} as const;

type VirtualLocaleModule = keyof typeof VIRTUAL_LOCALE_MODULES;

function isDevLocaleProduct(value: string | null): value is DevLocaleProduct {
    return value !== null && DEV_LOCALE_PRODUCTS.has(value);
}

function isVirtualLocaleModule(value: string): value is VirtualLocaleModule {
    return Object.hasOwn(VIRTUAL_LOCALE_MODULES, value);
}

function exportDevLocale(product: DevLocaleProduct, locale: string): Promise<string> {
    return new Promise((resolve, reject) => {
        const child = spawn(
            process.execPath,
            ['--import', DEV_TSX_IMPORT, DEV_LOCALE_EXPORT_SCRIPT, product, locale],
            {
                env: { ...process.env, NODE_NO_WARNINGS: '1' },
                stdio: ['ignore', 'pipe', 'pipe'],
            }
        );
        let output = '';
        let errorOutput = '';

        child.stdout.setEncoding('utf8');
        child.stdout.on('data', (chunk: string) => {
            output += chunk;
        });
        child.stderr.setEncoding('utf8');
        child.stderr.on('data', (chunk: string) => {
            errorOutput += chunk;
        });
        child.on('error', reject);
        child.on('close', (code) => {
            if (code === 0) {
                resolve(output);
                return;
            }

            reject(new Error(errorOutput.trim() || `Locale exporter exited with code ${code}.`));
        });
    });
}

/**
 * bundledDev follows every literal locale import. During development, load the
 * requested locale in a short-lived process so the other locale graphs never
 * become resident in Vite. Production keeps the regular static locale chunks.
 */
function workbenchLocaleLoader(command: 'build' | 'serve'): Plugin {
    const cache = new Map<string, Promise<string>>();

    return {
        name: 'workbench-locale-loader',
        resolveId(source) {
            return isVirtualLocaleModule(source) ? `\0${source}` : null;
        },
        load(id) {
            const source = id.startsWith('\0') ? id.slice(1) : id;
            if (!isVirtualLocaleModule(source)) {
                return null;
            }

            const localeModule = VIRTUAL_LOCALE_MODULES[source];
            const implementation = command === 'serve' ? localeModule.development : localeModule.production;
            return `export { ${localeModule.exportName} } from ${JSON.stringify(implementation)};`;
        },
        configureServer(server) {
            server.watcher.on('change', (file) => {
                if (/\/src\/locales?\//.test(file)) {
                    cache.clear();
                }
            });
            server.middlewares.use(async (request, response, next) => {
                if (!request.url) {
                    next();
                    return;
                }

                const requestUrl = new URL(request.url, 'http://localhost');
                if (requestUrl.pathname !== DEV_LOCALE_ENDPOINT) {
                    next();
                    return;
                }

                const product = requestUrl.searchParams.get('product');
                const locale = requestUrl.searchParams.get('locale');
                if (!isDevLocaleProduct(product) || !locale || !DEV_LOCALE_TAGS.has(locale)) {
                    response.statusCode = 400;
                    response.setHeader('content-type', 'application/json; charset=utf-8');
                    response.end(JSON.stringify({ error: 'Unsupported product or locale.' }));
                    return;
                }

                try {
                    const cacheKey = `${product}:${locale}`;
                    let localeData = cache.get(cacheKey);
                    if (!localeData) {
                        localeData = exportDevLocale(product, locale).catch((error) => {
                            cache.delete(cacheKey);
                            throw error;
                        });
                        cache.set(cacheKey, localeData);
                    }

                    response.statusCode = 200;
                    response.setHeader('cache-control', 'no-store');
                    response.setHeader('content-type', 'application/json; charset=utf-8');
                    response.end(await localeData);
                } catch (error) {
                    response.statusCode = 500;
                    response.setHeader('content-type', 'application/json; charset=utf-8');
                    response.end(JSON.stringify({
                        error: error instanceof Error ? error.message : String(error),
                    }));
                }
            });
        },
    };
}

function ignoreWorkspaceGlobalCss(): Plugin {
    return {
        name: 'ignore-workspace-global-css',
        enforce: 'pre',
        transform: {
            filter: { id: /\/packages\/.*\/src\/global\.css$/ },
            handler() {
                return '';
            },
        },
    };
}

export default defineConfig(({ command, mode }) => ({
    build: {
        sourcemap: false,
    },
    experimental: {
        bundledDev: command === 'serve' && mode !== 'test',
    },
    plugins: [workbenchLocaleLoader(command), ignoreWorkspaceGlobalCss()],
    preview: {
        port: 5173,
        strictPort: true,
    },
    server: {
        port: 5173,
        strictPort: true,
    },
}));