vite-plugin-taro 0.3.2 → 0.4.0

package/dist/node/plugins/wx/resolve/resolver.d.ts

@@ -0,0 +1,7 @@
+import type { VitePluginTaroOptions } from '../../../../options.ts';
+/** Creates the resolver and source specializer for the wx module graph. */
+export declare function createResolver(options: VitePluginTaroOptions): {
+    input: Record<string, string>;
+    resolveId(id: string, importer: string | undefined, projectRoot: string): string | undefined;
+    specialize(code: string, id: string, sourcemap?: boolean): Promise<import("../../../utils/transform.ts").AstTransformResult> | undefined;
+};

package/dist/node/plugins/wx/resolve/resolver.js

@@ -0,0 +1,86 @@
+import { normalizeModuleId, resolveAppComponentPath, resolvePageComponentPath } from '../../../utils/modules.js';
+import { createAppConfig } from '../../../utils/project-config.js';
+import { appComponentId } from '../../client/constant.js';
+import { appCapsulePath, appShellFileName, appShellPath, bootstrapPath, componentCapsulePath, componentShellFileName, componentShellPath, pageCapsuleId, pageCapsulePath, pageComponentId, pageShellPath, transportPath, vitePreloadId } from '../module.js';
+import { specializeBootstrap } from './specialize-bootstrap.js';
+import { specializePageCapsule } from './specialize-page-capsule.js';
+/** Creates the resolver and source specializer for the wx module graph. */
+export function createResolver(options) {
+    const normalizedBootstrapPath = normalizeModuleId(bootstrapPath);
+    const normalizedPageCapsulePath = normalizeModuleId(pageCapsulePath);
+    // Provide constant-time route validation and access to each configured Page JSON object.
+    const pageByPath = new Map(options.pages.map((page) => [page.path, page]));
+    const privateIdResolvers = new Map([
+        // Share bootstrap's preload identity through native require and its amphibious SystemJS registration.
+        [vitePreloadId, () => bootstrapPath],
+        // Keep the configured App component behind one stable private import in the App capsule.
+        [appComponentId, (_importer, projectRoot) => resolveAppComponentPath({ appPath: options.app, projectRoot })],
+        [
+            pageComponentId,
+            (importer, projectRoot) => {
+                const page = requireConfiguredPage({ moduleId: importer, pageByPath });
+                return resolvePageComponentPath({ pagePath: page.path, projectRoot });
+            }
+        ],
+        [
+            pageCapsuleId,
+            (importer) => {
+                // Query-qualify the capsule source so every Page retains a distinct graph identity.
+                const page = requireConfiguredPage({ moduleId: importer, pageByPath });
+                return createRouteModuleId({ moduleId: pageCapsulePath, pagePath: page.path });
+            }
+        ]
+    ]);
+    return {
+        input: createInput(options.pages),
+        resolveId(id, importer, projectRoot) {
+            // Unknown IDs fall through so Vite and other plugins retain normal resolution.
+            return privateIdResolvers.get(id)?.(importer, projectRoot);
+        },
+        specialize(code, id, sourcemap = true) {
+            const normalizedId = normalizeModuleId(id);
+            if (normalizedId === normalizedBootstrapPath) {
+                return specializeBootstrap({ code, id, appConfig: createAppConfig(options), sourcemap });
+            }
+            if (normalizedId === normalizedPageCapsulePath) {
+                return specializePageCapsule({
+                    code,
+                    id,
+                    page: requireConfiguredPage({ moduleId: id, pageByPath }),
+                    sourcemap
+                });
+            }
+        }
+    };
+}
+/** Declares native shells, infrastructure, and capsules as independent output entries. */
+function createInput(pages) {
+    return Object.fromEntries([
+        ['bootstrap', bootstrapPath],
+        ['transport', transportPath],
+        [appShellFileName, appShellPath],
+        ['app-capsule', appCapsulePath],
+        [componentShellFileName, componentShellPath],
+        ['component-capsule', componentCapsulePath],
+        ...pages.flatMap((page) => {
+            return [
+                [`${page.path}.js`, createRouteModuleId({ moduleId: pageShellPath, pagePath: page.path })],
+                [`${page.path}-capsule`, createRouteModuleId({ moduleId: pageCapsulePath, pagePath: page.path })]
+            ];
+        })
+    ]);
+}
+/** Creates one route-qualified module ID. */
+function createRouteModuleId({ moduleId, pagePath }) {
+    return `${moduleId}?route=${encodeURIComponent(pagePath)}`;
+}
+/** Returns the configured Page identified by a route-qualified capsule ID. */
+function requireConfiguredPage({ moduleId, pageByPath }) {
+    const queryIndex = moduleId?.indexOf('?') ?? -1;
+    const pagePath = queryIndex === -1 ? undefined : new URLSearchParams(moduleId?.slice(queryIndex + 1)).get('route');
+    const page = pagePath ? pageByPath.get(pagePath) : undefined;
+    if (!page) {
+        throw new Error(pagePath ? `Unknown Page capsule: ${pagePath}` : 'Page capsule import must originate from a route module');
+    }
+    return page;
+}

