vite-plugin-taro 0.3.1 → 0.4.0

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

@@ -1,170 +0,0 @@
-/**
- * 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/src/node/build-context.ts

@@ -1,63 +0,0 @@
-import path from 'node:path'
-import type { ConfigEnv, ResolvedConfig } from 'vite'
-import type { JsonObject, VitePluginTaroOptions, VitePluginTaroPageOption, VitePluginTaroTarget } from '../options.ts'
-import { CssPipeline } from './css/css-pipeline.ts'
-
-type ProjectContext = Readonly<{
-    target: VitePluginTaroTarget
-    appComponentFile: string
-    pages: readonly VitePluginTaroPageOption[]
-    appConfig: JsonObject
-    projectConfigJson: JsonObject
-    projectPrivateConfigJson?: JsonObject
-    sitemapJson: JsonObject
-}>
-
-/** Owns the shared project, Vite lifecycle state, and cross-target services for one build. */
-export class BuildContext {
-    readonly project: ProjectContext
-    readonly css: CssPipeline
-    private developmentMode: boolean | undefined
-    private resolvedViteConfig: ResolvedConfig | undefined
-
-    constructor(options: VitePluginTaroOptions) {
-        this.project = {
-            target: options.target,
-            appComponentFile: path.resolve(options.app),
-            pages: options.pages,
-            appConfig: {
-                ...options.appJson,
-                pages: options.pages.map((page) => page.path)
-            },
-            projectConfigJson: options.projectConfigJson,
-            projectPrivateConfigJson: options.projectPrivateConfigJson,
-            sitemapJson: options.sitemapJson
-        }
-        this.css = new CssPipeline(options.target)
-    }
-
-    configure(environment: ConfigEnv): void {
-        if (this.developmentMode !== undefined)
-            throw new Error('vite-plugin-taro build context was already configured.')
-        this.developmentMode = environment.command === 'serve'
-    }
-
-    resolve(config: ResolvedConfig): void {
-        if (this.developmentMode === undefined) {
-            throw new Error('vite-plugin-taro build context resolved before it was configured.')
-        }
-        if (this.resolvedViteConfig) throw new Error('vite-plugin-taro build context was already resolved.')
-        this.resolvedViteConfig = config
-        this.css.resolve(config.root)
-    }
-
-    get development(): boolean {
-        if (this.developmentMode === undefined) throw new Error('vite-plugin-taro build context is not configured.')
-        return this.developmentMode
-    }
-
-    get vite(): ResolvedConfig {
-        if (!this.resolvedViteConfig) throw new Error('vite-plugin-taro build context is not resolved.')
-        return this.resolvedViteConfig
-    }
-}

package/src/node/css/css-pipeline.ts

