vite-plugin-taro 0.3.2 → 0.4.0

package/dist/node/plugins/wx/dev/dev-host.js

@@ -0,0 +1,352 @@
+import path from 'node:path';
+import colors from 'picocolors';
+import { build } from 'rolldown';
+import { dev, viteReporterPlugin } from 'rolldown/experimental';
+import { once } from '../../../utils/once.js';
+import { resolvePackageFile } from '../../../utils/packages.js';
+import { appShellFileName } from '../module.js';
+import { hmrControlPath, hmrInfoFileName, hmrPatchesFileName, renderHmrInfo, renderInitialHmrPatches, writeHmrFile } from './hmr-files.js';
+import { PatchPublisher } from './patch-publisher.js';
+/**
+ * Creates the wx dev host: the adapter that owns the physical Rolldown DevEngine (created
+ * with dev(...)) and the patch publisher, and replaces Vite's bundledDev.listen so the
+ * engine writes directly to the Mini Program output directory instead of serving browser
+ * HMR over HTTP.
+ */
+export async function createWxDevHost({ server, options }) {
+    const bundledDev = getBundledDev(server);
+    // DevEngine does not reject run() after an initial plugin failure, so settle startup from its first buildEnd result.
+    // Later build errors belong to the running server and continue through onOutput/onHmrUpdates.
+    const initialBuild = Promise.withResolvers();
+    const settleInitialBuild = once((error) => {
+        if (error) {
+            initialBuild.reject(error);
+        }
+        else {
+            initialBuild.resolve();
+        }
+    });
+    const publisher = new PatchPublisher((content) => writeHmrFile(server.config.build.outDir, hmrPatchesFileName, content));
+    // Must install rolldown options before create engine
+    installRolldownOptions();
+    const engine = await createEngine();
+    // The wx dev host owns the only DevEngine. Vite's default listen() would create a second
+    // skip-write engine that renders into memory for browser HMR; instead the physical
+    // engine's initial build must finish before the HTTP server becomes ready, because
+    // DevTools opens the output directory directly and the app requires its files on disk.
+    bundledDev._devEngine = engine;
+    bundledDev.triggerBundleRegenerationIfStale = async () => false;
+    bundledDev.listen = async () => {
+        await Promise.all([engine.run(), initialBuild.promise]);
+        await engine.ensureCurrentBuildFinish();
+    };
+    // Vite binds the port only after initServer (and therefore the initial build) completes, so
+    // the actual port is not observable while onOutput runs for the first build. The App metadata
+    // is written once the port is real; later full builds rewrite it from onOutput.
+    server.httpServer?.once('listening', startFreshBuild);
+    // The runtime's metadata-only reports land on the control path; the buildId in each report
+    // IS the Rolldown client ID.
+    server.middlewares.use(hmrControlPath, (req, res) => void handleReport(req, res));
+    // Append the DevTools project directory line after Vite's own startup banner: DevTools
+    // opens the output directory directly, so the printed path is the one to select.
+    const originalPrintUrls = server.printUrls.bind(server);
+    server.printUrls = () => {
+        originalPrintUrls();
+        server.config.logger.info(`  ${colors.green('➜')}  ${colors.bold('WeChat DevTools')}: ${colors.cyan(relativeToViteConfig(server.config.build.outDir, server.config.configFile, server.config.root))}`);
+    };
+    return {
+        close: async () => {
+            await engine.close();
+        }
+    };
+    /** Rotates the build identity and materializes the App metadata for it. */
+    async function startFreshBuild() {
+        const port = boundPort(server);
+        if (port === undefined) {
+            // The initial output finishes before Vite binds its port. The listening listener
+            // starts the first real client build, avoiding a phantom registered client.
+            return;
+        }
+        const { buildId, previousBuildId } = publisher.startBuild();
+        if (previousBuildId) {
+            await engine.removeClient(previousBuildId);
+        }
+        await engine.registerClient(buildId);
+        // Publish info last: a heap that observes the new identity is guaranteed to see the
+        // matching reset patch file.
+        await writeHmrFile(server.config.build.outDir, hmrPatchesFileName, renderInitialHmrPatches());
+        await writeHmrInfo(server, buildId, port);
+    }
+    async function handleReport(req, res) {
+        if (req.method !== 'POST') {
+            res.statusCode = 404;
+            res.end();
+            return;
+        }
+        try {
+            const report = JSON.parse(await readBody(req));
+            // Only the current build's reports can advance physical delivery;
+            // delayed reports from older builds are ignored so they can never influence the
+            // live build.
+            if (!publisher.isCurrentBuild(report.buildId)) {
+                res.end();
+                return;
+            }
+            if (report.kind === 'rebuild') {
+                engine.triggerFullBuild();
+                res.end();
+                return;
+            }
+            // Commit every newly acknowledged Rolldown payload to this client's ship map.
+            const deliveredFiles = publisher.acknowledge(report.seq);
+            await Promise.all(deliveredFiles.map((fileName) => engine.notifyPayloadDelivered(fileName)));
+            res.end();
+        }
+        catch (e) {
+            logWxError(server.config.logger, 'wx HMR report failed', e);
+            res.statusCode = 400;
+            res.end();
+        }
+    }
+    /** Creates the physical DevEngine with the wx dev host hooks. */
+    async function createEngine() {
+        const rolldownOptions = await bundledDev.getRolldownOptions();
+        if (!rolldownOptions.output || Array.isArray(rolldownOptions.output)) {
+            throw new Error('wx development requires exactly one Rolldown output.');
+        }
+        return dev(rolldownOptions, rolldownOptions.output, {
+            onHmrUpdates: async (result) => {
+                if (result instanceof Error) {
+                    logWxError(server.config.logger, 'wx HMR update failed', result);
+                    return;
+                }
+                // Collect the current client's batch first: one HMR event can carry several
+                // client envelopes, while only the active build may enter its patch history.
+                const batch = [];
+                for (const { clientId, update } of result.updates) {
+                    // Removed and delayed client sessions can still appear in a completed
+                    // engine batch; they must never enter the current build's patch history.
+                    if (!publisher.isCurrentBuild(clientId) || update.type === 'Noop') {
+                        continue;
+                    }
+                    if (update.type === 'Patch') {
+                        batch.push(update);
+                        continue;
+                    }
+                    server.config.logger.info(`[vpt] wx full rebuild required${update.reason ? `: ${update.reason}` : ''}`);
+                    engine.triggerFullBuild();
+                    return;
+                }
+                if (batch.length > 0) {
+                    await publisher.produce(batch);
+                    // server.config.logger.info('[vpt] wx patch produced')
+                }
+            },
+            onOutput: async (result) => {
+                if (result instanceof Error) {
+                    logWxError(server.config.logger, 'wx dev build failed', result);
+                    return;
+                }
+                // A fresh build identity per complete physical build; the App runtime reads it
+                // from hmr/info.js before any module registers.
+                await startFreshBuild();
+            },
+            rebuildStrategy: 'never',
+            watch: { skipWrite: false }
+        });
+    }
+    /** Restores physical Mini Program output conventions after Vite applies browser bundled-dev defaults. */
+    function installRolldownOptions() {
+        const original = bundledDev.getRolldownOptions.bind(bundledDev);
+        bundledDev.getRolldownOptions = async () => {
+            const rolldownOptions = await original();
+            if (Array.isArray(rolldownOptions.output)) {
+                throw new Error('wx development requires one configured Rolldown output.');
+            }
+            rolldownOptions.output ??= {};
+            const output = rolldownOptions.output;
+            const configuredOutput = server.config.build.rolldownOptions.output;
+            if (Array.isArray(configuredOutput)) {
+                throw new Error('wx development supports one configured Rolldown output.');
+            }
+            // Every page entry must depend on hmr/patches.js: DevTools classifies a changed Page
+            // dependency as Page JavaScript hot reload and re-executes live Pages, which is the only
+            // trigger that delivers physical patches while keeping the App heap alive.
+            const pageFiles = new Set(options.pages.map((page) => `${page.path}.js`));
+            const configured = (configuredOutput ?? {});
+            Object.assign(output, configured, {
+                assetFileNames: createStableFileNames(configured.assetFileNames, 'assets/[name][extname]'),
+                banner: createEntryBanner(pageFiles),
+                chunkFileNames: createStableFileNames(configured.chunkFileNames, 'assets/[name].js'),
+                entryFileNames: createStableFileNames(configured.entryFileNames, '[name]'),
+                format: 'es',
+                minify: true,
+                sourcemap: false
+            });
+            rolldownOptions.experimental ??= {};
+            rolldownOptions.experimental.devMode = {
+                ...(typeof rolldownOptions.experimental.devMode === 'object'
+                    ? rolldownOptions.experimental.devMode
+                    : {}),
+                implement: await bundleRuntimeSource(),
+                lazy: false
+            };
+            const reportInitialBuildPlugin = {
+                name: 'vpt:wx-report-initial-build',
+                buildEnd: settleInitialBuild
+            };
+            rolldownOptions.plugins = [rolldownOptions.plugins, reportInitialBuildPlugin, createViteReporter(server)];
+            disableViteOxcSourcemap(rolldownOptions.plugins);
+            return rolldownOptions;
+        };
+    }
+}
+/** The bound HTTP port, or undefined before Vite's server is listening. */
+function boundPort(server) {
+    const httpServer = server.httpServer;
+    if (!httpServer) {
+        return undefined;
+    }
+    const address = httpServer.address();
+    if (!address || typeof address === 'string') {
+        return undefined;
+    }
+    return address.port;
+}
+/** Writes the immutable App metadata every full build starts from. */
+async function writeHmrInfo(server, buildId, port) {
+    const info = {
+        buildId,
+        endpoint: `${server.config.server.https ? 'https' : 'http'}://${resolveEndpointHost(server)}:${port}${hmrControlPath}`
+    };
+    await writeHmrFile(server.config.build.outDir, hmrInfoFileName, renderHmrInfo(info));
+}
+/**
+ * The project directory shown in the DevTools banner, relative to the Vite config:
+ * `dist/wx` instead of the absolute output path, so it can be pasted into DevTools.
+ */
+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}`;
+}
+/** Logs an error with the plugin prefix, distinguishing Error values from unknowns. */
+function logWxError(logger, prefix, error) {
+    if (Error.isError(error)) {
+        logger.error(`[vpt] ${prefix}`, { error });
+    }
+    else {
+        logger.error(`[vpt] ${prefix} with unknown error: ${error}`);
+    }
+}
+// The runtime source is immutable for the host's lifetime (it changes only when the
+// plugin is rebuilt), so the nested bundle runs once and every build reuses it.
+const bundleRuntimeSource = once(
+/** Bundles the runtime host and state machine into one plain script for injection. */
+async function bundleRuntimeSource() {
+    // write: false — only the code is consumed; without it rolldown drops the bundle into
+    // the default dist/ of the running project.
+    const result = await build({
+        input: resolvePackageFile('dist/runtime/wx/dev/dev-runtime.js'),
+        output: { format: 'iife', minify: true, sourcemap: false },
+        write: false
+    });
+    return result.output[0].code;
+});
+const maximumBodyBytes = 64 * 1024;
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString('utf8');
+            if (body.length > maximumBodyBytes) {
+                reject(new Error('report body too large'));
+                req.destroy();
+            }
+        });
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+/** The bound address host, or loopback for wildcard binds; IPv6 literals are bracketed. */
+function resolveEndpointHost(server) {
+    const address = server.httpServer?.address();
+    if (!address || typeof address === 'string') {
+        return '127.0.0.1';
+    }
+    if (address.address === '0.0.0.0' || address.address === '::') {
+        // Wildcard binds accept loopback connections; 127.0.0.1 is the address DevTools can reach.
+        return '127.0.0.1';
+    }
+    return address.address.includes(':') ? `[${address.address}]` : address.address;
+}
+/**
+ * Prepends entry banners. Banners are plain text appended after Rolldown's analysis, so the
+ * requires never become chunk dependencies (a bare require inside the injected runtime source
+ * would stall the build), and the wx render pipeline keeps this text after the hoisted chunk
+ * requires — so the runtime chunk exists before these run:
+ * - the app entry loads hmr/info.js and initializes the runtime before any module registers;
+ * - every page requires hmr/patches.js, the changed dependency that makes DevTools re-execute
+ *   live Pages and thereby load physical updates.
+ */
+function createEntryBanner(pageFiles) {
+    return (chunk) => {
+        if (chunk.name === appShellFileName) {
+            return "__rolldown_runtime__.initialize(require('./hmr/info.js'));\n";
+        }
+        if (pageFiles.has(chunk.name)) {
+            // Page files live at `pages/<route>/index.js`, so the dependency path must be
+            // computed relative to each page's own directory.
+            const patchesPath = path.posix.relative(path.posix.dirname(chunk.fileName), 'hmr/patches.js');
+            return `require('${patchesPath}');\n`;
+        }
+        return '';
+    };
+}
+function createStableFileNames(addon, fallback) {
+    if (typeof addon === 'function') {
+        return (value) => toStableFileName(String(addon(value)));
+    }
+    return toStableFileName(typeof addon === 'string' ? addon : fallback);
+}
+function toStableFileName(fileName) {
+    return fileName
+        .replace(/(^|\/)\[hash(?::\d+)?\](?=\.|$)/g, '$1[name]')
+        .replace(/[-_.]\[hash(?::\d+)?\]/g, '')
+        .replace(/\[hash(?::\d+)?\]/g, '[name]');
+}
+function disableViteOxcSourcemap(pluginOption) {
+    if (Array.isArray(pluginOption)) {
+        pluginOption.forEach(disableViteOxcSourcemap);
+        return;
+    }
+    if (!pluginOption || typeof pluginOption !== 'object') {
+        return;
+    }
+    const plugin = pluginOption;
+    if (plugin.name === 'builtin:vite-transform' && plugin._options?.transformOptions) {
+        plugin._options.transformOptions.sourcemap = false;
+    }
+}
+function createViteReporter(server) {
+    const { build, logger, root } = server.config;
+    return viteReporterPlugin({
+        assetsDir: path.join(build.assetsDir, '/'),
+        chunkLimit: 2000,
+        isLib: Boolean(build.lib),
+        isTty: Boolean(process.stdout.isTTY && !process.env.CI),
+        logInfo: (message) => logger.info(message),
+        reportCompressedSize: false,
+        root,
+        warnLargeChunks: false
+    });
+}
+function getBundledDev(server) {
+    const bundledDev = server.environments.client.bundledDev;
+    if (!bundledDev) {
+        throw new Error('Vite did not create the wx bundled-development environment.');
+    }
+    return bundledDev;
+}

package/dist/node/plugins/wx/dev/hmr-files.d.ts

@@ -0,0 +1,28 @@
+import type { BindingClientHmrUpdate } from 'rolldown/experimental';
+export declare const hmrInfoFileName = "hmr/info.js";
+export declare const hmrPatchesFileName = "hmr/patches.js";
+/** Report endpoint path served by the wx dev control edge. */
+export declare const hmrControlPath = "/__vpt_hmr__";
+/** Immutable App metadata for the current complete physical build. */
+export type HmrInfo = Readonly<{
+    buildId: string;
+    endpoint: string;
+}>;
+/** The Patch variant of Rolldown's per-client HMR update, admitted into the patch history. */
+export type PatchUpdate = Extract<BindingClientHmrUpdate['update'], {
+    type: 'Patch';
+}>;
+/** Renders the synchronous CommonJS metadata module loaded by the runtime chunk. */
+export declare function renderHmrInfo(info: HmrInfo): string;
+/** Provides a valid dependency before the host has a patch range to publish. */
+export declare function renderInitialHmrPatches(): string;
+/**
+ * Renders the missing patch suffix as a passive physical delivery module.
+ *
+ * DevTools re-executes the Page because this file changed. The module only stores the literal
+ * Rolldown factories in the persistent App runtime; storePatches applies them synchronously,
+ * so the Page's imports below the require resolve against the freshly registered modules.
+ */
+export declare function renderHmrPatches(buildId: string, patches: readonly PatchUpdate[]): string;
+/** Publishes one physical HMR file (direct write; atomic rename is reserved for later analysis). */
+export declare function writeHmrFile(outDir: string, fileName: string, source: string): Promise<void>;

package/dist/node/plugins/wx/dev/hmr-files.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export const hmrInfoFileName = 'hmr/info.js';
+export const hmrPatchesFileName = 'hmr/patches.js';
+/** Report endpoint path served by the wx dev control edge. */
+export const hmrControlPath = '/__vpt_hmr__';
+/** Renders the synchronous CommonJS metadata module loaded by the runtime chunk. */
+export function renderHmrInfo(info) {
+    return `module.exports = Object.freeze(${JSON.stringify(info)});\n`;
+}
+/** Provides a valid dependency before the host has a patch range to publish. */
+export function renderInitialHmrPatches() {
+    return 'module.exports = undefined;\n';
+}
+/**
+ * Renders the missing patch suffix as a passive physical delivery module.
+ *
+ * DevTools re-executes the Page because this file changed. The module only stores the literal
+ * Rolldown factories in the persistent App runtime; storePatches applies them synchronously,
+ * so the Page's imports below the require resolve against the freshly registered modules.
+ */
+export function renderHmrPatches(buildId, patches) {
+    if (patches.length === 0) {
+        throw new Error('Cannot render an empty WX patch range.');
+    }
+    const rendered = patches.map((patch) => `{seq: ${patch.seq}, changedIds: ${JSON.stringify(patch.changedIds)}, factory: () => {\n${patch.code}\n}}`);
+    return `__rolldown_runtime__.storePatches({buildId: ${JSON.stringify(buildId)}, patches: [${rendered.join(',')}]});\n`;
+}
+/** Publishes one physical HMR file (direct write; atomic rename is reserved for later analysis). */
+export async function writeHmrFile(outDir, fileName, source) {
+    const filePath = path.join(outDir, fileName);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, source);
+}

package/dist/node/plugins/wx/dev/patch-publisher.d.ts

@@ -0,0 +1,22 @@
+import { type PatchUpdate } from './hmr-files.ts';
+/** Abstracts the physical patches write; the engine owns the file destination. */
+export type WritePatches = (content: string) => Promise<void>;
+/** Owns one build's unacknowledged patches and physical publish decision. */
+export declare class PatchPublisher {
+    private readonly writePatches;
+    private buildId;
+    /** Executable updates retained only until the runtime acknowledges physical delivery. */
+    private readonly pendingPatches;
+    constructor(writePatches: WritePatches);
+    /** True when the buildId belongs to the current full build. */
+    isCurrentBuild(buildId: string): boolean;
+    /** Begins a fresh build and returns both sides of the client-session rotation. */
+    startBuild(): Readonly<{
+        buildId: string;
+        previousBuildId: string | undefined;
+    }>;
+    /** Appends a Rolldown batch and publishes every unacknowledged patch. */
+    produce(patches: readonly PatchUpdate[]): Promise<void>;
+    /** Removes the pending prefix covered by the runtime's Rolldown sequence receipt. */
+    acknowledge(seq: number): string[];
+}

package/dist/node/plugins/wx/dev/patch-publisher.js

@@ -0,0 +1,40 @@
+import { randomUUID } from 'node:crypto';
+import { renderHmrPatches } from './hmr-files.js';
+/** Owns one build's unacknowledged patches and physical publish decision. */
+export class PatchPublisher {
+    writePatches;
+    buildId;
+    /** Executable updates retained only until the runtime acknowledges physical delivery. */
+    pendingPatches = [];
+    // Explicit field assignment: node --test strips types and does not support parameter properties.
+    constructor(writePatches) {
+        this.writePatches = writePatches;
+    }
+    /** True when the buildId belongs to the current full build. */
+    isCurrentBuild(buildId) {
+        return buildId === this.buildId;
+    }
+    /** Begins a fresh build and returns both sides of the client-session rotation. */
+    startBuild() {
+        const previousBuildId = this.buildId;
+        const buildId = randomUUID();
+        this.buildId = buildId;
+        this.pendingPatches.length = 0;
+        return { buildId, previousBuildId };
+    }
+    /** Appends a Rolldown batch and publishes every unacknowledged patch. */
+    async produce(patches) {
+        if (this.buildId === undefined || patches.length === 0)
+            return;
+        this.pendingPatches.push(...patches);
+        await this.writePatches(renderHmrPatches(this.buildId, this.pendingPatches));
+    }
+    /** Removes the pending prefix covered by the runtime's Rolldown sequence receipt. */
+    acknowledge(seq) {
+        let deliveredCount = 0;
+        while (deliveredCount < this.pendingPatches.length && this.pendingPatches[deliveredCount].seq <= seq) {
+            deliveredCount++;
+        }
+        return this.pendingPatches.splice(0, deliveredCount).map((patch) => patch.filename);
+    }
+}

package/dist/node/plugins/wx/dev/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { PluginOption } from 'vite';
+import type { VitePluginTaroOptions } from '../../../../options.ts';
+/**
+ * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter
+ * (config, runtime lowering, dev host) plus the React Refresh adaptation transforms.
+ */
+export declare function createWxDevelopmentPlugin(options: VitePluginTaroOptions): PluginOption[];

package/dist/node/plugins/wx/dev/plugin.js

@@ -0,0 +1,73 @@
+import { transformWithOxc } from 'vite';
+import { esTarget } from '../../../utils/constant.js';
+import { rolldownRuntimeId } from '../module.js';
+import { memoize } from '../../../utils/memoize.js';
+import { createWxDevHost } from './dev-host.js';
+import { createWxReactRefreshTransforms } from './react-refresh.js';
+/**
+ * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter
+ * (config, runtime lowering, dev host) plus the React Refresh adaptation transforms.
+ */
+export function createWxDevelopmentPlugin(options) {
+    let host = null;
+    return [
+        {
+            name: 'vpt:wx-dev',
+            apply: 'serve',
+            config() {
+                return {
+                    build: {
+                        // Disable maps in resolved environment config as well as final output so Oxc and Babel skip producing
+                        // intermediate maps that Rolldown would discard.
+                        sourcemap: false
+                    },
+                    experimental: {
+                        // Ask Vite to resolve its bundled-development graph and expose the private adapter instance. The wx
+                        // configureServer hook replaces only its startup method with the directly writing DevEngine.
+                        bundledDev: true
+                    }
+                };
+            },
+            transform: {
+                order: 'post',
+                // The dev-mode transform assembles the runtime chunk (Rolldown's base runtime
+                // plus our injected implement) as this module's transform output, which
+                // bypasses the build's es2018 lowering. Real-device engines and WeChat's
+                // upload parser predate class fields and nullish operators, so the assembled
+                // runtime is lowered here — the only module that needs it. The exact id
+                // filter needs no code scan; the id must stay in sync with rolldownRuntimeId
+                // in module.ts (kept as a regex for the Rolldown-side filter).
+                filter: { id: /^\0rolldown\/runtime\.js(?:\?|$)/ },
+                handler(code, id) {
+                    // The `setPublicClassFields` assumption emits plain `this.x = ...`
+                    // assignments instead of external helpers, whose references the later
+                    // minifier would mangle.
+                    return fixRolldownRuntime(code);
+                }
+            },
+            configureServer: {
+                // Install after Vite and user plugins have finished configuring the environment, but before server.listen()
+                // asks bundledDev to create its hard-coded skip-write DevEngine.
+                order: 'post',
+                async handler(server) {
+                    host = await createWxDevHost({ server, options });
+                }
+            },
+            closeBundle() {
+                return host?.close();
+            }
+        },
+        ...createWxReactRefreshTransforms()
+    ];
+}
+// The assembled runtime chunk is byte-identical on every build (the base runtime and the
+// bundled implement are immutable for the server's lifetime), so the lowering runs once
+// and every build reuses it.
+const fixRolldownRuntime = memoize((code) => {
+    return transformWithOxc(code, rolldownRuntimeId, {
+        lang: 'js',
+        target: esTarget,
+        sourcemap: false,
+        assumptions: { setPublicClassFields: true }
+    });
+});

package/dist/node/plugins/wx/dev/react-refresh.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+/**
+ * Creates the serve-only React Refresh adaptation transforms for the wx target.
+ *
+ * @vitejs/plugin-react's generated refresh code assumes the web HTML preamble and a browser
+ * global scope; wx has neither. Each transform adapts one piece of that contract:
+ * - the refresh runtime module (id-filtered): the vendored runtime reads and assigns
+ *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation
+ *   — the preamble's `injectIntoGlobalHook` call has no HTML home in wx;
+ * - react-family modules (filtered on free references): the DevTools hook is read as a free
+ *   variable, which the WeChat runtime scope never resolves against `global` — every free
+ *   reference becomes an explicit member access;
+ * - boundary modules (filtered on the guard): the preamble's `$RefreshReg$` global is not
+ *   needed because the transform generates local wrappers over the imported refresh
+ *   runtime, so the guard that checks for the global is removed.
+ *
+ * Each transform's filter is its routing: the three domains are disjoint, so a module is
+ * transformed by at most one of them, and modules outside all three never reach a handler.
+ */
+export declare function createWxReactRefreshTransforms(): Plugin[];