vite-plugin-taro 0.2.2 → 0.3.0

package/dist/node/plugins/taro-runtime.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+/** Public IDs used by Taro's API transform and generated target modules. */
+export declare const virtualTaroApiId = "virtual:taro/api";
+/** Resolves target-neutral Taro shims once instead of duplicating this concern in every target plugin. */
+export declare function createTaroRuntimePlugin(): Plugin;

package/dist/node/plugins/taro-runtime.js

@@ -0,0 +1,18 @@
+import { resolvePackageFile } from '../utils/packages.js';
+/** Public IDs used by Taro's API transform and generated target modules. */
+export const virtualTaroApiId = 'virtual:taro/api';
+const virtualTaroComponentsId = 'virtual:taro/components';
+const runtimeModules = new Map([
+    [virtualTaroApiId, resolvePackageFile('dist/runtime/taro/api.js')],
+    [virtualTaroComponentsId, resolvePackageFile('dist/runtime/taro/components.js')]
+]);
+/** Resolves target-neutral Taro shims once instead of duplicating this concern in every target plugin. */
+export function createTaroRuntimePlugin() {
+    return {
+        name: 'vite-plugin-taro:runtime',
+        enforce: 'pre',
+        resolveId(id) {
+            return runtimeModules.get(id);
+        }
+    };
+}

package/dist/node/targets/h5/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { PluginOption, UserConfig } from 'vite';
+import type { BuildContext } from '../../build-context.ts';
+/** Creates the plugins that own the complete H5 target lifecycle. */
+export declare function createH5TargetPlugins(context: BuildContext): PluginOption[];
+/** Supplies the complete H5 target configuration from the same target owner as its plugins. */
+export declare function createH5ViteConfig(context: BuildContext): UserConfig;

package/dist/node/targets/h5/plugin.js

