vite-plugin-taro 0.6.18 → 0.6.19

package/dist/node/plugins/wx/module/module.js

@@ -1,79 +0,0 @@
-import path from 'node:path';
-import { normalizePath } from 'vite';
-import { normalizeModuleId } from '../../../utils/modules.js';
-import { packageRequire, resolvePackageFile } from '../../../utils/packages.js';
-/** Identifies Rolldown's generated helper module independently of its unstable output filename. */
-export const rolldownRuntimeId = '\0rolldown/runtime.js';
-/** Resolves the direct React Reconciler dependency without assuming pnpm's layout. */
-export const reactReconcilerRoot = normalizePath(path.dirname(packageRequire.resolve('react-reconciler/package.json')));
-/** Identifies the amphibious bootstrap that initializes SystemJS and serves every native shell. */
-export const bootstrapPath = resolvePackageFile('dist/runtime/wx/amphibious/bootstrap.js');
-/** Identifies the native transport source materialized before Rolldown finalizes content hashes. */
-export const transportPath = resolvePackageFile('dist/runtime/wx/amphibious/transport.js');
-/** Redirects Vite's injected browser preload helper to the bootstrap identity loader. */
-export const vitePreloadId = '\0vite/preload-helper.js';
-/** Forces the native App shell entry to emit at WeChat's required root path. */
-export const appShellFileName = 'app.js';
-/** Identifies the synchronous native App shell source. */
-export const appShellPath = resolvePackageFile('dist/runtime/wx/native/app.js');
-/** Identifies the App capsule kept behind the native shell boundary. */
-export const appCapsulePath = resolvePackageFile('dist/runtime/wx/capsule/app.js');
-/** Forces Taro's recursive native Component entry to emit at its configured root path. */
-export const componentShellFileName = 'comp.js';
-/** Identifies the synchronous recursive Component shell source. */
-export const componentShellPath = resolvePackageFile('dist/runtime/wx/native/component.js');
-/** Identifies the recursive Component capsule shared by generated Taro component shells. */
-export const componentCapsulePath = resolvePackageFile('dist/runtime/wx/capsule/component.js');
-/** Forces Taro's CustomWrapper native shell to emit at its configured root path. */
-export const customWrapperShellFileName = 'custom-wrapper.js';
-/** Identifies the synchronous CustomWrapper shell source. */
-export const customWrapperShellPath = resolvePackageFile('dist/runtime/wx/native/custom-wrapper.js');
-/** Resolves the configured Page component from its route-qualified capsule importer. */
-export const pageComponentId = '\0vpt:page-component';
-/** Gives every Page shell one private capsule target that can be resolved using its route. */
-export const pageCapsuleId = '\0vpt:page-capsule';
-/** Provides the Page capsule source specialized through a stable route query. */
-export const pageCapsulePath = resolvePackageFile('dist/runtime/wx/capsule/page.js');
-/** Identifies the Taro facade shared by the App, Page, and generated component capsules. */
-export const taroRuntimePath = resolvePackageFile('dist/runtime/wx/capsule/taro-runtime.js');
-/** Identifies the reusable synchronous native Page shell source. */
-export const pageShellPath = resolvePackageFile('dist/runtime/wx/native/page.js');
-// These fixed source identities describe entry roles independently from the final execution kind. A capsule entry may,
-// for example, become amphibious when Rolldown coalesces its generated runtime into the same output chunk.
-const shellModuleIds = new Set([
-    appShellPath,
-    componentShellPath,
-    customWrapperShellPath,
-    pageShellPath
-]);
-const capsuleModuleIds = new Set([appCapsulePath, componentCapsulePath, pageCapsulePath]);
-const amphibiousModuleIds = new Set([bootstrapPath, rolldownRuntimeId]);
-const transportModuleIds = new Set([transportPath]);
-/** Returns the one explicit lifecycle role owned by a chunk. */
-export function getWxEntryRole(chunk) {
-    const ownsShell = containsModule(chunk, shellModuleIds);
-    const ownsCapsule = containsModule(chunk, capsuleModuleIds);
-    if (ownsShell && ownsCapsule) {
-        throw new Error(`wx chunk mixes shell and capsule entries: ${chunk.moduleIds.join(', ')}`);
-    }
-    return ownsShell ? 'shell' : ownsCapsule ? 'capsule' : undefined;
-}
-/** Tests whether a chunk contains the physical transport implementation. */
-export function isTransportModule(chunk) {
-    return containsModule(chunk, transportModuleIds);
-}
-/**
- * Classifies one final output chunk by execution domain. Entry role is deliberately independent: explicit capsule entries
- * normally fall through to capsule rendering, but a capsule containing an amphibious runtime executes in both domains.
- */
-export function getWxExecutionKind(chunk) {
-    const entryRole = getWxEntryRole(chunk);
-    if (containsModule(chunk, amphibiousModuleIds)) {
-        return 'amphibious';
-    }
-    return entryRole === 'shell' || isTransportModule(chunk) ? 'native' : 'capsule';
-}
-/** Tests normalized chunk module IDs against one fixed identity set. */
-function containsModule(chunk, moduleIds) {
-    return chunk.moduleIds.some((moduleId) => moduleIds.has(normalizeModuleId(moduleId)));
-}

