@my-react/react-reconciler-compact 0.0.7 → 0.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/dist/cjs/index.development.js +288 -138
  2. package/dist/cjs/index.production.js +263 -113
  3. package/dist/types/dispatch.d.ts +2 -1
  4. package/dist/types/dispatch.d.ts.map +1 -1
  5. package/dist/types/dispatchUpdate.d.ts.map +1 -1
  6. package/dist/types/feature.d.ts +2 -1
  7. package/dist/types/feature.d.ts.map +1 -1
  8. package/dist/types/scheduler.d.ts.map +1 -1
  9. package/package.json +4 -4
package/dist/cjs/index.production.js CHANGED
@@ -913,7 +913,7 @@ function requireIndex_production_1 () {
913
913
  enableSyncFlush$1.current = stack.pop();
914
914
  };
915
915
 
916
- var currentRunningFiber$5 = react.__my_react_internal__.currentRunningFiber, currentScheduler$g = react.__my_react_internal__.currentScheduler, currentScopeFiber$1 = react.__my_react_internal__.currentScopeFiber, currentError$1 = react.__my_react_internal__.currentError, currentCallingFiber$1 = react.__my_react_internal__.currentCallingFiber;
916
+ var currentRunningFiber$5 = react.__my_react_internal__.currentRunningFiber, currentScheduler$h = react.__my_react_internal__.currentScheduler, currentScopeFiber$1 = react.__my_react_internal__.currentScopeFiber, currentError$1 = react.__my_react_internal__.currentError, currentCallingFiber$1 = react.__my_react_internal__.currentCallingFiber;
917
917
  var safeCall = function (action) {
918
918
  var args = [];
919
919
  for (var _i = 1; _i < arguments.length; _i++) {
@@ -924,7 +924,7 @@ function requireIndex_production_1 () {
924
924
  }
925
925
  catch (e) {
926
926
  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;
927
- var renderScheduler = currentScheduler$g.current;
927
+ var renderScheduler = currentScheduler$h.current;
928
928
  currentError$1.current = currentError$1.current || e;
929
929
  renderScheduler.dispatchError({ fiber: fiber, error: currentError$1.current });
930
930
  }
@@ -944,7 +944,7 @@ function requireIndex_production_1 () {
944
944
  return fallback();
945
945
  }
946
946
  else {
947
- var renderScheduler = currentScheduler$g.current;
947
+ var renderScheduler = currentScheduler$h.current;
948
948
  currentError$1.current = currentError$1.current || e;
949
949
  renderScheduler.dispatchError({ fiber: fiber, error: currentError$1.current });
950
950
  }
@@ -978,7 +978,7 @@ function requireIndex_production_1 () {
978
978
  }
979
979
  catch (e) {
980
980
  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;
981
- var renderScheduler = currentScheduler$g.current;
981
+ var renderScheduler = currentScheduler$h.current;
982
982
  currentError$1.current = currentError$1.current || e;
983
983
  renderScheduler.dispatchError({ fiber: fiber, error: currentError$1.current });
984
984
  }
@@ -987,7 +987,7 @@ function requireIndex_production_1 () {
987
987
  }
988
988
  };
989
989
 
990
- var currentScheduler$f = react.__my_react_internal__.currentScheduler, currentRunningFiber$4 = react.__my_react_internal__.currentRunningFiber, currentScopeFiber = react.__my_react_internal__.currentScopeFiber, currentCallingFiber = react.__my_react_internal__.currentCallingFiber;
990
+ var currentScheduler$g = react.__my_react_internal__.currentScheduler, currentRunningFiber$4 = react.__my_react_internal__.currentRunningFiber, currentScopeFiber = react.__my_react_internal__.currentScopeFiber, currentCallingFiber = react.__my_react_internal__.currentCallingFiber;
991
991
  var enableOptimizeTreeLog = react.__my_react_shared__.enableOptimizeTreeLog;
992
992
  var typeColor = {
993
993
  normal: "rgba(10, 190, 235, 0.8)",
@@ -1042,7 +1042,7 @@ function requireIndex_production_1 () {
1042
1042
  for (var _i = 0; _i < arguments.length; _i++) {
1043
1043
  args[_i] = arguments[_i];
1044
1044
  }
1045
- var renderScheduler = currentScheduler$f.current;
1045
+ var renderScheduler = currentScheduler$g.current;
1046
1046
  var startWithPlain = typeof args[0] === "string";
1047
1047
  var renderFiber = warnFiber || (currentCallingFiber === null || currentCallingFiber === void 0 ? void 0 : currentCallingFiber[(currentCallingFiber === null || currentCallingFiber === void 0 ? void 0 : currentCallingFiber.length) - 1]) || currentScopeFiber.current || currentRunningFiber$4.current;
1048
1048
  renderFiber && fiberWarn.apply(void 0, __spreadArray([renderFiber], args, false));
@@ -1079,7 +1079,7 @@ function requireIndex_production_1 () {
1079
1079
  for (var _i = 0; _i < arguments.length; _i++) {
1080
1080
  args[_i] = arguments[_i];
1081
1081
  }
1082
- var renderScheduler = currentScheduler$f.current;
1082
+ var renderScheduler = currentScheduler$g.current;
1083
1083
  var startWithPlain = typeof args[0] === "string";
1084
1084
  var renderFiber = errorFiber || (currentCallingFiber === null || currentCallingFiber === void 0 ? void 0 : currentCallingFiber[(currentCallingFiber === null || currentCallingFiber === void 0 ? void 0 : currentCallingFiber.length) - 1]) || currentScopeFiber.current || currentRunningFiber$4.current;
1085
1085
  renderFiber && fiberError.apply(void 0, __spreadArray([renderFiber], args, false));
@@ -1283,7 +1283,7 @@ function requireIndex_production_1 () {
1283
1283
  for (var _i = 2; _i < arguments.length; _i++) {
1284
1284
  args[_i - 2] = arguments[_i];
1285
1285
  }
1286
- var renderScheduler = currentScheduler$f.current;
1286
+ var renderScheduler = currentScheduler$g.current;
1287
1287
  var tree = renderScheduler.getFiberTree(fiber);
1288
1288
  if ((_b = warnMap === null || warnMap === void 0 ? void 0 : warnMap[tree]) === null || _b === void 0 ? void 0 : _b[key])
1289
1289
  return;
@@ -1299,7 +1299,7 @@ function requireIndex_production_1 () {
1299
1299
  for (var _i = 2; _i < arguments.length; _i++) {
1300
1300
  args[_i - 2] = arguments[_i];
1301
1301
  }
1302
- var renderScheduler = currentScheduler$f.current;
1302
+ var renderScheduler = currentScheduler$g.current;
1303
1303
  var tree = renderScheduler.getFiberTree(fiber);
1304
1304
  if ((_b = errorMap === null || errorMap === void 0 ? void 0 : errorMap[tree]) === null || _b === void 0 ? void 0 : _b[key])
1305
1305
  return;
@@ -1508,7 +1508,7 @@ function requireIndex_production_1 () {
1508
1508
  var initHMR = function (env) {
1509
1509
  };
1510
1510
 
1511
- var currentRunningFiber$3 = react.__my_react_internal__.currentRunningFiber, currentScheduler$e = react.__my_react_internal__.currentScheduler;
1511
+ var currentRunningFiber$3 = react.__my_react_internal__.currentRunningFiber, currentScheduler$f = react.__my_react_internal__.currentScheduler;
1512
1512
  var dispatchHook = function (params) {
1513
1513
  var fiber = currentRunningFiber$3.current;
1514
1514
  if (!fiber) {
@@ -1598,7 +1598,7 @@ function requireIndex_production_1 () {
1598
1598
  }
1599
1599
  };
1600
1600
  var initScheduler = function () {
1601
- var scheduler = currentScheduler$e.current;
1601
+ var scheduler = currentScheduler$f.current;
1602
1602
  scheduler.getFiberTree = getFiberTree;
1603
1603
  scheduler.readPromise = readPromise;
1604
1604
  scheduler.readContext = readContext;
@@ -1709,85 +1709,6 @@ function requireIndex_production_1 () {
1709
1709
  return listTree;
1710
1710
  };
1711
1711
 
1712
- var currentRunningFiber$2 = react.__my_react_internal__.currentRunningFiber;
1713
- var mountToNextFiberFromRoot = function (renderDispatch, fiber) {
1714
- if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__unmount__) || renderDispatch.isAppCrashed)
1715
- return null;
1716
- if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__create__ |
1717
- myreactSharedExports.STATE_TYPE.__inherit__ |
1718
- myreactSharedExports.STATE_TYPE.__triggerSync__ |
1719
- myreactSharedExports.STATE_TYPE.__triggerSyncForce__ |
1720
- myreactSharedExports.STATE_TYPE.__triggerConcurrent__ |
1721
- myreactSharedExports.STATE_TYPE.__triggerConcurrentForce__ |
1722
- myreactSharedExports.STATE_TYPE.__retrigger__ |
1723
- myreactSharedExports.STATE_TYPE.__reschedule__ |
1724
- myreactSharedExports.STATE_TYPE.__recreate__)) {
1725
- fiber.state = myreactSharedExports.remove(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__);
1726
- currentRunningFiber$2.current = fiber;
1727
- {
1728
- runtimeNextWork(renderDispatch, fiber);
1729
- }
1730
- currentRunningFiber$2.current = null;
1731
- }
1732
- if (!myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__)) {
1733
- fiber.state = myreactSharedExports.STATE_TYPE.__stable__;
1734
- }
1735
- else {
1736
- fiber.state = myreactSharedExports.STATE_TYPE.__triggerSync__;
1737
- }
1738
- if (fiber.child)
1739
- return fiber.child;
1740
- var nextFiber = fiber;
1741
- while (nextFiber && nextFiber !== renderDispatch.runtimeFiber.scheduledFiber) {
1742
- renderDispatch.generateCommitList(nextFiber);
1743
- if (nextFiber.sibling)
1744
- return nextFiber.sibling;
1745
- nextFiber = nextFiber.parent;
1746
- }
1747
- if (nextFiber === renderDispatch.runtimeFiber.scheduledFiber)
1748
- renderDispatch.generateCommitList(nextFiber);
1749
- return null;
1750
- };
1751
- var performToNextFiberFromRoot = function (renderDispatch, fiber) {
1752
- if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__unmount__) || renderDispatch.isAppCrashed)
1753
- return null;
1754
- if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__create__ |
1755
- myreactSharedExports.STATE_TYPE.__inherit__ |
1756
- myreactSharedExports.STATE_TYPE.__triggerSync__ |
1757
- myreactSharedExports.STATE_TYPE.__triggerSyncForce__ |
1758
- myreactSharedExports.STATE_TYPE.__triggerConcurrent__ |
1759
- myreactSharedExports.STATE_TYPE.__triggerConcurrentForce__ |
1760
- myreactSharedExports.STATE_TYPE.__retrigger__ |
1761
- myreactSharedExports.STATE_TYPE.__reschedule__ |
1762
- myreactSharedExports.STATE_TYPE.__recreate__)) {
1763
- fiber.state = myreactSharedExports.remove(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__);
1764
- currentRunningFiber$2.current = fiber;
1765
- {
1766
- runtimeNextWork(renderDispatch, fiber);
1767
- }
1768
- currentRunningFiber$2.current = null;
1769
- triggerFiberUpdateListener(renderDispatch, fiber);
1770
- }
1771
- if (!myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__)) {
1772
- fiber.state = myreactSharedExports.STATE_TYPE.__stable__;
1773
- }
1774
- else {
1775
- fiber.state = myreactSharedExports.STATE_TYPE.__triggerSync__;
1776
- }
1777
- if (fiber.child)
1778
- return fiber.child;
1779
- var nextFiber = fiber;
1780
- while (nextFiber && nextFiber !== renderDispatch.runtimeFiber.scheduledFiber) {
1781
- renderDispatch.generateCommitList(nextFiber);
1782
- if (nextFiber.sibling)
1783
- return nextFiber.sibling;
1784
- nextFiber = nextFiber.parent;
1785
- }
1786
- if (nextFiber === renderDispatch.runtimeFiber.scheduledFiber)
1787
- renderDispatch.generateCommitList(nextFiber);
1788
- return null;
1789
- };
1790
-
1791
1712
  var defaultGenerateEffectMap = function (fiber, effect, map, option) {
1792
1713
  var list = map.get(fiber);
1793
1714
  if (!list) {
@@ -1934,8 +1855,87 @@ function requireIndex_production_1 () {
1934
1855
  }
1935
1856
  };
1936
1857
 
1937
- var enableSuspenseRoot$2 = react.__my_react_shared__.enableSuspenseRoot;
1938
- var currentScheduler$d = react.__my_react_internal__.currentScheduler;
1858
+ var currentRunningFiber$2 = react.__my_react_internal__.currentRunningFiber;
1859
+ var mountToNextFiberFromRoot = function (renderDispatch, fiber) {
1860
+ if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__unmount__) || renderDispatch.isAppCrashed)
1861
+ return null;
1862
+ if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__create__ |
1863
+ myreactSharedExports.STATE_TYPE.__inherit__ |
1864
+ myreactSharedExports.STATE_TYPE.__triggerSync__ |
1865
+ myreactSharedExports.STATE_TYPE.__triggerSyncForce__ |
1866
+ myreactSharedExports.STATE_TYPE.__triggerConcurrent__ |
1867
+ myreactSharedExports.STATE_TYPE.__triggerConcurrentForce__ |
1868
+ myreactSharedExports.STATE_TYPE.__retrigger__ |
1869
+ myreactSharedExports.STATE_TYPE.__reschedule__ |
1870
+ myreactSharedExports.STATE_TYPE.__recreate__)) {
1871
+ fiber.state = myreactSharedExports.remove(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__);
1872
+ currentRunningFiber$2.current = fiber;
1873
+ {
1874
+ runtimeNextWork(renderDispatch, fiber);
1875
+ }
1876
+ currentRunningFiber$2.current = null;
1877
+ }
1878
+ if (!myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__)) {
1879
+ fiber.state = myreactSharedExports.STATE_TYPE.__stable__;
1880
+ }
1881
+ else {
1882
+ fiber.state = myreactSharedExports.STATE_TYPE.__triggerSync__;
1883
+ }
1884
+ if (fiber.child)
1885
+ return fiber.child;
1886
+ var nextFiber = fiber;
1887
+ while (nextFiber && nextFiber !== renderDispatch.runtimeFiber.scheduledFiber) {
1888
+ renderDispatch.generateCommitList(nextFiber);
1889
+ if (nextFiber.sibling)
1890
+ return nextFiber.sibling;
1891
+ nextFiber = nextFiber.parent;
1892
+ }
1893
+ if (nextFiber === renderDispatch.runtimeFiber.scheduledFiber)
1894
+ renderDispatch.generateCommitList(nextFiber);
1895
+ return null;
1896
+ };
1897
+ var performToNextFiberFromRoot = function (renderDispatch, fiber) {
1898
+ if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__unmount__) || renderDispatch.isAppCrashed)
1899
+ return null;
1900
+ if (myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__create__ |
1901
+ myreactSharedExports.STATE_TYPE.__inherit__ |
1902
+ myreactSharedExports.STATE_TYPE.__triggerSync__ |
1903
+ myreactSharedExports.STATE_TYPE.__triggerSyncForce__ |
1904
+ myreactSharedExports.STATE_TYPE.__triggerConcurrent__ |
1905
+ myreactSharedExports.STATE_TYPE.__triggerConcurrentForce__ |
1906
+ myreactSharedExports.STATE_TYPE.__retrigger__ |
1907
+ myreactSharedExports.STATE_TYPE.__reschedule__ |
1908
+ myreactSharedExports.STATE_TYPE.__recreate__)) {
1909
+ fiber.state = myreactSharedExports.remove(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__);
1910
+ currentRunningFiber$2.current = fiber;
1911
+ {
1912
+ runtimeNextWork(renderDispatch, fiber);
1913
+ }
1914
+ currentRunningFiber$2.current = null;
1915
+ triggerFiberUpdateListener(renderDispatch, fiber);
1916
+ }
1917
+ if (!myreactSharedExports.include(fiber.state, myreactSharedExports.STATE_TYPE.__retrigger__)) {
1918
+ fiber.state = myreactSharedExports.STATE_TYPE.__stable__;
1919
+ }
1920
+ else {
1921
+ fiber.state = myreactSharedExports.STATE_TYPE.__triggerSync__;
1922
+ }
1923
+ if (fiber.child)
1924
+ return fiber.child;
1925
+ var nextFiber = fiber;
1926
+ while (nextFiber && nextFiber !== renderDispatch.runtimeFiber.scheduledFiber) {
1927
+ renderDispatch.generateCommitList(nextFiber);
1928
+ if (nextFiber.sibling)
1929
+ return nextFiber.sibling;
1930
+ nextFiber = nextFiber.parent;
1931
+ }
1932
+ if (nextFiber === renderDispatch.runtimeFiber.scheduledFiber)
1933
+ renderDispatch.generateCommitList(nextFiber);
1934
+ return null;
1935
+ };
1936
+
1937
+ var enableSuspenseRoot$3 = react.__my_react_shared__.enableSuspenseRoot;
1938
+ var currentScheduler$e = react.__my_react_internal__.currentScheduler;
1939
1939
  var mountLoopAllFromScheduler = function (renderDispatch) {
1940
1940
  while (renderDispatch.runtimeFiber.nextWorkingFiber) {
1941
1941
  renderDispatch.runtimeFiber.retriggerFiber = null;
@@ -2006,7 +2006,7 @@ function requireIndex_production_1 () {
2006
2006
  _a.sent();
2007
2007
  return [3 /*break*/, 1];
2008
2008
  case 3:
2009
- if (!enableSuspenseRoot$2.current) return [3 /*break*/, 5];
2009
+ if (!enableSuspenseRoot$3.current) return [3 /*break*/, 5];
2010
2010
  suspenseField_1 = getInstanceFieldByInstance(renderDispatch);
2011
2011
  list = suspenseField_1.asyncLoadList.getAll();
2012
2012
  if (list.length === 0)
@@ -2087,7 +2087,7 @@ function requireIndex_production_1 () {
2087
2087
  }); })).then(function () {
2088
2088
  var aliveNode = defaultResolveAliveSuspenseFiber(node) || renderDispatch.rootFiber;
2089
2089
  aliveNode.state = myreactSharedExports.STATE_TYPE.__triggerSyncForce__;
2090
- var renderScheduler = currentScheduler$d.current;
2090
+ var renderScheduler = currentScheduler$e.current;
2091
2091
  var updater = {
2092
2092
  type: myreactSharedExports.UpdateQueueType.suspense,
2093
2093
  trigger: aliveNode,
@@ -2115,7 +2115,7 @@ function requireIndex_production_1 () {
2115
2115
  }
2116
2116
  }
2117
2117
  // TODO update flow
2118
- if (enableSuspenseRoot$2.current) {
2118
+ if (enableSuspenseRoot$3.current) {
2119
2119
  var suspenseField_2 = getInstanceFieldByInstance(renderDispatch);
2120
2120
  var list = suspenseField_2.asyncLoadList.getAll();
2121
2121
  if (list.length === 0)
@@ -2153,7 +2153,7 @@ function requireIndex_production_1 () {
2153
2153
  (_a = item._list) === null || _a === void 0 ? void 0 : _a.clear();
2154
2154
  allFiber.forEach(function (node) {
2155
2155
  node.state = myreactSharedExports.STATE_TYPE.__recreate__;
2156
- var renderScheduler = currentScheduler$d.current;
2156
+ var renderScheduler = currentScheduler$e.current;
2157
2157
  var updater = {
2158
2158
  type: myreactSharedExports.UpdateQueueType.suspense,
2159
2159
  trigger: node,
@@ -2183,6 +2183,8 @@ function requireIndex_production_1 () {
2183
2183
  }
2184
2184
  };
2185
2185
 
2186
+ var enableSuspenseRoot$2 = react.__my_react_shared__.enableSuspenseRoot;
2187
+ var currentScheduler$d = react.__my_react_internal__.currentScheduler;
2186
2188
  exports.updateTypeEnum = void 0;
2187
2189
  (function (updateTypeEnum) {
2188
2190
  updateTypeEnum[updateTypeEnum["syncFromRoot"] = 0] = "syncFromRoot";
@@ -2229,7 +2231,143 @@ function requireIndex_production_1 () {
2229
2231
  }
2230
2232
  return hasSync;
2231
2233
  };
2232
- var processAsyncLoadListOnUpdate = processAsyncLoadListOnSyncMount;
2234
+ var processAsyncLoadListOnUpdate = function (renderDispatch) {
2235
+ var _a;
2236
+ if ((_a = renderDispatch.pendingSuspenseFiberArray) === null || _a === void 0 ? void 0 : _a.length) {
2237
+ var allPendingSuspenseFiberArray = renderDispatch.pendingSuspenseFiberArray.getAll();
2238
+ if (renderDispatch.enableAsyncLoad) {
2239
+ var allField_1 = [];
2240
+ allPendingSuspenseFiberArray.forEach(function (node) {
2241
+ defaultDeleteChildEffect(renderDispatch, node);
2242
+ var field = getInstanceFieldByInstance(node.instance);
2243
+ var allPendingLoadArray = field.asyncLoadList.getAll().filter(function (item) {
2244
+ if (myreactSharedExports.isPromise(item)) {
2245
+ return typeof item.status !== "string";
2246
+ }
2247
+ else {
2248
+ return !item._loading && !item._loaded && !item._error;
2249
+ }
2250
+ });
2251
+ if (allPendingLoadArray.length) {
2252
+ Promise.all(allPendingLoadArray.map(function (item) { return __awaiter(void 0, void 0, void 0, function () {
2253
+ var _a;
2254
+ return __generator(this, function (_b) {
2255
+ switch (_b.label) {
2256
+ case 0:
2257
+ if (!myreactSharedExports.isPromise(item)) return [3 /*break*/, 2];
2258
+ return [4 /*yield*/, renderDispatch.processPromise(item)];
2259
+ case 1:
2260
+ _b.sent();
2261
+ return [3 /*break*/, 4];
2262
+ case 2: return [4 /*yield*/, renderDispatch.processLazy(item)];
2263
+ case 3:
2264
+ _b.sent();
2265
+ _b.label = 4;
2266
+ case 4:
2267
+ (_a = item._list) === null || _a === void 0 ? void 0 : _a.clear();
2268
+ field.asyncLoadList.uniDelete(item);
2269
+ return [2 /*return*/];
2270
+ }
2271
+ });
2272
+ }); })).then(function () {
2273
+ var aliveNode = defaultResolveAliveSuspenseFiber(node) || renderDispatch.rootFiber;
2274
+ aliveNode.state = myreactSharedExports.STATE_TYPE.__triggerSyncForce__;
2275
+ var renderScheduler = currentScheduler$d.current;
2276
+ var updater = {
2277
+ type: myreactSharedExports.UpdateQueueType.suspense,
2278
+ trigger: aliveNode,
2279
+ isSync: true,
2280
+ isForce: true,
2281
+ payLoad: allPendingLoadArray,
2282
+ };
2283
+ renderScheduler.dispatchState(updater);
2284
+ });
2285
+ }
2286
+ // fix hmr
2287
+ node.state = myreactSharedExports.STATE_TYPE.__reschedule__;
2288
+ field.isHidden = true;
2289
+ allField_1.push(field);
2290
+ });
2291
+ var root = renderDispatch.rootFiber;
2292
+ root.state = myreactSharedExports.remove(root.state, myreactSharedExports.STATE_TYPE.__stable__);
2293
+ root.state = myreactSharedExports.merge(root.state, myreactSharedExports.STATE_TYPE.__retrigger__);
2294
+ // TODO use hide tree to improve
2295
+ mountLoopAll(renderDispatch, root);
2296
+ allField_1.forEach(function (field) { return (field.isHidden = false); });
2297
+ renderDispatch.pendingSuspenseFiberArray.clear();
2298
+ }
2299
+ else {
2300
+ throw new Error("[@my-react/reconciler] should not process async load list on sync mount without enableAsyncLoad, you may use a wrong renderDispatch instance");
2301
+ }
2302
+ }
2303
+ // TODO update flow
2304
+ if (enableSuspenseRoot$2.current) {
2305
+ var suspenseField_1 = getInstanceFieldByInstance(renderDispatch);
2306
+ var list = suspenseField_1.asyncLoadList.getAll();
2307
+ if (list.length === 0)
2308
+ return;
2309
+ if (renderDispatch.enableAsyncLoad) {
2310
+ // defaultDeleteCurrentEffect(renderDispatch, renderDispatch.rootFiber);
2311
+ // defaultDeleteChildEffect(renderDispatch, renderDispatch.rootFiber);
2312
+ var allPendingLoadArray = list.filter(function (item) {
2313
+ if (myreactSharedExports.isPromise(item)) {
2314
+ return typeof item.status !== "string";
2315
+ }
2316
+ else {
2317
+ return !item._loading && !item._loaded && !item._error;
2318
+ }
2319
+ });
2320
+ if (allPendingLoadArray.length) {
2321
+ allPendingLoadArray.forEach(function (item) { var _a; return (_a = item._list) === null || _a === void 0 ? void 0 : _a.forEach(function (node) { return defaultDeleteCurrentEffect(renderDispatch, node); }); });
2322
+ Promise.all(allPendingLoadArray.map(function (item) { return __awaiter(void 0, void 0, void 0, function () {
2323
+ var allFiber;
2324
+ var _a;
2325
+ return __generator(this, function (_b) {
2326
+ switch (_b.label) {
2327
+ case 0:
2328
+ if (!myreactSharedExports.isPromise(item)) return [3 /*break*/, 2];
2329
+ return [4 /*yield*/, renderDispatch.processPromise(item)];
2330
+ case 1:
2331
+ _b.sent();
2332
+ return [3 /*break*/, 4];
2333
+ case 2: return [4 /*yield*/, renderDispatch.processLazy(item)];
2334
+ case 3:
2335
+ _b.sent();
2336
+ _b.label = 4;
2337
+ case 4:
2338
+ allFiber = new Set(item._list);
2339
+ (_a = item._list) === null || _a === void 0 ? void 0 : _a.clear();
2340
+ allFiber.forEach(function (node) {
2341
+ node.state = myreactSharedExports.STATE_TYPE.__recreate__;
2342
+ var renderScheduler = currentScheduler$d.current;
2343
+ var updater = {
2344
+ type: myreactSharedExports.UpdateQueueType.suspense,
2345
+ trigger: node,
2346
+ isSync: true,
2347
+ isForce: true,
2348
+ payLoad: [item],
2349
+ };
2350
+ renderScheduler.dispatchState(updater);
2351
+ });
2352
+ suspenseField_1.asyncLoadList.uniDelete(item);
2353
+ return [2 /*return*/];
2354
+ }
2355
+ });
2356
+ }); }));
2357
+ }
2358
+ // suspenseField.isHidden = true;
2359
+ // const root = renderDispatch.rootFiber;
2360
+ // root.state = remove(root.state, STATE_TYPE.__stable__);
2361
+ // root.state = merge(root.state, STATE_TYPE.__retrigger__);
2362
+ // // TODO use hide tree to improve
2363
+ // mountLoopAll(renderDispatch, root);
2364
+ // suspenseField.isHidden = false;
2365
+ }
2366
+ else {
2367
+ throw new Error("[@my-react/reconciler] should not process async load list on sync mount without enableAsyncLoad, you may use a wrong renderDispatch instance");
2368
+ }
2369
+ }
2370
+ };
2233
2371
 
2234
2372
  var isErrorBoundariesInstance = function (instance, Component) {
2235
2373
  return typeof instance.componentDidCatch === "function" || typeof Component.getDerivedStateFromError === "function";
@@ -3440,7 +3578,6 @@ function requireIndex_production_1 () {
3440
3578
  };
3441
3579
 
3442
3580
  var globalLoop$2 = react.__my_react_internal__.globalLoop, currentScheduler$a = react.__my_react_internal__.currentScheduler;
3443
- var enableConcurrentMode$1 = react.__my_react_shared__.enableConcurrentMode;
3444
3581
  var scheduleUpdateFromRoot = function (renderDispatch) {
3445
3582
  var allLive = renderDispatch.pendingUpdateFiberArray.getAll().filter(function (f) { return myreactSharedExports.exclude(f.state, myreactSharedExports.STATE_TYPE.__unmount__); });
3446
3583
  renderDispatch.pendingUpdateFiberArray.clear();
@@ -3448,7 +3585,7 @@ function requireIndex_production_1 () {
3448
3585
  renderDispatch.runtimeFiber.scheduledFiber = renderDispatch.rootFiber;
3449
3586
  renderDispatch.runtimeFiber.nextWorkingFiber = renderDispatch.rootFiber;
3450
3587
  allLive.forEach(function (fiber) { return applyTriggerFiberCb(renderDispatch, fiber); });
3451
- if (!enableConcurrentMode$1.current || allLive.some(function (f) { return myreactSharedExports.include(f.state, myreactSharedExports.STATE_TYPE.__triggerSync__ | myreactSharedExports.STATE_TYPE.__triggerSyncForce__); })) {
3588
+ if (!renderDispatch.enableConcurrentMode || allLive.some(function (f) { return myreactSharedExports.include(f.state, myreactSharedExports.STATE_TYPE.__triggerSync__ | myreactSharedExports.STATE_TYPE.__triggerSyncForce__); })) {
3452
3589
  updateSyncFromRoot(renderDispatch);
3453
3590
  }
3454
3591
  else {
@@ -4147,11 +4284,10 @@ function requireIndex_production_1 () {
4147
4284
  fiber.constructor.prototype.isMyReactFiberNode);
4148
4285
  };
4149
4286
 
4150
- var enableConcurrentMode = react.__my_react_shared__.enableConcurrentMode;
4151
4287
  var currentScheduler$5 = react.__my_react_internal__.currentScheduler;
4152
4288
  var processUpdateOnFiber = function (renderDispatch, fiber, _isImmediate, _isRetrigger) {
4153
4289
  var renderScheduler = currentScheduler$5.current;
4154
- var flag = enableConcurrentMode.current;
4290
+ var flag = renderDispatch.enableConcurrentMode;
4155
4291
  var updateState = null;
4156
4292
  if (myreactSharedExports.include(fiber.type, exports.NODE_TYPE.__class__)) {
4157
4293
  updateState = flag ? processClassComponentUpdateQueueLatest(renderDispatch, fiber, flag) : processClassComponentUpdateQueueLegacy(renderDispatch, fiber);
@@ -5871,7 +6007,7 @@ function requireIndex_production_1 () {
5871
6007
  _this.isAppMounted = false;
5872
6008
  _this.isAppCrashed = false;
5873
6009
  _this.isAppUnmounted = false;
5874
- _this.version = "0.3.16";
6010
+ _this.version = "0.3.17";
5875
6011
  _this.mode = "production";
5876
6012
  _this.renderMode = "render";
5877
6013
  _this.pendingCommitFiberList = null;
@@ -6283,7 +6419,7 @@ function requireIndex_production_1 () {
6283
6419
  });
6284
6420
  }); };
6285
6421
 
6286
- var version = "0.3.16";
6422
+ var version = "0.3.17";
6287
6423
 
6288
6424
  exports.CustomRenderDispatch = CustomRenderDispatch;
6289
6425
  exports.MyReactFiberNode = MyReactFiberNode;
@@ -7717,7 +7853,7 @@ var ReconcilerDispatchUpdate = function (_dispatch, _list, config) {
7717
7853
  }
7718
7854
  });
7719
7855
  myreactReconcilerExports.afterSyncUpdate();
7720
- var pendingCreateFiberArray = [];
7856
+ var pendingFinalizeInitialChildrenFiberSet = new Set();
7721
7857
  var pendingCommitFiberArray = [];
7722
7858
  _list.listToFoot(function invokeCreateAndUpdateList(_fiber) {
7723
7859
  if (myreactSharedExports.exclude(_fiber.state, myreactSharedExports.STATE_TYPE.__unmount__) && !_dispatch.isAppUnmounted) {
@@ -7731,7 +7867,7 @@ var ReconcilerDispatchUpdate = function (_dispatch, _list, config) {
7731
7867
  });
7732
7868
  var afterHasNode = _fiber.nativeNode;
7733
7869
  if (!beforeHasNode && afterHasNode) {
7734
- pendingCreateFiberArray.push(_fiber);
7870
+ pendingFinalizeInitialChildrenFiberSet.add(_fiber);
7735
7871
  }
7736
7872
  }
7737
7873
  });
@@ -7741,6 +7877,8 @@ var ReconcilerDispatchUpdate = function (_dispatch, _list, config) {
7741
7877
  fiber: _fiber,
7742
7878
  action: function safeCallPosition() {
7743
7879
  _dispatch.commitPosition(_fiber);
7880
+ var parentFiber = getValidParentFiberWithNode(_dispatch, _fiber);
7881
+ parentFiber && pendingFinalizeInitialChildrenFiberSet.add(parentFiber);
7744
7882
  },
7745
7883
  });
7746
7884
  }
@@ -7751,6 +7889,8 @@ var ReconcilerDispatchUpdate = function (_dispatch, _list, config) {
7751
7889
  fiber: _fiber,
7752
7890
  action: function safeCallAppendList() {
7753
7891
  _dispatch.commitAppend(_fiber);
7892
+ var parentFiber = getValidParentFiberWithNode(_dispatch, _fiber);
7893
+ parentFiber && pendingFinalizeInitialChildrenFiberSet.add(parentFiber);
7754
7894
  },
7755
7895
  });
7756
7896
  }
@@ -7765,7 +7905,7 @@ var ReconcilerDispatchUpdate = function (_dispatch, _list, config) {
7765
7905
  });
7766
7906
  }
7767
7907
  });
