vite-plugin-taro 0.3.2 → 0.4.0

package/src/node/targets/wx/dev-server/full-build-scheduler.ts

@@ -1,62 +0,0 @@
-/** Full-build scheduling owned by one WX development session. */
-
-type FullBuildPhase = 'idle' | 'scheduled' | 'building' | 'building-with-pending-request' | 'closed'
-
-/** Coalesces trailing-edge requests while guaranteeing one full build at a time. */
-export class FullBuildScheduler {
-    private readonly delay: number
-    private readonly runBuild: () => Promise<void>
-    private readonly reportError: (error: unknown) => void
-    private phase: FullBuildPhase = 'idle'
-    private timer: NodeJS.Timeout | undefined
-    private work: Promise<void> | undefined
-
-    constructor(delay: number, runBuild: () => Promise<void>, reportError: (error: unknown) => void) {
-        this.delay = delay
-        this.runBuild = runBuild
-        this.reportError = reportError
-    }
-
-    request(): void {
-        switch (this.phase) {
-            case 'closed':
-                return
-            case 'building':
-                this.phase = 'building-with-pending-request'
-                return
-            case 'building-with-pending-request':
-                return
-            case 'idle':
-            case 'scheduled':
-                if (this.timer) clearTimeout(this.timer)
-                this.phase = 'scheduled'
-                this.timer = setTimeout(() => this.start(), this.delay)
-        }
-    }
-
-    async close(): Promise<void> {
-        if (this.phase === 'closed') {
-            await this.work
-            return
-        }
-        this.phase = 'closed'
-        if (this.timer) clearTimeout(this.timer)
-        this.timer = undefined
-        await this.work
-    }
-
-    private start(): void {
-        if (this.phase !== 'scheduled') return
-        this.timer = undefined
-        this.phase = 'building'
-        this.work = this.runBuild()
-            .catch(this.reportError)
-            .finally(() => {
-                this.work = undefined
-                if (this.phase === 'closed') return
-                const repeat = this.phase === 'building-with-pending-request'
-                this.phase = 'idle'
-                if (repeat) this.request()
-            })
-    }
-}

package/src/node/targets/wx/dev-server/js-utils.ts

@@ -1,33 +0,0 @@
-import { transformWithOxc } from 'vite'
-import type { WxOutputFile } from './output.ts'
-
-const wxJavaScriptTarget = 'es2018'
-
-/** Lowers generated JavaScript syntax that WeChat's upload parser does not accept. */
-export async function transformWxCompatibleJavaScript(code: string, filename: string): Promise<string> {
-    const result = await transformWithOxc(code, filename, {
-        lang: 'js',
-        target: wxJavaScriptTarget,
-        sourcemap: false,
-        assumptions: {
-            // Avoid external Oxc helpers when lowering public class fields in already-bundled chunks.
-            setPublicClassFields: true
-        }
-    })
-    return result.code
-}
-
-/** Applies the compatibility transform to every JavaScript chunk in a DevEngine output batch. */
-export async function transformWxOutputChunks(output: WxOutputFile[]): Promise<void> {
-    await Promise.all(
-        output.map(async (item, index) => {
-            if (item.type !== 'chunk') return
-            output[index] = {
-                type: 'chunk',
-                fileName: item.fileName,
-                modules: item.modules,
-                code: await transformWxCompatibleJavaScript(item.code, item.fileName)
-            }
-        })
-    )
-}

package/src/node/targets/wx/dev-server/output.ts

