vite-plugin-taro 0.2.2 → 0.3.0

package/dist/node/targets/wx/dev-server/vite-bundled-dev-adapter.js

@@ -0,0 +1,145 @@
+import path from 'node:path';
+import { wxPagePreloadFile, wxUpdateControlFile, wxUpdateFile } from '../development-files.js';
+import { wxRolldownRuntimeSource } from './rolldown-runtime-source.js';
+const clientId = 'vite-plugin-taro-wx';
+/** Isolates the private Vite bundled-development API used by the WX session. */
+export class ViteBundledDevAdapter {
+    config;
+    server;
+    callbacks;
+    bundledDev;
+    constructor(config, server, callbacks) {
+        this.config = config;
+        this.server = server;
+        this.callbacks = callbacks;
+    }
+    install() {
+        const bundledDev = this.server.environments.client.bundledDev;
+        if (!bundledDev)
+            throw new Error('vite-plugin-taro requires Vite bundled development for WX development.');
+        if (typeof bundledDev.getRolldownOptions !== 'function' ||
+            typeof bundledDev.storeOutputFiles !== 'function' ||
+            typeof bundledDev.handleHmrOutput !== 'function') {
+            throw new Error('vite-plugin-taro does not support this Vite bundled-development API shape.');
+        }
+        this.bundledDev = bundledDev;
+        this.installOptions(bundledDev);
+        this.installOutput(bundledDev);
+        this.installPatches(bundledDev);
+        this.installListener(bundledDev);
+    }
+    registerBundleModules(output) {
+        const moduleIds = new Set();
+        for (const item of output) {
+            if (item.type !== 'chunk')
+                continue;
+            for (const id of Object.keys(item.modules ?? {}))
+                moduleIds.add(toStableModuleId(id, this.config.root));
+        }
+        this.registerModules([...moduleIds]);
+        return moduleIds.size;
+    }
+    registerPatchModules(code) {
+        const moduleIds = new Set();
+        for (const match of code.matchAll(/create(?:Esm|Cjs)Initializer\("([^"]+)"/g))
+            moduleIds.add(match[1]);
+        this.registerModules([...moduleIds]);
+    }
+    registerModules(moduleIds) {
+        if (moduleIds.length)
+            this.bundledDev?._devEngine?.registerModules(clientId, moduleIds);
+    }
+    async rebuild() {
+        const engine = this.bundledDev?._devEngine;
+        if (!engine)
+            return;
+        engine.triggerFullBuild();
+        await engine.ensureLatestBuildOutput();
+    }
+    installOptions(bundledDev) {
+        const getRolldownOptions = bundledDev.getRolldownOptions.bind(bundledDev);
+        bundledDev.getRolldownOptions = async () => {
+            const options = await getRolldownOptions();
+            if (!options.output)
+                options.output = {};
+            const output = getFirstOutput(options);
+            const configuredOutput = this.config.build.rolldownOptions.output;
+            const desiredOutput = Array.isArray(configuredOutput) ? configuredOutput[0] : configuredOutput;
+            Object.assign(output, desiredOutput, {
+                format: 'cjs',
+                sourcemap: false,
+                minify: false,
+                banner: createWxDevelopmentBanner
+            });
+            options.experimental ??= {};
+            options.experimental.devMode = {
+                ...(typeof options.experimental.devMode === 'object' ? options.experimental.devMode : {}),
+                lazy: false,
+                // Rolldown compiles this source into runtime.js before any Taro/React module executes.
+                implement: wxRolldownRuntimeSource
+            };
+            return options;
+        };
+    }
+    installOutput(bundledDev) {
+        const storeOutputFiles = bundledDev.storeOutputFiles.bind(bundledDev);
+        bundledDev.storeOutputFiles = (output) => {
+            storeOutputFiles(output);
+            this.callbacks.onOutput(output);
+        };
+    }
+    installPatches(bundledDev) {
+        const handleHmrOutput = bundledDev.handleHmrOutput.bind(bundledDev);
+        bundledDev.handleHmrOutput = (client, files, output, info) => {
+            if (output.type === 'Noop')
+                return;
+            if (this.callbacks.onPatch(files, output))
+                handleHmrOutput(client, files, output, info);
+        };
+    }
+    installListener(bundledDev) {
+        const listen = bundledDev.listen.bind(bundledDev);
+        bundledDev.listen = async () => {
+            await listen();
+            bundledDev.clients.setupIfNeeded({ send: (payload) => this.handlePayload(payload) }, clientId);
+            const engine = bundledDev._devEngine;
+            if (!engine)
+                throw new Error('vite-plugin-taro expected Vite to initialize the WX DevEngine.');
+            await engine.ensureCurrentBuildFinish();
+            if ((await engine.getBundleState()).lastBuildErrored) {
+                throw new Error('The initial WX bundled-development build failed.');
+            }
+            await this.callbacks.waitForInitialBundle();
+        };
+    }
+    handlePayload(payload) {
+        if (typeof payload !== 'object' || payload === null)
+            return;
+        const candidate = payload;
+        if (candidate.type === 'error' && typeof candidate.err?.message === 'string') {
+            this.callbacks.onError(candidate.err.message);
+        }
+    }
+}
+function toStableModuleId(id, root) {
+    const normalizedId = id.replace(/\\/g, '/');
+    if (normalizedId.startsWith('\0') || !path.posix.isAbsolute(normalizedId))
+        return normalizedId;
+    return path.posix.relative(root.replace(/\\/g, '/'), normalizedId);
+}
+function getFirstOutput(options) {
+    if (!Array.isArray(options.output))
+        return options.output;
+    const output = options.output[0] ?? {};
+    options.output[0] = output;
+    return output;
+}
+/** Adds native direct dependencies whose execution order cannot be represented through the Rolldown graph. */
+function createWxDevelopmentBanner(chunk) {
+    if (chunk.fileName === 'app.js')
+        return `require(${JSON.stringify(`./${wxUpdateControlFile}`)});`;
+    if (!chunk.fileName.startsWith('pages/') || !chunk.fileName.endsWith('.js'))
+        return '';
+    const prefix = '../'.repeat(chunk.fileName.split('/').length - 1);
+    return `require(${JSON.stringify(`${prefix}runtime.js`)});require(${JSON.stringify(`${prefix}${wxPagePreloadFile}`)});require(${JSON.stringify(`${prefix}${wxUpdateFile}`)});`;
+}

package/dist/node/targets/wx/development-files.d.ts

@@ -0,0 +1,8 @@
+/** Plugin-owned files added only to a WX development output. */
+export declare const wxDevelopmentDirectory = "vpt-hmr";
+/** App-only metadata containing the local transport URL, token, and build ID. */
+export declare const wxUpdateControlFile = "vpt-hmr/control.js";
+/** Stable page-component initialization required before replaying retained updates. */
+export declare const wxPagePreloadFile = "vpt-hmr/preload.js";
+/** The one mutable, literal JavaScript update dependency required by every page. */
+export declare const wxUpdateFile = "vpt-hmr/update.js";

package/dist/node/targets/wx/development-files.js

@@ -0,0 +1,8 @@
+/** Plugin-owned files added only to a WX development output. */
+export const wxDevelopmentDirectory = 'vpt-hmr';
+/** App-only metadata containing the local transport URL, token, and build ID. */
+export const wxUpdateControlFile = `${wxDevelopmentDirectory}/control.js`;
+/** Stable page-component initialization required before replaying retained updates. */
+export const wxPagePreloadFile = `${wxDevelopmentDirectory}/preload.js`;
+/** The one mutable, literal JavaScript update dependency required by every page. */
+export const wxUpdateFile = `${wxDevelopmentDirectory}/update.js`;

package/dist/node/targets/wx/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 WX build and development lifecycle. */
+export declare function createWxTargetPlugins(context: BuildContext): PluginOption[];
+/** Supplies the complete WX target configuration from the same target owner as its plugin. */
+export declare function createWxViteConfig(context: BuildContext): UserConfig;

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

@@ -0,0 +1,143 @@
+import path from 'node:path';
+import { normalizeModuleId, stripVirtualPrefix } from '../../utils/modules.js';
+import { packageRequire } from '../../utils/packages.js';
+import { emitWxCompanionAssets } from './companion-assets.js';
+import { WxDevelopmentSession } from './dev-server/development-session.js';
+import { transformWxReactRefreshModule } from './react-refresh.js';
+import { emitWxEntryChunks, isWxVirtualModuleId, loadWxVirtualModule, virtualWxAppId } from './virtual-modules.js';
+const taroWxComponentsPath = packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react');
+const vitePluginTaroSourcePath = normalizeModuleId(path.dirname(packageRequire.resolve('vite-plugin-taro')));
+const taroVersion = String(packageRequire('@tarojs/runtime/package.json').version);
+/** Creates the plugins that own the complete WX build and development lifecycle. */
+export function createWxTargetPlugins(context) {
+    return [createWxTargetPlugin(context)];
+}
+function createWxTargetPlugin(context) {
+    let developmentSession;
+    return {
+        name: 'vite-plugin-taro:wx',
+        resolveId: {
+            order: 'pre',
+            handler(id) {
+                return isWxVirtualModuleId(id) ? `\0${id}` : undefined;
+            }
+        },
+        load: {
+            order: 'post',
+            handler(id) {
+                const cleanId = stripVirtualPrefix(id);
+                emitWxEntryChunks(this, context, cleanId);
+                return loadWxVirtualModule(cleanId, context);
+            }
+        },
+        transform: {
+            order: 'post',
+            async handler(code, id) {
+                if (!context.development)
+                    return;
+                const transformed = await transformWxReactRefreshModule(code, id, context.project.appComponentFile);
+                return transformed === code ? undefined : transformed;
+            }
+        },
+        generateBundle: {
+            order: 'post',
+            handler(_, bundle) {
+                emitWxCompanionAssets(this, bundle, context);
+            }
+        },
+        configureServer: {
+            order: 'post',
+            handler(server) {
+                developmentSession = new WxDevelopmentSession(context, server);
+                developmentSession.install();
+            }
+        },
+        closeBundle() {
+            return developmentSession?.close();
+        }
+    };
+}
+/** Supplies the complete WX target configuration from the same target owner as its plugin. */
+export function createWxViteConfig(context) {
+    return {
+        define: createWxTaroDefines(),
+        experimental: context.development ? { bundledDev: true } : undefined,
+        css: {
+            lightningcss: {
+                visitor: {
+                    // keep CSS3 style single colon :before, :after
+                    // while WeChat Mini Program does not support the double colons versions
+                    Selector(selector) {
+                        return selector.map((component) => {
+                            if (component.type === 'pseudo-element' &&
+                                (component.kind === 'before' || component.kind === 'after')) {
+                                return {
+                                    type: 'pseudo-element',
+                                    kind: 'custom',
+                                    name: component.kind
+                                };
+                            }
+                            return component;
+                        });
+                    }
+                }
+            }
+        },
+        resolve: {
+            alias: [{ find: /^@tarojs\/components$/, replacement: taroWxComponentsPath }]
+        },
+        build: {
+            target: 'es2018',
+            assetsInlineLimit: 1024,
+            cssCodeSplit: false,
+            cssMinify: context.development ? false : 'lightningcss',
+            minify: !context.development,
+            rolldownOptions: {
+                input: { app: virtualWxAppId },
+                experimental: {
+                    // remove vite virtual module \0 in comments, which causes WeChat DevTools failed to compile
+                    attachDebugInfo: 'none'
+                },
+                output: {
+                    format: 'cjs',
+                    entryFileNames: '[name].js',
+                    assetFileNames: 'assets/[name][extname]',
+                    chunkFileNames: ({ name }) => `${name === 'rolldown-runtime' ? 'runtime' : name}.js`,
+                    strictExecutionOrder: true,
+                    codeSplitting: {
+                        includeDependenciesRecursively: false,
+                        minSize: 0,
+                        groups: [
+                            { name: 'taro', test: isWxTaroChunkModule, priority: 100 },
+                            { name: 'vendors', test: isNodeModule, priority: 10 },
+                            { name: 'common', minShareCount: 2, minModuleSize: 1, priority: 1 }
+                        ]
+                    }
+                }
+            }
+        }
+    };
+}
+function createWxTaroDefines() {
+    return {
+        'process.env.FRAMEWORK': JSON.stringify('react'),
+        'process.env.SUPPORT_TARO_POLYFILL': JSON.stringify('disabled'),
+        'process.env.TARO_ENV': JSON.stringify('weapp'),
+        'process.env.TARO_PLATFORM': JSON.stringify('mini'),
+        'process.env.TARO_VERSION': JSON.stringify(taroVersion),
+        ENABLE_ADJACENT_HTML: 'false',
+        ENABLE_CLONE_NODE: 'false',
+        ENABLE_CONTAINS: 'false',
+        ENABLE_INNER_HTML: 'false',
+        ENABLE_MUTATION_OBSERVER: 'false',
+        ENABLE_SIZE_APIS: 'false',
+        ENABLE_TEMPLATE_CONTENT: 'false'
+    };
+}
+function isWxTaroChunkModule(id) {
+    const normalizedId = normalizeModuleId(id);
+    return normalizedId.includes('/node_modules/@tarojs/') || normalizedId.startsWith(`${vitePluginTaroSourcePath}/`);
+}
+function isNodeModule(id) {
+    return normalizeModuleId(id).includes('/node_modules/');
+}

package/dist/node/targets/wx/react-refresh.d.ts

@@ -0,0 +1,4 @@
+/** Rewrites Vite's browser-oriented Refresh output for the WX App Service global environment. */
+export declare function transformWxReactRefreshModule(code: string, id: string, appComponentFile: string): Promise<string>;
+/** Creates the virtual preamble that installs React Refresh before the generated WX App entry executes. */
+export declare function createWxReactRefreshPreambleSource(): string;

package/dist/node/targets/wx/react-refresh.js

@@ -0,0 +1,38 @@
+import { transformWithOxc } from 'vite';
+import { normalizeModuleId } from '../../utils/modules.js';
+/** Rewrites Vite's browser-oriented Refresh output for the WX App Service global environment. */
+export async function transformWxReactRefreshModule(code, id, appComponentFile) {
+    const appFile = normalizeModuleId(appComponentFile);
+    const instrumented = normalizeModuleId(id) === appFile ? await instrumentWxAppComponent(code, appFile) : code;
+    return instrumented
+        .replaceAll('window.$Refresh', 'globalThis.$Refresh')
+        .replaceAll('window.__registerBeforePerformReactRefresh', 'globalThis.__registerBeforePerformReactRefresh')
+        .replaceAll('window.__getReactRefreshIgnoredExports', 'globalThis.__getReactRefreshIgnoredExports')
+        .replace('export function register(type, id) {', 'export function register(type, id) {\n  if (globalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?.blockRefreshRegistration) return')
+        .replace('\n  performReactRefresh()\n', '\n  globalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?.afterRefresh?.(performReactRefresh())\n');
+}
+/** Creates the virtual preamble that installs React Refresh before the generated WX App entry executes. */
+export function createWxReactRefreshPreambleSource() {
+    return `import RefreshRuntime from '/@react-refresh'
+RefreshRuntime.injectIntoGlobalHook(globalThis)
+globalThis.$RefreshReg$ = () => {}
+globalThis.$RefreshSig$ = () => (type) => type
+`;
+}
+/** Adds Refresh registration to JSX-free App modules that Vite's normal JSX transform would otherwise skip. */
+async function instrumentWxAppComponent(code, appFile) {
+    const transformed = await transformWithOxc(code, appFile, {
+        lang: 'js',
+        sourcemap: false,
+        jsx: { refresh: true }
+    });
+    return `import {
+    createSignatureFunctionForTransform as __wxCreateRefreshSignature,
+    register as __wxRegisterRefreshType
+} from '/@react-refresh'
+const $RefreshReg$ = (type, id) => __wxRegisterRefreshType(type, ${JSON.stringify(`${appFile} `)} + id)
+const $RefreshSig$ = __wxCreateRefreshSignature
+${transformed.code}
+if (import.meta.hot) import.meta.hot.accept()
+`;
+}

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

@@ -0,0 +1,16 @@
+import type { BuildContext } from '../../build-context.ts';
+/** Generated native App entry. */
+export declare const virtualWxAppId = "virtual:vite-plugin-taro/wx/app";
+type WxChunkEmitter = {
+    emitFile(chunk: {
+        type: 'chunk';
+        id: string;
+        fileName: string;
+        implicitlyLoadedAfterOneOf: string[];
+    }): string;
+};
+export declare function isWxVirtualModuleId(id: string): boolean;
+export declare function loadWxVirtualModule(id: string, context: BuildContext): string | undefined;
+/** Registers every configured page and the shared recursive component as eager WX entry chunks. */
+export declare function emitWxEntryChunks(emitter: WxChunkEmitter, context: BuildContext, id: string): void;
+export {};

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

@@ -0,0 +1,120 @@
+import { createPageComponentImportPath, toViteFileImportPath } from '../../utils/modules.js';
+import { resolvePackageFile } from '../../utils/packages.js';
+import { wxPagePreloadFile } from './development-files.js';
+import { createWxReactRefreshPreambleSource } from './react-refresh.js';
+const wxTaroRuntimeImportPath = runtimeImportPath('taro-runtime.js');
+const wxPageUpdateImportPath = runtimeImportPath('page-update.js');
+const wxUpdateClientImportPath = runtimeImportPath('update-client.js');
+/** Generated native App entry. */
+export const virtualWxAppId = 'virtual:vite-plugin-taro/wx/app';
+/** Generated recursive Taro component entry. */
+const virtualWxComponentId = 'virtual:vite-plugin-taro/wx/component';
+/** Prefix for one generated native entry per configured page route. */
+const virtualWxPageIdPrefix = 'virtual:vite-plugin-taro/wx/page/';
+/** App bootstrap module that installs React Refresh globals before application modules execute. */
+const virtualWxRefreshPreambleId = 'virtual:vite-plugin-taro/wx/refresh-preamble';
+/** Development-only entry that initializes all configured page components before update replay. */
+const virtualWxPagePreloadId = 'virtual:vite-plugin-taro/wx/page-preload';
+export function isWxVirtualModuleId(id) {
+    return (id === virtualWxAppId ||
+        id === virtualWxComponentId ||
+        id === virtualWxRefreshPreambleId ||
+        id === virtualWxPagePreloadId ||
+        id.startsWith(virtualWxPageIdPrefix));
+}
+export function loadWxVirtualModule(id, context) {
+    if (id === virtualWxRefreshPreambleId) {
+        return createWxReactRefreshPreambleSource();
+    }
+    if (id === virtualWxAppId) {
+        return createWxAppEntrySource(context);
+    }
+    if (id === virtualWxComponentId) {
+        return createWxComponentEntrySource();
+    }
+    if (id === virtualWxPagePreloadId) {
+        return createWxPagePreloadSource(context);
+    }
+    if (id.startsWith(virtualWxPageIdPrefix)) {
+        const pagePath = id.slice(virtualWxPageIdPrefix.length);
+        const page = context.project.pages.find((candidate) => candidate.path === pagePath);
+        if (page) {
+            return createWxPageEntrySource(page, context);
+        }
+    }
+}
+/** Registers every configured page and the shared recursive component as eager WX entry chunks. */
+export function emitWxEntryChunks(emitter, context, id) {
+    if (id !== virtualWxAppId)
+        return;
+    for (const page of context.project.pages) {
+        emitter.emitFile({
+            type: 'chunk',
+            id: `${virtualWxPageIdPrefix}${page.path}`,
+            fileName: `${page.path}.js`,
+            implicitlyLoadedAfterOneOf: [id]
+        });
+    }
+    emitter.emitFile({
+        type: 'chunk',
+        id: virtualWxComponentId,
+        fileName: 'comp.js',
+        implicitlyLoadedAfterOneOf: [id]
+    });
+    if (context.development) {
+        emitter.emitFile({
+            type: 'chunk',
+            id: virtualWxPagePreloadId,
+            fileName: wxPagePreloadFile,
+            implicitlyLoadedAfterOneOf: [id]
+        });
+    }
+}
+function createWxAppEntrySource(context) {
+    const refreshPreamble = context.development ? `import ${JSON.stringify(virtualWxRefreshPreambleId)}\n` : '';
+    const updateClient = context.development
+        ? `import { startWxUpdateClient } from ${JSON.stringify(wxUpdateClientImportPath)}\n`
+        : '';
+    return `${refreshPreamble}${updateClient}import { createReactApp, ReactDOM } from ${JSON.stringify(wxTaroRuntimeImportPath)}
+import React from 'react'
+import AppComponent from ${JSON.stringify(toViteFileImportPath(context.project.appComponentFile))}
+
+const appConfig = ${JSON.stringify(context.project.appConfig)}
+App(createReactApp(AppComponent, React, ReactDOM, appConfig))
+${context.development ? 'startWxUpdateClient()' : ''}
+`;
+}
+function createWxPageEntrySource(page, context) {
+    const hotUpdateImport = context.development
+        ? `import { decorateWxPageConfig, registerWxPage } from ${JSON.stringify(wxPageUpdateImportPath)}\n`
+        : '';
+    const createConfig = `createPageConfig(PageComponent, '${page.path}', { root: { cn: [] } }, pageConfig)`;
+    const pageRegistration = context.development
+        ? `registerWxPage(${JSON.stringify(page.path)}, () => Page(taroPageConfig))`
+        : 'Page(taroPageConfig)';
+    return `${hotUpdateImport}import { createPageConfig } from ${JSON.stringify(wxTaroRuntimeImportPath)}
+import PageComponent from ${JSON.stringify(createPageComponentImportPath(page.path))}
+
+const pageConfig = ${JSON.stringify(page.config)}
+const taroPageConfig = ${context.development ? `decorateWxPageConfig(${createConfig})` : createConfig}
+if (PageComponent && PageComponent.behaviors) {
+  taroPageConfig.behaviors = (taroPageConfig.behaviors || []).concat(PageComponent.behaviors)
+}
+${pageRegistration}
+`;
+}
+function createWxPagePreloadSource(context) {
+    const imports = context.project.pages.map((page, index) => {
+        return `import Page${index} from ${JSON.stringify(createPageComponentImportPath(page.path))}`;
+    });
+    return `${imports.join('\n')}\nvoid [${context.project.pages.map((_, index) => `Page${index}`).join(', ')}]\n`;
+}
+function runtimeImportPath(fileName) {
+    return toViteFileImportPath(resolvePackageFile('dist/runtime/wx', fileName));
+}
+function createWxComponentEntrySource() {
+    return `import { createRecursiveComponentConfig } from ${JSON.stringify(wxTaroRuntimeImportPath)}
+
+Component(createRecursiveComponentConfig())
+`;
+}

package/dist/node/utils/async.d.ts

@@ -0,0 +1,8 @@
+/** Generic asynchronous coordination helpers for Node-side plugin services. */
+export declare class SerializedTaskQueue {
+    private readonly reportError;
+    private tail;
+    constructor(reportError: (error: unknown) => void);
+    enqueue(task: () => Promise<void>): Promise<void>;
+    waitForIdle(): Promise<void>;
+}

package/dist/node/utils/async.js

@@ -0,0 +1,16 @@
+/** Generic asynchronous coordination helpers for Node-side plugin services. */
+export class SerializedTaskQueue {
+    reportError;
+    tail = Promise.resolve();
+    constructor(reportError) {
+        this.reportError = reportError;
+    }
+    enqueue(task) {
+        const work = this.tail.then(task);
+        this.tail = work.catch(this.reportError);
+        return work;
+    }
+    async waitForIdle() {
+        await this.tail;
+    }
+}

package/dist/node/utils/filesystem.d.ts

@@ -0,0 +1,13 @@
+type FileSource = string | Uint8Array;
+type FileWrite = {
+    file: string;
+    source: FileSource;
+};
+/** Writes through a sibling temporary file so observers never read partial contents. */
+export declare function writeFileAtomically(file: string, source: FileSource): Promise<void>;
+export declare function writeFilesAtomically(files: FileWrite[]): Promise<void>;
+/** Copies a directory when present and treats a missing optional source as empty. */
+export declare function copyDirectoryIfExists(source: string, destination: string): Promise<void>;
+/** Mirrors one optional file: copy existing files, ignore directories, and remove a missing source's destination. */
+export declare function copyFileOrRemove(source: string, destination: string): Promise<void>;
+export {};

package/dist/node/utils/filesystem.js

@@ -0,0 +1,43 @@
+/** Node-only filesystem helpers shared by build targets and development services. */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/** Writes through a sibling temporary file so observers never read partial contents. */
+export async function writeFileAtomically(file, source) {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const temporaryFile = `${file}.tmp`;
+    await fs.writeFile(temporaryFile, source);
+    await fs.rename(temporaryFile, file);
+}
+export async function writeFilesAtomically(files) {
+    await Promise.all(files.map(({ file, source }) => writeFileAtomically(file, source)));
+}
+/** Copies a directory when present and treats a missing optional source as empty. */
+export async function copyDirectoryIfExists(source, destination) {
+    if (!source)
+        return;
+    try {
+        await fs.cp(source, destination, { recursive: true, force: true });
+    }
+    catch (error) {
+        if (!isMissingFileError(error))
+            throw error;
+    }
+}
+/** Mirrors one optional file: copy existing files, ignore directories, and remove a missing source's destination. */
+export async function copyFileOrRemove(source, destination) {
+    try {
+        const stat = await fs.stat(source);
+        if (stat.isDirectory())
+            return;
+        await fs.mkdir(path.dirname(destination), { recursive: true });
+        await fs.copyFile(source, destination);
+    }
+    catch (error) {
+        if (!isMissingFileError(error))
+            throw error;
+        await fs.rm(destination, { recursive: true, force: true });
+    }
+}
+function isMissingFileError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}