package/dist/node/plugins/wx/resolve/specialize-bootstrap.d.ts

@@ -0,0 +1,9 @@
+import type { JsonObject } from '../../../../options.ts';
+import { type AstTransformResult } from '../../../utils/transform.ts';
+/** Specializes the amphibious bootstrap with the shared App configuration. */
+export declare function specializeBootstrap({ code, id, appConfig, sourcemap }: {
+    code: string;
+    id: string;
+    appConfig: JsonObject;
+    sourcemap?: boolean;
+}): Promise<AstTransformResult>;

package/dist/node/plugins/wx/resolve/specialize-bootstrap.js

@@ -0,0 +1,9 @@
+import { types } from '@babel/core';
+import { replaceWithAst } from '../../../utils/transform.js';
+const appConfigPlaceholder = '__VITE_PLUGIN_TARO_APP_CONFIG__';
+/** Specializes the amphibious bootstrap with the shared App configuration. */
+export function specializeBootstrap({ code, id, appConfig, sourcemap = true }) {
+    return replaceWithAst(code, id, {
+        [appConfigPlaceholder]: types.valueToNode(appConfig)
+    }, sourcemap);
+}

package/dist/node/plugins/wx/resolve/specialize-page-capsule.d.ts

@@ -0,0 +1,9 @@
+import type { VitePluginTaroPageOption } from '../../../../options.ts';
+import { type AstTransformResult } from '../../../utils/transform.ts';
+/** Specializes the Page capsule for one configured route. */
+export declare function specializePageCapsule({ code, id, page, sourcemap }: {
+    code: string;
+    id: string;
+    page: VitePluginTaroPageOption;
+    sourcemap?: boolean;
+}): Promise<AstTransformResult>;

package/dist/node/plugins/wx/resolve/specialize-page-capsule.js

@@ -0,0 +1,11 @@
+import { types } from '@babel/core';
+import { replaceWithAst } from '../../../utils/transform.js';
+const pagePathPlaceholder = '__VITE_PLUGIN_TARO_PAGE_PATH__';
+const pageConfigPlaceholder = '__VITE_PLUGIN_TARO_PAGE_CONFIG__';
+/** Specializes the Page capsule for one configured route. */
+export function specializePageCapsule({ code, id, page, sourcemap = true }) {
+    return replaceWithAst(code, id, {
+        [pagePathPlaceholder]: types.stringLiteral(page.path),
+        [pageConfigPlaceholder]: types.valueToNode(page.config)
+    }, sourcemap);
+}

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

@@ -0,0 +1 @@
+export declare const esTarget = "es2018";

package/dist/node/utils/constant.js

@@ -0,0 +1 @@
+export const esTarget = 'es2018';

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