package/dist/node/plugins/wx/native/compile-native-component-interface.js

@@ -1,30 +0,0 @@
-import path from 'node:path';
-import { normalizePath } from 'vite';
-import { normalizeModuleId } from '../../../utils/modules.js';
-import { collectNativeComponentAssets, nativeComponentMetaKey } from './native-component-assets.js';
-import { transformNativeComponentInterfaces } from './native-component-interface.js';
-/** Compiles one JSX interface module and attaches its opaque native sources to Rolldown metadata. */
-export async function compileNativeComponentInterface({ code, id, sourcemap, addWatchFile }) {
-    const transformed = transformNativeComponentInterfaces(code, id, sourcemap);
-    const interfacePath = normalizeModuleId(id);
-    const nativeComponents = await Promise.all(transformed.definitions.map((definition) => collectNativeComponentAssets(definition, interfacePath)));
-    nativeComponents.forEach((source) => {
-        addWatchFile(source.folder);
-        source.assets.forEach((asset) => {
-            addWatchFile(normalizePath(path.join(source.folder, asset.relativePath)));
-        });
-    });
-    const assetBytes = nativeComponents.reduce((sourceTotal, source) => {
-        return sourceTotal + source.assets.reduce((assetTotal, asset) => assetTotal + asset.byteLength, 0);
-    }, 0);
-    return {
-        code: transformed.code,
-        map: transformed.map,
-        meta: {
-            [nativeComponentMetaKey]: {
-                sources: nativeComponents,
-                assetBytes
-            }
-        }
-    };
-}

package/dist/node/plugins/wx/native/create-native-component-output.js

@@ -1,39 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { getNativeComponentSources } from './native-component-assets.js';
-/** Creates opaque native files and their registrations from each surviving JSX interface module. */
-export async function createNativeComponentOutput({ bundle, getModuleInfo, getPackageLocation }) {
-    // Files and registrations accumulate in final chunk order for deterministic output.
-    const files = [];
-    const registrations = [];
-    for (const output of Object.values(bundle)) {
-        if (output.type !== 'chunk') {
-            continue;
-        }
-        const location = getPackageLocation(output);
-        const packageRoot = location.kind === 'subpackage' ? location.root : undefined;
-        for (const moduleId of output.moduleIds) {
-            const sources = getNativeComponentSources(getModuleInfo(moduleId)?.meta);
-            for (const source of sources) {
-                const name = path.posix.basename(source.folder);
-                const componentFolder = path.posix.join('components', name);
-                const outputFolder = packageRoot ? path.posix.join(packageRoot, componentFolder) : componentFolder;
-                registrations.push({
-                    name,
-                    componentPath: `/${path.posix.join(outputFolder, source.entry)}`,
-                    fields: source.fields
-                });
-                for (const asset of source.assets) {
-                    // Native folders are intentionally opaque to Rolldown, so no bundle asset contains these bytes to reuse.
-                    // Read each planned source once here to transfer it into the compiler-owned output bundle.
-                    files.push({
-                        type: 'asset',
-                        fileName: path.posix.join(outputFolder, asset.relativePath),
-                        source: await readFile(path.join(source.folder, asset.relativePath))
-                    });
-                }
-            }
-        }
-    }
-    return { files, registrations };
-}

package/dist/node/plugins/wx/native/native-component-assets.js

