vite-plugin-taro 0.3.1 → 0.4.0

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

@@ -1,120 +0,0 @@
-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

@@ -1,8 +0,0 @@
-/** 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

@@ -1,16 +0,0 @@
-/** 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

@@ -1,13 +0,0 @@
-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

@@ -1,43 +0,0 @@
-/** 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/runtime/taro/api.js

@@ -1,11 +0,0 @@
-/** Physical runtime module backing the public `virtual:taro/api` facade. */
-// Ensure Taro's React runtime registers its `initNativeApi` hook before @tarojs/taro is initialized.
-import '@tarojs/plugin-framework-react/dist/runtime';
-import { hooks } from '@tarojs/runtime';
-import Taro from '@tarojs/taro';
-if (hooks.isExist('initNativeApi')) {
-    hooks.call('initNativeApi', Taro);
-}
-// @ts-expect-error @tarojs/taro declares export= types, but vite-plugin-taro target aliases expose runtime named exports.
-export * from '@tarojs/taro';
-export default Taro;

package/dist/runtime/taro/components.d.ts

@@ -1,2 +0,0 @@
-/** Physical runtime module backing the public `virtual:taro/components` facade. */
-export * from '@tarojs/components';

package/dist/runtime/taro/components.js

@@ -1,2 +0,0 @@
-/** Physical runtime module backing the public `virtual:taro/components` facade. */
-export * from '@tarojs/components';

package/dist/runtime/wx/page-update.d.ts

@@ -1,6 +0,0 @@
-type WxPageConfig = Record<string, unknown>;
-/** Registers a native route once per App Service runtime generation. */
-export declare function registerWxPage(route: string, register: () => void): void;
-/** Retains Taro's live root while filtering DevTools' synthetic update lifecycles. */
-export declare function decorateWxPageConfig(config: WxPageConfig): WxPageConfig;
-export {};

package/dist/runtime/wx/page-update.js