@@ -0,0 +1,117 @@
+import babel from '@rolldown/plugin-babel';
+import { virtualTaroApiId } from '../../plugins/taro-runtime.js';
+import { stripVirtualPrefix } from '../../utils/modules.js';
+import { packageRequire } from '../../utils/packages.js';
+import { createH5IndexHtmlTags, isH5VirtualModuleId, loadH5VirtualModule } from './virtual-modules.js';
+/** Creates the plugins that own the complete H5 target lifecycle. */
+export function createH5TargetPlugins(context) {
+    return [...createH5SupportPlugins(), createH5TargetPlugin(context)];
+}
+function createH5TargetPlugin(context) {
+    return {
+        name: 'vite-plugin-taro:h5',
+        resolveId: {
+            order: 'pre',
+            handler(id) {
+                return isH5VirtualModuleId(id) ? `\0${id}` : undefined;
+            }
+        },
+        load: {
+            order: 'post',
+            handler(id) {
+                return loadH5VirtualModule(stripVirtualPrefix(id), context);
+            }
+        },
+        transformIndexHtml: {
+            order: 'pre',
+            handler() {
+                return createH5IndexHtmlTags(context);
+            }
+        }
+    };
+}
+/** Creates H5-only Babel transforms for Stencil CSS ordering and Taro API imports. */
+function createH5SupportPlugins() {
+    return [
+        babel({
+            include: /[\\/]@stencil[\\/]core[\\/]internal[\\/]client[\\/]index\.js(?:\?.*)?$/,
+            exclude: [],
+            plugins: [rewriteStencilStyleInsertion]
+        }),
+        babel({
+            plugins: [
+                [
+                    packageRequire.resolve('babel-plugin-transform-taroapi'),
+                    {
+                        packageName: virtualTaroApiId,
+                        definition: packageRequire(packageRequire.resolve('@tarojs/plugin-platform-h5/dist/definition.json'))
+                    }
+                ]
+            ]
+        })
+    ];
+}
+/** Keeps Stencil-injected Taro component styles before application stylesheets. */
+function rewriteStencilStyleInsertion() {
+    return {
+        name: 'rewrite-stencil-style-insertion',
+        visitor: {
+            CallExpression(path) {
+                if (!isStencilStyleInsertBeforeCall(path))
+                    return;
+                path.get('arguments.1').replaceWithSourceString(`scopeId.startsWith('sc-taro-') ? styleContainerNode.querySelector('style,link[rel="stylesheet"]') : styleContainerNode.querySelector('link')`);
+            }
+        }
+    };
+}
+function isStencilStyleInsertBeforeCall(path) {
+    return (path.get('callee').matchesPattern('styleContainerNode.insertBefore') &&
+        path.get('arguments.0').toString() === 'styleElm' &&
+        path.get('arguments.1').toString() === "styleContainerNode.querySelector('link')");
+}
+/** Supplies the complete H5 target configuration from the same target owner as its plugins. */
+export function createH5ViteConfig(context) {
+    return {
+        define: createH5TaroDefines(),
+        resolve: {
+            mainFields: ['main:h5', 'browser', 'module', 'jsnext:main', 'jsnext'],
+            alias: [
+                {
+                    find: /^@stencil\/core\/internal\/client$/,
+                    replacement: packageRequire.resolve('@stencil/core/internal/client', {
+                        paths: [packageRequire.resolve('@tarojs/components/package.json')]
+                    })
+                },
+                {
+                    find: /^@tarojs\/components$/,
+                    replacement: packageRequire.resolve('@tarojs/components/lib/react')
+                },
+                {
+                    find: /^@tarojs\/components\/dist\/components$/,
+                    replacement: packageRequire.resolve('@tarojs/components/dist/components')
+                },
+                {
+                    find: /^@tarojs\/taro$/,
+                    replacement: packageRequire.resolve('@tarojs/plugin-platform-h5/dist/runtime/apis')
+                }
+            ]
+        },
+        optimizeDeps: {
+            exclude: ['@stencil/core/internal/client']
+        },
+        build: {
+            target: 'es2018',
+            minify: !context.development
+        }
+    };
+}
+function createH5TaroDefines() {
+    return {
+        'process.env.FRAMEWORK': JSON.stringify('react'),
+        'process.env.SUPPORT_TARO_POLYFILL': JSON.stringify('disabled'),
+        'process.env.TARO_ENV': JSON.stringify('h5'),
+        'process.env.TARO_PLATFORM': JSON.stringify('web'),
+        'process.env.SUPPORT_DINGTALK_NAVIGATE': JSON.stringify('disabled'),
+        DEPRECATED_ADAPTER_COMPONENT: 'false'
+    };
+}

package/dist/node/targets/h5/virtual-modules.d.ts

@@ -0,0 +1,5 @@
+import type { HtmlTagDescriptor } from 'vite';
+import type { BuildContext } from '../../build-context.ts';
+export declare function isH5VirtualModuleId(id: string): boolean;
+export declare function loadH5VirtualModule(id: string, context: BuildContext): string | undefined;
+export declare function createH5IndexHtmlTags(context: BuildContext): HtmlTagDescriptor[] | undefined;

package/dist/node/targets/h5/virtual-modules.js