@@ -0,0 +1,122 @@
+/**
+ * Creates a memoized version of the provided function. The memoized function caches
+ * results based on the argument it receives, so if the same argument is passed again,
+ * it returns the cached result instead of recomputing it.
+ *
+ * This function works with functions that take zero or just one argument. If your function
+ * originally takes multiple arguments, you should refactor it to take a single object or array
+ * that combines those arguments.
+ *
+ * If the argument is not primitive (e.g., arrays or objects), provide a
+ * `getCacheKey` function to generate a unique cache key for proper caching.
+ *
+ * @template F - The type of the function to be memoized.
+ * @param fn - The function to be memoized. It should accept a single argument and return a value.
+ * @param [options={}] - Optional configuration for the memoization.
+ * @param [options.cache] - The cache object used to store results. Defaults to a new `Map`.
+ * @param [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
+ *
+ * @returns The memoized function with an additional `cache` property that exposes the internal cache.
+ *
+ * @example
+ * // Example using the default cache
+ * const add = (x: number) => x + 10;
+ * const memoizedAdd = memoize(add);
+ *
+ * console.log(memoizedAdd(5)); // 15
+ * console.log(memoizedAdd(5)); // 15 (cached result)
+ * console.log(memoizedAdd.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom resolver
+ * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
+ * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
+ * console.log(memoizedSum([1, 2])); // 3
+ * console.log(memoizedSum([1, 2])); // 3 (cached result)
+ * console.log(memoizedSum.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom cache implementation
+ * class CustomCache<K, T> implements MemoizeCache<K, T> {
+ *   private cache = new Map<K, T>();
+ *
+ *   set(key: K, value: T): void {
+ *     this.cache.set(key, value);
+ *   }
+ *
+ *   get(key: K): T | undefined {
+ *     return this.cache.get(key);
+ *   }
+ *
+ *   has(key: K): boolean {
+ *     return this.cache.has(key);
+ *   }
+ *
+ *   delete(key: K): boolean {
+ *     return this.cache.delete(key);
+ *   }
+ *
+ *   clear(): void {
+ *     this.cache.clear();
+ *   }
+ *
+ *   get size(): number {
+ *     return this.cache.size;
+ *   }
+ * }
+ * const customCache = new CustomCache<string, number>();
+ * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
+ * console.log(memoizedSumWithCustomCache.cache.size); // 1
+ */
+export declare function memoize<F extends (arg: never) => unknown>(fn: F, options?: {
+    cache?: MemoizeCache<unknown, ReturnType<F>>;
+    getCacheKey?: (arg: Parameters<F>[0]) => unknown;
+}): F & {
+    cache: MemoizeCache<unknown, ReturnType<F>>;
+};
+/**
+ * Represents a cache for memoization, allowing storage and retrieval of computed values.
+ *
+ * @template K - The type of keys used to store values in the cache.
+ * @template V - The type of values stored in the cache.
+ */
+export interface MemoizeCache<K, V> {
+    /**
+     * Stores a value in the cache with the specified key.
+     *
+     * @param key - The key to associate with the value.
+     * @param value - The value to store in the cache.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Retrieves a value from the cache by its key.
+     *
+     * @param key - The key of the value to retrieve.
+     * @returns The value associated with the key, or undefined if the key does not exist.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Checks if a value exists in the cache for the specified key.
+     *
+     * @param key - The key to check for existence in the cache.
+     * @returns True if the cache contains the key, false otherwise.
+     */
+    has(key: K): boolean;
+    /**
+     * Deletes a value from the cache by its key.
+     *
+     * @param key - The key of the value to delete.
+     * @returns True if the value was successfully deleted, false otherwise.
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears all values from the cache.
+     */
+    clear(): void;
+    /**
+     * The number of entries in the cache.
+     */
+    size: number;
+}

package/dist/node/utils/memoize.js