@@ -1,157 +0,0 @@
-/**
- * Coordinates page-side update execution after the Rolldown and Taro runtimes exist.
- *
- * This module is intentionally page-only: it suppresses DevTools' synthetic lifecycles, preserves the Taro root,
- * commits React Refresh, and relaunches stale component families. HTTP transport remains in update-client.ts.
- */
-import { document } from '@tarojs/runtime';
-import { validateRefreshBoundaryAndEnqueueUpdate } from '/@react-refresh';
-const wxRuntimeGlobal = globalThis;
-wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__ ??= { ready: false };
-const bridge = wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__;
-const refreshBoundary = { default: function WxRefreshBoundary() { } };
-const registeredRoutes = new Set();
-const ignoredPages = new WeakSet();
-let pageRuntimeState = { suppressLifecycles: false };
-/** Registers a native route once per App Service runtime generation. */
-export function registerWxPage(route, register) {
-    if (registeredRoutes.has(route))
-        return;
-    register();
-    registeredRoutes.add(route);
-}
-/** Retains Taro's live root while filtering DevTools' synthetic update lifecycles. */
-export function decorateWxPageConfig(config) {
-    const onLoad = getLifecycle(config, 'onLoad');
-    config.onLoad = function (...args) {
-        if (pageRuntimeState.suppressLifecycles) {
-            ignoredPages.add(this);
-            this.$taroPath = pageRuntimeState.activePage?.$taroPath;
-            this.$taroParams = pageRuntimeState.activePage?.$taroParams;
-            dispatchPageRuntime({ type: 'page-activated', page: this });
-            return;
-        }
-        const result = onLoad?.apply(this, args);
-        dispatchPageRuntime({ type: 'page-activated', page: this });
-        return result;
-    };
-    wrapLifecycle(config, 'onReady', applyPendingPageUpdate);
-    wrapLifecycle(config, 'onShow', function () {
-        dispatchPageRuntime({ type: 'page-activated', page: this });
-    });
-    wrapLifecycle(config, 'onHide');
-    wrapLifecycle(config, 'onUnload', function () {
-        dispatchPageRuntime({ type: 'page-unloaded', page: this });
-    });
-    return config;
-}
-function wrapLifecycle(config, name, after) {
-    const original = getLifecycle(config, name);
-    config[name] = function (...args) {
-        if (pageRuntimeState.suppressLifecycles)
-            return;
-        if (ignoredPages.has(this)) {
-            if (name === 'onUnload')
-                ignoredPages.delete(this);
-            return;
-        }
-        const result = original?.apply(this, args);
-        after?.apply(this, args);
-        return result;
-    };
-}
-function getLifecycle(config, name) {
-    return typeof config[name] === 'function' ? config[name] : undefined;
-}
-function applyPendingPageUpdate() {
-    bridge.ready = true;
-    const pendingUpdate = bridge.pendingUpdate;
-    if (pendingUpdate) {
-        delete bridge.pendingUpdate;
-        pendingUpdate();
-    }
-    wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?.routeReady();
-}
-function getActiveTaroRoot() {
-    const page = pageRuntimeState.activePage;
-    if (!page?.$taroPath)
-        return;
-    return document.getElementById(page.$taroPath) ?? undefined;
-}
-bridge.enqueueRefresh = () => {
-    validateRefreshBoundaryAndEnqueueUpdate('vite-plugin-taro-wx', refreshBoundary, refreshBoundary);
-};
-bridge.beginUpdate = () => {
-    bridge.blockRefreshRegistration = false;
-    wxRuntimeGlobal.__rolldown_runtime__?.beginPatch?.();
-    dispatchPageRuntime({ type: 'update-started', root: getActiveTaroRoot() });
-    refreshTaroRoot(pageRuntimeState.pendingUpdate?.root, pageRuntimeState.pendingUpdate?.page);
-    runInNextNativeTask(() => dispatchPageRuntime({ type: 'suppression-ended' }));
-};
-bridge.endUpdate = () => {
-    wxRuntimeGlobal.__rolldown_runtime__?.endPatch?.();
-    bridge.blockRefreshRegistration = true;
-    bridge.enqueueRefresh?.();
-};
-bridge.afterRefresh = (update) => {
-    bridge.blockRefreshRegistration = false;
-    const pendingUpdate = pageRuntimeState.pendingUpdate;
-    dispatchPageRuntime({ type: 'refresh-finished' });
-    const page = pendingUpdate?.page;
-    const root = pendingUpdate?.root;
-    const stale = Boolean(update?.staleFamilies?.size);
-    if (stale) {
-        wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?.refreshCompleted(true);
-        relaunchActiveRoute(page);
-        return;
-    }
-    runInNextNativeTask(() => {
-        refreshTaroRoot(root, pageRuntimeState.activePage ?? page);
-        wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?.refreshCompleted(false);
-    });
-};
-function dispatchPageRuntime(event) {
-    pageRuntimeState = transitionPageRuntime(pageRuntimeState, event);
-}
-function transitionPageRuntime(state, event) {
-    switch (event.type) {
-        case 'page-activated':
-            return { ...state, activePage: event.page };
-        case 'page-unloaded':
-            return state.activePage === event.page ? { ...state, activePage: undefined } : state;
-        case 'update-started':
-            return {
-                ...state,
-                pendingUpdate: { page: state.activePage, root: event.root },
-                suppressLifecycles: true
-            };
-        case 'suppression-ended':
-            return { ...state, suppressLifecycles: false };
-        case 'refresh-finished':
-            return { ...state, pendingUpdate: undefined };
-    }
-}
-function refreshTaroRoot(root, page) {
-    if (!root)
-        return;
-    root.ctx = page ?? null;
-    root.updateChildNodes();
-    root.performUpdate(true);
-}
-function relaunchActiveRoute(page) {
-    const route = wxRuntimeGlobal.getCurrentPages().at(-1)?.route;
-    if (!route)
-        return;
-    const query = Object.entries(page?.$taroParams ?? {})
-        .filter(([key, value]) => key !== '$taroTimestamp' && value !== undefined)
-        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
-        .join('&');
-    runInNextNativeTask(() => wxRuntimeGlobal.wx.reLaunch({ url: `/${route}${query ? `?${query}` : ''}` }));
-}
-/**
- * DevTools dispatches synthetic page lifecycles after the changed module returns. A macrotask—not a microtask—runs
- * after that native turn and also avoids navigation or Taro root mutation from inside React Refresh's callback.
- */
-function runInNextNativeTask(task) {
-    setTimeout(task);
-}

package/dist/runtime/wx/taro-runtime.d.ts

@@ -1,5 +0,0 @@
-/** Runtime exports consumed by generated WX App, page, and recursive-component entries. */
-import '@tarojs/plugin-platform-weapp/dist/runtime.js';
-export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
-export { default as ReactDOM } from '@tarojs/react';
-export { createPageConfig, createRecursiveComponentConfig } from '@tarojs/runtime';

package/dist/runtime/wx/taro-runtime.js

@@ -1,6 +0,0 @@
-/** Runtime exports consumed by generated WX App, page, and recursive-component entries. */
-import '@tarojs/plugin-platform-weapp/dist/runtime.js';
-// @ts-expect-error Taro exposes createReactApp from this runtime-only deep entry without types.
-export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
-export { default as ReactDOM } from '@tarojs/react';
-export { createPageConfig, createRecursiveComponentConfig } from '@tarojs/runtime';

package/dist/runtime/wx/update-client-state.d.ts

