vite-plugin-taro 0.6.18 → 0.6.19

package/src/runtime/wx/systemjs/system-core.js

@@ -1,370 +0,0 @@
-// biome-ignore-start lint: vendored SystemJS core
-
-/*
- * SystemJS Core
- *
- * Provides
- * - System.import and System.importSync
- * - System.register support for
- *     live bindings, function hoisting through circular references,
- *     reexports, dynamic import, import.meta.url, top-level await
- * - System.getRegister to get the registration
- * - Symbol.toStringTag support in Module objects
- * - Hookable System.createContext to customize import.meta
- *
- * Core comes with no System.prototype.resolve or
- * System.prototype.instantiate implementations
- */
-var envGlobal = global
-var hasSymbol = typeof Symbol !== 'undefined'
-
-function createMissingRegistrationError(id) {
-    return Error('Module did not instantiate: ' + id)
-}
-
-export { REGISTRY, systemJSPrototype }
-
-var toStringTag = hasSymbol && Symbol.toStringTag
-var REGISTRY = hasSymbol ? Symbol() : '@'
-
-function SystemJS() {
-    this[REGISTRY] = {}
-}
-
-var systemJSPrototype = SystemJS.prototype
-
-systemJSPrototype.import = function (id, parentId, meta) {
-    var loader = this
-    if (parentId && typeof parentId === 'object') meta = parentId
-    var load = getOrCreateLoad(loader, id, undefined, meta)
-    return Promise.resolve(load.C || topLevelLoad(loader, load))
-}
-
-/**
- * Instantiates, links, and evaluates a graph without yielding the current JavaScript turn.
- *
- * WX placement guarantees that every registration in a synchronous graph uses the main-package transport. Encountering
- * a thenable therefore indicates a fatal placement invariant violation. No rollback is attempted: rows already published
- * to the shared registry remain there and the current runtime heap must not be reused.
- */
-systemJSPrototype.importSync = function (id) {
-    var loader = this
-    var load = linkLoadSync(loader, id)
-    var execution = postOrderExec(loader, load, {})
-    if (isThenable(execution)) throw createAsyncGraphError(id)
-
-    // Share completion and namespace identity with normal System.import calls.
-    load.C = load.n
-    return load.n
-}
-
-// Hookable createContext function -> allowing eg custom import meta
-systemJSPrototype.createContext = function (parentId) {
-    return { url: parentId }
-}
-
-/** Publishes one synchronous row before linking dependencies so cycles observe the same live namespace. */
-function linkLoadSync(loader, id) {
-    var existing = loader[REGISTRY][id]
-    if (existing) return existing
-
-    var registration = loader.instantiate(id)
-    if (isThenable(registration)) throw createAsyncGraphError(id)
-    if (!registration) throw createMissingRegistrationError(id)
-
-    // This row is intentionally mutable SystemJS-owned linking and execution state.
-    var load = {
-        id: id,
-        i: [],
-        n: createModuleNamespace(),
-        h: false,
-        d: undefined,
-        e: undefined,
-        C: undefined
-    }
-    loader[REGISTRY][id] = load
-
-    var declared = registration[1](
-        createExport(load),
-        registration[1].length === 2 ? createDeclarationContext(loader, id) : undefined
-    )
-    load.e = declared.execute || function () {}
-    var setters = declared.setters || []
-    load.d = registration[0].map(function (dependency, index) {
-        var dependencyLoad = linkLoadSync(loader, dependency)
-        var setter = setters[index]
-        if (setter) {
-            dependencyLoad.i.push(setter)
-            if (dependencyLoad.h || dependencyLoad.C === dependencyLoad.n) setter(dependencyLoad.n)
-        }
-        return dependencyLoad
-    })
-    return load
-}
-
-/** Supplies dynamic import and import.meta using the canonical IDs emitted at build time. */
-function createDeclarationContext(loader, id) {
-    return {
-        import: function (dependency, meta) {
-            return loader.import(dependency, undefined, meta)
-        },
-        meta: loader.createContext(id)
-    }
-}
-
-/** Creates a live module namespace shared by both completion policies. */
-function createModuleNamespace() {
-    var namespace = Object.create(null)
-    if (toStringTag) Object.defineProperty(namespace, toStringTag, { value: 'Module' })
-    return namespace
-}
-
-/** Creates the shared live-binding publisher used by synchronous and asynchronous load records. */
-function createExport(load) {
-    return function (name, value) {
-        load.h = true
-        // This flag coalesces object-form exports into one importer notification pass.
-        var changed = false
-        if (typeof name === 'string') {
-            if (!(name in load.n) || load.n[name] !== value) {
-                load.n[name] = value
-                changed = true
-            }
-        } else {
-            for (var property in name) {
-                var propertyValue = name[property]
-                if (!(property in load.n) || load.n[property] !== propertyValue) {
-                    load.n[property] = propertyValue
-                    changed = true
-                }
-            }
-            if (name && name.__esModule) load.n.__esModule = name.__esModule
-        }
-        if (changed) {
-            for (var i = 0; i < load.i.length; i++) {
-                var setter = load.i[i]
-                if (setter) setter(load.n)
-            }
-        }
-        return value
-    }
-}
-
-/** Accepts cross-realm and custom thenables rather than only native Promises. */
-function isThenable(value) {
-    return (
-        value !== null && (typeof value === 'object' || typeof value === 'function') && typeof value.then === 'function'
-    )
-}
-
-function createAsyncGraphError(id) {
-    return Error('Cannot synchronously import ' + id + ': module graph is asynchronous')
-}
-
-var lastRegister
-systemJSPrototype.register = function (deps, declare, metas) {
-    lastRegister = [deps, declare, metas]
-}
-
-/*
- * getRegister provides the last anonymous System.register call
- */
-systemJSPrototype.getRegister = function () {
-    var _lastRegister = lastRegister
-    lastRegister = undefined
-    return _lastRegister
-}
-
-export function getOrCreateLoad(loader, id, firstParentUrl, meta) {
-    var load = loader[REGISTRY][id]
-    if (load) return load
-
-    var importerSetters = []
-    var ns = createModuleNamespace()
-
-    var instantiatePromise = Promise.resolve()
-        .then(function () {
-            return loader.instantiate(id, firstParentUrl, meta)
-        })
-        .then(
-            function (registration) {
-                if (!registration) throw createMissingRegistrationError(id)
-                var declared = registration[1](
-                    createExport(load),
-                    registration[1].length === 2 ? createDeclarationContext(loader, id) : undefined
-                )
-                load.e = declared.execute || function () {}
-                return [registration[0], declared.setters || [], registration[2] || []]
-            },
-            function (err) {
-                load.e = null
-                load.er = err
-                throw err
-            }
-        )
-
-    var linkPromise = instantiatePromise.then(function (instantiation) {
-        return Promise.all(
-            instantiation[0].map(function (dep, i) {
-                var setter = instantiation[1][i]
-                var meta = instantiation[2][i]
-                var depLoad = getOrCreateLoad(loader, dep, id, meta)
-                // depLoad.I may be undefined for already-evaluated
-                return Promise.resolve(depLoad.I).then(function () {
-                    if (setter) {
-                        depLoad.i.push(setter)
-                        // only run early setters when there are hoisted exports of that module
-                        // the timing works here as pending hoisted export calls will trigger through importerSetters
-                        if (depLoad.h || !depLoad.I) setter(depLoad.n)
-                    }
-                    return depLoad
-                })
-            })
-        ).then(function (depLoads) {
-            load.d = depLoads
-        })
-    })
-
-    // Capital letter = a promise function
-    return (load = loader[REGISTRY][id] =
-        {
-            id: id,
-            // importerSetters, the setters functions registered to this dependency
-            // we retain this to add more later
-            i: importerSetters,
-            // module namespace object
-            n: ns,
-            // extra module information for import assertion
-            // shape like: { assert: { type: 'xyz' } }
-            m: meta,
-
-            // instantiate
-            I: instantiatePromise,
-            // link
-            L: linkPromise,
-            // whether it has hoisted exports
-            h: false,
-
-            // On instantiate completion we have populated:
-            // dependency load records
-            d: undefined,
-            // execution function
-            e: undefined,
-
-            // On execution we have populated:
-            // the execution error if any
-            er: undefined,
-            // in the case of TLA, the execution promise
-            E: undefined,
-
-            // On execution, L, I, E cleared
-
-            // Promise for top-level completion
-            C: undefined,
-
-            // parent instantiator / executor
-            p: undefined
-        })
-}
-
-function instantiateAll(loader, load, parent, loaded) {
-    if (!loaded[load.id]) {
-        loaded[load.id] = true
-        // load.L may be undefined for already-instantiated
-        return Promise.resolve(load.L)
-            .then(function () {
-                if (!load.p || load.p.e === null) load.p = parent
-                return Promise.all(
-                    load.d.map(function (dep) {
-                        return instantiateAll(loader, dep, parent, loaded)
-                    })
-                )
-            })
-            .catch(function (err) {
-                if (load.er) throw err
-                load.e = null
-                throw err
-            })
-    }
-}
-
-function topLevelLoad(loader, load) {
-    return (load.C = instantiateAll(loader, load, load, {})
-        .then(function () {
-            return postOrderExec(loader, load, {})
-        })
-        .then(function () {
-            return load.n
-        }))
-}
-
-// the closest we can get to call(undefined)
-var nullContext = Object.freeze(Object.create(null))
-
-// returns a promise if and only if a top-level await subgraph
-// throws on sync errors
-function postOrderExec(loader, load, seen) {
-    if (seen[load.id]) return
-    seen[load.id] = true
-
-    if (!load.e) {
-        if (load.er) throw load.er
-        if (load.E) return load.E
-        return
-    }
-
-    // From here we're about to execute the load.
-    // Because the execution may be async, we pop the `load.e` first.
-    // So `load.e === null` always means the load has been executed or is executing.
-    // To inspect the state:
-    // - If `load.er` is truthy, the execution has threw or has been rejected;
-    // - otherwise, either the `load.E` is a promise, means it's under async execution, or
-    // - the `load.E` is null, means the load has completed the execution or has been async resolved.
-    var exec = load.e
-    load.e = null
-
-    // deps execute first, unless circular
-    var depLoadPromises
-    load.d.forEach(function (depLoad) {
-        try {
-            var depLoadPromise = postOrderExec(loader, depLoad, seen)
-            if (depLoadPromise) (depLoadPromises = depLoadPromises || []).push(depLoadPromise)
-        } catch (err) {
-            load.er = err
-            throw err
-        }
-    })
-    if (depLoadPromises) return Promise.all(depLoadPromises).then(doExec)
-
-    return doExec()
-
-    function doExec() {
-        try {
-            var execPromise = exec.call(nullContext)
-            if (execPromise) {
-                execPromise = execPromise.then(
-                    function () {
-                        load.C = load.n
-                        load.E = null // indicates completion
-                    },
-                    function (err) {
-                        load.er = err
-                        load.E = null
-                        throw err
-                    }
-                )
-                return (load.E = execPromise)
-            }
-            // (should be a promise, but a minify optimization to leave out Promise.resolve)
-            load.C = load.n
-            load.L = load.I = undefined
-        } catch (err) {
-            load.er = err
-            throw err
-        }
-    }
-}
-
-envGlobal.System = new SystemJS()
-
-// biome-ignore-end lint: vendored SystemJS core

