vite-plugin-taro 0.2.2 → 0.3.0

package/dist/node/vite-plugin.js

@@ -0,0 +1,33 @@
+import react from '@vitejs/plugin-react';
+import { BuildContext } from './build-context.js';
+import { createConditionalDirectivePlugin } from './plugins/conditional-directives.js';
+import { createTaroRuntimePlugin } from './plugins/taro-runtime.js';
+import { createH5TargetPlugins, createH5ViteConfig } from './targets/h5/plugin.js';
+import { createWxTargetPlugins, createWxViteConfig } from './targets/wx/plugin.js';
+/** Creates the Vite plugins for the selected Taro target. */
+export default function vitePluginTaro(options) {
+    const context = new BuildContext(options);
+    const targetPlugins = context.project.target === 'wx' ? createWxTargetPlugins(context) : createH5TargetPlugins(context);
+    return [
+        createBuildCoordinator(context),
+        createConditionalDirectivePlugin(context),
+        createTaroRuntimePlugin(),
+        context.css.plugin,
+        ...react(),
+        ...targetPlugins
+    ];
+}
+/** Establishes build mode and resolved Vite state before target hooks consume the context. */
+function createBuildCoordinator(context) {
+    return {
+        name: 'vite-plugin-taro:build',
+        enforce: 'pre',
+        config(_, environment) {
+            context.configure(environment);
+            return context.project.target === 'wx' ? createWxViteConfig(context) : createH5ViteConfig(context);
+        },
+        configResolved(config) {
+            context.resolve(config);
+        }
+    };
+}

package/dist/options.d.ts

@@ -0,0 +1,21 @@
+/** Plain JSON object emitted into Mini Program/Web config payloads. */
+export type JsonObject = Record<string, unknown>;
+/** Build target handled by this plugin. */
+export type VitePluginTaroTarget = 'wx' | 'h5';
+/** Describes one React-backed page shared by WeChat Mini Program and Web builds. */
+export type VitePluginTaroPageOption = {
+    /** Taro route and output path without a file extension. */
+    path: string;
+    /** Page config merged into the generated target config. */
+    config: JsonObject;
+};
+/** Required build inputs for the Vite/Rolldown Taro renderer plugin. */
+export interface VitePluginTaroOptions {
+    target: VitePluginTaroTarget;
+    app: string;
+    pages: VitePluginTaroPageOption[];
+    appJson: JsonObject;
+    projectConfigJson: JsonObject;
+    projectPrivateConfigJson: JsonObject;
+    sitemapJson: JsonObject;
+}

package/dist/{shim/h5.d.ts → runtime/h5/taro-runtime.d.ts}

@@ -1,4 +1,6 @@
-import '@tarojs/plugin-platform-h5/dist/runtime';
+/** Runtime exports consumed by the generated H5 entry. */
+import '@tarojs/components/global.css';
+import '@tarojs/components/dist/taro-components/taro-components.css';
 export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
 export { createBrowserHistory, createHashHistory, createRouter, handleAppMount } from '@tarojs/router';
 export { window } from '@tarojs/runtime';

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

@@ -0,0 +1,9 @@
+/** Runtime exports consumed by the generated H5 entry. */
+import '@tarojs/components/global.css';
+import '@tarojs/components/dist/taro-components/taro-components.css';
+// Import the CSS files directly instead of @tarojs/plugin-platform-h5/dist/runtime:
+// that runtime adds only taro-components.css plus optional polyfills, while generated H5 entries also need global.css.
+// @ts-expect-error Taro exposes createReactApp from this runtime-only deep entry without types.
+export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
+export { createBrowserHistory, createHashHistory, createRouter, handleAppMount } from '@tarojs/router';
+export { window } from '@tarojs/runtime';

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

@@ -0,0 +1,5 @@
+/** Physical runtime module backing the public `virtual:taro/api` facade. */
+import '@tarojs/plugin-framework-react/dist/runtime';
+import Taro from '@tarojs/taro';
+export * from '@tarojs/taro';
+export default Taro;

package/dist/{virtual → runtime/taro}/api.js