package/dist/{vite/utils.d.ts → node/utils/modules.d.ts}

@@ -5,14 +5,14 @@
  * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-webpack5-runner/src/utils/app.ts#L74-L90
  * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-loader/src/h5.ts#L12-L21
  */
-export declare function createPageComponentImport(pagePath: string): string;
+export declare function createPageComponentImportPath(pagePath: string): string;
 /**
  * Converts a local file path into a Vite file-system import specifier.
  *
  * Rolldown does not reliably resolve raw Windows absolute paths from virtual
  * module source, so generated imports use Vite's /@fs/ prefix instead.
  */
-export declare function toImportPath(filePath: string): string;
+export declare function toViteFileImportPath(filePath: string): string;
 /**
  * Removes Rollup/Vite's internal virtual-module prefix before ID comparisons.
  */

package/dist/{vite/utils.js → node/utils/modules.js}

@@ -1,3 +1,4 @@
+/** Node-side helpers for application module files, Vite import specifiers, and normalized module IDs. */
 import path from 'node:path';
 /**
  * Derives a page component import from a Taro-style page path.
@@ -6,8 +7,14 @@ import path from 'node:path';
  * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-webpack5-runner/src/utils/app.ts#L74-L90
  * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-loader/src/h5.ts#L12-L21
  */