package/src/runtime/wx/systemjs/system.d.ts

@@ -1,55 +0,0 @@
-export {}
-
-declare global {
-    namespace System {
-        /** A live SystemJS module namespace. */
-        type Module = Readonly<Record<string, unknown>>
-
-        /** Publishes bindings from a System.register declaration. */
-        type Export = (name: string | Readonly<Record<string, unknown>>, value?: unknown) => unknown
-
-        /** Receives live updates from a dependency namespace. */
-        type Setter = (module: Module) => void
-
-        /** The linker callbacks and evaluator returned by a module declaration. */
-        interface Declaration {
-            setters?: readonly (Setter | undefined)[]
-            execute?: () => void | PromiseLike<void>
-        }
-
-        /** The import.meta object supplied to a module declaration. */
-        interface Meta {
-            readonly url: string
-            readonly [name: string]: unknown
-        }
-
-        /** Runtime operations supplied to a module declaration. */
-        interface Context {
-            readonly import: (id: string) => Promise<Module>
-            readonly meta: Meta
-        }
-
-        /** Declares a module without executing it. */
-        type Declare = (exportBinding: Export, context: Context) => Declaration
-
-        /** The registration captured from one System.register call. */
-        type Registration = readonly [dependencies: readonly string[], declare: Declare]
-
-        /** A hookable SystemJS loader instance. */
-        interface Loader {
-            /** Creates the import.meta context supplied to a registration declaration. */
-            createContext(parentId: string): Meta
-
-            /** Links and evaluates a graph through the normal asynchronous completion policy. */
-            import(id: string): Promise<Module>
-
-            /**
-             * Uses the same registry and evaluator but requires every unresolved registration and execute function in the
-             * static closure to complete synchronously. An asynchronous phase throws without rollback and must be treated
-             * as a fatal placement invariant violation for the current runtime heap.
-             */
-            importSync(id: string): Module
-            instantiate(id: string): Registration | PromiseLike<Registration>
-        }
-    }
-}