@@ -1,3 +1,6 @@
+/** 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')) {

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

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

package/dist/runtime/taro/components.js

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

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

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

@@ -0,0 +1,157 @@
+/**
+ * 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/{shim/wx.d.ts → runtime/wx/taro-runtime.d.ts}

@@ -1,3 +1,4 @@
+/** 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';

package/dist/{shim/wx.js → runtime/wx/taro-runtime.js}

@@ -1,3 +1,4 @@
+/** 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';

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

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

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

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

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

@@ -0,0 +1,170 @@
+/**
+ * App-owned adapter for the WX update protocol.
+ *
+ * It transports metadata with wx.request and executes literal batches delivered through update.js. React/Taro page
+ * preservation is delegated to page-update.ts so the App never depends on the mutable update file.
+ */
+import { createWxUpdateClientState, transitionWxUpdateClient } from './update-client-state.js';
+const wxClientGlobal = globalThis;
+const transportRetryDelay = 500;
+const rebuildPollDelay = 1_000;
+const updateFileWatchdogDelay = 2_000;
+export function startWxUpdateClient() {
+    if (wxClientGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__)
+        return;
+    const control = wxClientGlobal.__VITE_PLUGIN_TARO_WX_CONTROL__;
+    if (!control)
+        throw new Error('vite-plugin-taro could not find its WX update control configuration.');
+    let state = createWxUpdateClientState(control.buildId);
+    const sessionId = createSessionId();
+    let requestGeneration = 0;
+    let activeRequest;
+    let scheduledRequest;
+    let pendingBatchApply;
+    const dispatch = (event, apply) => {
+        const transition = transitionWxUpdateClient(state, event);
+        state = transition.state;
+        for (const command of transition.commands)
+            execute(command, apply);
+    };
+    const send = (action, version) => {
+        if (scheduledRequest)
+            clearTimeout(scheduledRequest);
+        scheduledRequest = undefined;
+        activeRequest?.abort();
+        const generation = ++requestGeneration;
+        activeRequest = wxClientGlobal.wx.request({
+            url: control.url,
+            method: 'POST',
+            data: {
+                token: control.token,
+                action,
+                buildId: state.buildId,
+                sessionId,
+                version
+            },
+            timeout: 30_000,
+            success(result) {
+                if (generation !== requestGeneration)
+                    return;
+                activeRequest = undefined;
+                const response = parseResponse(result.data);
+                if (action === 'register' && response.type === 'registered') {
+                    dispatch({ type: 'registration-completed' });
+                    return;
+                }
+                if (action === 'poll' && (response.type === 'idle' || response.type === 'changed')) {
+                    dispatch({ type: 'poll-completed' });
+                    return;
+                }
+                if (response.type === 'batch-published') {
+                    // If DevTools misses the update.js event, report the unchanged version and republish with a new nonce.
+                    scheduleRequest(updateFileWatchdogDelay);
+                    return;
+                }
+                if (response.type === 'rebuilding') {
+                    scheduleRequest(rebuildPollDelay);
+                    return;
+                }
+                dispatch({ type: 'transport-failed' });
+            },
+            fail() {
+                if (generation !== requestGeneration)
+                    return;
+                activeRequest = undefined;
+                dispatch({ type: 'transport-failed' });
+            }
+        });
+    };
+    /** Keeps exactly one delayed metadata request and discards it when protocol state advances. */
+    const scheduleRequest = (delay) => {
+        if (scheduledRequest)
+            clearTimeout(scheduledRequest);
+        const expectedPhase = state.phase;
+        const expectedVersion = state.version;
+        scheduledRequest = setTimeout(() => {
+            scheduledRequest = undefined;
+            if (state.phase !== expectedPhase || state.version !== expectedVersion)
+                return;
+            send(state.phase === 'registering' ? 'register' : 'poll', state.version);
+        }, delay);
+    };
+    const execute = (command, apply) => {
+        switch (command.type) {
+            case 'register':
+                send('register', command.version);
+                return;
+            case 'poll':
+            case 'report-version':
+                send('poll', command.version);
+                return;
+            case 'apply-batch': {
+                const batchApply = apply ?? pendingBatchApply;
+                pendingBatchApply = undefined;
+                if (!batchApply) {
+                    dispatch({ type: 'batch-failed' });
+                    return;
+                }
+                const applyUpdate = () => {
+                    const bridge = wxClientGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__;
+                    if (!bridge) {
+                        dispatch({ type: 'batch-failed' });
+                        return;
+                    }
+                    bridge.beginUpdate?.();
+                    try {
+                        batchApply();
+                        dispatch({ type: 'batch-executed', targetVersion: command.targetVersion });
+                    }
+                    catch {
+                        dispatch({ type: 'batch-failed' });
+                    }
+                    finally {
+                        bridge.endUpdate?.();
+                    }
+                };
+                const bridge = wxClientGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__;
+                if (bridge?.ready)
+                    applyUpdate();
+                else if (bridge)
+                    bridge.pendingUpdate = applyUpdate;
+                else
+                    dispatch({ type: 'batch-failed' });
+                return;
+            }
+            case 'request-full-build':
+                send('rebuild', state.version);
+                return;
+            case 'retry-transport':
+                scheduleRequest(transportRetryDelay);
+        }
+    };
+    wxClientGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__ = {
+        receiveBatch(metadata, apply) {
+            dispatch({ type: 'batch-observed', ...metadata }, apply);
+            if (state.pendingBatch?.fromVersion === metadata.fromVersion &&
+                state.pendingBatch.targetVersion === metadata.targetVersion) {
+                pendingBatchApply = apply;
+            }
+            else if (!state.pendingBatch && state.phase !== 'applying') {
+                pendingBatchApply = undefined;
+            }
+        },
+        refreshCompleted(stale) {
+            dispatch({ type: 'refresh-completed', stale });
+        },
+        routeReady() {
+            dispatch({ type: 'route-ready' });
+        }
+    };
+    dispatch({ type: 'started' });
+}
+function createSessionId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function parseResponse(value) {
+    if (typeof value !== 'object' || value === null || !('type' in value) || typeof value.type !== 'string') {
+        return { type: 'invalid' };
+    }
+    return { type: value.type };
+}

package/dist/vite.d.ts

@@ -1,2 +1,2 @@
-export type { VitePluginTaroOptions, VitePluginTaroPageOption, VitePluginTaroTarget } from './vite/types.ts';
-export { default } from './vite/vite-plugin-taro.ts';
+export { default } from './node/vite-plugin.ts';
+export type { VitePluginTaroOptions, VitePluginTaroPageOption, VitePluginTaroTarget } from './options.ts';

package/dist/vite.js

@@ -1 +1 @@
-export { default } from './vite/vite-plugin-taro.js';
+export { default } from './node/vite-plugin.js';