@@ -1,56 +0,0 @@
-/**
- * Normalizes private DevEngine output before the development session writes it to the fixed WX project directory.
- * DevEngine rebuilds may be partial, so these helpers mutate only files present in the current output.
- */
-
-/** File shape emitted by Vite's private bundled-development engine. */
-export type WxOutputFile =
-    | {
-          type: 'chunk'
-          fileName: string
-          code: string
-          modules?: Record<string, unknown>
-      }
-    | {
-          type: 'asset'
-          fileName: string
-          source: string | Uint8Array
-      }
-
-/** Extracts Vite's development CSS payloads and materializes them as app.wxss. */
-export function normalizeWxBundleStyles(output: WxOutputFile[]): string | undefined {
-    const styles: string[] = []
-    for (let index = output.length - 1; index >= 0; index--) {
-        const item = output[index]
-        if (!item) continue
-        if (item.type === 'asset' && item.fileName.endsWith('.css')) {
-            styles.unshift(typeof item.source === 'string' ? item.source : new TextDecoder().decode(item.source))
-            output.splice(index, 1)
-        } else if (item.type === 'chunk') {
-            styles.push(...collectEmbeddedStyles(item.code))
-        }
-    }
-    if (styles.length === 0) return
-    const source = styles.join('\n')
-    setWxAppStyles(output, source)
-    return source
-}
-
-export function setWxAppStyles(output: WxOutputFile[], source: string): void {
-    const index = output.findIndex((item) => item.type === 'asset' && item.fileName === 'app.wxss')
-    const appStyle: WxOutputFile = { type: 'asset', fileName: 'app.wxss', source }
-    if (index >= 0) output[index] = appStyle
-    else output.push(appStyle)
-}
-
-export function isWxFullBuildOutput(output: WxOutputFile[]): boolean {
-    return output.some((item) => item.fileName === 'app.js')
-}
-
-function collectEmbeddedStyles(code: string): string[] {
-    const styles: string[] = []
-    for (const match of code.matchAll(/__vite__css(?:\$\d+)?\s*=\s*("(?:\\.|[^"\\])*");/g)) {
-        if (match[1]) styles.push(JSON.parse(match[1]) as string)
-    }
-    return styles
-}

package/src/node/targets/wx/dev-server/rolldown-runtime-source.ts

@@ -1,95 +0,0 @@
-/**
- * Self-contained source injected into Rolldown's DevEngine as the WX module bootstrap runtime.
- *
- * This TypeScript module runs in Node and only exports source text. The exported JavaScript becomes
- * `runtime.js`, executes before every application module, and therefore cannot import Taro, React,
- * or any module that depends on the runtime it is creating.
- */
-export const wxRolldownRuntimeSource = `
-var BaseDevRuntime = DevRuntime;
-class WxHotContext {
-  callbacks = [];
-  data = {};
-  _internal = { updateStyle() {}, removeStyle() {} };
-  constructor(moduleId) { this.moduleId = moduleId; }
-  accept(...args) {
-    if (args.length === 0) {
-      this.callbacks.push({ deps: this.moduleId, callback: undefined });
-    } else if (args.length === 1 && typeof args[0] === 'function') {
-      this.callbacks.push({ deps: this.moduleId, callback: args[0] });
-    } else if (args.length === 1) {
-      this.callbacks.push({ deps: args[0], callback: undefined });
-    } else {
-      this.callbacks.push({ deps: args[0], callback: args[1] });
-    }
-  }
-  acceptExports(_exports, callback) { this.accept(callback); }
-  dispose() {}
-  prune() {}
-  invalidate() {}
-  on() {}
-  off() {}
-  send() {}
-}
-class WxRolldownRuntime extends BaseDevRuntime {
-  contexts = new Map();
-  patchedModules = new Set();
-  applyingPatch = false;
-
-  createEsmInitializer = (id, initialize, _deduplicate, result) => () => {
-    if (!initialize) return result;
-    if (!this.applyingPatch && this.patchedModules.has(id)) {
-      initialize = undefined;
-      return result;
-    }
-    const callback = initialize;
-    initialize = undefined;
-    result = callback(id);
-    if (this.applyingPatch) this.patchedModules.add(id);
-    return result;
-  };
-
-  createCjsInitializer = (id, initialize, _deduplicate, module) => () => {
-    if (module) return module.exports;
-    if (!this.applyingPatch && this.patchedModules.has(id)) return this.loadExports(id);
-    module = { exports: {} };
-    initialize(module.exports, module, id);
-    if (this.applyingPatch) this.patchedModules.add(id);
-    return module.exports;
-  };
-
-  createModuleHotContext(moduleId) {
-    const previous = this.contexts.get(moduleId);
-    const context = new WxHotContext(moduleId);
-    if (previous) {
-      context.callbacks = previous.callbacks;
-      context.data = previous.data;
-    }
-    this.contexts.set(moduleId, context);
-    return context;
-  }
-
-  beginPatch() { this.applyingPatch = true; }
-  endPatch() { this.applyingPatch = false; }
-
-  applyUpdates(boundaries) {
-    for (const [boundary, acceptedVia] of boundaries) {
-      const context = this.contexts.get(boundary);
-      if (!context) continue;
-      const callbacks = [...context.callbacks];
-      if (boundary === acceptedVia) context.callbacks = [];
-      for (const { deps, callback } of callbacks) {
-        if (!callback) continue;
-        if (Array.isArray(deps)) {
-          if (deps.includes(acceptedVia)) callback(deps.map((id) => this.loadExports(id)));
-        } else if (deps === acceptedVia) {
-          callback(this.loadExports(acceptedVia));
-        }
-      }
-    }
-  }
-}
-// A full DevEngine runtime starts a new page-update generation before any application chunk executes.
-globalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__ = { ready: false };
-globalThis.__rolldown_runtime__ = new WxRolldownRuntime(undefined, 'vite-plugin-taro-wx');
-`