@@ -1,68 +0,0 @@
-/**
- * Pure App-side stop-and-wait protocol state machine.
- *
- * It knows build versions and sequencing only; wx.request, literal code execution, and page lifecycle effects live in
- * update-client.ts and page-update.ts.
- */
-type WxUpdateClientPhase = 'stopped' | 'registering' | 'polling' | 'applying' | 'refreshing' | 'relaunching';
-type WxUpdateClientState = {
-    buildId: string;
-    version: number;
-    phase: WxUpdateClientPhase;
-    targetVersion?: number;
-    pendingBatch?: {
-        fromVersion: number;
-        targetVersion: number;
-    };
-};
-export type WxUpdateClientEvent = {
-    type: 'started';
-} | {
-    type: 'registration-completed';
-} | {
-    type: 'poll-completed';
-} | {
-    type: 'batch-observed';
-    buildId: string;
-    fromVersion: number;
-    targetVersion: number;
-} | {
-    type: 'batch-executed';
-    targetVersion: number;
-} | {
-    type: 'batch-failed';
-} | {
-    type: 'refresh-completed';
-    stale: boolean;
-} | {
-    type: 'route-ready';
-} | {
-    type: 'transport-failed';
-};
-export type WxUpdateClientCommand = {
-    type: 'register';
-    version: number;
-} | {
-    type: 'poll';
-    version: number;
-} | {
-    type: 'apply-batch';
-    fromVersion: number;
-    targetVersion: number;
-} | {
-    type: 'report-version';
-    version: number;
-    reason: 'applied' | 'batch-mismatch';
-} | {
-    type: 'request-full-build';
-    reason: 'batch-execution-failed';
-} | {
-    type: 'retry-transport';
-};
-type WxUpdateClientTransition = {
-    state: WxUpdateClientState;
-    commands: WxUpdateClientCommand[];
-};
-export declare function createWxUpdateClientState(buildId: string): WxUpdateClientState;
-export declare function transitionWxUpdateClient(state: WxUpdateClientState, event: WxUpdateClientEvent): WxUpdateClientTransition;
-export {};

package/dist/runtime/wx/update-client-state.js

@@ -1,84 +0,0 @@
-export function createWxUpdateClientState(buildId) {
-    return { buildId, version: 0, phase: 'stopped' };
-}
-export function transitionWxUpdateClient(state, event) {
-    switch (event.type) {
-        case 'started':
-            if (state.phase !== 'stopped')
-                return transition(state);
-            return command({ ...state, phase: 'registering' }, { type: 'register', version: state.version });
-        case 'registration-completed': {
-            if (state.phase !== 'registering')
-                return transition(state);
-            const pending = state.pendingBatch;
-            if (!pending)
-                return command({ ...state, phase: 'polling' }, { type: 'poll', version: state.version });
-            return command({ ...state, phase: 'applying', targetVersion: pending.targetVersion, pendingBatch: undefined }, { type: 'apply-batch', ...pending });
-        }
-        case 'poll-completed':
-            if (state.phase !== 'polling')
-                return transition(state);
-            return command(state, { type: 'poll', version: state.version });
-        case 'batch-observed':
-            return observeBatch(state, event);
-        case 'batch-executed':
-            if (state.phase !== 'applying' || state.targetVersion !== event.targetVersion) {
-                return command(state, { type: 'report-version', version: state.version, reason: 'batch-mismatch' });
-            }
-            return transition({ ...state, phase: 'refreshing', version: event.targetVersion });
-        case 'batch-failed':
-            return command({ ...state, phase: 'polling', targetVersion: undefined }, { type: 'request-full-build', reason: 'batch-execution-failed' });
-        case 'refresh-completed':
-            if (state.phase !== 'refreshing')
-                return transition(state);
-            if (event.stale)
-                return transition({ ...state, phase: 'relaunching' });
-            return applied(state);
-        case 'route-ready':
-            if (state.phase !== 'relaunching')
-                return transition(state);
-            return applied(state);
-        case 'transport-failed':
-            return command(state, { type: 'retry-transport' });
-    }
-}
-function observeBatch(state, batch) {
-    const valid = batch.buildId === state.buildId &&
-        Number.isInteger(batch.fromVersion) &&
-        Number.isInteger(batch.targetVersion) &&
-        batch.fromVersion >= 0 &&
-        batch.targetVersion > batch.fromVersion;
-    if (state.phase === 'registering') {
-        if (!valid || batch.fromVersion !== state.version || batch.targetVersion <= state.version) {
-            return transition(state);
-        }
-        return transition({
-            ...state,
-            pendingBatch: { fromVersion: batch.fromVersion, targetVersion: batch.targetVersion }
-        });
-    }
-    if (!valid) {
-        return command(state, { type: 'report-version', version: state.version, reason: 'batch-mismatch' });
-    }
-    if (batch.targetVersion <= state.version) {
-        return command(state, { type: 'report-version', version: state.version, reason: 'applied' });
-    }
-    if (state.phase !== 'polling' || batch.fromVersion !== state.version) {
-        return command(state, { type: 'report-version', version: state.version, reason: 'batch-mismatch' });
-    }
-    return command({ ...state, phase: 'applying', targetVersion: batch.targetVersion }, {
-        type: 'apply-batch',
-        fromVersion: batch.fromVersion,
-        targetVersion: batch.targetVersion
-    });
-}
-function applied(state) {
-    const appliedState = { ...state, phase: 'polling', targetVersion: undefined };
-    return command(appliedState, { type: 'report-version', version: state.version, reason: 'applied' });
-}
-function transition(state) {
-    return { state, commands: [] };
-}
-function command(state, value) {
-    return { state, commands: [value] };
-}

package/dist/runtime/wx/update-client.d.ts

@@ -1 +0,0 @@
-export declare function startWxUpdateClient(): void;