@@ -0,0 +1,86 @@
+/**
+ * Creates a memoized version of the provided function. The memoized function caches
+ * results based on the argument it receives, so if the same argument is passed again,
+ * it returns the cached result instead of recomputing it.
+ *
+ * This function works with functions that take zero or just one argument. If your function
+ * originally takes multiple arguments, you should refactor it to take a single object or array
+ * that combines those arguments.
+ *
+ * If the argument is not primitive (e.g., arrays or objects), provide a
+ * `getCacheKey` function to generate a unique cache key for proper caching.
+ *
+ * @template F - The type of the function to be memoized.
+ * @param fn - The function to be memoized. It should accept a single argument and return a value.
+ * @param [options={}] - Optional configuration for the memoization.
+ * @param [options.cache] - The cache object used to store results. Defaults to a new `Map`.
+ * @param [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
+ *
+ * @returns The memoized function with an additional `cache` property that exposes the internal cache.
+ *
+ * @example
+ * // Example using the default cache
+ * const add = (x: number) => x + 10;
+ * const memoizedAdd = memoize(add);
+ *
+ * console.log(memoizedAdd(5)); // 15
+ * console.log(memoizedAdd(5)); // 15 (cached result)
+ * console.log(memoizedAdd.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom resolver
+ * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
+ * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
+ * console.log(memoizedSum([1, 2])); // 3
+ * console.log(memoizedSum([1, 2])); // 3 (cached result)
+ * console.log(memoizedSum.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom cache implementation
+ * class CustomCache<K, T> implements MemoizeCache<K, T> {
+ *   private cache = new Map<K, T>();
+ *
+ *   set(key: K, value: T): void {
+ *     this.cache.set(key, value);
+ *   }
+ *
+ *   get(key: K): T | undefined {
+ *     return this.cache.get(key);
+ *   }
+ *
+ *   has(key: K): boolean {
+ *     return this.cache.has(key);
+ *   }
+ *
+ *   delete(key: K): boolean {
+ *     return this.cache.delete(key);
+ *   }
+ *
+ *   clear(): void {
+ *     this.cache.clear();
+ *   }
+ *
+ *   get size(): number {
+ *     return this.cache.size;
+ *   }
+ * }
+ * const customCache = new CustomCache<string, number>();
+ * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
+ * console.log(memoizedSumWithCustomCache.cache.size); // 1
+ */
+export function memoize(fn, options = {}) {
+    const { cache = new Map(), getCacheKey } = options;
+    const memoizedFn = function (arg) {
+        const key = getCacheKey ? getCacheKey(arg) : arg;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn.call(this, arg);
+        cache.set(key, result);
+        return result;
+    };
+    memoizedFn.cache = cache;
+    return memoizedFn;
+}

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

@@ -1,25 +1,21 @@
-/**
- * Derives a page component import from a Taro-style page path.
- *
- * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-webpack5-runner/src/plugins/MiniPlugin.ts#L660-L668
- * 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 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 toViteFileImportPath(filePath: string): string;
-/**
- * Removes Rollup/Vite's internal virtual-module prefix before ID comparisons.
- */
-export declare function stripVirtualPrefix(id: string): string;
-/**
- * Uses Taro-style slash normalization, plus Vite query-string stripping for module IDs.
- *
- * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-helper/src/utils.ts#L32-L34
- */
+type AppComponentPathOptions = {
+    appPath: string;
+    projectRoot: string;
+};
+type PageComponentPathOptions = {
+    pagePath: string;
+    projectRoot: string;
+};
+/** Resolves a final relative reference to the canonical output chunk ID used by the WX module registry. */
+export declare function resolveChunkReference(importerChunkId: string, reference: string): string;
+/** Resolves the source file for the configured App component. */
+export declare function resolveAppComponentPath({ appPath, projectRoot }: AppComponentPathOptions): string;
+/** Resolves the source file for one configured Page component. */
+export declare function resolvePageComponentPath({ pagePath, projectRoot }: PageComponentPathOptions): string;
+/** Creates a portable import for one configured Page component. */
+export declare function createPageComponentImportPath(options: PageComponentPathOptions): string;
+/** Normalizes a file-backed Vite module ID for stable comparisons. */
 export declare function normalizeModuleId(id: string): string;
+/** Converts a local file path into Vite's portable file-system import form. */
+export declare function toViteFileImportPath(filePath: string): string;
+export {};

package/dist/node/utils/modules.js

@@ -1,41 +1,28 @@
-/** 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.
- *
- * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-webpack5-runner/src/plugins/MiniPlugin.ts#L660-L668
- * 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 createPageComponentImportPath(pagePath) {
-    return toViteFileImportPath(createPageComponentFile(pagePath));
+/** Resolves a final relative reference to the canonical output chunk ID used by the WX module registry. */
+export function resolveChunkReference(importerChunkId, reference) {
+    if (!reference.startsWith('./') && !reference.startsWith('../')) {
+        throw new Error(`Expected a relative chunk reference in ${importerChunkId}: ${reference}`);
+    }
+    return path.posix.join(path.posix.dirname(importerChunkId), reference);
 }