package/src/node/targets/wx/dev-server/update-server-state.ts

@@ -1,183 +0,0 @@
-/**
- * Pure host-side stop-and-wait protocol state machine.
- *
- * It retains versioned Rolldown deltas and selects one missing range for the active App Service. HTTP and filesystem
- * effects are represented as commands and handled by update-transport.ts.
- */
-type WxUpdateDelta = {
-    version: number
-    code: string
-}
-
-export type WxUpdateBatch = {
-    buildId: string
-    sessionId: string
-    fromVersion: number
-    targetVersion: number
-    deltas: WxUpdateDelta[]
-}
-
-type WxUpdateServerState = {
-    buildId: string
-    hostVersion: number
-    retainedDeltaBytes: number
-    deltas: WxUpdateDelta[]
-    activeSessionId?: string
-    retiredSessionIds: string[]
-    inFlight?: Pick<WxUpdateBatch, 'sessionId' | 'fromVersion' | 'targetVersion'>
-}
-
-type WxUpdateServerEvent =
-    | { type: 'delta-added'; code: string; bytes?: number }
-    | { type: 'client-registered'; buildId: string; sessionId: string; version: number }
-    | { type: 'client-reported'; buildId: string; sessionId: string; version: number }
-    | { type: 'batch-publish-failed'; sessionId: string; targetVersion: number }
-    | { type: 'full-build-committed'; buildId: string }
-
-export type WxUpdateServerCommand =
-    | { type: 'publish-batch'; batch: WxUpdateBatch }
-    | { type: 'request-full-build'; reason: 'client-version-ahead' | 'invalid-client-version' }
-    | { type: 'ignore-client'; reason: 'stale-build' | 'retired-session' | 'unknown-session' }
-
-type WxUpdateServerTransition = {
-    state: WxUpdateServerState
-    commands: WxUpdateServerCommand[]
-}
-
-export function createWxUpdateServerState(buildId: string): WxUpdateServerState {
-    return {
-        buildId,
-        hostVersion: 0,
-        retainedDeltaBytes: 0,
-        deltas: [],
-        retiredSessionIds: []
-    }
-}
-
-export function transitionWxUpdateServer(
-    state: WxUpdateServerState,
-    event: WxUpdateServerEvent
-): WxUpdateServerTransition {
-    switch (event.type) {
-        case 'delta-added': {
-            const version = state.hostVersion + 1
-            return transition({
-                ...state,
-                hostVersion: version,
-                retainedDeltaBytes: state.retainedDeltaBytes + (event.bytes ?? event.code.length),
-                deltas: [...state.deltas, { version, code: event.code }]
-            })
-        }
-        case 'client-registered':
-            return registerClient(state, event)
-        case 'client-reported':
-            return reportClient(state, event)
-        case 'batch-publish-failed':
-            if (state.inFlight?.sessionId !== event.sessionId || state.inFlight.targetVersion !== event.targetVersion) {
-                return transition(state)
-            }
-            return transition({ ...state, inFlight: undefined })
-        case 'full-build-committed':
-            return transition(createWxUpdateServerState(event.buildId))
-    }
-}
-
-function registerClient(
-    state: WxUpdateServerState,
-    client: { buildId: string; sessionId: string; version: number }
-): WxUpdateServerTransition {
-    const rejected = rejectClient(state, client)
-    if (rejected) return rejected
-    if (state.retiredSessionIds.includes(client.sessionId)) {
-        return command(state, { type: 'ignore-client', reason: 'retired-session' })
-    }
-    if (state.activeSessionId === client.sessionId) return transition(state)
-
-    const retiredSessionIds = state.activeSessionId
-        ? [...new Set([...state.retiredSessionIds, state.activeSessionId])]
-        : state.retiredSessionIds
-    const registered = {
-        ...state,
-        activeSessionId: client.sessionId,
-        retiredSessionIds,
-        inFlight: undefined
-    }
-    return transition(registered)
-}
-
-function reportClient(
-    state: WxUpdateServerState,
-    client: { buildId: string; sessionId: string; version: number }
-): WxUpdateServerTransition {
-    const rejected = rejectClient(state, client)
-    if (rejected) return rejected
-    if (state.retiredSessionIds.includes(client.sessionId)) {
-        return command(state, { type: 'ignore-client', reason: 'retired-session' })
-    }
-    if (client.sessionId !== state.activeSessionId) {
-        return command(state, { type: 'ignore-client', reason: 'unknown-session' })
-    }
-    return synchronizeClient(state, client.version)
-}
-
-function rejectClient(
-    state: WxUpdateServerState,
-    client: { buildId: string; version: number }
-): WxUpdateServerTransition | undefined {
-    if (client.buildId !== state.buildId) {
-        return command(state, { type: 'ignore-client', reason: 'stale-build' })
-    }
-    if (!Number.isInteger(client.version) || client.version < 0) {
-        return command(state, { type: 'request-full-build', reason: 'invalid-client-version' })
-    }
-    if (client.version > state.hostVersion) {
-        return command(state, { type: 'request-full-build', reason: 'client-version-ahead' })
-    }
-}
-
-function synchronizeClient(state: WxUpdateServerState, clientVersion: number): WxUpdateServerTransition {
-    let synchronized = state
-    const inFlight = state.inFlight
-    if (inFlight) {
-        if (clientVersion === inFlight.fromVersion) {
-            const batch = createBatch(state, clientVersion, inFlight.targetVersion)
-            return command(state, { type: 'publish-batch', batch })
-        }
-        if (clientVersion !== inFlight.targetVersion) {
-            return command(state, { type: 'request-full-build', reason: 'invalid-client-version' })
-        }
-        synchronized = { ...state, inFlight: undefined }
-    }
-    if (clientVersion >= synchronized.hostVersion) return transition(synchronized)
-
-    const batch = createBatch(synchronized, clientVersion, synchronized.hostVersion)
-    return command(
-        {
-            ...synchronized,
-            inFlight: {
-                sessionId: batch.sessionId,
-                fromVersion: batch.fromVersion,
-                targetVersion: batch.targetVersion
-            }
-        },
-        { type: 'publish-batch', batch }
-    )
-}
-
-function createBatch(state: WxUpdateServerState, fromVersion: number, targetVersion: number): WxUpdateBatch {
-    return {
-        buildId: state.buildId,
-        sessionId: state.activeSessionId!,
-        fromVersion,
-        targetVersion,
-        deltas: state.deltas.filter((delta) => delta.version > fromVersion && delta.version <= targetVersion)
-    }
-}
-
-function transition(state: WxUpdateServerState): WxUpdateServerTransition {
-    return { state, commands: [] }
-}
-
-function command(state: WxUpdateServerState, value: WxUpdateServerCommand): WxUpdateServerTransition {
-    return { state, commands: [value] }
-}