-export function createPageComponentImport(pagePath) {
-    return toImportPath(`src/${pagePath}.tsx`);
+export function createPageComponentImportPath(pagePath) {
+    return toViteFileImportPath(createPageComponentFile(pagePath));
+}
+/**
+ * Resolves the source file backing a Taro-style page path.
+ */
+function createPageComponentFile(pagePath) {
+    return path.resolve(`src/${pagePath}.tsx`);
 }
 /**
  * Converts a local file path into a Vite file-system import specifier.
@@ -15,7 +22,7 @@ export function createPageComponentImport(pagePath) {
  * Rolldown does not reliably resolve raw Windows absolute paths from virtual
  * module source, so generated imports use Vite's /@fs/ prefix instead.
  */
-export function toImportPath(filePath) {
+export function toViteFileImportPath(filePath) {
     return `/@fs/${normalizeModuleId(path.resolve(filePath))}`;
 }
 /**

package/dist/node/utils/packages.d.ts

@@ -0,0 +1,2 @@
+export declare const packageRequire: NodeJS.Require;
+export declare function resolvePackageFile(...segments: string[]): string;

package/dist/node/utils/packages.js

@@ -0,0 +1,8 @@
+/** Resolves dependencies and package-owned files relative to the installed plugin rather than the user project. */
+import { createRequire } from 'node:module';
+import path from 'node:path';
+export const packageRequire = createRequire(import.meta.url);
+const packageRoot = path.dirname(packageRequire.resolve('vite-plugin-taro/package.json'));
+export function resolvePackageFile(...segments) {
+    return path.join(packageRoot, ...segments);
+}

package/dist/node/vite-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { PluginOption } from 'vite';
+import type { VitePluginTaroOptions } from '../options.ts';
+/** Creates the Vite plugins for the selected Taro target. */
+export default function vitePluginTaro(options: VitePluginTaroOptions): PluginOption[];