@my-react/react-reconciler-compact 0.0.15 → 0.0.16

package/dist/cjs/index.production.js

@@ -812,12 +812,13 @@ function requireIndex_production () {
 
 		var currentRunningFiber$5 = typeExports.__my_react_internal__.currentRunningFiber, currentScheduler$h = typeExports.__my_react_internal__.currentScheduler, currentScopeFiber$1 = typeExports.__my_react_internal__.currentScopeFiber, currentError$1 = typeExports.__my_react_internal__.currentError, currentCallingFiber$1 = typeExports.__my_react_internal__.currentCallingFiber;
 		var safeCall = function (action) {
+		    var _a;
 		    var args = [];
 		    for (var _i = 1; _i < arguments.length; _i++) {
 		        args[_i - 1] = arguments[_i];
 		    }
 		    try {
-		        return action.call.apply(action, __spreadArray([null], args, false));
+		        return (_a = action === null || action === void 0 ? void 0 : action.call) === null || _a === void 0 ? void 0 : _a.call.apply(_a, __spreadArray([action, null], args, false));
 		    }
 		    catch (e) {
 		        var fiber = (currentCallingFiber$1 === null || currentCallingFiber$1 === void 0 ? void 0 : currentCallingFiber$1[(currentCallingFiber$1 === null || currentCallingFiber$1 === void 0 ? void 0 : currentCallingFiber$1.length) - 1]) || currentScopeFiber$1.current || currentRunningFiber$5.current;
@@ -827,6 +828,7 @@ function requireIndex_production () {
 		    }
 		};
 		var safeCallWithCurrentFiber = function (_a) {
+		    var _b;
 		    var action = _a.action, fiber = _a.fiber, fallback = _a.fallback;
 		    var args = [];
 		    for (var _i = 1; _i < arguments.length; _i++) {
@@ -834,7 +836,7 @@ function requireIndex_production () {
 		    }
 		    currentCallingFiber$1.push(fiber);
 		    try {
-		        return action.call.apply(action, __spreadArray([null], args, false));
+		        return (_b = action === null || action === void 0 ? void 0 : action.call) === null || _b === void 0 ? void 0 : _b.call.apply(_b, __spreadArray([action, null], args, false));
 		    }
 		    catch (e) {
 		        if (fallback) {
@@ -851,6 +853,7 @@ function requireIndex_production () {
 		    }
 		};
 		var callWithFiber = function (_a) {
+		    var _b;
 		    var action = _a.action, fiber = _a.fiber;
 		    var args = [];
 		    for (var _i = 1; _i < arguments.length; _i++) {
@@ -858,20 +861,21 @@ function requireIndex_production () {
 		    }
 		    currentScopeFiber$1.current = fiber;
 		    try {
-		        return action.call.apply(action, __spreadArray([null], args, false));
+		        return (_b = action === null || action === void 0 ? void 0 : action.call) === null || _b === void 0 ? void 0 : _b.call.apply(_b, __spreadArray([action, null], args, false));
 		    }
 		    finally {
 		        currentScopeFiber$1.current = null;
 		    }
 		};
 		var safeCallWithSync = function (action) {
+		    var _a;
 		    var args = [];
 		    for (var _i = 1; _i < arguments.length; _i++) {
 		        args[_i - 1] = arguments[_i];
 		    }
 		    try {
 		        beforeSyncUpdate();
-		        return action.call.apply(action, __spreadArray([null], args, false));
+		        return (_a = action === null || action === void 0 ? void 0 : action.call) === null || _a === void 0 ? void 0 : _a.call.apply(_a, __spreadArray([action, null], args, false));
 		    }
 		    catch (e) {
 		        var fiber = (currentCallingFiber$1 === null || currentCallingFiber$1 === void 0 ? void 0 : currentCallingFiber$1[(currentCallingFiber$1 === null || currentCallingFiber$1 === void 0 ? void 0 : currentCallingFiber$1.length) - 1]) || currentScopeFiber$1.current || currentRunningFiber$5.current;
@@ -3956,9 +3960,11 @@ function requireIndex_production () {
 		    var renderScheduler = currentScheduler$7.current;
 		    var currentHook = (_b = currentHookTreeNode$1.current) === null || _b === void 0 ? void 0 : _b.value;
 		    if (!currentHook) {
-		        throw new Error("[@my-react/react] should have a hookList for current node, this is a bug for @my-react");
+		        // throw new Error(`[@my-react/react] should have a hookList for current node, this is a bug for @my-react`);
+		        return createHookNode(renderDispatch, { type: type, value: value, reducer: reducer, deps: deps }, fiber);
 		    }
 		    if (type !== (currentHook === null || currentHook === void 0 ? void 0 : currentHook.type)) {
+		        // only throw error when type not match
 		        throw new Error(getHookTree(currentHookTreeNode$1.current.prev, {
 		            lastRender: currentHook === null || currentHook === void 0 ? void 0 : currentHook.type,
 		            nextRender: type,
@@ -6424,7 +6430,7 @@ function requireIndex_production () {
 		        _this.isAppMounted = false;
 		        _this.isAppCrashed = false;
 		        _this.isAppUnmounted = false;
-		        _this.version = "0.3.24";
+		        _this.version = "0.3.25";
 		        _this.id = Math.random().toString(16).slice(2);
 		        _this.mode = "production";
 		        _this.renderMode = "render";
@@ -6470,9 +6476,7 @@ function requireIndex_production () {
 		            if (include(_fiber.type, this.runtimeRef.typeForRef)) {
 		                _fiber.patch = merge(_fiber.patch, PATCH_TYPE.__ref__);
 		            }
-		            else if (exclude(_fiber.type, exports$1.NODE_TYPE.__forwardRef__)) {
-		                onceWarnWithKeyAndFiber(_fiber, "ref", "[@my-react/react] set ref for current element will be ignored");
-		            }
+		            else if (exclude(_fiber.type, exports$1.NODE_TYPE.__forwardRef__)) ;
 		        }
 		    };
 		    CustomRenderDispatch.prototype.pendingUnmount = function (_fiber, _pendingUnmount) {
@@ -6662,7 +6666,7 @@ function requireIndex_production () {
 		    });
 		}); };
 
-		var version = "0.3.24";
+		var version = "0.3.25";
 
 		exports$1.CustomRenderDispatch = CustomRenderDispatch;
 		exports$1.MyReactFiberNode = MyReactFiberNode;
@@ -7796,6 +7800,9 @@ var createDispatch = function (rootNode, rootFiber, rootElement, config, flag) {
     return dispatch;
 };
 
+var autoSetDevHMR = function (dispatch) {
+};
+
 var enableDebugFiled$1 = typeExports.__my_react_shared__.enableDebugFiled, enableScopeTreeLog$1 = typeExports.__my_react_shared__.enableScopeTreeLog;
 /**
  * @internal
@@ -7813,15 +7820,14 @@ var currentScheduler = typeExports.__my_react_internal__.currentScheduler;
 // react-reconciler compat implementation
 var Reconciler = function (_config) {
     var rendererPackageName = "@my-react";
+    var isRendering = false;
     var ReconcilerSet = new Set();
     var createContainer = function (_container, flag) {
         prepareScheduler();
         if (flag === 0) {
-            // legacy mode
             _container.__flag__ = 0;
         }
         else {
-            // concurrent mode
             _container.__flag__ = 1;
         }
         enableDebugFiled.current = false;
@@ -7830,48 +7836,60 @@ var Reconciler = function (_config) {
         myreactReconcilerExports.enableFiberForLog.current = false;
         return _container;
     };
+    var createHydrationContainer = function (_initialChildren, _callback, _container, flag, _hydrationCallbacks, _isStrictMode, _concurrentUpdatesByDefaultOverride, _identifierPrefix, _onRecoverableError, _transitionCallbacks) {
+        var opaqueRoot = createContainer(_container, flag);
+        updateContainer(_initialChildren, opaqueRoot, null, _callback !== null && _callback !== void 0 ? _callback : (function () { }));
+        return opaqueRoot;
+    };
     var updateContainer = function (_element, _container, _ignore, _cb) {
         var _a;
         var renderDispatch = _container.__container__;
         var renderScheduler = currentScheduler.current;
-        if (renderDispatch instanceof myreactReconcilerExports.CustomRenderDispatch) {
-            var _fiber_1 = _container.__fiber__;
-            if (renderDispatch.isAppCrashed || include(_fiber_1.state, STATE_TYPE.__unmount__)) {
-                // is there are not a valid render tree, try do the pure rerender
-                _container.__fiber__ = null;
-                _container.__container__ = null;
-                updateContainer(_element, _container, _config, _cb);
-                return;
-            }
-            if (myreactReconcilerExports.checkIsSameType(_fiber_1, _element)) {
-                _fiber_1._installElement(_element);
-                myreactReconcilerExports.triggerUpdateOnFiber(_fiber_1, STATE_TYPE.__triggerSync__, _cb);
-                return;
+        isRendering = true;
+        try {
+            if (renderDispatch instanceof myreactReconcilerExports.CustomRenderDispatch) {
+                var _fiber_1 = _container.__fiber__;
+                if (renderDispatch.isAppCrashed || include(_fiber_1.state, STATE_TYPE.__unmount__)) {
+                    _container.__fiber__ = null;
+                    _container.__container__ = null;
+                    updateContainer(_element, _container, _config, _cb);
+                    return;
+                }
+                if (myreactReconcilerExports.checkIsSameType(_fiber_1, _element)) {
+                    _fiber_1._installElement(_element);
+                    myreactReconcilerExports.triggerUpdateOnFiber(_fiber_1, STATE_TYPE.__triggerSync__, _cb);
+                    return;
+                }
+                myreactReconcilerExports.unmountContainer(renderDispatch);
+                (_a = _config === null || _config === void 0 ? void 0 : _config.clearContainer) === null || _a === void 0 ? void 0 : _a.call(_config, _container);
+                ReconcilerSet.delete(renderDispatch);
+                renderScheduler.dispatchSet.uniDelete(renderDispatch);
+                delGlobalDispatch(renderDispatch);
             }
-            myreactReconcilerExports.unmountContainer(renderDispatch);
-            (_a = _config === null || _config === void 0 ? void 0 : _config.clearContainer) === null || _a === void 0 ? void 0 : _a.call(_config, _container);
-            ReconcilerSet.delete(renderDispatch);
-            renderScheduler.dispatchSet.uniDelete(renderDispatch);
-            delGlobalDispatch(renderDispatch);
+            var _fiber = new myreactReconcilerExports.MyReactFiberNode(_element);
+            var _renderDispatch = createDispatch(_container, _fiber, _element, _config, _container.__flag__);
+            _cb && _renderDispatch.pendingEffect(_fiber, _cb);
+            ReconcilerSet.add(_renderDispatch);
+            renderScheduler.dispatchSet.uniPush(_renderDispatch);
+            _renderDispatch.renderPackage = rendererPackageName;
+            _container.__fiber__ = _fiber;
+            _container.__container__ = _renderDispatch;
+            autoSetDevTools(_renderDispatch);
+            autoSetDevHMR(_renderDispatch);
+            myreactReconcilerExports.initialFiberNode(_renderDispatch, _fiber);
+            myreactReconcilerExports.mountSync(_renderDispatch, _fiber);
+            _renderDispatch.isAppMounted = true;
+        }
+        finally {
+            isRendering = false;
         }
-        var _fiber = new myreactReconcilerExports.MyReactFiberNode(_element);
-        var _renderDispatch = createDispatch(_container, _fiber, _element, _config, _container.__flag__);
-        _cb && _renderDispatch.pendingEffect(_fiber, _cb);
-        ReconcilerSet.add(_renderDispatch);
-        renderScheduler.dispatchSet.uniPush(_renderDispatch);
-        _renderDispatch.renderPackage = rendererPackageName;
-        _container.__fiber__ = _fiber;
-        _container.__container__ = _renderDispatch;
-        autoSetDevTools(_renderDispatch);
-        myreactReconcilerExports.initialFiberNode(_renderDispatch, _fiber);
-        myreactReconcilerExports.mountSync(_renderDispatch, _fiber);
-        _renderDispatch.isAppMounted = true;
     };
     var injectIntoDevTools = function (_config) {
         rendererPackageName = _config.rendererPackageName || rendererPackageName;
         ReconcilerSet.forEach(function (renderDispatch) { return (renderDispatch.renderPackage = rendererPackageName); });
         if (globalThis["__MY_REACT_DEVTOOL_INTERNAL__"])
-            return;
+            return true;
+        return false;
     };
     var injectIntoDevToolsAuto = function (url, _config) { return __awaiter(void 0, void 0, void 0, function () {
         var init;
@@ -7897,25 +7915,179 @@ var Reconciler = function (_config) {
         });
     }); };
     var getPublicRootInstance = function (_container) {
-        return _container.__container__;
+        var fiber = _container.__fiber__;
+        if (!fiber || !fiber.child) {
+            return null;
+        }
+        return fiber.child.nativeNode;
+    };
+    var discreteUpdates = function (fn, a, b, c, d) {
+        myreactReconcilerExports.beforeSyncUpdate();
+        try {
+            return fn(a, b, c, d);
+        }
+        finally {
+            myreactReconcilerExports.afterSyncUpdate();
+        }
+    };
+    var updateContainerSync = function (element, container, ignore, callback) {
+        myreactReconcilerExports.beforeSyncUpdate();
+        try {
+            updateContainer(element, container, ignore, callback);
+        }
+        finally {
+            myreactReconcilerExports.afterSyncUpdate();
+        }
+    };
+    var flushPassiveEffects = function () {
+        try {
+            myreactReconcilerExports.flushEffectCallback();
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    var isAlreadyRendering = function () {
+        return isRendering;
+    };
+    var deferredUpdates = function (fn) {
+        return fn();
+    };
+    var findHostInstance = function (component) {
+        try {
+            var fiber = myreactReconcilerExports.getInstanceOwnerFiber(component);
+            if (!fiber)
+                return null;
+            var current = fiber;
+            while (current) {
+                if (current.nativeNode && typeof current.type === "string") {
+                    return (_config === null || _config === void 0 ? void 0 : _config.getPublicInstance) ? _config.getPublicInstance(current.nativeNode) : current.nativeNode;
+                }
+                current = current.child;
+            }
+            return null;
+        }
+        catch (_a) {
+            return null;
+        }
+    };
+    var findHostInstanceWithWarning = function (component, _methodName) {
+        return findHostInstance(component);
+    };
+    var findHostInstanceWithNoPortals = function (fiber) {
+        return findHostInstance(fiber);
+    };
+    var attemptSynchronousHydration = function (_fiber) {
+        // no-op: hydration not yet supported in MyReact reconciler-compact
+    };
+    var attemptDiscreteHydration = function (_fiber) {
+        // no-op
+    };
+    var attemptContinuousHydration = function (_fiber) {
+        // no-op
+    };
+    var attemptHydrationAtCurrentPriority = function (_fiber) {
+        // no-op
+    };
+    var getCurrentUpdatePriority = function () {
+        return 0;
+    };
+    var runWithPriority = function (_priority, fn) {
+        return fn();
+    };
+    var shouldErrorImpl = null;
+    var shouldSuspendImpl = null;
+    var shouldError = function (fiber) {
+        return shouldErrorImpl ? shouldErrorImpl(fiber) : undefined;
+    };
+    var shouldSuspend = function (fiber) {
+        return shouldSuspendImpl ? shouldSuspendImpl(fiber) : false;
+    };
+    var registerMutableSourceForHydration = function (_root, _mutableSource) {
+        // no-op
+    };
+    var createComponentSelector = function (component) { return ({ $$typeof: Symbol.for("react.test.selector"), value: component }); };
+    var createHasPseudoClassSelector = function (selectors) { return ({ $$typeof: Symbol.for("react.test.selector"), value: selectors }); };
+    var createRoleSelector = function (role) { return ({ $$typeof: Symbol.for("react.test.selector"), value: role }); };
+    var createTextSelector = function (text) { return ({ $$typeof: Symbol.for("react.test.selector"), value: text }); };
+    var createTestNameSelector = function (id) { return ({ $$typeof: Symbol.for("react.test.selector"), value: id }); };
+    var getFindAllNodesFailureDescription = function (_hostRoot, _selectors) {
+        return null;
+    };
+    var findAllNodes = function (_hostRoot, _selectors) {
+        return [];
+    };
+    var findBoundingRects = function (_hostRoot, _selectors) {
+        return [];
+    };
+    var focusWithin = function (_hostRoot, _selectors) {
+        return false;
+    };
+    var observeVisibleRects = function (_hostRoot, _selectors, _callback, _options) {
+        return { disconnect: function () { } };
     };
     return {
         createPortal: createPortal,
         createContainer: createContainer,
+        createHydrationContainer: createHydrationContainer,
         updateContainer: updateContainer,
+        updateContainerSync: updateContainerSync,
         injectIntoDevTools: injectIntoDevTools,
         getPublicRootInstance: getPublicRootInstance,
         injectIntoDevToolsAuto: injectIntoDevToolsAuto,
         flushSync: myreactReconcilerExports.safeCallWithSync,
         flushSyncWork: myreactReconcilerExports.safeCallWithSync,
         batchedUpdates: myreactReconcilerExports.safeCallWithSync,
+        discreteUpdates: discreteUpdates,
+        deferredUpdates: deferredUpdates,
+        flushPassiveEffects: flushPassiveEffects,
+        isAlreadyRendering: isAlreadyRendering,
+        findHostInstance: findHostInstance,
+        findHostInstanceWithWarning: findHostInstanceWithWarning,
+        findHostInstanceWithNoPortals: findHostInstanceWithNoPortals,
+        attemptSynchronousHydration: attemptSynchronousHydration,
+        attemptDiscreteHydration: attemptDiscreteHydration,
+        attemptContinuousHydration: attemptContinuousHydration,
+        attemptHydrationAtCurrentPriority: attemptHydrationAtCurrentPriority,
+        getCurrentUpdatePriority: getCurrentUpdatePriority,
+        runWithPriority: runWithPriority,
+        shouldError: shouldError,
+        shouldSuspend: shouldSuspend,
+        registerMutableSourceForHydration: registerMutableSourceForHydration,
+        createComponentSelector: createComponentSelector,
+        createHasPseudoClassSelector: createHasPseudoClassSelector,
+        createRoleSelector: createRoleSelector,
+        createTextSelector: createTextSelector,
+        createTestNameSelector: createTestNameSelector,
+        getFindAllNodesFailureDescription: getFindAllNodesFailureDescription,
+        findAllNodes: findAllNodes,
+        findBoundingRects: findBoundingRects,
+        focusWithin: focusWithin,
+        observeVisibleRects: observeVisibleRects,
     };
 };
 
-var version = "0.0.15";
+var version = "0.0.16";
 var createReconciler = Reconciler;
+var defaultOnUncaughtError = function (error) {
+    console.error("Uncaught", error);
+};
+var defaultOnCaughtError = function (error) {
+    console.error("Caught", error);
+};
+var defaultOnRecoverableError = function (error) {
+    console.error("Recoverable", error);
+};
+var startHostTransition = function () {
+    // no-op
+};
 
 exports.createReconciler = createReconciler;
 exports.default = createReconciler;
+exports.defaultOnCaughtError = defaultOnCaughtError;
+exports.defaultOnRecoverableError = defaultOnRecoverableError;
+exports.defaultOnUncaughtError = defaultOnUncaughtError;
 exports.enableKnownConfigLog = enableKnownConfigLog;
+exports.startHostTransition = startHostTransition;
 exports.version = version;