-/**
- * Resolves the source file backing a Taro-style page path.
- */
-function createPageComponentFile(pagePath) {
-    return path.resolve(`src/${pagePath}.tsx`);
+/** Resolves the source file for the configured App component. */
+export function resolveAppComponentPath({ appPath, projectRoot }) {
+    return path.resolve(projectRoot, appPath);
 }
-/**
- * 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 function toViteFileImportPath(filePath) {
-    return `/@fs/${normalizeModuleId(path.resolve(filePath))}`;
+/** Resolves the source file for one configured Page component. */
+export function resolvePageComponentPath({ pagePath, projectRoot }) {
+    return path.resolve(projectRoot, 'src', `${pagePath}.tsx`);
 }
-/**
- * Removes Rollup/Vite's internal virtual-module prefix before ID comparisons.
- */
-export function stripVirtualPrefix(id) {
-    return id.startsWith('\0') ? id.slice(1) : id;
+/** Creates a portable import for one configured Page component. */
+export function createPageComponentImportPath(options) {
+    return toViteFileImportPath(resolvePageComponentPath(options));
 }
-/**
- * Uses Taro-style slash normalization, plus Vite query-string stripping for module IDs.
- *
- * https://github.com/NervJS/taro/blob/f0e5c39d5f04290db975670411e23c3a396e15f8/packages/taro-helper/src/utils.ts#L32-L34
- */
+/** Normalizes a file-backed Vite module ID for stable comparisons. */
 export function normalizeModuleId(id) {
-    return id.replace(/\\/g, '/').replace(/\?.*$/, '');
+    return id.replaceAll('\\', '/').replace(/\?.*$/, '');
+}
+/** Converts a local file path into Vite's portable file-system import form. */
+export function toViteFileImportPath(filePath) {
+    return `/@fs/${normalizeModuleId(path.resolve(filePath))}`;
 }

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

@@ -0,0 +1,10 @@
+/**
+ * Creates a function that runs its argument once and returns the first result on every
+ * later call.
+ *
+ * @example
+ * const initialize = once(createApplication)
+ * initialize() // runs createApplication
+ * initialize() // returns the cached result
+ */
+export declare function once<F extends (...args: never[]) => unknown>(func: F): F;

package/dist/node/utils/once.js

@@ -0,0 +1,20 @@
+/**
+ * Creates a function that runs its argument once and returns the first result on every
+ * later call.
+ *
+ * @example
+ * const initialize = once(createApplication)
+ * initialize() // runs createApplication
+ * initialize() // returns the cached result
+ */
+export function once(func) {
+    let called = false;
+    let cache;
+    return ((...args) => {
+        if (!called) {
+            called = true;
+            cache = func(...args);
+        }
+        return cache;
+    });
+}

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

@@ -1,2 +1,3 @@
 export declare const packageRequire: NodeJS.Require;
+/** Resolves a file shipped by this package. */
 export declare function resolvePackageFile(...segments: string[]): string;

package/dist/node/utils/packages.js

@@ -1,8 +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'));
+/** Resolves a file shipped by this package. */
 export function resolvePackageFile(...segments) {
     return path.join(packageRoot, ...segments);
 }

package/dist/node/utils/project-config.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject, VitePluginTaroOptions } from '../../options.ts';
+/** Creates shared App configuration with configured Page order as the authoritative value. */
+export declare function createAppConfig(options: VitePluginTaroOptions): JsonObject;

package/dist/node/utils/project-config.js

@@ -0,0 +1,8 @@
+/** Creates shared App configuration with configured Page order as the authoritative value. */
+export function createAppConfig(options) {
+    const { subPackages: _subPackages, subpackages: _subpackages, ...appJson } = options.appJson;
+    return {
+        ...appJson,
+        pages: options.pages.map((page) => page.path)
+    };
+}

package/dist/node/utils/serialized-task-queue.d.ts

@@ -0,0 +1,9 @@
+/** Runs recoverable background tasks in insertion order and reports failures without blocking later work. */
+export declare class SerializedTaskQueue {
+    private tail;
+    private readonly reportError;
+    constructor(reportError: (operation: string, error: unknown) => void);
+    enqueue(operation: string, task: () => Promise<void>): void;
+    /** Waits for every task that was queued when this method was called. */
+    waitForIdle(): Promise<void>;
+}

package/dist/node/utils/serialized-task-queue.js

@@ -0,0 +1,17 @@
+/** Runs recoverable background tasks in insertion order and reports failures without blocking later work. */
+export class SerializedTaskQueue {
+    tail = Promise.resolve();
+    reportError;
+    constructor(reportError) {
+        this.reportError = reportError;
+    }
+    enqueue(operation, task) {
+        this.tail = this.tail.then(task).catch((error) => {
+            this.reportError(operation, error);
+        });
+    }
+    /** Waits for every task that was queued when this method was called. */
+    async waitForIdle() {
+        await this.tail;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { type PluginItem } from '@babel/core';
+import generate from '@babel/generator';
+import { type Rolldown } from 'vite';
+export type AstTransformResult = {
+    code: string;
+    map: Rolldown.ExistingRawSourceMap | null;
+};
+/** Replaces each placeholder with a Babel AST expression while transforming the module through Oxc. */
+export declare function replaceWithAst(code: string, filename: string, replacement: Readonly<Record<string, Parameters<typeof generate>[0]>>, sourcemap?: boolean): Promise<AstTransformResult>;
+/** Transforms one module with Babel's shared parser and source-map configuration. */
+export declare function transformWithBabel(code: string, filename: string, plugins: PluginItem[], sourcemap?: boolean): AstTransformResult;

package/dist/node/utils/transform.js

@@ -0,0 +1,58 @@
+import { transformSync } from '@babel/core';
+import generate from '@babel/generator';
+import { transformWithOxc } from 'vite';
+import { esTarget } from './constant.js';
+/** Replaces each placeholder with a Babel AST expression while transforming the module through Oxc. */
+export async function replaceWithAst(code, filename, replacement, sourcemap = true) {
+    const define = {};
+    for (const [placeholder, node] of Object.entries(replacement)) {
+        requireOnePlaceholder(code, placeholder);
+        define[placeholder] = ast2str(node);
+    }
+    const transformed = await transformWithOxc(code, filename, { define, sourcemap, target: esTarget });
+    for (const placeholder of Object.keys(replacement)) {
+        if (transformed.code.includes(placeholder)) {
+            throw new Error(`Failed to replace placeholder ${placeholder} in ${filename}`);
+        }
+    }
+    if (sourcemap && !transformed.map) {
+        throw new Error(`Failed to generate a source map for ${filename}`);
+    }
+    return {
+        code: transformed.code,
+        map: sourcemap ? (transformed.map ?? null) : null
+    };
+}
+/** Serializes a Babel AST node as a compact expression for Oxc substitution. */
+function ast2str(node) {
+    return generate(node, { comments: false, compact: true, concise: true, minified: true }).code;
+}
+/** Validates exactly one placeholder before Babel expression substitution. */
+function requireOnePlaceholder(code, placeholder) {
+    const replacementCount = code.split(placeholder).length - 1;
+    if (replacementCount !== 1) {
+        throw new Error(`Expected one placeholder ${placeholder}, found ${replacementCount}`);
+    }
+}
+/** Transforms one module with Babel's shared parser and source-map configuration. */
+export function transformWithBabel(code, filename, plugins, sourcemap = true) {
+    const transformed = transformSync(code, {
+        babelrc: false,
+        compact: true,
+        minified: true,
+        comments: false,
+        configFile: false,
+        filename,
+        plugins,
+        sourceFileName: filename,
+        sourceMaps: sourcemap,
+        sourceType: 'module'
+    });
+    if (!transformed?.code || (sourcemap && !transformed.map)) {
+        throw new Error(`Failed to transform ${filename} with Babel`);
+    }
+    return {
+        code: transformed.code,
+        map: sourcemap ? transformed.map : null
+    };
+}

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

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