@@ -1,76 +0,0 @@
-import { readdir, stat } from 'node:fs/promises';
-import path from 'node:path';
-import { normalizePath } from 'vite';
-export const nativeComponentMetaKey = 'vpt:native-components';
-/** Reads the native contribution to a transformed module's package weight. */
-export function getNativeComponentAssetBytes(meta) {
-    return meta?.[nativeComponentMetaKey]?.assetBytes ?? 0;
-}
-/** Reads native sources attached to one transformed JSX interface module. */
-export function getNativeComponentSources(meta) {
-    return meta?.[nativeComponentMetaKey]?.sources ?? [];
-}
-/** Collects a native component folder as opaque, recursively ordered assets without copying its interface module. */
-export async function collectNativeComponentAssets(definition, interfacePath) {
-    await requireNativeComponentDirectory(definition.folder);
-    await requireNativeComponentEntry(definition);
-    // This mutable accumulator is local to one traversal and avoids repeatedly copying growing asset arrays.
-    const assets = [];
-    await collectDirectory(definition.folder, [], assets, normalizePath(interfacePath));
-    return { ...definition, assets };
-}
-/** Rejects a missing or non-directory source before Rolldown starts its recursive traversal. */
-async function requireNativeComponentDirectory(folder) {
-    try {
-        if ((await stat(folder)).isDirectory()) {
-            return;
-        }
-    }
-    catch (error) {
-        if (Error.isError(error) && 'code' in error && error.code === 'ENOENT') {
-            throw new Error(`Native component folder does not exist: ${folder}`, { cause: error });
-        }
-        throw error;
-    }
-    throw new Error(`Native component source is not a directory: ${folder}`);
-}
-/** Rejects a missing or non-file JavaScript entry before native output registration. */
-async function requireNativeComponentEntry(definition) {
-    const entryPath = path.join(definition.folder, `${definition.entry}.js`);
-    try {
-        if ((await stat(entryPath)).isFile()) {
-            return;
-        }
-    }
-    catch (error) {
-        if (Error.isError(error) && 'code' in error && error.code === 'ENOENT') {
-            throw new Error(`Native component entry file does not exist: ${entryPath}`, { cause: error });
-        }
-        throw error;
-    }
-    throw new Error(`Native component entry is not a file: ${entryPath}`);
-}
-/** Traverses entries lexically so output remains deterministic across filesystems. */
-async function collectDirectory(folder, segments, assets, interfacePath) {
-    const directory = path.join(folder, ...segments);
-    const entries = await readdir(directory, { withFileTypes: true });
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-    for (const entry of entries) {
-        const entrySegments = [...segments, entry.name];
-        if (entry.isDirectory()) {
-            await collectDirectory(folder, entrySegments, assets, interfacePath);
-            continue;
-        }
-        if (!entry.isFile()) {
-            continue;
-        }
-        const sourcePath = path.join(folder, ...entrySegments);
-        if (normalizePath(sourcePath) === interfacePath) {
-            continue;
-        }
-        assets.push({
-            relativePath: entrySegments.join('/'),
-            byteLength: (await stat(sourcePath)).size
-        });
-    }
-}

package/dist/node/plugins/wx/native/native-component-interface.js

