vite-plugin-taro 0.3.2 → 0.4.0

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]`
-}

package/src/node/targets/wx/companion-assets.ts

@@ -1,174 +0,0 @@
-import path from 'node:path'
-import { recursiveMerge } from '@tarojs/helper'
-import { Weapp as WxPlatform } from '@tarojs/plugin-platform-weapp'
-import type { JsonObject } from '../../../options.ts'
-import type { BuildContext } from '../../build-context.ts'
-import { normalizeModuleId } from '../../utils/modules.ts'
-import { packageRequire } from '../../utils/packages.ts'
-
-type WxAssetSource = string | Uint8Array
-
-export type WxBundle = Record<
-    string,
-    {
-        type: 'asset' | 'chunk'
-        source?: WxAssetSource
-        modules?: Record<string, { renderedExports?: string[] }>
-    }
->
-
-type WxAssetEmitter = {
-    emitFile(asset: { type: 'asset'; fileName: string; source: WxAssetSource }): string
-    warn(message: string): void
-}
-
-type WxTemplateComponentConfig = {
-    includes: Set<string>
-    exclude: Set<string>
-    thirdPartyComponents: Map<string, Set<string>>
-    includeAll: boolean
-}
-
-const taroWxComponentsPath = packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react')
-const templateBuilder = createWxTemplateBuilder()
-
-export async function emitWxCompanionAssets(
-    emitter: WxAssetEmitter,
-    bundle: WxBundle,
-    context: BuildContext
-): Promise<void> {
-    for (const asset of await createWxCompanionAssets(bundle, context)) {
-        if (!asset) continue
-        if (asset.source === undefined) {
-            emitter.warn(
-                `[vite-plugin-taro] WX companion asset "${asset.fileName}" is missing its source and was not emitted.`
-            )
-            continue
-        }
-        emitter.emitFile({ type: 'asset', fileName: asset.fileName, source: asset.source })
-    }
-}
-
-async function createWxCompanionAssets(
-    bundle: WxBundle,
-    context: BuildContext
-): Promise<({ fileName: string; source: WxAssetSource } | undefined)[]> {
-    const json = (value: JsonObject) => (context.development ? JSON.stringify(value, null, 2) : JSON.stringify(value))
-
-    return [
-        { fileName: 'app.json', source: json(context.project.appConfig) },
-        { fileName: 'app.wxss', source: await context.css.transformWxss(collectWxBundleStyles(bundle)) },
-        {
-            fileName: 'base.wxml',
-            source: templateBuilder.buildTemplate(collectWxTemplateComponentConfig(bundle))
-        },
-        { fileName: 'utils.wxs', source: templateBuilder.buildXScript() },
-        { fileName: 'comp.wxml', source: templateBuilder.buildBaseComponentTemplate('.wxml') },
-        { fileName: 'comp.json', source: json(createWxComponentConfig()) },
-        { fileName: 'project.config.json', source: json(createWxProjectConfig(context)) },
-        context.project.projectPrivateConfigJson
-            ? { fileName: 'project.private.config.json', source: json(context.project.projectPrivateConfigJson) }
-            : undefined,
-        { fileName: 'sitemap.json', source: json(context.project.sitemapJson) },
-        ...context.project.pages.flatMap((page) => [
-            {
-                fileName: `${page.path}.wxml`,
-                source: templateBuilder.buildPageTemplate(relativeWxRootAsset(page.path, 'base.wxml'), {
-                    content: page.config,
-                    path: page.path
-                })
-            },
-            {
-                fileName: `${page.path}.json`,
-                source: json({
-                    ...page.config,
-                    usingComponents: { comp: relativeWxRootAsset(page.path, 'comp') }
-                })
-            },
-            { fileName: `${page.path}.wxss`, source: '' }
-        ])
-    ]
-}
-
-function createWxProjectConfig(context: BuildContext): JsonObject {
-    const projectConfig = context.project.projectConfigJson
-    const setting = isJsonObject(projectConfig.setting) ? projectConfig.setting : {}
-    return {
-        ...projectConfig,
-        setting: { ...setting, compileHotReLoad: true }
-    }
-}
-
-function isJsonObject(value: unknown): value is JsonObject {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function createWxTemplateBuilder() {
-    const platform = new WxPlatform(
-        { helper: { recursiveMerge }, modifyWebpackChain() {}, registerPlatform() {} },
-        {},
-        {}
-    )
-    platform.modifyTemplate({})
-    return platform.template
-}
-
-function relativeWxRootAsset(pagePath: string, rootAsset: string): string {
-    const relativePath = path.posix.relative(path.posix.dirname(pagePath), rootAsset)
-    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
-}
-
-function collectWxTemplateComponentConfig(bundle: WxBundle): WxTemplateComponentConfig {
-    const config: WxTemplateComponentConfig = {
-        includes: new Set([
-            'view',
-            'catch-view',
-            'static-view',
-            'pure-view',
-            'click-view',
-            'scroll-view',
-            'image',
-            'static-image',
-            'text',
-            'static-text'
-        ]),
-        exclude: new Set(),
-        thirdPartyComponents: new Map(),
-        includeAll: false
-    }
-    const components = findBundleModule(bundle, taroWxComponentsPath)
-    for (const name of components?.renderedExports ?? []) config.includes.add(toDashed(name))
-    return config
-}
-
-function findBundleModule(bundle: WxBundle, resolvedId: string): { renderedExports?: string[] } | undefined {
-    const normalizedResolvedId = normalizeModuleId(resolvedId)
-    for (const item of Object.values(bundle)) {
-        if (item.type !== 'chunk') continue
-        const found = Object.entries(item.modules ?? {}).find(([id]) => normalizeModuleId(id) === normalizedResolvedId)
-        if (found) return found[1]
-    }
-}
-
-function toDashed(value: string): string {
-    return value.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
-}
-
-function createWxComponentConfig(): JsonObject {
-    return {
-        component: true,
-        styleIsolation: 'apply-shared',
-        usingComponents: { comp: './comp' }
-    }
-}
-
-function collectWxBundleStyles(bundle: WxBundle): string {
-    const styles: string[] = []
-    for (const [fileName, item] of Object.entries(bundle)) {
-        if (item.type !== 'asset' || !fileName.endsWith('.css')) continue
-        const source = typeof item.source === 'string' ? item.source : new TextDecoder().decode(item.source)
-        if (source) styles.push(source)
-        delete bundle[fileName]
-    }
-    return styles.join('\n')
-}

package/src/node/targets/wx/dev-server/development-session.ts

@@ -1,271 +0,0 @@
-/**
- * Top-level owner of one WX development lifecycle.
- *
- * It serializes every output write, connects DevEngine patches to the update transport, and coalesces conservative full
- * rebuilds. No other module writes plugin-generated WX development files directly.
- */
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import colors from 'picocolors'
-import type { ViteDevServer } from 'vite'
-import type { BuildContext } from '../../../build-context.ts'
-import { SerializedTaskQueue } from '../../../utils/async.ts'
-import {
-    copyDirectoryIfExists,
-    copyFileOrRemove,
-    writeFileAtomically,
-    writeFilesAtomically
-} from '../../../utils/filesystem.ts'
-import { wxDevelopmentDirectory, wxUpdateControlFile, wxUpdateFile } from '../development-files.ts'
-import { FullBuildScheduler } from './full-build-scheduler.ts'
-import { transformWxCompatibleJavaScript, transformWxOutputChunks } from './js-utils.ts'
-import { isWxFullBuildOutput, normalizeWxBundleStyles, setWxAppStyles, type WxOutputFile } from './output.ts'
-import { WxUpdateTransport } from './update-transport.ts'
-import { ViteBundledDevAdapter, type WxDevEngineUpdate } from './vite-bundled-dev-adapter.ts'
-
-const maxRetainedDeltaCount = 1_000
-const maxRetainedDeltaBytes = 16 * 1024 * 1024
-const fullBuildDebounceDelay = 100
-
-type WxDevServerContext = Pick<BuildContext, 'vite' | 'css'>
-type SessionSnapshot = Readonly<{
-    lifecycle: 'open' | 'closed'
-    outputPhase: 'starting' | 'ready'
-    latestAppStyles: string
-}>
-
-/** Owns one WX bundled-development graph and all writes to its fixed output directory. */
-export class WxDevelopmentSession {
-    private readonly adapter: ViteBundledDevAdapter
-    private readonly updateTransport: WxUpdateTransport
-    private readonly outDir: string
-    private readonly initialBundle = Promise.withResolvers<void>()
-    private readonly outputQueue: SerializedTaskQueue
-    private readonly fullBuildScheduler: FullBuildScheduler
-    private originalPrintUrls: (() => void) | undefined
-    private snapshot: SessionSnapshot = { lifecycle: 'open', outputPhase: 'starting', latestAppStyles: '' }
-
-    constructor(
-        private readonly context: WxDevServerContext,
-        private readonly server: ViteDevServer
-    ) {
-        const config = context.vite
-        this.outDir = path.resolve(config.root, config.build.outDir)
-        this.outputQueue = new SerializedTaskQueue((error) => this.reportOutputError(error))
-        this.updateTransport = new WxUpdateTransport(
-            server,
-            () => this.requestFullBuild(),
-            (buildId, source) =>
-                this.outputQueue.enqueue(async () => {
-                    // A full build queued before this write invalidates the old batch instead of letting it overwrite
-                    // the new build's empty update.js.
-                    if (!this.updateTransport.isCurrentBuild(buildId)) return
-                    await writeFileAtomically(path.join(this.outDir, wxUpdateFile), source)
-                })
-        )
-        this.adapter = new ViteBundledDevAdapter(config, server, {
-            onOutput: (output) => this.handleBundleOutput(output),
-            onPatch: (files, output) => this.handlePatch(files, output),
-            onError: (message) => this.handleError(message),
-            waitForInitialBundle: () => this.waitForInitialBundle()
-        })
-        this.fullBuildScheduler = new FullBuildScheduler(
-            fullBuildDebounceDelay,
-            () => this.adapter.rebuild(),
-            (error) => this.reportRebuildError(error)
-        )
-    }
-
-    private get config() {
-        return this.context.vite
-    }
-
-    install(): void {
-        this.updateTransport.install()
-        this.server.httpServer?.once('listening', this.handleHttpListening)
-        this.adapter.install()
-        this.originalPrintUrls = this.server.printUrls.bind(this.server)
-        this.server.printUrls = this.printUrls
-        if (this.config.publicDir) this.server.watcher.add(this.config.publicDir)
-        this.server.watcher.on('change', this.handleWatchedFile)
-        this.server.watcher.on('add', this.handleWatchedFile)
-        this.server.watcher.on('unlink', this.handleWatchedFile)
-    }
-
-    async close(): Promise<void> {
-        if (this.snapshot.lifecycle === 'closed') return
-        this.snapshot = { ...this.snapshot, lifecycle: 'closed' }
-        this.server.watcher.off('change', this.handleWatchedFile)
-        this.server.watcher.off('add', this.handleWatchedFile)
-        this.server.watcher.off('unlink', this.handleWatchedFile)
-        this.server.httpServer?.off('listening', this.handleHttpListening)
-        if (this.server.printUrls === this.printUrls && this.originalPrintUrls) {
-            this.server.printUrls = this.originalPrintUrls
-        }
-        this.updateTransport.close()
-        await this.fullBuildScheduler.close()
-        await this.outputQueue.waitForIdle()
-    }
-
-    private readonly printUrls = (): void => {
-        this.originalPrintUrls?.()
-        const projectDirectory = relativeToViteConfig(this.outDir, this.config.configFile, this.config.root)
-        this.server.config.logger.info(
-            `  ${colors.green('➜')}  ${colors.bold('WeChat DevTools')}: ${colors.cyan(projectDirectory)}`
-        )
-    }
-
-    private readonly handleHttpListening = (): void => {
-        this.outputQueue.enqueue(() =>
-            writeFileAtomically(path.join(this.outDir, wxUpdateControlFile), this.updateTransport.createControlSource())
-        )
-    }
-
-    private readonly handleWatchedFile = (file: string): void => {
-        if (isFileInside(file, this.config.publicDir)) {
-            const destination = path.join(this.outDir, path.relative(this.config.publicDir, file))
-            this.outputQueue.enqueue(() => copyFileOrRemove(file, destination))
-            this.requestFullBuild()
-        }
-    }
-
-    private handleBundleOutput(output: WxOutputFile[]): void {
-        const appStyles = normalizeWxBundleStyles(output)
-        const fullBuild = isWxFullBuildOutput(output)
-
-        if (!fullBuild) {
-            this.outputQueue.enqueue(async () => {
-                await this.finalizeAppStyles(output, appStyles, false)
-                await transformWxOutputChunks(output)
-                await writeDevelopmentOutput(this.outDir, output)
-            })
-            return
-        }
-
-        const buildId = this.updateTransport.createBuildId()
-        setDevelopmentAsset(output, wxUpdateControlFile, this.updateTransport.createControlSource(buildId))
-        setDevelopmentAsset(output, wxUpdateFile, 'void 0;\n')
-        this.outputQueue.enqueue(async () => {
-            await this.finalizeAppStyles(output, appStyles, true)
-            await transformWxOutputChunks(output)
-            if (this.snapshot.outputPhase === 'starting') {
-                // The directory is plugin-owned; clearing it once removes stale files from previous protocol designs.
-                await fs.rm(path.join(this.outDir, wxDevelopmentDirectory), { recursive: true, force: true })
-            }
-            // Invalidate old HTTP reports before writing the new build epoch into the fixed DevTools directory.
-            this.updateTransport.commitFullBuild(buildId)
-            await writeDevelopmentOutput(this.outDir, output)
-            await copyDirectoryIfExists(this.config.publicDir, this.outDir)
-            await this.context.css.captureFullBuild()
-            const moduleCount = this.adapter.registerBundleModules(output)
-            this.snapshot = { ...this.snapshot, outputPhase: 'ready' }
-            this.initialBundle.resolve()
-            this.server.config.logger.info(
-                `[vite-plugin-taro] WX bundle ready (${moduleCount} modules, ${output.length} files)`
-            )
-        })
-    }
-
-    private async finalizeAppStyles(
-        output: WxOutputFile[],
-        source: string | undefined,
-        fullBuild: boolean
-    ): Promise<void> {
-        if (source !== undefined) {
-            const transformed = await this.context.css.transformWxss(source)
-            this.snapshot = { ...this.snapshot, latestAppStyles: transformed }
-            setWxAppStyles(output, transformed)
-        } else if (fullBuild && this.snapshot.latestAppStyles) {
-            setWxAppStyles(output, this.snapshot.latestAppStyles)
-        }
-    }
-
-    private handlePatch(files: string[], output: WxDevEngineUpdate): boolean {
-        if (!isSafeJavaScriptPatch(files, output)) {
-            this.requestFullBuild()
-            return false
-        }
-
-        this.adapter.registerPatchModules(output.code)
-        this.outputQueue.enqueue(async () => {
-            const transformed = await this.context.css.transformNativePatch(output.code, output.filename, files)
-            if ('requiresFullBuild' in transformed) {
-                this.requestFullBuild()
-                return
-            }
-            const compatibleCode = await transformWxCompatibleJavaScript(transformed.code, output.filename)
-            if (
-                this.updateTransport.retainedDeltaCount >= maxRetainedDeltaCount ||
-                this.updateTransport.retainedDeltaBytes + Buffer.byteLength(compatibleCode) >= maxRetainedDeltaBytes
-            ) {
-                this.requestFullBuild()
-                return
-            }
-            this.updateTransport.addDelta(compatibleCode)
-        })
-        return true
-    }
-
-    private handleError(message: string): void {
-        this.server.config.logger.error('[vite-plugin-taro] WX update failed', { error: new Error(message) })
-    }
-
-    private requestFullBuild(): void {
-        this.fullBuildScheduler.request()
-    }
-
-    private async waitForInitialBundle(): Promise<void> {
-        await this.initialBundle.promise
-        await this.outputQueue.waitForIdle()
-    }
-
-    private reportOutputError(error: unknown): void {
-        const normalizedError = error instanceof Error ? error : new Error(String(error))
-        this.server.config.logger.error(
-            `[vite-plugin-taro] WX development output failed: ${normalizedError.stack ?? normalizedError.message}`
-        )
-    }
-
-    private reportRebuildError(error: unknown): void {
-        const normalizedError = error instanceof Error ? error : new Error(String(error))
-        this.server.config.logger.error('[vite-plugin-taro] WX rebuild failed', { error: normalizedError })
-    }
-}
-
-function writeDevelopmentOutput(outDir: string, output: WxOutputFile[]): Promise<void> {
-    return writeFilesAtomically(
-        output.map((item) => ({
-            file: path.join(outDir, item.fileName),
-            source: item.type === 'chunk' ? item.code : item.source
-        }))
-    )
-}
-
-function setDevelopmentAsset(output: WxOutputFile[], fileName: string, source: string): void {
-    const index = output.findIndex((item) => item.type === 'asset' && item.fileName === fileName)
-    const asset: WxOutputFile = { type: 'asset', fileName, source }
-    if (index >= 0) output[index] = asset
-    else output.push(asset)
-}
-
-function relativeToViteConfig(outDir: string, configFile: string | undefined, root: string): string {
-    const configDirectory = configFile ? path.dirname(configFile) : root
-    const relativePath = path.relative(configDirectory, outDir).replaceAll('\\', '/')
-    if (!relativePath) return '.'
-    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
-}
-
-function isFileInside(file: string, directory: string): boolean {
-    if (!directory) return false
-    const relative = path.relative(directory, file)
-    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative)
-}
-
-function isSafeJavaScriptPatch(
-    files: string[],
-    output: WxDevEngineUpdate
-): output is Extract<WxDevEngineUpdate, { type: 'Patch' }> {
-    if (output.type !== 'Patch' || output.hmrBoundaries.length === 0) return false
-    if (output.code.includes('__vite__updateStyle') || output.code.includes('.updateStyle(')) return false
-    return files.every((file) => /\.[cm]?[jt]sx?$/.test(file))
-}