package/src/node/targets/wx/dev-server/update-transport.ts

@@ -1,261 +0,0 @@
-/**
- * Adapts the pure server protocol to Vite HTTP middleware and literal update-file publication.
- * HTTP messages contain metadata only; executable JavaScript reaches DevTools through the injected file writer.
- */
-import { randomBytes } from 'node:crypto'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import type { ViteDevServer } from 'vite'
-import {
-    createWxUpdateServerState,
-    transitionWxUpdateServer,
-    type WxUpdateBatch,
-    type WxUpdateServerCommand
-} from './update-server-state.ts'
-
-const endpointPath = '/__vite_plugin_taro_wx_update__'
-// Keep the host response below update-client.ts's 30-second wx.request timeout.
-const pollTimeout = 25_000
-
-type PendingPoll = {
-    response: ServerResponse
-    timeout: NodeJS.Timeout
-}
-
-type UpdateRequest = {
-    token?: unknown
-    action?: unknown
-    buildId?: unknown
-    sessionId?: unknown
-    version?: unknown
-}
-
-export class WxUpdateTransport {
-    private state = createWxUpdateServerState(createId())
-    private readonly token = createId()
-    private readonly pendingPolls = new Map<string, PendingPoll>()
-    private closed = false
-
-    constructor(
-        private readonly server: ViteDevServer,
-        private readonly requestFullBuild: () => void,
-        private readonly writeUpdateFile: (buildId: string, source: string) => Promise<void>
-    ) {}
-
-    get retainedDeltaCount(): number {
-        return this.state.hostVersion
-    }
-
-    get retainedDeltaBytes(): number {
-        return this.state.retainedDeltaBytes
-    }
-
-    install(): void {
-        this.server.middlewares.use(endpointPath, this.handleRequest)
-    }
-
-    close(): void {
-        this.closed = true
-        this.respondToAll({ type: 'rebuilding' })
-    }
-
-    addDelta(code: string): void {
-        this.apply({ type: 'delta-added', code, bytes: Buffer.byteLength(code) })
-        this.respondToAll({ type: 'changed' })
-    }
-
-    createBuildId(): string {
-        return createId()
-    }
-
-    isCurrentBuild(buildId: string): boolean {
-        return this.state.buildId === buildId
-    }
-
-    commitFullBuild(buildId: string): void {
-        this.apply({ type: 'full-build-committed', buildId })
-        this.respondToAll({ type: 'rebuilding' })
-    }
-
-    /** Generates late-bound App metadata after Vite has selected its actual listening port. */
-    createControlSource(buildId = this.state.buildId): string {
-        const address = this.server.httpServer?.address()
-        const port = address && typeof address !== 'string' ? address.port : this.server.config.server.port
-        return `globalThis.__VITE_PLUGIN_TARO_WX_CONTROL__ = ${JSON.stringify({
-            url: `http://localhost:${port}${endpointPath}`,
-            token: this.token,
-            buildId
-        })};\n`
-    }
-
-    private readonly handleRequest = async (request: IncomingMessage, response: ServerResponse): Promise<void> => {
-        if (this.closed || request.method !== 'POST') {
-            respond(response, 404, { type: 'not-found' })
-            return
-        }
-
-        let body: UpdateRequest
-        try {
-            body = JSON.parse(await readBody(request)) as UpdateRequest
-        } catch {
-            respond(response, 400, { type: 'invalid-request' })
-            return
-        }
-        if (body.token !== this.token || !isClientReport(body)) {
-            respond(response, 403, { type: 'forbidden' })
-            return
-        }
-
-        if (body.action === 'rebuild') {
-            this.requestFullBuild()
-            respond(response, 202, { type: 'rebuilding' })
-            return
-        }
-        if (body.action === 'register') {
-            const transition = this.apply({
-                type: 'client-registered',
-                buildId: body.buildId,
-                sessionId: body.sessionId,
-                version: body.version
-            })
-            if (transition.some((command) => command.type === 'request-full-build')) this.requestFullBuild()
-            respond(response, 200, { type: 'registered' })
-            return
-        }
-        if (body.action !== 'poll') {
-            respond(response, 400, { type: 'invalid-request' })
-            return
-        }
-
-        const commands = this.apply({
-            type: 'client-reported',
-            buildId: body.buildId,
-            sessionId: body.sessionId,
-            version: body.version
-        })
-        await this.executePollCommands(body.sessionId, commands, response)
-    }
-
-    private async executePollCommands(
-        sessionId: string,
-        commands: WxUpdateServerCommand[],
-        response: ServerResponse
-    ): Promise<void> {
-        const publish = commands.find((command) => command.type === 'publish-batch')
-        if (publish?.type === 'publish-batch') {
-            try {
-                await this.writeBatch(publish.batch)
-                respond(response, 200, { type: 'batch-published', targetVersion: publish.batch.targetVersion })
-            } catch {
-                this.apply({
-                    type: 'batch-publish-failed',
-                    sessionId: publish.batch.sessionId,
-                    targetVersion: publish.batch.targetVersion
-                })
-                respond(response, 500, { type: 'publish-failed' })
-            }
-            return
-        }
-        if (commands.some((command) => command.type === 'request-full-build')) {
-            this.requestFullBuild()
-            respond(response, 202, { type: 'rebuilding' })
-            return
-        }
-        if (commands.some((command) => command.type === 'ignore-client')) {
-            respond(response, 409, { type: 'rebuilding' })
-            return
-        }
-        this.holdPoll(sessionId, response)
-    }
-
-    private holdPoll(sessionId: string, response: ServerResponse): void {
-        const previous = this.pendingPolls.get(sessionId)
-        if (previous) this.finishPoll(sessionId, previous, { type: 'changed' })
-
-        let pending: PendingPoll
-        pending = {
-            response,
-            timeout: setTimeout(() => this.finishPoll(sessionId, pending, { type: 'idle' }), pollTimeout)
-        }
-        this.pendingPolls.set(sessionId, pending)
-        response.on('close', () => this.finishPoll(sessionId, pending))
-    }
-
-    private respondToAll(value: { type: string }): void {
-        for (const [sessionId, pending] of this.pendingPolls) this.finishPoll(sessionId, pending, value)
-    }
-
-    private finishPoll(sessionId: string, pending: PendingPoll, value?: { type: string }): void {
-        if (this.pendingPolls.get(sessionId) !== pending) return
-        clearTimeout(pending.timeout)
-        this.pendingPolls.delete(sessionId)
-        if (value) respond(pending.response, 200, value)
-    }
-
-    private apply(event: Parameters<typeof transitionWxUpdateServer>[1]): WxUpdateServerCommand[] {
-        const transition = transitionWxUpdateServer(this.state, event)
-        this.state = transition.state
-        return transition.commands
-    }
-
-    private async writeBatch(batch: WxUpdateBatch): Promise<void> {
-        await this.writeUpdateFile(batch.buildId, renderBatch(batch, createId()))
-    }
-}
-
-/** Renders executable code for update.js; this source is never included in an HTTP response. */
-function renderBatch(batch: WxUpdateBatch, nonce: string): string {
-    return `// ${nonce}\nglobalThis.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__.receiveBatch(${JSON.stringify({
-        buildId: batch.buildId,
-        fromVersion: batch.fromVersion,
-        targetVersion: batch.targetVersion
-    })}, () => {
-${indent(batch.deltas.map((delta) => delta.code).join('\n'), 4)}
-});\n`
-}
-
-function indent(value: string, spaces: number): string {
-    const prefix = ' '.repeat(spaces)
-    return value
-        .split('\n')
-        .map((line) => `${prefix}${line}`)
-        .join('\n')
-}
-
-function isClientReport(value: UpdateRequest): value is {
-    token: string
-    action: 'register' | 'poll' | 'rebuild'
-    buildId: string
-    sessionId: string
-    version: number
-} {
-    return (
-        typeof value.token === 'string' &&
-        typeof value.action === 'string' &&
-        typeof value.buildId === 'string' &&
-        typeof value.sessionId === 'string' &&
-        typeof value.version === 'number'
-    )
-}
-
-async function readBody(request: IncomingMessage): Promise<string> {
-    const chunks: Buffer[] = []
-    let size = 0
-    for await (const chunk of request) {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
-        size += buffer.length
-        if (size > 64 * 1024) throw new Error('WX update request body is too large.')
-        chunks.push(buffer)
-    }
-    return Buffer.concat(chunks).toString('utf8')
-}
-
-function respond(response: ServerResponse, status: number, body: unknown): void {
-    if (response.writableEnded) return
-    response.statusCode = status
-    response.setHeader('content-type', 'application/json')
-    response.end(JSON.stringify(body))
-}
-
-function createId(): string {
-    return randomBytes(16).toString('hex')
-}