vite-plugin-taro-runtime 0.7.0 → 0.7.1-beta.2

package/dist/react/react.esm.js

@@ -0,0 +1,1165 @@
+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 Reconciler from 'react-reconciler';
+import {
+    ContinuousEventPriority,
+    DefaultEventPriority,
+    DiscreteEventPriority,
+    NoEventPriority
+} from 'react-reconciler/constants';
+
+const supportedInputTypes = {
+    color: true,
+    date: true,
+    datetime: true,
+    'datetime-local': true,
+    email: true,
+    month: true,
+    number: true,
+    password: true,
+    range: true,
+    search: true,
+    tel: true,
+    text: true,
+    time: true,
+    url: true,
+    week: true,
+};
+function getEventPriority(domEventName) {
+    switch (domEventName) {
+        case 'cancel':
+        case 'click':
+        case 'close':
+        case 'contextmenu':
+        case 'copy':
+        case 'cut':
+        case 'dragend':
+        case 'dragstart':
+        case 'drop':
+        case 'input':
+        case 'paste':
+        case 'pause':
+        case 'play':
+        case 'pointercancel':
+        case 'pointerdown':
+        case 'pointerup':
+        case 'reset':
+        case 'resize':
+        case 'submit':
+        case 'touchcancel':
+        case 'touchend':
+        case 'touchstart':
+        case 'change':
+        case 'blur':
+        case 'focus':
+        case 'select':
+        case 'selectstart':
+            return DiscreteEventPriority;
+        case 'drag':
+        case 'dragenter':
+        case 'dragexit':
+        case 'dragleave':
+        case 'dragover':
+        case 'pointermove':
+        case 'pointerout':
+        case 'pointerover':
+        case 'scroll':
+        case 'toggle':
+        case 'touchmove':
+        case 'pointerenter':
+        case 'pointerleave':
+            return ContinuousEventPriority;
+        default:
+            return DefaultEventPriority;
+    }
+}
+const randomKey = Math.random()
+    .toString(36)
+    .slice(2);
+const internalPropsKey = '__reactProps$' + randomKey;
+const internalInstanceKey = '__reactFiber$' + randomKey;
+const internalContainerInstanceKey = '__reactContainer$' + randomKey;
+// const internalEventHandlersKey = '__reactEvents$' + randomKey
+// const internalEventHandlerListenersKey = '__reactListeners$' + randomKey
+// const internalEventHandlesSetKey = '__reactHandles$' + randomKey
+
+const HostRoot = 3; // Root of a host tree. Could be nested inside another node.
+const HostComponent = 5;
+const HostText = 6;
+const SuspenseComponent = 13;
+
+/**
+ * 给 TaroElement 绑定 react fiber、react props 等属性
+ * 提供 fiber -> element、element -> fiber、element -> props 的方法
+*/
+function precacheFiberNode(hostInst, node) {
+    node[internalInstanceKey] = hostInst;
+}
+function markContainerAsRoot(hostRoot, node) {
+    node[internalContainerInstanceKey] = hostRoot;
+}
+/**
+ * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+ * instance, or null if the node was not rendered by this React.
+ */
+function getInstanceFromNode(node) {
+    const inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
+    if (inst) {
+        if (inst.tag === HostComponent ||
+            inst.tag === HostText ||
+            inst.tag === SuspenseComponent ||
+            inst.tag === HostRoot) {
+            return inst;
+        }
+        else {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+ * DOM node.
+ */
+function getNodeFromInstance(inst) {
+    if (inst.tag === HostComponent || inst.tag === HostText) {
+        // In Fiber this, is just the state node right now. We assume it will be
+        // a host component or host text.
+        return inst.stateNode;
+    }
+}
+function getFiberCurrentPropsFromNode(node) {
+    return node[internalPropsKey] || null;
+}
+function updateFiberProps(node, props) {
+    node[internalPropsKey] = props;
+    if (process.env.TARO_PLATFORM === 'harmony') {
+        // @ts-ignore
+        node.updateTextNode();
+    }
+}
+
+// 从 props 中，更新 input 组件的 value 值
+function updateInputWrapper(element, oldValue, props) {
+    const node = element;
+    const checked = props.checked;
+    if (checked != null) {
+        console.warn('updateCheck 未实现', node);
+        return;
+    }
+    updateWrapper(element, oldValue, props);
+    updateNamedCousins(element, props);
+}
+// react 中原本处理 type=radio 的逻辑，这里留个空，暂时不处理
+function updateNamedCousins(rootNode, props) {
+    const name = props.name;
+    if (props.type === 'radio' && name != null) {
+        console.warn('radio updateNamedCousins 未实现', rootNode, props);
+    }
+}
+function getToStringValue(value) {
+    const isEmptyType = typeof value === 'function' || typeof value === 'symbol';
+    return isEmptyType ? '' : value;
+}
+function toString(value) {
+    return '' + value;
+}
+function updateWrapper(element, oldValue, props) {
+    const node = element;
+    const value = getToStringValue(props.value);
+    const type = props.type;
+    setNodeValue(node, oldValue, value, type);
+}
+// oldValue 为 event.detail.value，value 为 fiber.props.value
+// 如果 oldValue 和 value 不相等，代表受控组件需要更新
+// 更新的原则为，fiber.props.value 永远为用户所需要的值，因此 node.value = toString(value)
+function setNodeValue(node, oldValue, value, type = 'string') {
+    if (value != null) {
+        if (type === 'number') {
+            if ((value === 0 && node.value === '')
+                // We explicitly want to coerce to number here if possible.
+                // eslint-disable-next-line
+                || oldValue != value) {
+                node.value = toString(value);
+            }
+        }
+        else if (oldValue !== toString(value)) {
+            node.value = toString(value);
+        }
+    }
+    else if (type === 'submit' || type === 'reset') {
+        // Submit/reset inputs need the attribute removed completely to avoid
+        // blank-text buttons.
+        node.removeAttribute('value');
+    }
+}
+// 判断当前 TaroElement 是否为 supportedInputTypes input 或 textarea
+function isTextInputElement(elem) {
+    const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+    if (nodeName === 'input') {
+        const type = elem.type;
+        return !type || !!supportedInputTypes[type];
+    }
+    if (nodeName === 'textarea') {
+        return true;
+    }
+    return false;
+}
+const ReactDOMTextareaRestoreControlledState = updateWrapper;
+const ReactDOMInputRestoreControlledState = updateInputWrapper;
+
+function isCheckable(elem) {
+    const type = elem.type;
+    const nodeName = elem.nodeName;
+    return (nodeName &&
+        nodeName.toLowerCase() === 'input' &&
+        (type === 'checkbox' || type === 'radio'));
+}
+function getTracker(node) {
+    return node._valueTracker;
+}
+function detachTracker(node) {
+    node._valueTracker = null;
+}
+// 之所以单独创建一个 tacker，是为了统一监听不同 type 的 input 值
+// 比如 type=checkbox 或者 type=radio，就需要监听 checked，而不是 value
+// 虽然目前还未实现 checkbox 和 radio 的 finishEventHandle，但后续不好说，所以先统一和 react 一样的写法
+// 需要特别注意的是，tracker 初始化时的值为 node 的初始值，但后续会变更为事件的 detail.value 值
+function trackValueOnNode(node) {
+    const valueField = isCheckable(node) ? 'checked' : 'value';
+    const descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
+    let currentValue = '' + node[valueField];
+    if (node.hasOwnProperty(valueField) ||
+        typeof descriptor === 'undefined' ||
+        typeof descriptor.get !== 'function' ||
+        typeof descriptor.set !== 'function') {
+        return;
+    }
+    const { get, set } = descriptor;
+    Object.defineProperty(node, valueField, {
+        configurable: true,
+        enumerable: descriptor.enumerable,
+        get: function () {
+            return get.call(this);
+        },
+        set: function (value) {
+            currentValue = '' + value;
+            set.call(this, value);
+        },
+    });
+    const tracker = {
+        getValue() {
+            return currentValue;
+        },
+        setValue(value) {
+            currentValue = '' + value;
+        },
+        stopTracking() {
+            detachTracker(node);
+            delete node[valueField];
+        },
+    };
+    return tracker;
+}
+function track(node) {
+    if (getTracker(node)) {
+        return;
+    }
+    node._valueTracker = trackValueOnNode(node);
+}
+function updateValueIfChanged(node, nextValue) {
+    if (!node) {
+        return false;
+    }
+    const tracker = getTracker(node);
+    if (!tracker) {
+        return true;
+    }
+    const lastValue = tracker.getValue();
+    if (nextValue !== lastValue) {
+        tracker.setValue(nextValue);
+        return true;
+    }
+    return false;
+}
+
+const IS_NON_DIMENSIONAL = /aspect|acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
+const IS_DATASET_OR_ARIA = /^(data|aria)-/;
+function isEventName(s) {
+    return s[0] === 'o' && s[1] === 'n';
+}
+function isEqual(obj1, obj2) {
+    // 首先检查引用是否相同
+    if (obj1 === obj2) {
+        return true;
+    }
+    // 如果两者中有一个不是对象，或者为 null，直接返回 false
+    if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null) {
+        return false;
+    }
+    // 获取两个对象键的数组
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    // 如果键的数量不相同，对象显然不相等
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    // 遍历对象的每个键，比较两个对象同一键的值
+    for (let i = 0; i < keys1.length; i++) {
+        const key = keys1[i];
+        if (obj1[key] !== obj2[key]) {
+            return false;
+        }
+    }
+    // 如果所有键的值都相等，返回 true
+    return true;
+}
+function updateProps(dom, oldProps, newProps) {
+    const updatePayload = getUpdatePayload(dom, oldProps, newProps);
+    if (updatePayload) {
+        updatePropsByPayload(dom, oldProps, updatePayload);
+    }
+}
+function updatePropsByPayload(dom, oldProps, updatePayload) {
+    const handlers = [];
+    let fixedHandler = null;
+    for (let i = 0; i < updatePayload.length; i += 2) {
+        // key, value 成对出现
+        const key = updatePayload[i];
+        const newProp = updatePayload[i + 1];
+        const oldProp = oldProps[key];
+        if (process.env.TARO_PLATFORM === PLATFORM_TYPE.HARMONY) {
+            if (key === '__fixed') {
+                // hack: __fixed最先识别
+                fixedHandler = () => setProperty(dom, key, newProp, oldProp);
+                continue;
+            }
+            // 鸿蒙样式前置插入，防止覆盖style
+            if (key === '__hmStyle') {
+                handlers.splice(0, 0, () => setHarmonyStyle(dom, newProp, oldProp));
+            }
+            else {
+                handlers.push(() => setProperty(dom, key, newProp, oldProp));
+            }
+        }
+        else {
+            setProperty(dom, key, newProp, oldProp);
+        }
+    }
+    if (process.env.TARO_PLATFORM === PLATFORM_TYPE.HARMONY) {
+        fixedHandler && fixedHandler();
+        for (let i = 0; i < handlers.length; i++) {
+            handlers[i]();
+        }
+    }
+}
+function getUpdatePayload(dom, oldProps, newProps) {
+    let i;
+    let updatePayload = null;
+    for (i in oldProps) {
+        if (!(i in newProps)) {
+            (updatePayload = updatePayload || []).push(i, null);
+        }
+    }
+    const isFormElement = dom instanceof FormElement;
+    for (i in newProps) {
+        if (oldProps[i] !== newProps[i] || (isFormElement && i === 'value')) {
+            // 如果都是 style，且 style 里面的值相等，则无需记录到 payload 中
+            if (i === 'style' && isObject(oldProps[i]) && isObject(newProps[i]) && isEqual(oldProps[i], newProps[i]))
+                continue;
+            (updatePayload = updatePayload || []).push(i, newProps[i]);
+        }
+    }
+    return updatePayload;
+}
+// function eventProxy (e: CommonEvent) {
+//   const el = document.getElementById(e.currentTarget.id)
+//   const handlers = el!.__handlers[e.type]
+//   handlers[0](e)
+// }
+function setEvent(dom, name, value, oldValue) {
+    const isCapture = name.endsWith('Capture');
+    let eventName = name.toLowerCase().slice(2);
+    if (isCapture) {
+        eventName = eventName.slice(0, -7);
+    }
+    const compName = capitalize(toCamelCase(dom.tagName.toLowerCase()));
+    if (eventName === 'click' && process.env.TARO_PLATFORM !== PLATFORM_TYPE.HARMONY && compName in internalComponents) {
+        eventName = 'tap';
+    }
+    if (process.env.TARO_ENV === 'tt' && isEnableTTDom()) {
+        if (isFunction(oldValue)) {
+            dom.removeEventListener(`bind${eventName}`, dom[`__${eventName}__`]);
+        }
+        if (isFunction(value)) {
+            dom[`__${eventName}__`] = eventHandlerTTDom.bind(null, dom, value);
+            dom.addEventListener(`bind${eventName}`, dom[`__${eventName}__`], isCapture);
+        }
+        return;
+    }
+    if (isFunction(value)) {
+        if (oldValue) {
+            dom.removeEventListener(eventName, oldValue, process.env.TARO_PLATFORM !== PLATFORM_TYPE.HARMONY ? false : undefined);
+            dom.addEventListener(eventName, value, process.env.TARO_PLATFORM !== PLATFORM_TYPE.HARMONY ? { isCapture, sideEffect: false } : undefined);
+        }
+        else {
+            dom.addEventListener(eventName, value, process.env.TARO_PLATFORM !== PLATFORM_TYPE.HARMONY ? isCapture : undefined);
+        }
+    }
+    else {
+        dom.removeEventListener(eventName, oldValue);
+    }
+}
+function setStyle(style, key, value) {
+    if (key[0] === '-' && process.env.TARO_PLATFORM !== PLATFORM_TYPE.HARMONY) {
+        // css variables need not further judgment
+        style.setProperty(key, value.toString());
+        return;
+    }
+    style[key] =
+        isNumber(value) && IS_NON_DIMENSIONAL.test(key) === false
+            ? (process.env.TARO_PLATFORM === PLATFORM_TYPE.HARMONY ? value + 'px' : convertNumber2PX(value))
+            : value === null
+                ? ''
+                : value;
+}
+// 鸿蒙样式特殊处理，需要在插入顺序中前置插入，防止覆盖了style
+function setHarmonyStyle(dom, value, oldValue) {
+    // @ts-ignore
+    const style = dom._st.hmStyle; // __hmStyle是已经被处理过的鸿蒙样式，可以直接塞进hmStyle对象内
+    if (isObject(oldValue)) {
+        for (const i in oldValue) {
+            if (!(value && i in value)) {
+                // 鸿蒙伪类特殊处理
+                if (process.env.TARO_PLATFORM === PLATFORM_TYPE.HARMONY) {
+                    if (i === '::after' || i === '::before') {
+                        setPseudo(dom, i, null);
+                    }
+                    else if (['::first-child', '::last-child', '::empty'].includes(i) || `${i}`.indexOf('::nth-child') === 0) {
+                        // @ts-ignore
+                        dom.set_pseudo_class(i, null);
+                    }
+                    else {
+                        if (i === 'position' && oldValue[i] === 'fixed') {
+                            // @ts-ignore
+                            dom.setLayer(0);
+                        }
+                        else if (i === 'animationName') {
+                            // @ts-ignore
+                            dom.setAnimation(false);
+                        }
+                        style[i] = '';
+                    }
+                }
+                else {
+                    style[i] = '';
+                }
+            }
+        }
+    }
+    if (isObject(value)) {
+        for (const i in value) {
+            if (!oldValue || !isEqual(value[i], oldValue[i])) {
+                // 鸿蒙伪类特殊处理
+                if (process.env.TARO_PLATFORM === PLATFORM_TYPE.HARMONY) {
+                    if (i === '::after' || i === '::before') {
+                        setPseudo(dom, i, value[i]);
+                    }
+                    else if (['::first-child', '::last-child', '::empty'].includes(i) || i.startsWith('::nth-child')) {
+                        // @ts-ignore
+                        dom.set_pseudo_class(i, value[i]);
+                    }
+                    else {
+                        if (i === 'position') {
+                            if (value[i] === 'fixed' || (value[i] !== 'fixed' && (oldValue === null || oldValue === void 0 ? void 0 : oldValue[i]))) {
+                                // @ts-ignore
+                                dom.setLayer(value[i] === 'fixed' ? 1 : 0);
+                            }
+                        }
+                        else if (i === 'animationName') {
+                            // @ts-ignore
+                            dom.setAnimation(true);
+                        }
+                        style[i] = value[i];
+                    }
+                }
+                else {
+                    style[i] = value[i];
+                }
+            }
+        }
+    }
+    dom.setAttribute('__hmStyle', value);
+}
+function setProperty(dom, name, value, oldValue) {
+    var _a, _b;
+    name = name === 'className' ? 'class' : name;
+    if (name === 'key' ||
+        name === 'children' ||
+        name === 'ref') ;
+    else if (name === 'style') {
+        if (process.env.TARO_ENV === 'tt' && isEnableTTDom()) {
+            if (isString(value)) {
+                dom.setAttribute('style', value);
+            }
+            else if (isObject(value)) {
+                dom.setAttribute('style', styleObjectToCss(value));
+            }
+        }
+        else {
+            if (/harmony.*cpp/.test(process.env.TARO_ENV || '')) {
+                return dom.setAttribute('_style4cpp', value);
+            }
+            const style = dom.style;
+            if (isString(value)) {
+                style.cssText = value;
+            }
+            else {
+                if (isString(oldValue)) {
+                    style.cssText = '';
+                    oldValue = null;
+                }
+                if (isObject(oldValue)) {
+                    for (const i in oldValue) {
+                        if (!(value && i in value)) {
+                            // Harmony特殊处理
+                            if (process.env.TARO_PLATFORM === PLATFORM_TYPE.HARMONY && i === 'position' && oldValue[i] === 'fixed') {
+                                // @ts-ignore
+                                dom.setLayer(0);
+                            }
+                            setStyle(style, i, '');
+                        }
+                    }
+                }
+                if (isObject(value)) {
+                    for (const i in value) {
+                        if (!oldValue || !isEqual(value[i], oldValue[i])) {
+                            // Harmony特殊处理
+                            if (process.env.TARO_PLATFORM === PLATFORM_TYPE.HARMONY && i === 'position') {
+                                if (value[i] === 'fixed' || (value[i] !== 'fixed' && (oldValue === null || oldValue === void 0 ? void 0 : oldValue[i]))) {
+                                    // @ts-ignore
+                                    dom.setLayer(value[i] === 'fixed' ? 1 : 0);
+                                }
+                            }
+                            setStyle(style, i, value[i]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else if (isEventName(name)) {
+        setEvent(dom, name, value, oldValue);
+    }
+    else if (name === 'dangerouslySetInnerHTML') {
+        const newHtml = (_a = value === null || value === void 0 ? void 0 : value.__html) !== null && _a !== void 0 ? _a : '';
+        const oldHtml = (_b = oldValue === null || oldValue === void 0 ? void 0 : oldValue.__html) !== null && _b !== void 0 ? _b : '';
+        if (newHtml || oldHtml) {
+            if (oldHtml !== newHtml) {
+                if (process.env.TARO_ENV === 'tt' && isEnableTTDom()) {
+                    setInnerHTML(dom, newHtml);
+                }
+                else {
+                    dom.innerHTML = newHtml;
+                }
+            }
+        }
+    }
+    else if (!isFunction(value)) {
+        if (process.env.TARO_ENV === 'tt' && isEnableTTDom() && !IS_DATASET_OR_ARIA.test(name)) {
+            name = toCamelCase(name);
+        }
+        if (value == null) {
+            dom.removeAttribute(name);
+        }
+        else {
+            dom.setAttribute(name, value);
+        }
+    }
+}
+// 设置鸿蒙伪类属性(特殊设置)
+function setPseudo(dom, name, value) {
+    if (name === '::after') {
+        // @ts-ignore
+        dom.set_pseudo_after(value);
+    }
+    else if (name === '::before') {
+        // @ts-ignore
+        dom.set_pseudo_before(value);
+    }
+}
+function styleObjectToCss(style) {
+    return Object.entries(style)
+        .map(([key, value]) => {
+        const kebabCaseKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
+        const cssValue = typeof value === 'number' && !UNITLESS_PROPERTIES_SET.has(kebabCaseKey) ? `${value}px` : value === null ? '' : value;
+        return `${kebabCaseKey}: ${cssValue};`;
+    })
+        .join(' ');
+}
+
+/* eslint-disable @typescript-eslint/indent */
+let taroCurrentUpdatePriority = NoEventPriority;
+const taroNotPendingTransition = null;
+const taroHostTransitionContext = {
+    $$typeof: Symbol.for('react.context'),
+    _currentValue: taroNotPendingTransition,
+    _currentValue2: taroNotPendingTransition,
+    _threadCount: 0,
+    Provider: null,
+    Consumer: null
+};
+taroHostTransitionContext.Provider = taroHostTransitionContext;
+taroHostTransitionContext.Consumer = taroHostTransitionContext;
+/**
+ * WX VPT Page outlet projection
+ * -----------------------------
+ * VPT retains one React ownership tree while WX exposes one independent setData surface per native Page. The singleton App
+ * host records live in each Page's `app` data, the current Page records live in `page`, and Page WXML supplies its own template
+ * as the default light-DOM slot of the virtual recursive App component. Taro restarts deep template recursion through nested
+ * `comp` components. At every such native component boundary the slot must be forwarded only through the App branch that
+ * contains the VPT Page outlet rendered for React's `{children}`: forwarding through all sibling branches creates duplicate
+ * unnamed slot consumers, while forwarding through none loses the Page.
+ *
+ * `vo` is the compact, branch-local answer to "does this App subtree contain the VPT Page outlet?". WXML reads only `i.vo`,
+ * so its decision is O(1) and it never scans descendants or receives Page data. This renderer owns `vo` rather than Taro's
+ * hydrate or root scheduler because React's commit boundary is the first point where every host mutation has completed and
+ * the final parent chain is authoritative. TaroElement already supports arbitrary properties: setAttribute updates
+ * node.props and queues the normal granular `app.*.vo` path. Structural Taro payloads are lazy functions flushed by setTimeout, so they run
+ * after resetAfterCommit and naturally serialize the same final `vo` props. There is consequently no projection-specific
+ * hydration mode, update-path translation, or full App snapshot.
+ *
+ * High-level commit flow:
+ * 1. React applies all Taro host insertions, removals, and reparenting synchronously.
+ * 2. resetAfterCommit obtains the unique VPT Page outlet and walks parentNode from that outlet to the App root.
+ * 3. The unchanged root-side suffix is skipped; old leaf-side nodes receive vo=false and new ones receive vo=true.
+ * 4. Ordinary Taro attribute updates join structural updates in the already scheduled App batch.
+ * 5. Lazy hydration observes node.props.vo, and the App batch fans out unchanged to every retained native Page.
+ *
+ * The App root stores the only persistent projection state as a VPT Page outlet-to-root node array. It contains O(D)
+ * references, where D is outlet depth, so index 0 is the outlet represented by the latest queued native batch. A normal commit
+ * performs an O(D) parent walk and raw array comparison and emits no native data when the spine is unchanged. A move touches
+ * only the leaf-side portions outside the common root-side suffix and never depends on total App size W or Page size. React
+ * can replace a host when moving it across parents; only then (and during initialization) a single O(W) search finds the new
+ * VPT Page outlet. WXML still performs one constant-time boolean check per recursive boundary.
+ */
+const VPT_PAGE_OUTLET = 'vpt_page_outlet';
+const VPT_PAGE_OUTLET_BRANCH = 'vo';
+const vptPageOutletSpineKey = Symbol('vptPageOutletSpine');
+/** Finds the VPT Page outlet only during initialization or after React replaced the cached VPT Page outlet host. */
+function findVptPageOutlet(node) {
+    if (node.nodeName === VPT_PAGE_OUTLET)
+        return node;
+    const children = node.childNodes;
+    for (let index = 0; index < children.length; index++) {
+        const vptPageOutlet = findVptPageOutlet(children[index]);
+        if (vptPageOutlet)
+            return vptPageOutlet;
+    }
+}
+/** Builds the final ancestor identity array from the VPT Page outlet to the App root. */
+function collectVptPageOutletSpine(container, vptPageOutlet) {
+    // This local array is filled once in parent-link order, then retained unchanged as the next VPT Page outlet spine.
+    const spine = [];
+    for (let node = vptPageOutlet; node !== container; node = node.parentNode) {
+        spine.push(node);
+    }
+    return spine;
+}
+/** Reconciles VPT Page outlet branch membership through ordinary Taro host props after one complete React commit. */
+function reconcileVptPageOutletSpine(container) {
+    // Other React roots, including standalone Page/component roots, do not own the singleton VPT App-view projection.
+    if (!container.parentNode || container.parentNode.nodeName !== 'container')
+        return;
+    const previousSpine = container[vptPageOutletSpineKey] || [];
+    const previousVptPageOutlet = previousSpine[0];
+    /*
+     * Reuse the cached VPT Page outlet while it remains under this App root. Cross-parent React reconciliation may replace
+     * the host rather than reparent its Taro node, so a detached cache entry requires one search of the committed tree.
+     */
+    const vptPageOutlet = previousVptPageOutlet && previousVptPageOutlet._root === container
+        ? previousVptPageOutlet
+        : findVptPageOutlet(container);
+    ensure(vptPageOutlet, 'App must render children exactly once.');
+    const currentSpine = collectVptPageOutletSpine(container, vptPageOutlet);
+    /*
+     * VPT Page outlet parent chains are stored outlet-to-root, so equal nodes form a root-side suffix. These mutable indexes
+     * walk that suffix once without iterator, callback, Set, or intermediate-array allocation; the remaining prefixes are the
+     * only candidates whose branch marker can differ.
+     */
+    let previousIndex = previousSpine.length - 1;
+    let currentIndex = currentSpine.length - 1;
+    while (previousIndex >= 0 && currentIndex >= 0 && previousSpine[previousIndex] === currentSpine[currentIndex]) {
+        previousIndex--;
+        currentIndex--;
+    }
+    /*
+     * Detached old nodes are already removed by their parent's structural payload. Surviving nodes in the changed old prefix
+     * still have native records, so clear their marker through Taro's ordinary attribute queue.
+     */
+    for (let index = 0; index <= previousIndex; index++) {
+        const node = previousSpine[index];
+        if (node._root === container) {
+            node.setAttribute(VPT_PAGE_OUTLET_BRANCH, false);
+        }
+    }
+    // Write the changed current prefix after clearing the old prefix so any surviving moved identity ends with vo=true.
+    for (let index = 0; index <= currentIndex; index++) {
+        currentSpine[index].setAttribute(VPT_PAGE_OUTLET_BRANCH, true);
+    }
+    // This is the sole persistent VPT projection state: the ancestor identities in the latest queued native App batch.
+    container[vptPageOutletSpineKey] = currentSpine;
+}
+const hostConfig = {
+    // React 19 react-reconciler host config additions.
+    setCurrentUpdatePriority(priority) {
+        taroCurrentUpdatePriority = priority;
+    },
+    getCurrentUpdatePriority() {
+        return taroCurrentUpdatePriority;
+    },
+    resolveUpdatePriority() {
+        return taroCurrentUpdatePriority === NoEventPriority ? DefaultEventPriority : taroCurrentUpdatePriority;
+    },
+    trackSchedulerEvent: noop,
+    resolveEventType: () => null,
+    resolveEventTimeStamp: () => -1.1,
+    requestPostPaintCallback: noop,
+    NotPendingTransition: taroNotPendingTransition,
+    HostTransitionContext: taroHostTransitionContext,
+    resetFormInstance: noop,
+    bindToConsole(methodName, args) {
+        const consoleMethod = console[methodName];
+        return typeof consoleMethod === 'function' ? consoleMethod.bind(console, ...args) : noop;
+    },
+    shouldAttemptEagerTransition: () => false,
+    maySuspendCommit: () => false,
+    maySuspendCommitOnUpdate: () => false,
+    maySuspendCommitInSyncRender: () => false,
+    preloadInstance: () => true,
+    startSuspendingCommit: noop,
+    suspendInstance: noop,
+    suspendOnActiveViewTransition: noop,
+    waitForCommitToBeReady: () => null,
+    getSuspendedCommitReason: () => null,
+    // below keys order by {React ReactFiberHostConfig.custom.js}, convenient for comparing each other.
+    // -------------------
+    // required by @types/react-reconciler
+    // -------------------
+    getPublicInstance(inst) {
+        return inst;
+    },
+    getRootHostContext() {
+        return {};
+    },
+    getChildHostContext(parentHostContext) {
+        return parentHostContext;
+    },
+    prepareForCommit(..._) {
+        return null;
+    },
+    /*
+     * React invokes this synchronously after host mutations and before returning from the commit. Taro defers evaluation of
+     * structural hydrate functions with setTimeout, so VPT Page outlet branch props written here are batched and visible to
+     * every compact record serialized for this commit.
+     */
+    resetAfterCommit(container) {
+        reconcileVptPageOutletSpine(container);
+    },
+    createInstance(type, props, _rootContainerInstance, _hostContext, internalInstanceHandle) {
+        const element = document.createElement(type);
+        precacheFiberNode(internalInstanceHandle, element);
+        updateFiberProps(element, props);
+        return element;
+    },
+    appendInitialChild(parent, child) {
+        parent.appendChild(child);
+    },
+    finalizeInitialChildren(dom, type, props) {
+        let newProps = props;
+        if (dom instanceof FormElement) {
+            const [defaultName, defaultKey] = ['switch', 'checkbox', 'radio'].includes(type) ? ['checked', 'defaultChecked'] : ['value', 'defaultValue'];
+            if (props.hasOwnProperty(defaultKey)) {
+                newProps = Object.assign(Object.assign({}, newProps), { [defaultName]: props[defaultKey] });
+                delete newProps[defaultKey];
+            }
+        }
+        updateProps(dom, {}, newProps); // 提前执行更新属性操作，Taro 在 Page 初始化后会立即从 dom 读取必要信息
+        if (type === 'input' || type === 'textarea') {
+            track(dom);
+        }
+        return false;
+    },
+    prepareUpdate(instance, _, oldProps, newProps) {
+        return getUpdatePayload(instance, oldProps, newProps);
+    },
+    shouldSetTextContent() {
+        return false;
+    },
+    createTextInstance(text, _rootContainerInstance, _hostContext, internalInstanceHandle) {
+        const textNode = document.createTextNode(text);
+        precacheFiberNode(internalInstanceHandle, textNode);
+        return textNode;
+    },
+    scheduleTimeout: setTimeout,
+    cancelTimeout: clearTimeout,
+    noTimeout: -1,
+    isPrimaryRenderer: true,
+    warnsIfNotActing: true,
+    supportsMutation: true,
+    supportsPersistence: false,
+    supportsHydration: false,
+    getInstanceFromNode: () => null,
+    beforeActiveInstanceBlur: noop,
+    afterActiveInstanceBlur: noop,
+    preparePortalMount: noop,
+    prepareScopeUpdate: noop,
+    getInstanceFromScope: () => null,
+    getCurrentEventPriority() {
+        return DefaultEventPriority;
+    },
+    detachDeletedInstance: noop,
+    // -------------------
+    //      Microtasks
+    //     (optional)
+    // -------------------
+    supportsMicrotasks: true,
+    scheduleMicrotask: isUndefined(Promise)
+        ? setTimeout
+        : (callback) => Promise.resolve(null)
+            .then(callback)
+            .catch(function (error) {
+            setTimeout(() => {
+                throw error;
+            });
+        }),
+    // -------------------
+    //      Mutation
+    //     (required if supportsMutation is true)
+    // -------------------
+    appendChild(parent, child) {
+        parent.appendChild(child);
+    },
+    appendChildToContainer(parent, child) {
+        parent.appendChild(child);
+    },
+    commitTextUpdate(textInst, _, newText) {
+        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;
+        if (!updatePayload)
+            return;
+        // payload 只包含 children 的时候，不应该再继续触发后续的属性比较和更新的逻辑了
+        if (updatePayload.length === 2 && updatePayload.includes('children'))
+            return;
+        updatePropsByPayload(dom, oldProps, updatePayload);
+        updateFiberProps(dom, newProps);
+    },
+    insertBefore(parent, child, refChild) {
+        parent.insertBefore(child, refChild);
+    },
+    insertInContainerBefore(parent, child, refChild) {
+        parent.insertBefore(child, refChild);
+    },
+    removeChild(parent, child) {
+        parent.removeChild(child);
+    },
+    removeChildFromContainer(parent, child) {
+        parent.removeChild(child);
+    },
+    resetTextContent: noop,
+    hideInstance(instance) {
+        const style = instance.style;
+        style.setProperty('display', 'none');
+    },
+    hideTextInstance(textInstance) {
+        textInstance.nodeValue = '';
+    },
+    unhideInstance(instance, props) {
+        const styleProp = props.style;
+        let display = (styleProp === null || styleProp === void 0 ? void 0 : styleProp.hasOwnProperty('display')) ? styleProp.display : null;
+        display = display == null || isBoolean(display) || display === '' ? '' : ('' + display).trim();
+        // eslint-disable-next-line dot-notation
+        instance.style['display'] = display;
+    },
+    unhideTextInstance(textInstance, text) {
+        textInstance.nodeValue = text;
+    },
+    clearContainer(element) {
+        if (element.childNodes.length > 0) {
+            element.textContent = '';
+        }
+    }
+};
+const TaroReconciler = Reconciler(hostConfig);
+TaroReconciler.flushSync = TaroReconciler.flushSync || TaroReconciler.flushSyncFromReconciler || TaroReconciler.flushSyncWork;
+TaroReconciler.runWithPriority = TaroReconciler.runWithPriority || ((priority, fn) => {
+    const previousPriority = hostConfig.getCurrentUpdatePriority();
+    try {
+        hostConfig.setCurrentUpdatePriority(priority);
+        return fn();
+    }
+    finally {
+        hostConfig.setCurrentUpdatePriority(previousPriority);
+    }
+});
+if (process.env.NODE_ENV !== 'production') {
+    const foundDevTools = TaroReconciler.injectIntoDevTools({
+        bundleType: 1,
+        version: '18.0.0',
+        rendererPackageName: 'taro-react'
+    });
+    if (!foundDevTools) {
+        // eslint-disable-next-line no-console
+        console.info('%cDownload the React DevTools ' +
+            'for a better development experience: ' +
+            'https://reactjs.org/link/react-devtools', 'font-weight:bold');
+    }
+}
+
+let restoreQueue = null;
+// 对比 TaroElement tracker 下的 value 和事件下的 value，判断 element 的值是否存在更改
+function getTargetInstForInputOrChangeEvent(e, node) {
+    var _a, _b;
+    const targetInst = getInstanceFromNode(node);
+    const domEventName = e.type;
+    if (!targetInst || !isTextInputElement(node))
+        return;
+    if (domEventName === 'input' || domEventName === 'change') {
+        const nextValue = toString((_b = (_a = e.mpEvent) === null || _a === void 0 ? void 0 : _a.detail) === null || _b === void 0 ? void 0 : _b.value);
+        return getInstIfValueChanged(targetInst, nextValue);
+    }
+}
+function getInstIfValueChanged(targetInst, nextValue) {
+    const targetNode = getNodeFromInstance(targetInst);
+    if (!targetNode)
+        return false;
+    if (updateValueIfChanged(targetNode, nextValue)) {
+        return targetInst;
+    }
+}
+// 把 target 塞入更新队列中
+function enqueueStateRestore(target) {
+    if (restoreQueue) {
+        restoreQueue.push(target);
+    }
+    else {
+        restoreQueue = [target];
+    }
+}
+// 判断是否需要恢复 target（input、textarea） 的状态
+function needsStateRestore() {
+    return restoreQueue !== null;
+}
+function finishEventHandler() {
+    const controlledComponentsHavePendingUpdates = needsStateRestore();
+    if (controlledComponentsHavePendingUpdates) {
+        TaroReconciler.flushSync();
+        restoreStateIfNeeded();
+    }
+}
+// 遍历 restoreQueue、restoreTarget，恢复其状态
+function restoreStateIfNeeded() {
+    if (!restoreQueue) {
+        return;
+    }
+    const queuedTargets = restoreQueue;
+    restoreQueue = null;
+    for (let i = 0; i < queuedTargets.length; i++) {
+        restoreStateOfTarget(queuedTargets[i]);
+    }
+}
+function restoreImpl(domElement, tag, oldValue, props) {
+    switch (tag) {
+        case 'input':
+            ReactDOMInputRestoreControlledState(domElement, oldValue, props);
+            break;
+        case 'textarea':
+            ReactDOMTextareaRestoreControlledState(domElement, oldValue, props);
+            break;
+    }
+}
+function restoreStateOfTarget(item) {
+    const internalInstance = getInstanceFromNode(item.target);
+    if (!internalInstance)
+        return;
+    const { stateNode, type } = internalInstance;
+    if (stateNode) {
+        const props = getFiberCurrentPropsFromNode(stateNode);
+        restoreImpl(stateNode, type, item.value, props);
+    }
+}
+
+const ContainerMap = new WeakMap();
+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
+            null // onDefaultTransitionIndicator
+            );
+        }
+    }
+    render(children, cb) {
+        const { renderer, internalRoot } = this;
+        renderer.updateContainer(children, internalRoot, null, cb);
+        return renderer.getPublicRootInstance(internalRoot);
+    }
+    unmount(cb) {
+        this.renderer.updateContainer(null, this.internalRoot, 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;
+    const oldRoot = ContainerMap.get(domContainer);
+    if (oldRoot != null) {
+        return oldRoot;
+    }
+    // options should be an object
+    const root = new Root(TaroReconciler, 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);
+    hooks.tap('dispatchTaroEvent', (e, node) => {
+        const eventPriority = getEventPriority(e.type);
+        TaroReconciler.runWithPriority(eventPriority, () => {
+            node.dispatchEvent(e);
+        });
+    });
+    // 对比 event.detail.value 和 node.tracker.value，判断 value 值是否有变动，存在变动则塞入队列中
+    hooks.tap('modifyTaroEvent', (e, node) => {
+        var _a, _b;
+        const inst = getTargetInstForInputOrChangeEvent(e, node);
+        if (!inst)
+            return;
+        // 这里塞入的是 event.detail.value，也就是事件的值，在受控组件中，你可以理解为需要被变更的值
+        // 后续会在 finishEventHandler 中，使用最新的 fiber.props.value 来与其比较
+        // 如果不一致，则表示需要更新，会执行 node.value = fiber.props.value 的更新操作
+        const nextValue = (_b = (_a = e.mpEvent) === null || _a === void 0 ? void 0 : _a.detail) === null || _b === void 0 ? void 0 : _b.value;
+        enqueueStateRestore({ target: node, value: nextValue });
+    });
+    return root;
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+let isInsideEventHandler = false;
+// 重新包裹 batchedUpdates，使其可以在触发事件后执行 finishEventHandler
+const unstable_batchedUpdates = (fn, a) => {
+    if (isInsideEventHandler) {
+        return fn(a);
+    }
+    isInsideEventHandler = true;
+    try {
+        return TaroReconciler.batchedUpdates(fn, a);
+    }
+    finally {
+        isInsideEventHandler = false;
+        finishEventHandler();
+    }
+};
+function unmountComponentAtNode(dom) {
+    ensure(dom && [1, 8, 9, 11].includes(dom.nodeType), 'unmountComponentAtNode(...): Target container is not a DOM element.');
+    const root = ContainerMap.get(dom);
+    if (!root)
+        return false;
+    unstable_batchedUpdates(() => {
+        root.unmount(() => {
+            ContainerMap.delete(dom);
+        });
+    }, 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;
+function createPortal(children, containerInfo, key) {
+    return {
+        $$typeof: portalType,
+        key: key == null ? null : String(key),
+        children,
+        containerInfo,
+        implementation: null
+    };
+}
+const flushSync = TaroReconciler.flushSync;
+var index = {
+    render,
+    flushSync,
+    createRoot,
+    unstable_batchedUpdates,
+    unmountComponentAtNode,
+    findDOMNode,
+    createPortal,
+    internalInstanceKey
+};
+
+export { createPortal, createRoot, index as default, findDOMNode, flushSync, internalInstanceKey, render, unmountComponentAtNode, unstable_batchedUpdates };
+//# sourceMappingURL=react.esm.js.map