package/src/runtime/wx/wechat.d.ts

@@ -1,56 +0,0 @@
-/**
- * The WeChat global. Free-variable reads never resolve its properties (verified: the
- * free lookup is undefined while `global.X` exists), so everything stored here must be
- * accessed as an explicit member expression.
- */
-type WeChatGlobal = object
-
-/** The App-global Rolldown dev runtime; present only in wx development builds. */
-declare const __rolldown_runtime__:
-    | {
-          injectPageHmr(config: object): object
-      }
-    | undefined
-
-// This object is available everywhere, but no globalThis, window on WeChat Mini Program
-declare const global: WeChatGlobal
-
-/** Minimal wx.request surface used by the DevRuntime; application API types remain owned by Taro/WeChat packages. */
-type WeChatRequestOptions = Readonly<{
-    url: string
-    method: 'POST'
-    data: unknown
-    header: Readonly<Record<string, string>>
-    timeout?: number
-    success(result: unknown): void
-    fail(error: unknown): void
-}>
-
-/** Native HTTP request API available in the Mini Program JavaScript environment. */
-declare const wx: {
-    request(options: WeChatRequestOptions): void
-}
-
-/** Native Page surface used by the singleton App-data scheduler. */
-type WeChatPage = {
-    setData(data: Readonly<Record<string, unknown>>, callback?: () => void): void
-}
-
-/** Returns every mounted native Page in stack order. */
-declare function getCurrentPages(): WeChatPage[]
-
-/** Registers the native WeChat Mini Program application. */
-declare function App(options: object): void
-
-/** Registers a native WeChat Mini Program page. */
-declare function Page(options: object): void
-
-/** Registers a native WeChat Mini Program component. */
-declare function Component(options: object): void
-
-/**
- * Returns the native WeChat Mini Program application instance.
- * Only available after App() is called.
- * https://developers.weixin.qq.com/miniprogram/dev/reference/api/getApp.html
- */
-declare function getApp(options: object): { globalData: unknown }

package/src/vite.ts

@@ -1,2 +0,0 @@
-export { default } from './node/vpt.ts'
-export type { VptJsonObject, VptOptions, VptPageOption, VptTarget } from './options.ts'