vite-plugin-taro-runtime 0.7.11 → 0.7.12-beta.0

package/dist/plugin-framework-react/runtime.js

@@ -322,7 +322,6 @@ function createReactApp(App, react, dom, config) {
         // appWrapper ? cb() : appWrapperPromise.then(() => cb())
     }
     function renderReactRoot() {
-        var _a, _b;
         const appId = (config === null || config === void 0 ? void 0 : config.appId) || 'app';
         let container = document.getElementById(appId);
         if (container == null) {
@@ -343,18 +342,9 @@ function createReactApp(App, react, dom, config) {
          * batches across Page surfaces. No detached scheduler node, second React root, or host-property override participates.
          */
         container.ctx = { setData: broadcastAppUpdate };
-        /*
-         * Upstream enables createRoot only for a React 18 version string, which skips the entire App render on React 19.
-         * Detect the renderer capability instead: React 18/19 take the modern path and older renderers retain the fallback.
-         */
-        if (typeof ReactDOM$1.createRoot === 'function') {
-            const root = ReactDOM$1.createRoot(container);
-            (_a = root.render) === null || _a === void 0 ? void 0 : _a.call(root, h$1(AppWrapper));
-        }
-        else {
-            // eslint-disable-next-line react/no-deprecated
-            (_b = ReactDOM$1.render) === null || _b === void 0 ? void 0 : _b.call(ReactDOM$1, h$1(AppWrapper), container);
-        }
+        // VPT requires React 19: both the Mini renderer and react-dom/client provide concurrent roots.
+        const root = ReactDOM$1.createRoot(container);
+        root.render(h$1(AppWrapper));
         /*
          * Return the exact host passed to ReactDOM. AppWrapper.mount closes over this immutable value when a Page is added,
          * guaranteeing that its initial snapshot comes from the same singleton App tree without a host registry or lookup.
@@ -371,10 +361,14 @@ function createReactApp(App, react, dom, config) {
             appWrapperResolver(this);
         }
         mount(pageComponent, id, cb) {
-            const pageWrapper = connectReactPage(react, id)(pageComponent);
-            const key = id + pageKeyId();
-            const page = () => h$1(pageWrapper, { key, tid: id });
-            this.pages.push(page);
+            // Prerender and onLoad share an identity, even when both mounts arrive before the queued Page renders.
+            if (!this.pages.some(page => page.tid === id) && !this.elements.some(element => element.props.tid === id)) {
+                const pageWrapper = connectReactPage(react, id)(pageComponent);
+                const key = id + pageKeyId();
+                const page = () => h$1(pageWrapper, { key, tid: id });
+                page.tid = id;
+                this.pages.push(page);
+            }
             this.forceUpdate((...args) => {
                 perf.stop(PAGE_INIT);
                 if (process.env.TARO_PLATFORM !== 'web') {
@@ -669,8 +663,10 @@ function initNativeComponentEntry(params) {
         (_a = app === null || app === void 0 ? void 0 : app.parentNode) === null || _a === void 0 ? void 0 : _a.appendChild(nativeApp);
         app = nativeApp;
     }
-    // eslint-disable-next-line react/no-deprecated
-    ReactDOM.render(h(Entry, {}), app);
+    // Native created/attached callbacks require Entry.componentDidMount to install the App before setup returns.
+    ReactDOM.flushSync(() => {
+        ReactDOM.createRoot(app).render(h(Entry, {}));
+    });
 }
 function createNativePageConfig(Component, pageName, data, react, reactDOM, pageConfig) {
     reactMeta.R = react;

package/dist/react/index.d.ts

@@ -1,10 +1,9 @@
 import { internalInstanceKey } from './constant';
-import { createRoot, render } from './render';
+import { createRoot } from './render';
 import type { TaroElement } from 'vite-plugin-taro-runtime/runtime/mini';
 import type { ReactNode } from 'react';
 declare const unstable_batchedUpdates: (fn: any, a: any) => any;
 declare function unmountComponentAtNode(dom: TaroElement): boolean;
-declare function findDOMNode(comp?: TaroElement | ReactNode): string | number | boolean | TaroElement | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null;
 declare function createPortal(children: ReactNode, containerInfo: TaroElement, key?: string): {
     $$typeof: number | symbol;
     key: string | null;
@@ -16,9 +15,8 @@ declare const flushSync: {
     (): void;
     <R>(fn: () => R): R;
 };
-export { createPortal, createRoot, findDOMNode, flushSync, internalInstanceKey, render, unmountComponentAtNode, unstable_batchedUpdates, };
+export { createPortal, createRoot, flushSync, internalInstanceKey, unmountComponentAtNode, unstable_batchedUpdates };
 declare const _default: {
-    render: typeof render;
     flushSync: {
         (): void;
         <R>(fn: () => R): R;
@@ -26,7 +24,6 @@ declare const _default: {
     createRoot: typeof createRoot;
     unstable_batchedUpdates: (fn: any, a: any) => any;
     unmountComponentAtNode: typeof unmountComponentAtNode;
-    findDOMNode: typeof findDOMNode;
     createPortal: typeof createPortal;
     internalInstanceKey: string;
 };

package/dist/react/react.esm.js

@@ -1,7 +1,9 @@
 import { PLATFORM_TYPE, isObject, isEnableTTDom, isString, isFunction, toCamelCase, UNITLESS_PROPERTIES_SET, isNumber, capitalize, internalComponents, isUndefined, noop, isBoolean, hooks, ensure } from '@tarojs/shared';
 import { setInnerHTML, FormElement, convertNumber2PX, eventHandlerTTDom, document } from '@tarojs/runtime';
+import { version } from 'react';
 import Reconciler from 'react-reconciler';
 import {
+    ConcurrentRoot,
     ContinuousEventPriority,
     DefaultEventPriority,
     DiscreteEventPriority,
@@ -599,6 +601,7 @@ function styleObjectToCss(style) {
 }
 
 /* eslint-disable @typescript-eslint/indent */
+// React and native event dispatch share this scoped priority; nested dispatch restores its caller's priority.
 let taroCurrentUpdatePriority = NoEventPriority;
 const taroNotPendingTransition = null;
 const taroHostTransitionContext = {
@@ -790,9 +793,6 @@ const hostConfig = {
         }
         return false;
     },
-    prepareUpdate(instance, _, oldProps, newProps) {
-        return getUpdatePayload(instance, oldProps, newProps);
-    },
     shouldSetTextContent() {
         return false;
     },
@@ -815,9 +815,6 @@ const hostConfig = {
     preparePortalMount: noop,
     prepareScopeUpdate: noop,
     getInstanceFromScope: () => null,
-    getCurrentEventPriority() {
-        return DefaultEventPriority;
-    },
     detachDeletedInstance: noop,
     // -------------------
     //      Microtasks
@@ -847,11 +844,8 @@ const hostConfig = {
         textInst.nodeValue = newText;
     },
     commitMount: noop,
-    commitUpdate(dom, updatePayloadOrType, maybeOldProps, maybeNewProps, maybeFiber) {
-        const isReact19Signature = typeof updatePayloadOrType === 'string';
-        const oldProps = isReact19Signature ? maybeOldProps : maybeNewProps;
-        const newProps = isReact19Signature ? maybeNewProps : maybeFiber;
-        const updatePayload = isReact19Signature ? getUpdatePayload(dom, oldProps, newProps) : updatePayloadOrType;
+    commitUpdate(dom, _type, oldProps, newProps) {
+        const updatePayload = getUpdatePayload(dom, oldProps, newProps);
         if (!updatePayload)
             return;
         // payload 只包含 children 的时候，不应该再继续触发后续的属性比较和更新的逻辑了
@@ -897,8 +891,8 @@ const hostConfig = {
     }
 };
 const TaroReconciler = Reconciler(hostConfig);
-TaroReconciler.flushSync = TaroReconciler.flushSync || TaroReconciler.flushSyncFromReconciler || TaroReconciler.flushSyncWork;
-TaroReconciler.runWithPriority = TaroReconciler.runWithPriority || ((priority, fn) => {
+// react-reconciler 0.34 delegates native event priority to the host, not a runWithPriority export.
+function runWithPriority(priority, fn) {
     const previousPriority = hostConfig.getCurrentUpdatePriority();
     try {
         hostConfig.setCurrentUpdatePriority(priority);
@@ -907,11 +901,11 @@ TaroReconciler.runWithPriority = TaroReconciler.runWithPriority || ((priority, f
     finally {
         hostConfig.setCurrentUpdatePriority(previousPriority);
     }
-});
+}
 if (process.env.NODE_ENV !== 'production') {
     const foundDevTools = TaroReconciler.injectIntoDevTools({
         bundleType: 1,
-        version: '18.0.0',
+        version,
         rendererPackageName: 'taro-react'
     });
     if (!foundDevTools) {
@@ -959,7 +953,7 @@ function needsStateRestore() {
 function finishEventHandler() {
     const controlledComponentsHavePendingUpdates = needsStateRestore();
     if (controlledComponentsHavePendingUpdates) {
-        TaroReconciler.flushSync();
+        TaroReconciler.flushSyncWork();
         restoreStateIfNeeded();
     }
 }
@@ -995,92 +989,55 @@ function restoreStateOfTarget(item) {
     }
 }
 
+// Native teardown looks up the one concurrent root per host; unmount removes its entry after the commit.
 const ContainerMap = new WeakMap();
+function reportRootError(error) {
+    console.error(error);
+}
+function reportCaughtError(error, errorInfo) {
+    console.error(error);
+    if (errorInfo.componentStack) {
+        console.error(errorInfo.componentStack);
+    }
+}
 class Root {
-    constructor(renderer, domContainer, options) {
-        this.renderer = renderer;
-        this.initInternalRoot(renderer, domContainer, options);
-    }
-    initInternalRoot(renderer, domContainer, options) {
-        // Since react-reconciler v0.27, createContainer need more parameters
-        // @see:https://github.com/facebook/react/blob/0b974418c9a56f6c560298560265dcf4b65784bc/packages/react-reconciler/src/ReactFiberReconciler.js#L248
-        const containerInfo = domContainer;
-        if (options) {
-            const tag = 1; // ConcurrentRoot
-            const concurrentUpdatesByDefaultOverride = false;
-            let isStrictMode = false;
-            let identifierPrefix = '';
-            let onUncaughtError = (error) => console.error(error);
-            let onCaughtError = (error, errorInfo) => {
-                console.error(error);
-                if (errorInfo === null || errorInfo === void 0 ? void 0 : errorInfo.componentStack) {
-                    console.error(errorInfo.componentStack);
-                }
-            };
-            let onRecoverableError = (error) => console.error(error);
-            const onDefaultTransitionIndicator = null;
-            if (options.unstable_strictMode === true) {
-                isStrictMode = true;
-            }
-            if (options.identifierPrefix !== undefined) {
-                identifierPrefix = options.identifierPrefix;
-            }
-            if (options.onUncaughtError !== undefined) {
-                onUncaughtError = options.onUncaughtError;
-            }
-            if (options.onCaughtError !== undefined) {
-                onCaughtError = options.onCaughtError;
-            }
-            if (options.onRecoverableError !== undefined) {
-                onRecoverableError = options.onRecoverableError;
-            }
-            this.internalRoot = renderer.createContainer(containerInfo, tag, null, // hydrationCallbacks
-            isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator);
-        }
-        else {
-            const tag = 0; // LegacyRoot
-            this.internalRoot = renderer.createContainer(containerInfo, tag, null, // hydrationCallbacks
-            false, // isStrictMode
-            false, // concurrentUpdatesByDefaultOverride,
-            '', // identifierPrefix
-            (error) => console.error(error), // onUncaughtError
-            (error) => console.error(error), // onCaughtError
-            (error) => console.error(error), // onRecoverableError
+    constructor(domContainer, options) {
+        this.domContainer = domContainer;
+        this.internalRoot = TaroReconciler.createContainer(
+            domContainer,
+            ConcurrentRoot,
+            null, // hydrationCallbacks
+            options.unstable_strictMode === true,
+            false, // concurrentUpdatesByDefaultOverride
+            options.identifierPrefix ?? '',
+            options.onUncaughtError ?? reportRootError,
+            options.onCaughtError ?? reportCaughtError,
+            options.onRecoverableError ?? reportRootError,
             null // onDefaultTransitionIndicator
-            );
-        }
+        );
     }
     render(children, cb) {
-        const { renderer, internalRoot } = this;
-        renderer.updateContainer(children, internalRoot, null, cb);
-        return renderer.getPublicRootInstance(internalRoot);
+        TaroReconciler.updateContainer(children, this.internalRoot, null, cb);
     }
     unmount(cb) {
-        this.renderer.updateContainer(null, this.internalRoot, null, cb);
+        TaroReconciler.updateContainer(null, this.internalRoot, null, () => {
+            ContainerMap.delete(this.domContainer);
+            this.domContainer[internalContainerInstanceKey] = null;
+            cb?.();
+        });
     }
 }
-function render(element, domContainer, cb) {
-    const oldRoot = ContainerMap.get(domContainer);
-    if (oldRoot != null) {
-        return oldRoot.render(element, cb);
-    }
-    const root = new Root(TaroReconciler, domContainer);
-    ContainerMap.set(domContainer, root);
-    return root.render(element, cb);
-}
-function createRoot(domContainer, options = {}) {
-    var _a;
+function createRoot(domContainer, options) {
     const oldRoot = ContainerMap.get(domContainer);
     if (oldRoot != null) {
         return oldRoot;
     }
-    // options should be an object
-    const root = new Root(TaroReconciler, domContainer, options);
+    const root = new Root(domContainer, options ?? {});
     ContainerMap.set(domContainer, root);
-    markContainerAsRoot((_a = root === null || root === void 0 ? void 0 : root.internalRoot) === null || _a === void 0 ? void 0 : _a.current, domContainer);
+    markContainerAsRoot(root.internalRoot.current, domContainer);
     hooks.tap('dispatchTaroEvent', (e, node) => {
         const eventPriority = getEventPriority(e.type);
-        TaroReconciler.runWithPriority(eventPriority, () => {
+        runWithPriority(eventPriority, () => {
             node.dispatchEvent(e);
         });
     });
@@ -1121,22 +1078,10 @@ function unmountComponentAtNode(dom) {
     if (!root)
         return false;
     unstable_batchedUpdates(() => {
-        root.unmount(() => {
-            ContainerMap.delete(dom);
-        });
+        root.unmount();
     }, null);
     return true;
 }
-function findDOMNode(comp) {
-    if (comp == null) {
-        return null;
-    }
-    const nodeType = comp.nodeType;
-    if (nodeType === 1 || nodeType === 3) {
-        return comp;
-    }
-    return TaroReconciler.findHostInstance(comp);
-}
 const portalType = isFunction(Symbol) && Symbol.for
     ? Symbol.for('react.portal')
     : 0xeaca;
@@ -1149,17 +1094,16 @@ function createPortal(children, containerInfo, key) {
         implementation: null
     };
 }
-const flushSync = TaroReconciler.flushSync;
+// Public flushSync runs a callback at synchronous priority; controlled-input restoration only flushes queued sync work.
+const flushSync = TaroReconciler.flushSyncFromReconciler;
 var index = {
-    render,
     flushSync,
     createRoot,
     unstable_batchedUpdates,
     unmountComponentAtNode,
-    findDOMNode,
     createPortal,
     internalInstanceKey
 };
 
-export { createPortal, createRoot, index as default, findDOMNode, flushSync, internalInstanceKey, render, unmountComponentAtNode, unstable_batchedUpdates };
+export { createPortal, createRoot, index as default, flushSync, internalInstanceKey, unmountComponentAtNode, unstable_batchedUpdates };
 //# sourceMappingURL=react.esm.js.map

package/dist/react/render.d.ts

@@ -1,25 +1,21 @@
-import { TaroReconciler } from './reconciler';
 import type { TaroElement } from 'vite-plugin-taro-runtime/runtime/mini';
-import type { ReactNode } from 'react';
+import type { ErrorInfo, ReactNode } from 'react';
 import type { OpaqueRoot } from 'react-reconciler';
 export declare const ContainerMap: WeakMap<TaroElement, Root>;
-type Renderer = typeof TaroReconciler;
 type CreateRootOptions = {
     unstable_strictMode?: boolean;
-    unstable_concurrentUpdatesByDefault?: boolean;
-    unstable_transitionCallbacks?: any;
     identifierPrefix?: string;
-    onRecoverableError?: (error: any) => void;
+    onUncaughtError?: (error: unknown, errorInfo: ErrorInfo) => void;
+    onCaughtError?: (error: unknown, errorInfo: ErrorInfo) => void;
+    onRecoverableError?: (error: unknown, errorInfo: ErrorInfo) => void;
 };
-export type Callback = () => void | null | undefined;
+export type Callback = () => void;
 declare class Root {
-    private renderer;
+    private domContainer;
     internalRoot: OpaqueRoot;
-    constructor(renderer: Renderer, domContainer: TaroElement, options?: CreateRootOptions);
-    private initInternalRoot;
-    render(children: ReactNode, cb: Callback): TaroElement | import("react").Component<any, any, any> | null;
-    unmount(cb: Callback): void;
+    constructor(domContainer: TaroElement, options: CreateRootOptions);
+    render(children: ReactNode, cb?: Callback): void;
+    unmount(cb?: Callback): void;
 }
-export declare function render(element: ReactNode, domContainer: TaroElement, cb: Callback): TaroElement | import("react").Component<any, any, any> | null;
 export declare function createRoot(domContainer: TaroElement, options?: CreateRootOptions): Root;
 export {};

package/dist/runtime/dsl/common.js

@@ -95,8 +95,12 @@ function createPageConfig(component, pageName, data, pageConfig) {
             Current.page = this;
             this.config = pageConfig || {};
             // this.$taroPath 是页面唯一标识
-            const uniqueOptions = Object.assign({}, options, { $taroTimestamp: Date.now() });
-            const $taroPath = this.$taroPath = getPath(id, uniqueOptions);
+            const prerenderIdentity = config.__vpt_meta?.prerenderIdentity;
+            if (prerenderIdentity) {
+                config.__vpt_meta.prerenderIdentity = undefined;
+            }
+            const uniqueOptions = prerenderIdentity?.params ?? Object.assign({}, options, { $taroTimestamp: Date.now() });
+            const $taroPath = this.$taroPath = prerenderIdentity?.path ?? getPath(id, uniqueOptions);
             if (process.env.TARO_PLATFORM === 'web') {
                 config.path = $taroPath;
             }

package/dist/runtime/dsl/instance.d.ts

@@ -56,8 +56,10 @@ interface PageLifeCycle extends Show {
     onUnload?(): void;
 }
 interface PageInstance extends PageLifeCycle {
+    /** @internal VPT metadata; native onLoad consumes the prepared identity once. */
+    __vpt_meta?: { prerenderIdentity?: { path: string; params: Record<string, unknown> } };
     /** 页面的初始数据 */
-    data?: Record<string, unknown>;
+    data?: Record<string, unknown> | (() => Record<string, unknown>);
     /** 页面路径 */
     path?: string;
     /** 页面的组件选项 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro-runtime",
-  "version": "0.7.11",
+  "version": "0.7.12-beta.0",
   "description": "Taro runtime, React, and platform support for vite-plugin-taro.",
   "author": "sep2",
   "license": "MIT",