7768
- pendingCreateFiberArray.forEach(function invokeFinalizeInitialChildren(_fiber) {
7908
+ pendingFinalizeInitialChildrenFiberSet.forEach(function invokeFinalizeInitialChildren(_fiber) {
7769
7909
  if (_fiber.nativeNode) {
7770
7910
  var node = config.getPublicInstance(_fiber.nativeNode);
7771
7911
  var type = _fiber.elementType;
@@ -7810,7 +7950,7 @@ var initialRef = {
7810
7950
  typeForAppend: myreactReconcilerExports.NODE_TYPE.__text__ | myreactReconcilerExports.NODE_TYPE.__plain__,
7811
7951
  typeForNativeNode: myreactReconcilerExports.NODE_TYPE.__text__ | myreactReconcilerExports.NODE_TYPE.__plain__ | myreactReconcilerExports.NODE_TYPE.__portal__,
7812
7952
  };
7813
- var createDispatch = function (rootNode, rootFiber, rootElement, config) {
7953
+ var createDispatch = function (rootNode, rootFiber, rootElement, config, flag) {
7814
7954
  var ReconcilerDispatch = /** @class */ (function (_super) {
7815
7955
  __extends(ReconcilerDispatch, _super);
7816
7956
  function ReconcilerDispatch() {
@@ -7911,7 +8051,10 @@ var createDispatch = function (rootNode, rootFiber, rootElement, config) {
7911
8051
  };
7912
8052
  return ReconcilerDispatch;
7913
8053
  }(myreactReconcilerExports.CustomRenderDispatch));
7914
- return new ReconcilerDispatch(rootNode, rootFiber, rootElement);
8054
+ var dispatch = new ReconcilerDispatch(rootNode, rootFiber, rootElement);
8055
+ dispatch.enableConcurrentMode = flag !== 0;
8056
+ dispatch.renderMode = flag !== 0 ? "concurrent" : "legacy";
8057
+ return dispatch;
7915
8058
  };
7916
8059
 
7917
8060
  /* eslint-disable @typescript-eslint/no-require-imports */
@@ -7973,12 +8116,11 @@ var loadScript = function (url) {
7973
8116
  }
7974
8117
  };
7975
8118
 
7976
- var enableDebugFiled$1 = require$$0.__my_react_shared__.enableDebugFiled, enableScopeTreeLog$1 = require$$0.__my_react_shared__.enableScopeTreeLog /* enableConcurrentMode */;
8119
+ var enableDebugFiled$1 = require$$0.__my_react_shared__.enableDebugFiled, enableScopeTreeLog$1 = require$$0.__my_react_shared__.enableScopeTreeLog;
7977
8120
  /**
7978
8121
  * @internal
7979
8122
  */
7980
8123
  var prepareScheduler = function () {
7981
- // enableConcurrentMode.current = false;
7982
8124
  enableDebugFiled$1.current = true;
7983
8125
  enableScopeTreeLog$1.current = true;
7984
8126
  myreactReconcilerExports.enableFiberForLog.current = true;
@@ -7992,8 +8134,16 @@ var currentScheduler = require$$0.__my_react_internal__.currentScheduler;
7992
8134
  var Reconciler = function (_config) {
7993
8135
  var rendererPackageName = "@my-react";
7994
8136
  var ReconcilerSet = new Set();
7995
- var createContainer = function (_container) {
8137
+ var createContainer = function (_container, flag) {
7996
8138
  prepareScheduler();
8139
+ if (flag === 0) {
8140
+ // legacy mode
8141
+ _container.__flag__ = 0;
8142
+ }
8143
+ else {
8144
+ // concurrent mode
8145
+ _container.__flag__ = 1;
8146
+ }
7997
8147
  enableDebugFiled.current = false;
7998
8148
  enableScopeTreeLog.current = false;
7999
8149
  // enableFiberForLog.current = false;
@@ -8022,7 +8172,7 @@ var Reconciler = function (_config) {
8022
8172
  delGlobalDispatch(renderDispatch);
8023
8173
  }
8024
8174
  var _fiber = new myreactReconcilerExports.MyReactFiberNode(_element);
8025
- var _renderDispatch = createDispatch(_container, _fiber, _element, _config);
8175
+ var _renderDispatch = createDispatch(_container, _fiber, _element, _config, _container.__flag__);
8026
8176
  _cb && _renderDispatch.pendingEffect(_fiber, _cb);
8027
8177
  ReconcilerSet.add(_renderDispatch);
8028
8178
  renderScheduler.dispatchSet.uniPush(_renderDispatch);
@@ -8089,7 +8239,7 @@ var Reconciler = function (_config) {
8089
8239
  };
8090
8240
  };
8091
8241
 
8092
- var version = "0.0.7";
8242
+ var version = "0.0.8";
8093
8243
  var createReconciler = Reconciler;
8094
8244
 
8095
8245
  exports.createReconciler = createReconciler;
package/dist/types/dispatch.d.ts CHANGED
@@ -2,7 +2,7 @@ import { CustomRenderDispatch, NODE_TYPE } from "@my-react/react-reconciler";
2
2
  import type { MyReactElementNode, RenderHookParams, UpdateQueue } from "@my-react/react";
3
3
  import type { MyReactFiberRoot, MyReactFiberNode } from "@my-react/react-reconciler";
4
4
  import type { ListTree } from "@my-react/react-shared";
5
- export declare const createDispatch: (rootNode: any, rootFiber: MyReactFiberRoot, rootElement: MyReactElementNode, config: any) => {
5
+ export declare const createDispatch: (rootNode: any, rootFiber: MyReactFiberRoot, rootElement: MyReactElementNode, config: any, flag: number) => {
6
6
  enableUpdate: boolean;
7
7
  enableAsyncLoad: boolean;
8
8
  runtimeDom: {
@@ -40,6 +40,7 @@ export declare const createDispatch: (rootNode: any, rootFiber: MyReactFiberRoot
40
40
  version: string;
41
41
  mode: string;
42
42
  enableNewEntry: boolean;
43
+ enableConcurrentMode: boolean;
43
44
  renderMode: string;
44
45
  renderPackage?: string;
45
46
  pendingCommitFiberList: ListTree<MyReactFiberNode>;
package/dist/types/dispatch.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/dispatch.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,oBAAoB,EACpB,SAAS,EAcV,MAAM,4BAA4B,CAAC;AAQpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAO,MAAM,4BAA4B,CAAC;AAC1F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAgBvD,eAAO,MAAM,cAAc,aAAc,GAAG,aAAa,gBAAgB,eAAe,kBAAkB,UAAU,GAAG;;;;;;;;0BAa7F,gBAAgB,GAAG,IAAI;yBAIxB,gBAAgB,GAAG,IAAI;yBAIvB,gBAAgB,GAAG,IAAI;yBAIvB,gBAAgB,GAAG,IAAI;2BAIrB,gBAAgB,GAAG,IAAI;yBAIzB,gBAAgB,GAAG,IAAI;2BAIrB,gBAAgB,GAAG,IAAI;wBAI1B,gBAAgB,GAAG,IAAI;4BAInB,gBAAgB,GAAG,IAAI;2BA0BxB,SAAS,gBAAgB,CAAC,GAAG,IAAI;gCA0B5B,gBAAgB,GAAG,IAAI;gCAIvB,gBAAgB,GAAG,IAAI;2BAI5B,WAAW,GAAG,IAAI;0BAInB,gBAAgB,GAAG,OAAO;6BAIvB;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,OAAO,CAAC,EAAE,QAAQ,OAAO,CAAC,CAAA;KAAE,GAAG,kBAAkB;2BAI/E;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC1F,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}
1
+ {"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/dispatch.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,oBAAoB,EACpB,SAAS,EAcV,MAAM,4BAA4B,CAAC;AAQpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAO,MAAM,4BAA4B,CAAC;AAC1F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAgBvD,eAAO,MAAM,cAAc,aAAc,GAAG,aAAa,gBAAgB,eAAe,kBAAkB,UAAU,GAAG,QAAQ,MAAM;;;;;;;;0BAa3G,gBAAgB,GAAG,IAAI;yBAIxB,gBAAgB,GAAG,IAAI;yBAIvB,gBAAgB,GAAG,IAAI;yBAIvB,gBAAgB,GAAG,IAAI;2BAIrB,gBAAgB,GAAG,IAAI;yBAIzB,gBAAgB,GAAG,IAAI;2BAIrB,gBAAgB,GAAG,IAAI;wBAI1B,gBAAgB,GAAG,IAAI;4BAInB,gBAAgB,GAAG,IAAI;2BA0BxB,SAAS,gBAAgB,CAAC,GAAG,IAAI;gCA0B5B,gBAAgB,GAAG,IAAI;gCAIvB,gBAAgB,GAAG,IAAI;2BAI5B,WAAW,GAAG,IAAI;0BAInB,gBAAgB,GAAG,OAAO;6BAIvB;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,OAAO,CAAC,EAAE,QAAQ,OAAO,CAAC,CAAA;KAAE,GAAG,kBAAkB;2BAI/E;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC1F,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}
package/dist/types/dispatchUpdate.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"dispatchUpdate.d.ts","sourceRoot":"","sources":["../../src/dispatchUpdate.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAMvD,eAAO,MAAM,wBAAwB,cAAe,kBAAkB,SAAS,SAAS,gBAAgB,CAAC,UAAU,GAAG,SA6HrH,CAAC"}
1
+ {"version":3,"file":"dispatchUpdate.d.ts","sourceRoot":"","sources":["../../src/dispatchUpdate.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAMvD,eAAO,MAAM,wBAAwB,cAAe,kBAAkB,SAAS,SAAS,gBAAgB,CAAC,UAAU,GAAG,SAqIrH,CAAC"}