@@ -1,203 +0,0 @@
-import path from 'node:path';
-import { RolldownMagicString } from 'rolldown';
-import { parseAst } from 'rolldown/parseAst';
-import { normalizePath } from 'vite';
-import { normalizeModuleId } from '../../../utils/modules.js';
-import { clientTaroNativeId } from '../../client/constant.js';
-/** Replaces native component interface calls with source-folder names and returns their static metadata. */
-export function transformNativeComponentInterfaces(code, id, sourcemap) {
-    const moduleId = normalizeModuleId(id);
-    const program = parseAst(code, {
-        astType: 'ts',
-        lang: 'tsx',
-        preserveParens: false,
-        sourceType: 'module'
-    }, moduleId);
-    const declaredInterfaces = collectInterfaceDeclarations(program);
-    const macroImports = collectMacroImports(program);
-    const importedMacroNames = new Set(macroImports.flatMap((item) => item.names));
-    const calls = collectTopLevelMacroCalls(program, importedMacroNames);
-    const replacements = calls.map((call) => {
-        const definition = parseDefinition(call, moduleId, declaredInterfaces, (message) => createTransformError(message, moduleId, code, call.start));
-        return { call, definition };
-    });
-    // This transform-local mutable buffer applies non-overlapping AST edits without regenerating untouched source.
-    const transformed = new RolldownMagicString(code, { filename: moduleId });
-    replacements.forEach(({ call, definition }) => {
-        transformed.overwrite(call.start, call.end, JSON.stringify(path.posix.basename(definition.folder)));
-    });
-    macroImports.forEach(({ declaration }) => {
-        transformed.remove(declaration.start, declaration.end);
-    });
-    return {
-        code: transformed.toString(),
-        map: sourcemap ? createSourceMap(transformed, moduleId) : null,
-        definitions: replacements.map(({ definition }) => definition)
-    };
-}
-/** Normalizes Rolldown's native source-map object to the public plugin source-map shape. */
-function createSourceMap(transformed, moduleId) {
-    const sourceMap = transformed.generateMap({
-        hires: 'boundary',
-        includeContent: true,
-        source: moduleId
-    });
-    return {
-        file: sourceMap.file,
-        mappings: sourceMap.mappings,
-        names: sourceMap.names,
-        sources: sourceMap.sources,
-        sourcesContent: sourceMap.sourcesContent,
-        version: sourceMap.version
-    };
-}
-/** Finds named imports of the compile-time macro and records their local aliases. */
-function collectMacroImports(program) {
-    return program.body.flatMap((statement) => {
-        if (statement.type !== 'ImportDeclaration' || statement.source.value !== clientTaroNativeId) {
-            return [];
-        }
-        const names = statement.specifiers.flatMap((specifier) => {
-            if (specifier.type !== 'ImportSpecifier' || getStaticName(specifier.imported) !== 'defineNativeComponent') {
-                return [];
-            }
-            return [specifier.local.name];
-        });
-        return names.length === 0 ? [] : [{ declaration: statement, names }];
-    });
-}
-/** Collects direct module-level macro calls, excluding calls inside nested scopes. */
-function collectTopLevelMacroCalls(program, importedMacroNames) {
-    return program.body.flatMap((statement) => {
-        if (statement.type === 'ExpressionStatement') {
-            return isImportedMacroCall(statement.expression, importedMacroNames) ? [statement.expression] : [];
-        }
-        if (statement.type === 'ExportDefaultDeclaration') {
-            return isImportedMacroCall(statement.declaration, importedMacroNames) ? [statement.declaration] : [];
-        }
-        const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
-        if (declaration?.type !== 'VariableDeclaration') {
-            return [];
-        }
-        return declaration.declarations.flatMap(({ init }) => {
-            return isImportedMacroCall(init, importedMacroNames) ? [init] : [];
-        });
-    });
-}
-/** Matches a direct call to one of the macro's module-level import bindings. */
-function isImportedMacroCall(node, importedMacroNames) {
-    return (node?.type === 'CallExpression' && node.callee.type === 'Identifier' && importedMacroNames.has(node.callee.name));
-}
-/** Parses one native entry loader and its optional TypeScript interface. */
-function parseDefinition(call, moduleId, declaredInterfaces, buildError) {
-    if (call.arguments.length !== 1) {
-        throw buildError('defineNativeComponent() requires exactly one entry loader');
-    }
-    const entryReference = readStaticEntryImport(call.arguments[0]);
-    if (!entryReference) {
-        throw buildError('Native component entry must use () => import(...) with a static relative .js path');
-    }
-    const entryPath = normalizePath(path.resolve(path.dirname(moduleId), entryReference));
-    return {
-        folder: path.posix.dirname(entryPath),
-        entry: path.posix.basename(entryPath, '.js'),
-        fields: readInterfaceFields(call.typeArguments, declaredInterfaces, buildError)
-    };
-}
-/** Collects non-generic local object aliases and interfaces as native template field declarations. */
-function collectInterfaceDeclarations(program) {
-    // This module-local map supports nearby declarations without constructing a TypeScript type-checker program.
-    const declarations = new Map();
-    for (const statement of program.body) {
-        const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
-        if (declaration?.type === 'TSTypeAliasDeclaration' &&
-            !declaration.typeParameters &&
-            declaration.typeAnnotation.type === 'TSTypeLiteral') {
-            declarations.set(declaration.id.name, declaration.typeAnnotation.members);
-            continue;
-        }
-        if (declaration?.type === 'TSInterfaceDeclaration' &&
-            !declaration.typeParameters &&
-            declaration.extends.length === 0) {
-            declarations.set(declaration.id.name, declaration.body.body);
-        }
-    }
-    return declarations;
-}
-/** Resolves an inline type or a non-generic object declaration from the current module. */
-function resolveInterfaceMembers(typeNode, declarations) {
-    if (typeNode.type === 'TSTypeLiteral') {
-        return typeNode.members;
-    }
-    if (typeNode.type === 'TSTypeReference' && typeNode.typeName.type === 'Identifier' && !typeNode.typeArguments) {
-        return declarations.get(typeNode.typeName.name);
-    }
-}
-/** Reads native template field names without resolving or validating their TypeScript value types. */
-function readInterfaceFields(typeArguments, declaredInterfaces, buildError) {
-    if (!typeArguments) {
-        return [];
-    }
-    if (typeArguments.params.length !== 1) {
-        throw buildError('Native component interface must be one TypeScript object type');
-    }
-    // The length check above proves the one parameter exists; ESTree models the array element as optional generically.
-    const firstType = typeArguments.params[0];
-    const members = resolveInterfaceMembers(firstType, declaredInterfaces);
-    if (!members) {
-        throw buildError('Native component interface must be inline or declared in the same module');
-    }
-    // This local set preserves declaration order while rejecting ambiguous duplicate template fields.
-    const names = new Set();
-    for (const member of members) {
-        if (member.type !== 'TSPropertySignature' && member.type !== 'TSMethodSignature') {
-            throw buildError('Native component interface must contain only static fields');
-        }
-        if (member.computed) {
-            throw buildError('Native component interface contains a computed field');
-        }
-        const name = getStaticName(member.key);
-        if (!name) {
-            throw buildError('Native component interface contains a computed field');
-        }
-        if (names.has(name)) {
-            throw buildError(`Duplicate native component interface field: ${name}`);
-        }
-        names.add(name);
-    }
-    return [...names].filter((name) => name !== 'children');
-}
-/** Reads an identifier or string-literal key. */
-function getStaticName(node) {
-    if (node.type === 'Identifier') {
-        return node.name;
-    }
-    if (node.type === 'Literal' && typeof node.value === 'string') {
-        return node.value;
-    }
-}
-/** Reads a zero-argument entry loader containing one statically resolvable native `.js` import. */
-function readStaticEntryImport(node) {
-    if (node?.type !== 'ArrowFunctionExpression' || node.params.length !== 0 || node.body.type !== 'ImportExpression') {
-        return undefined;
-    }
-    const importExpression = node.body;
-    if (importExpression.source.type !== 'Literal' ||
-        typeof importExpression.source.value !== 'string' ||
-        importExpression.options !== null ||
-        !isLocalJavaScriptEntry(importExpression.source.value)) {
-        return undefined;
-    }
-    return importExpression.source.value;
-}
-/** Limits component entries to JavaScript files reachable from their interface module. */
-function isLocalJavaScriptEntry(entry) {
-    return (entry.startsWith('./') || entry.startsWith('../')) && path.posix.extname(entry) === '.js';
-}
-/** Adds a stable source location to semantic errors reported after parsing. */
-function createTransformError(message, moduleId, code, offset) {
-    const prefix = code.slice(0, offset);
-    const line = prefix.split('\n').length;
-    const column = offset - prefix.lastIndexOf('\n');
-    return new Error(`${message}\n${moduleId}:${line}:${column}`);
-}