@@ -0,0 +1,60 @@
+import { createPageComponentImportPath, toViteFileImportPath } from '../../utils/modules.js';
+import { resolvePackageFile } from '../../utils/packages.js';
+const h5TaroRuntimeImportPath = toViteFileImportPath(resolvePackageFile('dist/runtime/h5/taro-runtime.js'));
+const virtualH5EntryId = 'virtual:vite-plugin-taro/h5';
+export function isH5VirtualModuleId(id) {
+    return id === virtualH5EntryId;
+}
+export function loadH5VirtualModule(id, context) {
+    if (id === virtualH5EntryId)
+        return createH5EntrySource(context);
+}
+export function createH5IndexHtmlTags(context) {
+    if (context.project.target !== 'h5')
+        return;
+    return [
+        {
+            tag: 'script',
+            attrs: { type: 'module' },
+            children: `import '${virtualH5EntryId}'`,
+            injectTo: 'body'
+        }
+    ];
+}
+function createH5EntrySource(context) {
+    const appConfig = JSON.stringify(createH5AppConfig(context.project.appConfig));
+    const routes = createH5RoutesSource(context.project.pages);
+    return `import {
+    createHashHistory,
+    createReactApp,
+    createRouter,
+    handleAppMount,
+    window
+} from ${JSON.stringify(h5TaroRuntimeImportPath)}
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import AppComponent from ${JSON.stringify(toViteFileImportPath(context.project.appComponentFile))}
+
+const config = window.__taroAppConfig = ${appConfig}
+config.routes = ${routes}
+const app = createReactApp(AppComponent, React, ReactDOM, config)
+const history = createHashHistory({ window })
+handleAppMount(config, history)
+createRouter(history, app, config, React)
+`;
+}
+function createH5AppConfig(sharedAppConfig) {
+    return { router: {}, ...sharedAppConfig };
+}
+function createH5RoutesSource(pages) {
+    const routes = pages.map((page) => [
+        'Object.assign({',
+        `  path: ${JSON.stringify(page.path)},`,
+        '  load: async function(context, params) {',
+        `    const page = await import(${JSON.stringify(createPageComponentImportPath(page.path))})`,
+        '    return [page, context, params]',
+        '  }',
+        `}, ${JSON.stringify(page.config)})`
+    ].join('\n'));
+    return `[\n${routes.join(',\n')}\n]`;
+}

package/dist/node/targets/wx/companion-assets.d.ts

@@ -0,0 +1,18 @@
+import type { BuildContext } from '../../build-context.ts';
+type WxAssetSource = string | Uint8Array;
+export type WxBundle = Record<string, {
+    type: 'asset' | 'chunk';
+    source?: WxAssetSource;
+    modules?: Record<string, {
+        renderedExports?: string[];
+    }>;
+}>;
+type WxAssetEmitter = {
+    emitFile(asset: {
+        type: 'asset';
+        fileName: string;
+        source: WxAssetSource;
+    }): string;
+};
+export declare function emitWxCompanionAssets(emitter: WxAssetEmitter, bundle: WxBundle, context: BuildContext): void;
+export {};

package/dist/node/targets/wx/companion-assets.js

