vite-plugin-taro 0.2.2 → 0.3.0

package/src/runtime/wx/page-update.ts

@@ -0,0 +1,230 @@
+/**
+ * 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'
+
+type WxPage = {
+    $taroPath?: string
+    $taroParams?: Record<string, unknown>
+}
+
+type WxPageConfig = Record<string, unknown>
+type PageLifecycle = (this: WxPage, ...args: unknown[]) => unknown
+
+type TaroRoot = {
+    ctx: WxPage | null
+    updateChildNodes(): void
+    performUpdate(initRender?: boolean): void
+}
+
+type ReactRefreshResult = {
+    staleFamilies?: Set<unknown>
+}
+
+type WxRolldownRuntime = {
+    beginPatch?(): void
+    endPatch?(): void
+}
+
+type WxPageUpdateCoordinator = {
+    ready: boolean
+    pendingUpdate?: () => void
+    blockRefreshRegistration?: boolean
+    enqueueRefresh?: () => void
+    beginUpdate?: () => void
+    endUpdate?: () => void
+    afterRefresh?: (update?: ReactRefreshResult) => void
+}
+
+type WxUpdateClient = {
+    refreshCompleted(stale: boolean): void
+    routeReady(): void
+}
+
+type WxRuntimeGlobal = typeof globalThis & {
+    __rolldown_runtime__?: WxRolldownRuntime
+    __VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?: WxPageUpdateCoordinator
+    __VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?: WxUpdateClient
+    getCurrentPages(): Array<{ route?: string }>
+    wx: {
+        reLaunch(options: { url: string }): void
+    }
+}
+
+const wxRuntimeGlobal = globalThis as WxRuntimeGlobal
+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<string>()
+const ignoredPages = new WeakSet<WxPage>()
+
+type PageRuntimeState = Readonly<{
+    activePage?: WxPage
+    pendingUpdate?: { page?: WxPage; root?: TaroRoot }
+    suppressLifecycles: boolean
+}>
+
+type PageRuntimeEvent =
+    | { type: 'page-activated'; page: WxPage }
+    | { type: 'page-unloaded'; page: WxPage }
+    | { type: 'update-started'; root?: TaroRoot }
+    | { type: 'suppression-ended' }
+    | { type: 'refresh-finished' }
+
+let pageRuntimeState: PageRuntimeState = { suppressLifecycles: false }
+
+/** Registers a native route once per App Service runtime generation. */
+export function registerWxPage(route: string, register: () => void): void {
+    if (registeredRoutes.has(route)) return
+    register()
+    registeredRoutes.add(route)
+}
+
+/** Retains Taro's live root while filtering DevTools' synthetic update lifecycles. */
+export function decorateWxPageConfig(config: WxPageConfig): WxPageConfig {
+    const onLoad = getLifecycle(config, 'onLoad')
+    config.onLoad = function (this: WxPage, ...args: unknown[]) {
+        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: WxPageConfig, name: string, after?: PageLifecycle): void {
+    const original = getLifecycle(config, name)
+    config[name] = function (this: WxPage, ...args: unknown[]) {
+        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: WxPageConfig, name: string): PageLifecycle | undefined {
+    return typeof config[name] === 'function' ? (config[name] as PageLifecycle) : undefined
+}
+
+function applyPendingPageUpdate(): void {
+    bridge.ready = true
+    const pendingUpdate = bridge.pendingUpdate
+    if (pendingUpdate) {
+        delete bridge.pendingUpdate
+        pendingUpdate()
+    }
+    wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?.routeReady()
+}
+
+function getActiveTaroRoot(): TaroRoot | undefined {
+    const page = pageRuntimeState.activePage
+    if (!page?.$taroPath) return
+    return (document.getElementById(page.$taroPath) as TaroRoot | null) ?? 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: PageRuntimeEvent): void {
+    pageRuntimeState = transitionPageRuntime(pageRuntimeState, event)
+}
+
+function transitionPageRuntime(state: PageRuntimeState, event: PageRuntimeEvent): PageRuntimeState {
+    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: TaroRoot | undefined, page: WxPage | undefined): void {
+    if (!root) return
+    root.ctx = page ?? null
+    root.updateChildNodes()
+    root.performUpdate(true)
+}
+
+function relaunchActiveRoute(page: WxPage | undefined): void {
+    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: () => void): void {
+    setTimeout(task)
+}

package/src/runtime/wx/react-refresh.d.ts

@@ -0,0 +1,20 @@
+/** Vite's development-only React Refresh virtual module used by the WX runtime. */
+declare module '*/@react-refresh' {
+    export type RefreshResult = {
+        updatedFamilies: Set<unknown>
+        staleFamilies: Set<unknown>
+    }
+
+    export function register(type: unknown, id: string): void
+    export function registerExportsForReactRefresh(filename: string, moduleExports: Record<string, unknown>): void
+    export function validateRefreshBoundaryAndEnqueueUpdate(
+        id: string,
+        previousExports: Record<string, unknown>,
+        nextExports: Record<string, unknown>
+    ): string | undefined
+
+    const runtime: {
+        injectIntoGlobalHook(globalObject: typeof globalThis): void
+    }
+    export default runtime
+}

package/src/{shim/wx.ts → runtime/wx/taro-runtime.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'
 
 // @ts-expect-error Taro exposes createReactApp from this runtime-only deep entry without types.

package/src/runtime/wx/update-client-state.ts

@@ -0,0 +1,138 @@
+/**
+ * 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 function createWxUpdateClientState(buildId: string): WxUpdateClientState {
+    return { buildId, version: 0, phase: 'stopped' }
+}
+
+export function transitionWxUpdateClient(
+    state: WxUpdateClientState,
+    event: WxUpdateClientEvent
+): WxUpdateClientTransition {
+    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: WxUpdateClientState,
+    batch: { buildId: string; fromVersion: number; targetVersion: number }
+): WxUpdateClientTransition {
+    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: WxUpdateClientState): WxUpdateClientTransition {
+    const appliedState = { ...state, phase: 'polling' as const, targetVersion: undefined }
+    return command(appliedState, { type: 'report-version', version: state.version, reason: 'applied' })
+}
+
+function transition(state: WxUpdateClientState): WxUpdateClientTransition {
+    return { state, commands: [] }
+}
+
+function command(state: WxUpdateClientState, value: WxUpdateClientCommand): WxUpdateClientTransition {
+    return { state, commands: [value] }
+}

package/src/runtime/wx/update-client.ts

@@ -0,0 +1,222 @@
+/**
+ * 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,
+    type WxUpdateClientCommand,
+    type WxUpdateClientEvent
+} from './update-client-state.ts'
+
+type WxUpdateControl = {
+    url: string
+    token: string
+    buildId: string
+}
+
+type WxUpdateBatchMetadata = {
+    buildId: string
+    fromVersion: number
+    targetVersion: number
+}
+
+type WxRequestTask = {
+    abort(): void
+}
+
+type WxRequestResult = {
+    data?: unknown
+}
+
+type WxPageUpdateCoordinator = {
+    ready: boolean
+    pendingUpdate?: () => void
+    beginUpdate?: () => void
+    endUpdate?: () => void
+}
+
+type WxUpdateClient = {
+    receiveBatch(metadata: WxUpdateBatchMetadata, apply: () => void): void
+    refreshCompleted(stale: boolean): void
+    routeReady(): void
+}
+
+type WxClientGlobal = typeof globalThis & {
+    __VITE_PLUGIN_TARO_WX_CONTROL__?: WxUpdateControl
+    __VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?: WxUpdateClient
+    __VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?: WxPageUpdateCoordinator
+    wx: {
+        request(options: {
+            url: string
+            method: 'POST'
+            data: unknown
+            timeout: number
+            success(result: WxRequestResult): void
+            fail(error: { errMsg?: string }): void
+        }): WxRequestTask
+    }
+}
+
+const wxClientGlobal = globalThis as WxClientGlobal
+const transportRetryDelay = 500
+const rebuildPollDelay = 1_000
+const updateFileWatchdogDelay = 2_000
+
+export function startWxUpdateClient(): void {
+    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: WxRequestTask | undefined
+    let scheduledRequest: ReturnType<typeof setTimeout> | undefined
+    let pendingBatchApply: (() => void) | undefined
+
+    const dispatch = (event: WxUpdateClientEvent, apply?: () => void): void => {
+        const transition = transitionWxUpdateClient(state, event)
+        state = transition.state
+        for (const command of transition.commands) execute(command, apply)
+    }
+
+    const send = (action: 'register' | 'poll' | 'rebuild', version: number): void => {
+        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: number): void => {
+        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: WxUpdateClientCommand, apply?: () => void): void => {
+        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(): string {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`
+}
+
+function parseResponse(value: unknown): { type: string } {
+    if (typeof value !== 'object' || value === null || !('type' in value) || typeof value.type !== 'string') {
+        return { type: 'invalid' }
+    }
+    return { type: value.type }
+}

package/src/vite.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/shim/h5.js

@@ -1,5 +0,0 @@
-import '@tarojs/plugin-platform-h5/dist/runtime';
-// @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/virtual/api.d.ts

@@ -1,3 +0,0 @@
-import Taro from '@tarojs/taro';
-export * from '@tarojs/taro';
-export default Taro;

package/dist/virtual/components.d.ts

@@ -1 +0,0 @@
-export * from '@tarojs/components';

package/dist/virtual/components.js

@@ -1 +0,0 @@
-export * from '@tarojs/components';

package/dist/vite/constants.d.ts

@@ -1,4 +0,0 @@
-export declare const isProd: boolean;
-export declare const nodeRequire: NodeJS.Require;
-export declare const h5ShimImportPath: string;
-export declare const wxShimImportPath: string;

package/dist/vite/constants.js

@@ -1,8 +0,0 @@
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { toImportPath } from './utils.js';
-export const isProd = process.env.NODE_ENV === 'production';
-export const nodeRequire = createRequire(import.meta.url);
-const packageRoot = path.dirname(nodeRequire.resolve('vite-plugin-taro/package.json'));
-export const h5ShimImportPath = toImportPath(path.join(packageRoot, 'dist/shim/h5.js'));
-export const wxShimImportPath = toImportPath(path.join(packageRoot, 'dist/shim/wx.js'));

package/dist/vite/plugins.d.ts

@@ -1,8 +0,0 @@
-import type { Plugin } from 'vite';
-import type { VitePluginTaroBuildContext } from './types.ts';
-/**
- * Applies Taro-style conditional compilation comments before Vite parses source files.
- *
- * Mirrors Taro's CSS #ifdef/#ifndef handling, generalized before Vite parses code.
- */
-export declare function createVitePluginTaroConditionalDirectivePlugin(context: VitePluginTaroBuildContext): Plugin;