package/dist/node/plugins/wx/output/files.js

@@ -1,21 +0,0 @@
-import { createNativeComponentOutput } from '../native/create-native-component-output.js';
-import { createTemplateAssets } from './templates.js';
-/** Creates every compiler-owned WX file derived from the final Rolldown bundle. */
-export async function createOutputFiles({ bundle, options, subpackages, isProduction, getModuleInfo, getPackageLocation }) {
-    const nativeOutput = await createNativeComponentOutput({ bundle, getModuleInfo, getPackageLocation });
-    return [
-        {
-            type: 'asset',
-            fileName: 'app.wxss',
-            source: '@import "./assets/global.wxss";\n'
-        },
-        ...createTemplateAssets({
-            bundle: bundle,
-            options: options,
-            subpackages: subpackages,
-            nativeComponents: nativeOutput.registrations,
-            isProduction: isProduction
-        }),
-        ...nativeOutput.files
-    ];
-}

package/dist/node/plugins/wx/output/relative-root.js

@@ -1,6 +0,0 @@
-import path from 'node:path';
-/** Creates a Page-relative path to a file emitted at the wx output root. */
-export function toRootRelativePath(pagePath, rootFileName) {
-    const relativePath = path.posix.relative(path.posix.dirname(pagePath), rootFileName);
-    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
-}