@@ -1,147 +0,0 @@
-import path from 'node:path'
-import type { Plugin } from 'vite'
-import { createContext } from 'weapp-tailwindcss/core'
-import { createWeappTailwindcssGenerator, resolveTailwindV4Source } from 'weapp-tailwindcss/generator'
-import type { VitePluginTaroTarget } from '../../options.ts'
-import { normalizeModuleId } from '../utils/modules.ts'
-
-const wxStyleOptions = {
-    cssCalc: false,
-    autoprefixer: false,
-    rem2rpx: true,
-    px2rpx: true
-} as const
-
-type WxCssContext = ReturnType<typeof createContext>
-type CssTransformResult = { code: string; map: null }
-
-/** Owns CSS generation and the class-name state shared by normal chunks and literal WX patches. */
-export class CssPipeline {
-    readonly plugin: Plugin
-    private readonly target: VitePluginTaroTarget
-    private readonly runtimeClassSet = new Set<string>()
-    private projectRoot: string | undefined
-    private wxContext: WxCssContext | undefined
-
-    constructor(target: VitePluginTaroTarget) {
-        this.target = target
-        this.plugin = this.createPlugin()
-    }
-
-    resolve(projectRoot: string): void {
-        if (this.projectRoot) throw new Error('vite-plugin-taro CSS pipeline was already resolved.')
-        this.projectRoot = projectRoot
-        this.wxContext = this.target === 'wx' ? createWxCssContext(projectRoot) : undefined
-    }
-
-    async transformWxClassNames(code: string, filename: string): Promise<CssTransformResult> {
-        if (!this.wxContext || this.runtimeClassSet.size === 0) return { code, map: null }
-        const result = await this.wxContext.transformJs(code, {
-            runtimeSet: this.runtimeClassSet,
-            filename,
-            generateMap: false
-        })
-        return { code: result.code, map: null }
-    }
-
-    private createPlugin(): Plugin {
-        const pipeline = this
-        return {
-            name: 'vite-plugin-taro:css',
-            enforce: 'pre',
-
-            buildStart() {
-                pipeline.runtimeClassSet.clear()
-            },
-
-            async transform(code, id) {
-                if (!isCssModuleId(id) || !shouldGenerateTailwindCss(code)) return
-
-                const projectRoot = pipeline.getProjectRoot()
-                const cssFile = resolveCssFile(id, projectRoot)
-                const cssBase = path.dirname(cssFile)
-                const source = await resolveTailwindV4Source({
-                    projectRoot,
-                    cwd: projectRoot,
-                    base: cssBase,
-                    css: code,
-                    cssSources: [{ file: cssFile, base: cssBase, css: code, dependencies: [cssFile] }]
-                })
-                const generator = createWeappTailwindcssGenerator(source)
-                const generated = await generator.generate({
-                    target: pipeline.target === 'wx' ? 'weapp' : 'web',
-                    scanSources: true,
-                    candidates: [],
-                    styleOptions: pipeline.target === 'wx' ? wxStyleOptions : undefined
-                })
-
-                for (const className of generated.classSet) pipeline.runtimeClassSet.add(className)
-                for (const dependency of generated.dependencies) this.addWatchFile(dependency)
-                return generated.css
-            },
-
-            async renderChunk(code, chunk) {
-                if (pipeline.target !== 'wx') return
-                return await pipeline.transformWxClassNames(code, chunk.fileName)
-            },
-
-            async generateBundle(_, bundle) {
-                if (pipeline.target !== 'wx') return
-                const core = pipeline.getWxContext()
-                await Promise.all(
-                    Object.entries(bundle).map(async ([fileName, item]) => {
-                        if (item.type === 'asset' && fileName.endsWith('.css')) {
-                            await transformWxssAsset(core, item)
-                        }
-                    })
-                )
-            }
-        }
-    }
-
-    private getProjectRoot(): string {
-        if (!this.projectRoot) throw new Error('vite-plugin-taro CSS pipeline was used before configuration resolved.')
-        return this.projectRoot
-    }
-
-    private getWxContext(): WxCssContext {
-        if (!this.wxContext) throw new Error('vite-plugin-taro expected a resolved WeChat CSS pipeline.')
-        return this.wxContext
-    }
-}
-
-function createWxCssContext(projectRoot: string): WxCssContext {
-    return createContext({
-        appType: 'taro',
-        tailwindcssBasedir: projectRoot,
-        generator: { target: 'weapp' },
-        ...wxStyleOptions,
-        logLevel: 'silent'
-    })
-}
-
-async function transformWxssAsset(core: WxCssContext, item: { source?: string | Uint8Array }): Promise<void> {
-    const result = await core.transformWxss(getAssetSource(item), { isMainChunk: true })
-    item.source = result.css
-}
-
-function shouldGenerateTailwindCss(code: string): boolean {
-    const tailwindEntryImportPattern =
-        /@(import|reference)\s+(?:url\(\s*)?(?:["'])tailwindcss(?:\/(?:theme|preflight|utilities)(?:\.css)?)?(?:["'])/
-    return code.includes('tailwindcss') && tailwindEntryImportPattern.test(code)
-}
-
-function isCssModuleId(id: string): boolean {
-    return /\.(?:css|scss|sass|less|styl|stylus)(?:$|[?#])/.test(id)
-}
-
-function getAssetSource(item: { source?: string | Uint8Array }): string {
-    if (typeof item.source === 'string') return item.source
-    return item.source ? new TextDecoder().decode(item.source) : ''
-}
-
-function resolveCssFile(id: string, root: string): string {
-    const normalizedId = normalizeModuleId(id)
-    const cleanId = normalizedId.startsWith('/@fs/') ? normalizedId.slice('/@fs'.length) : normalizedId
-    return path.isAbsolute(cleanId) ? cleanId : path.resolve(root, cleanId)
-}

package/src/node/plugins/taro-runtime.ts

@@ -1,22 +0,0 @@
-import type { Plugin } from 'vite'
-import { resolvePackageFile } from '../utils/packages.ts'
-
-/** Public IDs used by Taro's API transform and generated target modules. */
-export const virtualTaroApiId = 'virtual:taro/api'
-const virtualTaroComponentsId = 'virtual:taro/components'
-
-const runtimeModules = new Map([
-    [virtualTaroApiId, resolvePackageFile('dist/runtime/taro/api.js')],
-    [virtualTaroComponentsId, resolvePackageFile('dist/runtime/taro/components.js')]
-])
-
-/** Resolves target-neutral Taro shims once instead of duplicating this concern in every target plugin. */
-export function createTaroRuntimePlugin(): Plugin {
-    return {
-        name: 'vite-plugin-taro:runtime',
-        enforce: 'pre',
-        resolveId(id) {
-            return runtimeModules.get(id)
-        }
-    }
-}

package/src/node/targets/h5/plugin.ts

@@ -1,135 +0,0 @@
-import type { types as BabelTypes, NodePath, PluginObj } from '@babel/core'
-import babel from '@rolldown/plugin-babel'
-import type { Plugin, PluginOption, UserConfig } from 'vite'
-import type { BuildContext } from '../../build-context.ts'
-import { virtualTaroApiId } from '../../plugins/taro-runtime.ts'
-import { stripVirtualPrefix } from '../../utils/modules.ts'
-import { packageRequire } from '../../utils/packages.ts'
-import { createH5IndexHtmlTags, isH5VirtualModuleId, loadH5VirtualModule } from './virtual-modules.ts'
-
-/** Creates the plugins that own the complete H5 target lifecycle. */
-export function createH5TargetPlugins(context: BuildContext): PluginOption[] {
-    return [...createH5SupportPlugins(), createH5TargetPlugin(context)]
-}
-
-function createH5TargetPlugin(context: BuildContext): Plugin {
-    return {
-        name: 'vite-plugin-taro:h5',
-
-        resolveId: {
-            order: 'pre',
-            handler(id) {
-                return isH5VirtualModuleId(id) ? `\0${id}` : undefined
-            }
-        },
-
-        load: {
-            order: 'post',
-            handler(id) {
-                return loadH5VirtualModule(stripVirtualPrefix(id), context)
-            }
-        },
-
-        transformIndexHtml: {
-            order: 'pre',
-            handler() {
-                return createH5IndexHtmlTags(context)
-            }
-        }
-    }
-}
-
-/** Creates H5-only Babel transforms for Stencil CSS ordering and Taro API imports. */
-function createH5SupportPlugins(): PluginOption[] {
-    return [
-        babel({
-            include: /[\\/]@stencil[\\/]core[\\/]internal[\\/]client[\\/]index\.js(?:\?.*)?$/,
-            exclude: [],
-            plugins: [rewriteStencilStyleInsertion]
-        }),
-        babel({
-            plugins: [
-                [
-                    packageRequire.resolve('babel-plugin-transform-taroapi'),
-                    {
-                        packageName: virtualTaroApiId,
-                        definition: packageRequire(
-                            packageRequire.resolve('@tarojs/plugin-platform-h5/dist/definition.json')
-                        )
-                    }
-                ]
-            ]
-        })
-    ]
-}
-
-/** Keeps Stencil-injected Taro component styles before application stylesheets. */
-function rewriteStencilStyleInsertion(): PluginObj {
-    return {
-        name: 'rewrite-stencil-style-insertion',
-        visitor: {
-            CallExpression(path: NodePath<BabelTypes.CallExpression>) {
-                if (!isStencilStyleInsertBeforeCall(path)) return
-                path.get('arguments.1').replaceWithSourceString(
-                    `scopeId.startsWith('sc-taro-') ? styleContainerNode.querySelector('style,link[rel="stylesheet"]') : styleContainerNode.querySelector('link')`
-                )
-            }
-        }
-    }
-}
-
-function isStencilStyleInsertBeforeCall(path: NodePath<BabelTypes.CallExpression>): boolean {
-    return (
-        path.get('callee').matchesPattern('styleContainerNode.insertBefore') &&
-        path.get('arguments.0').toString() === 'styleElm' &&
-        path.get('arguments.1').toString() === "styleContainerNode.querySelector('link')"
-    )
-}
-
-/** Supplies the complete H5 target configuration from the same target owner as its plugins. */
-export function createH5ViteConfig(context: BuildContext): UserConfig {
-    return {
-        define: createH5TaroDefines(),
-        resolve: {
-            mainFields: ['main:h5', 'browser', 'module', 'jsnext:main', 'jsnext'],
-            alias: [
-                {
-                    find: /^@stencil\/core\/internal\/client$/,
-                    replacement: packageRequire.resolve('@stencil/core/internal/client', {
-                        paths: [packageRequire.resolve('@tarojs/components/package.json')]
-                    })
-                },
-                {
-                    find: /^@tarojs\/components$/,
-                    replacement: packageRequire.resolve('@tarojs/components/lib/react')
-                },
-                {
-                    find: /^@tarojs\/components\/dist\/components$/,
-                    replacement: packageRequire.resolve('@tarojs/components/dist/components')
-                },
-                {
-                    find: /^@tarojs\/taro$/,
-                    replacement: packageRequire.resolve('@tarojs/plugin-platform-h5/dist/runtime/apis')
-                }
-            ]
-        },
-        optimizeDeps: {
-            exclude: ['@stencil/core/internal/client']
-        },
-        build: {
-            target: 'es2018',
-            minify: !context.development
-        }
-    }
-}
-
-function createH5TaroDefines(): Record<string, string> {
-    return {
-        'process.env.FRAMEWORK': JSON.stringify('react'),
-        'process.env.SUPPORT_TARO_POLYFILL': JSON.stringify('disabled'),
-        'process.env.TARO_ENV': JSON.stringify('h5'),
-        'process.env.TARO_PLATFORM': JSON.stringify('web'),
-        'process.env.SUPPORT_DINGTALK_NAVIGATE': JSON.stringify('disabled'),
-        DEPRECATED_ADAPTER_COMPONENT: 'false'
-    }
-}

package/src/node/targets/h5/virtual-modules.ts

@@ -1,71 +0,0 @@
-import type { HtmlTagDescriptor } from 'vite'
-import type { JsonObject, VitePluginTaroPageOption } from '../../../options.ts'
-import type { BuildContext } from '../../build-context.ts'
-import { createPageComponentImportPath, toViteFileImportPath } from '../../utils/modules.ts'
-import { resolvePackageFile } from '../../utils/packages.ts'
-
-const h5TaroRuntimeImportPath = toViteFileImportPath(resolvePackageFile('dist/runtime/h5/taro-runtime.js'))
-
-const virtualH5EntryId = 'virtual:vite-plugin-taro/h5'
-
-export function isH5VirtualModuleId(id: string): boolean {
-    return id === virtualH5EntryId
-}
-
-export function loadH5VirtualModule(id: string, context: BuildContext): string | undefined {
-    if (id === virtualH5EntryId) return createH5EntrySource(context)
-}
-
-export function createH5IndexHtmlTags(context: BuildContext): HtmlTagDescriptor[] | undefined {
-    if (context.project.target !== 'h5') return
-    return [
-        {
-            tag: 'script',
-            attrs: { type: 'module' },
-            children: `import '${virtualH5EntryId}'`,
-            injectTo: 'body'
-        }
-    ]
-}
-
-function createH5EntrySource(context: BuildContext): string {
-    const appConfig = JSON.stringify(createH5AppConfig(context.project.appConfig))
-    const routes = createH5RoutesSource(context.project.pages)
-    return `import {
-    createHashHistory,
-    createReactApp,
-    createRouter,
-    handleAppMount,
-    window
-} from ${JSON.stringify(h5TaroRuntimeImportPath)}
-import React from 'react'
-import ReactDOM from 'react-dom/client'
-import AppComponent from ${JSON.stringify(toViteFileImportPath(context.project.appComponentFile))}
-
-const config = window.__taroAppConfig = ${appConfig}
-config.routes = ${routes}
-const app = createReactApp(AppComponent, React, ReactDOM, config)
-const history = createHashHistory({ window })
-handleAppMount(config, history)
-createRouter(history, app, config, React)
-`
-}
-
-function createH5AppConfig(sharedAppConfig: JsonObject): JsonObject {
-    return { router: {}, ...sharedAppConfig }
-}
-
-function createH5RoutesSource(pages: readonly VitePluginTaroPageOption[]): string {
-    const routes = pages.map((page) =>
-        [
-            'Object.assign({',
-            `  path: ${JSON.stringify(page.path)},`,
-            '  load: async function(context, params) {',
-            `    const page = await import(${JSON.stringify(createPageComponentImportPath(page.path))})`,
-            '    return [page, context, params]',
-            '  }',
-            `}, ${JSON.stringify(page.config)})`
-        ].join('\n')
-    )
-    return `[\n${routes.join(',\n')}\n]`
-}