@@ -0,0 +1,121 @@
+import path from 'node:path';
+import { recursiveMerge } from '@tarojs/helper';
+import { Weapp as WxPlatform } from '@tarojs/plugin-platform-weapp';
+import { normalizeModuleId } from '../../utils/modules.js';
+import { packageRequire } from '../../utils/packages.js';
+const taroWxComponentsPath = packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react');
+const templateBuilder = createWxTemplateBuilder();
+export function emitWxCompanionAssets(emitter, bundle, context) {
+    for (const asset of createWxCompanionAssets(bundle, context)) {
+        emitter.emitFile({ type: 'asset', fileName: asset.fileName, source: asset.source });
+    }
+}
+function createWxCompanionAssets(bundle, context) {
+    const json = (value) => (context.development ? JSON.stringify(value, null, 2) : JSON.stringify(value));
+    return [
+        { fileName: 'app.json', source: json(context.project.appConfig) },
+        { fileName: 'app.wxss', source: collectWxBundleStyles(bundle) },
+        {
+            fileName: 'base.wxml',
+            source: templateBuilder.buildTemplate(collectWxTemplateComponentConfig(bundle))
+        },
+        { fileName: 'utils.wxs', source: templateBuilder.buildXScript() },
+        { fileName: 'comp.wxml', source: templateBuilder.buildBaseComponentTemplate('.wxml') },
+        { fileName: 'comp.json', source: json(createWxComponentConfig()) },
+        { fileName: 'project.config.json', source: json(createWxProjectConfig(context)) },
+        { fileName: 'project.private.config.json', source: json(context.project.projectPrivateConfigJson) },
+        { fileName: 'sitemap.json', source: json(context.project.sitemapJson) },
+        ...context.project.pages.flatMap((page) => [
+            {
+                fileName: `${page.path}.wxml`,
+                source: templateBuilder.buildPageTemplate(relativeWxRootAsset(page.path, 'base.wxml'), {
+                    content: page.config,
+                    path: page.path
+                })
+            },
+            {
+                fileName: `${page.path}.json`,
+                source: json({
+                    ...page.config,
+                    usingComponents: { comp: relativeWxRootAsset(page.path, 'comp') }
+                })
+            },
+            { fileName: `${page.path}.wxss`, source: '' }
+        ])
+    ];
+}
+function createWxProjectConfig(context) {
+    const projectConfig = context.project.projectConfigJson;
+    const setting = isJsonObject(projectConfig.setting) ? projectConfig.setting : {};
+    return {
+        ...projectConfig,
+        setting: { ...setting, compileHotReLoad: true }
+    };
+}
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function createWxTemplateBuilder() {
+    const platform = new WxPlatform({ helper: { recursiveMerge }, modifyWebpackChain() { }, registerPlatform() { } }, {}, {});
+    platform.modifyTemplate({});
+    return platform.template;
+}
+function relativeWxRootAsset(pagePath, rootAsset) {
+    const relativePath = path.posix.relative(path.posix.dirname(pagePath), rootAsset);
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function collectWxTemplateComponentConfig(bundle) {
+    const config = {
+        includes: new Set([
+            'view',
+            'catch-view',
+            'static-view',
+            'pure-view',
+            'click-view',
+            'scroll-view',
+            'image',
+            'static-image',
+            'text',
+            'static-text'
+        ]),
+        exclude: new Set(),
+        thirdPartyComponents: new Map(),
+        includeAll: false
+    };
+    const components = findBundleModule(bundle, taroWxComponentsPath);
+    for (const name of components?.renderedExports ?? [])
+        config.includes.add(toDashed(name));
+    return config;
+}
+function findBundleModule(bundle, resolvedId) {
+    const normalizedResolvedId = normalizeModuleId(resolvedId);
+    for (const item of Object.values(bundle)) {
+        if (item.type !== 'chunk')
+            continue;
+        const found = Object.entries(item.modules ?? {}).find(([id]) => normalizeModuleId(id) === normalizedResolvedId);
+        if (found)
+            return found[1];
+    }
+}
+function toDashed(value) {
+    return value.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function createWxComponentConfig() {
+    return {
+        component: true,
+        styleIsolation: 'apply-shared',
+        usingComponents: { comp: './comp' }
+    };
+}
+function collectWxBundleStyles(bundle) {
+    const styles = [];
+    for (const [fileName, item] of Object.entries(bundle)) {
+        if (item.type !== 'asset' || !fileName.endsWith('.css'))
+            continue;
+        const source = typeof item.source === 'string' ? item.source : new TextDecoder().decode(item.source);
+        if (source)
+            styles.push(source);
+        delete bundle[fileName];
+    }
+    return styles.join('\n');
+}

package/dist/node/targets/wx/dev-server/development-session.d.ts

@@ -0,0 +1,31 @@
+import type { ViteDevServer } from 'vite';
+import type { BuildContext } from '../../../build-context.ts';
+type WxDevServerContext = Pick<BuildContext, 'vite' | 'css'>;
+/** Owns one WX bundled-development graph and all writes to its fixed output directory. */
+export declare class WxDevelopmentSession {
+    private readonly context;
+    private readonly server;
+    private readonly adapter;
+    private readonly updateTransport;
+    private readonly outDir;
+    private readonly initialBundle;
+    private readonly outputQueue;
+    private readonly fullBuildScheduler;
+    private originalPrintUrls;
+    private snapshot;
+    constructor(context: WxDevServerContext, server: ViteDevServer);
+    private get config();
+    install(): void;
+    close(): Promise<void>;
+    private readonly printUrls;
+    private readonly handleHttpListening;
+    private readonly handleWatchedFile;
+    private handleBundleOutput;
+    private handlePatch;
+    private handleError;
+    private requestFullBuild;
+    private waitForInitialBundle;
+    private reportOutputError;
+    private reportRebuildError;
+}
+export {};

package/dist/node/targets/wx/dev-server/development-session.js

@@ -0,0 +1,202 @@
+/**
+ * Top-level owner of one WX development lifecycle.
+ *
+ * It serializes every output write, connects DevEngine patches to the update transport, and coalesces conservative full
+ * rebuilds. No other module writes plugin-generated WX development files directly.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import colors from 'picocolors';
+import { SerializedTaskQueue } from '../../../utils/async.js';
+import { copyDirectoryIfExists, copyFileOrRemove, writeFileAtomically, writeFilesAtomically } from '../../../utils/filesystem.js';
+import { wxDevelopmentDirectory, wxUpdateControlFile, wxUpdateFile } from '../development-files.js';
+import { FullBuildScheduler } from './full-build-scheduler.js';
+import { transformWxCompatibleJavaScript, transformWxOutputChunks } from './js-utils.js';
+import { isWxFullBuildOutput, normalizeWxBundleStyles, setWxAppStyles } from './output.js';
+import { WxUpdateTransport } from './update-transport.js';
+import { ViteBundledDevAdapter } from './vite-bundled-dev-adapter.js';
+const maxRetainedDeltaCount = 1_000;
+const maxRetainedDeltaBytes = 16 * 1024 * 1024;
+const fullBuildDebounceDelay = 100;
+/** Owns one WX bundled-development graph and all writes to its fixed output directory. */
+export class WxDevelopmentSession {
+    context;
+    server;
+    adapter;
+    updateTransport;
+    outDir;
+    initialBundle = Promise.withResolvers();
+    outputQueue;
+    fullBuildScheduler;
+    originalPrintUrls;
+    snapshot = { lifecycle: 'open', outputPhase: 'starting', latestAppStyles: '' };
+    constructor(context, server) {
+        this.context = context;
+        this.server = server;
+        const config = context.vite;
+        this.outDir = path.resolve(config.root, config.build.outDir);
+        this.outputQueue = new SerializedTaskQueue((error) => this.reportOutputError(error));
+        this.updateTransport = new WxUpdateTransport(server, () => this.requestFullBuild(), (buildId, source) => this.outputQueue.enqueue(async () => {
+            // A full build queued before this write invalidates the old batch instead of letting it overwrite
+            // the new build's empty update.js.
+            if (!this.updateTransport.isCurrentBuild(buildId))
+                return;
+            await writeFileAtomically(path.join(this.outDir, wxUpdateFile), source);
+        }));
+        this.adapter = new ViteBundledDevAdapter(config, server, {
+            onOutput: (output) => this.handleBundleOutput(output),
+            onPatch: (files, output) => this.handlePatch(files, output),
+            onError: (message) => this.handleError(message),
+            waitForInitialBundle: () => this.waitForInitialBundle()
+        });
+        this.fullBuildScheduler = new FullBuildScheduler(fullBuildDebounceDelay, () => this.adapter.rebuild(), (error) => this.reportRebuildError(error));
+    }
+    get config() {
+        return this.context.vite;
+    }
+    install() {
+        this.updateTransport.install();
+        this.server.httpServer?.once('listening', this.handleHttpListening);
+        this.adapter.install();
+        this.originalPrintUrls = this.server.printUrls.bind(this.server);
+        this.server.printUrls = this.printUrls;
+        if (this.config.publicDir)
+            this.server.watcher.add(this.config.publicDir);
+        this.server.watcher.on('change', this.handleWatchedFile);
+        this.server.watcher.on('add', this.handleWatchedFile);
+        this.server.watcher.on('unlink', this.handleWatchedFile);
+    }
+    async close() {
+        if (this.snapshot.lifecycle === 'closed')
+            return;
+        this.snapshot = { ...this.snapshot, lifecycle: 'closed' };
+        this.server.watcher.off('change', this.handleWatchedFile);
+        this.server.watcher.off('add', this.handleWatchedFile);
+        this.server.watcher.off('unlink', this.handleWatchedFile);
+        this.server.httpServer?.off('listening', this.handleHttpListening);
+        if (this.server.printUrls === this.printUrls && this.originalPrintUrls) {
+            this.server.printUrls = this.originalPrintUrls;
+        }
+        this.updateTransport.close();
+        await this.fullBuildScheduler.close();
+        await this.outputQueue.waitForIdle();
+    }
+    printUrls = () => {
+        this.originalPrintUrls?.();
+        const projectDirectory = relativeToViteConfig(this.outDir, this.config.configFile, this.config.root);
+        this.server.config.logger.info(`  ${colors.green('➜')}  ${colors.bold('WeChat DevTools')}: ${colors.cyan(projectDirectory)}`);
+    };
+    handleHttpListening = () => {
+        this.outputQueue.enqueue(() => writeFileAtomically(path.join(this.outDir, wxUpdateControlFile), this.updateTransport.createControlSource()));
+    };
+    handleWatchedFile = (file) => {
+        if (isFileInside(file, this.config.publicDir)) {
+            const destination = path.join(this.outDir, path.relative(this.config.publicDir, file));
+            this.outputQueue.enqueue(() => copyFileOrRemove(file, destination));
+            this.requestFullBuild();
+        }
+    };
+    handleBundleOutput(output) {
+        const appStyles = normalizeWxBundleStyles(output);
+        if (appStyles !== undefined)
+            this.snapshot = { ...this.snapshot, latestAppStyles: appStyles };
+        if (isWxFullBuildOutput(output) && this.snapshot.latestAppStyles) {
+            setWxAppStyles(output, this.snapshot.latestAppStyles);
+        }
+        if (!isWxFullBuildOutput(output)) {
+            this.outputQueue.enqueue(async () => {
+                await transformWxOutputChunks(output);
+                await writeDevelopmentOutput(this.outDir, output);
+            });
+            return;
+        }
+        const buildId = this.updateTransport.createBuildId();
+        setDevelopmentAsset(output, wxUpdateControlFile, this.updateTransport.createControlSource(buildId));
+        setDevelopmentAsset(output, wxUpdateFile, 'void 0;\n');
+        this.outputQueue.enqueue(async () => {
+            await transformWxOutputChunks(output);
+            if (this.snapshot.outputPhase === 'starting') {
+                // The directory is plugin-owned; clearing it once removes stale files from previous protocol designs.
+                await fs.rm(path.join(this.outDir, wxDevelopmentDirectory), { recursive: true, force: true });
+            }
+            // Invalidate old HTTP reports before writing the new build epoch into the fixed DevTools directory.
+            this.updateTransport.commitFullBuild(buildId);
+            await writeDevelopmentOutput(this.outDir, output);
+            await copyDirectoryIfExists(this.config.publicDir, this.outDir);
+            const moduleCount = this.adapter.registerBundleModules(output);
+            this.snapshot = { ...this.snapshot, outputPhase: 'ready' };
+            this.initialBundle.resolve();
+            this.server.config.logger.info(`[vite-plugin-taro] WX bundle ready (${moduleCount} modules, ${output.length} files)`);
+        });
+    }
+    handlePatch(files, output) {
+        if (!isSafeJavaScriptPatch(files, output)) {
+            this.requestFullBuild();
+            return false;
+        }
+        this.adapter.registerPatchModules(output.code);
+        this.outputQueue.enqueue(async () => {
+            const transformed = await this.context.css.transformWxClassNames(output.code, output.filename);
+            const compatibleCode = await transformWxCompatibleJavaScript(transformed.code, output.filename);
+            if (this.updateTransport.retainedDeltaCount >= maxRetainedDeltaCount ||
+                this.updateTransport.retainedDeltaBytes + Buffer.byteLength(compatibleCode) >= maxRetainedDeltaBytes) {
+                this.requestFullBuild();
+                return;
+            }
+            this.updateTransport.addDelta(compatibleCode);
+        });
+        return true;
+    }
+    handleError(message) {
+        this.server.config.logger.error('[vite-plugin-taro] WX update failed', { error: new Error(message) });
+    }
+    requestFullBuild() {
+        this.fullBuildScheduler.request();
+    }
+    async waitForInitialBundle() {
+        await this.initialBundle.promise;
+        await this.outputQueue.waitForIdle();
+    }
+    reportOutputError(error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        this.server.config.logger.error(`[vite-plugin-taro] WX development output failed: ${normalizedError.stack ?? normalizedError.message}`);
+    }
+    reportRebuildError(error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        this.server.config.logger.error('[vite-plugin-taro] WX rebuild failed', { error: normalizedError });
+    }
+}
+function writeDevelopmentOutput(outDir, output) {
+    return writeFilesAtomically(output.map((item) => ({
+        file: path.join(outDir, item.fileName),
+        source: item.type === 'chunk' ? item.code : item.source
+    })));
+}
+function setDevelopmentAsset(output, fileName, source) {
+    const index = output.findIndex((item) => item.type === 'asset' && item.fileName === fileName);
+    const asset = { type: 'asset', fileName, source };
+    if (index >= 0)
+        output[index] = asset;
+    else
+        output.push(asset);
+}
+function relativeToViteConfig(outDir, configFile, root) {
+    const configDirectory = configFile ? path.dirname(configFile) : root;
+    const relativePath = path.relative(configDirectory, outDir).replaceAll('\\', '/');
+    if (!relativePath)
+        return '.';
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function isFileInside(file, directory) {
+    if (!directory)
+        return false;
+    const relative = path.relative(directory, file);
+    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+function isSafeJavaScriptPatch(files, output) {
+    if (output.type !== 'Patch' || output.hmrBoundaries.length === 0)
+        return false;
+    if (output.code.includes('__vite__updateStyle') || output.code.includes('.updateStyle('))
+        return false;
+    return files.every((file) => /\.[cm]?[jt]sx?$/.test(file));
+}

package/dist/node/targets/wx/dev-server/full-build-scheduler.d.ts

@@ -0,0 +1,14 @@
+/** Full-build scheduling owned by one WX development session. */
+/** Coalesces trailing-edge requests while guaranteeing one full build at a time. */
+export declare class FullBuildScheduler {
+    private readonly delay;
+    private readonly runBuild;
+    private readonly reportError;
+    private phase;
+    private timer;
+    private work;
+    constructor(delay: number, runBuild: () => Promise<void>, reportError: (error: unknown) => void);
+    request(): void;
+    close(): Promise<void>;
+    private start;
+}

package/dist/node/targets/wx/dev-server/full-build-scheduler.js

@@ -0,0 +1,60 @@
+/** Full-build scheduling owned by one WX development session. */
+/** Coalesces trailing-edge requests while guaranteeing one full build at a time. */
+export class FullBuildScheduler {
+    delay;
+    runBuild;
+    reportError;
+    phase = 'idle';
+    timer;
+    work;
+    constructor(delay, runBuild, reportError) {
+        this.delay = delay;
+        this.runBuild = runBuild;
+        this.reportError = reportError;
+    }
+    request() {
+        switch (this.phase) {
+            case 'closed':
+                return;
+            case 'building':
+                this.phase = 'building-with-pending-request';
+                return;
+            case 'building-with-pending-request':
+                return;
+            case 'idle':
+            case 'scheduled':
+                if (this.timer)
+                    clearTimeout(this.timer);
+                this.phase = 'scheduled';
+                this.timer = setTimeout(() => this.start(), this.delay);
+        }
+    }
+    async close() {
+        if (this.phase === 'closed') {
+            await this.work;
+            return;
+        }
+        this.phase = 'closed';
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.work;
+    }
+    start() {
+        if (this.phase !== 'scheduled')
+            return;
+        this.timer = undefined;
+        this.phase = 'building';
+        this.work = this.runBuild()
+            .catch(this.reportError)
+            .finally(() => {
+            this.work = undefined;
+            if (this.phase === 'closed')
+                return;
+            const repeat = this.phase === 'building-with-pending-request';
+            this.phase = 'idle';
+            if (repeat)
+                this.request();
+        });
+    }
+}

package/dist/node/targets/wx/dev-server/js-utils.d.ts

@@ -0,0 +1,5 @@
+import type { WxOutputFile } from './output.ts';
+/** Lowers generated JavaScript syntax that WeChat's upload parser does not accept. */
+export declare function transformWxCompatibleJavaScript(code: string, filename: string): Promise<string>;
+/** Applies the compatibility transform to every JavaScript chunk in a DevEngine output batch. */
+export declare function transformWxOutputChunks(output: WxOutputFile[]): Promise<void>;