@plasmicapp/react-web 1.0.38 → 1.0.39

package/dist/react-web.esm.js

@@ -2257,7 +2257,6 @@ function ensureStateCell(target, property, path, node) {
     var stateCell = proxyObjToStateCell.get(target);
     if (!(property in stateCell)) {
         stateCell[property] = {
-            listeners: [],
             initialValue: UNINITIALIZED,
             path: path,
             node: node,
@@ -2315,7 +2314,6 @@ function subscribeToValtio($$state, statePath, node) {
 function initializeStateValue($$state, initialStateCell, proxyRoot) {
     var _a;
     var initialStateName = initialStateCell.node.getSpec().path;
-    var stateAccess = new Set();
     $$state.stateInitializationEnv.visited.add(initialStateName);
     $$state.stateInitializationEnv.stack.push(initialStateName);
     var $state = create$StateProxy($$state, function (internalStateCell) { return ({
@@ -2337,7 +2335,6 @@ function initializeStateValue($$state, initialStateCell, proxyRoot) {
                 throw new UnknownError("Internal error: cycle not found");
             }
             var stateCell = getStateCellFrom$StateRoot(proxyRoot, internalStateCell.path);
-            stateAccess.add({ stateCell: stateCell });
             if (spec.valueProp) {
                 return $$state.env.$props[spec.valueProp];
             }
@@ -2350,14 +2347,6 @@ function initializeStateValue($$state, initialStateCell, proxyRoot) {
             throw new InvalidOperation("Cannot update state values during initialization");
         },
     }); });
-    stateAccess.forEach(function (_a) {
-        var stateCell = _a.stateCell;
-        stateCell.listeners.push(function () {
-            var _a;
-            var newValue = invokeInitFunc(initialStateCell.node.getSpec().initFunc, __assign({ $state: $state }, ((_a = initialStateCell.overrideEnv) !== null && _a !== void 0 ? _a : $$state.env)));
-            set(proxyRoot, initialStateCell.path, newValue);
-        });
-    });
     var initialValue = invokeInitFunc(initialStateCell.initFunc, __assign({ $state: $state }, ((_a = initialStateCell.overrideEnv) !== null && _a !== void 0 ? _a : $$state.env)));
     var initialSpec = initialStateCell.node.getSpec();
     // Try to clone initialValue. It can fail if it's a PlasmicUndefinedDataProxy
@@ -2542,6 +2531,83 @@ function extractDollarStateParametersBackwardCompatible() {
 function invokeInitFunc(initFunc, env) {
     return initFunc(env);
 }
+function initFuncEnv($$state, stateCell, $state) {
+    var _a;
+    return __assign({ $state: $state }, ((_a = stateCell.overrideEnv) !== null && _a !== void 0 ? _a : $$state.env));
+}
+// Pure check with no effect on the reset budget; the layout scan decides.
+function initValueChanged($$state, stateCell, $state) {
+    try {
+        return !deepEqual(invokeInitFunc(stateCell.initFunc, initFuncEnv($$state, stateCell, $state)), stateCell.initialValue);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+// Bound consecutive resets without a settled evaluation, even on slow renders.
+var MAX_UNSETTLED_RESETS = 5;
+function warnUnstableInitFunc(stateCell, reason) {
+    if (stateCell.warnedUnstableInitFunc) {
+        return;
+    }
+    stateCell.warnedUnstableInitFunc = true;
+    console.warn("Plasmic: the initial value of state \"".concat(stateCell.path.join("."), "\" ").concat(reason, ", so it is kept at its current value instead of being reset. To set a random or time-based value, run an interaction from a Side Effect component instead."));
+}
+/**
+ * Whether `stateCell` should be reset to what `initFunc` now returns. An
+ * initFunc that returns a new value every time it runs would reset on every
+ * render, and each reset renders again, so the loop never ends. We refuse to
+ * reset in two cases:
+ *
+ * - Two back-to-back calls disagree, indicating an unstable initializer.
+ * - Too many resets occur without a settled evaluation. This also catches
+ *   values that are stable within a render but drift between renders.
+ *
+ * This is a circuit breaker, not a proof of determinism: legitimate feedback
+ * chains can also exceed the budget, and unstable functions can return equal
+ * values by chance. Initializers must be pure and deterministic for fixed inputs.
+ *
+ * Rejected probes never change the installed initial value used by preview
+ * reset. A rejected value that repeats on a later render can reopen the budget.
+ */
+function shouldReInitialize(stateCell, initFunc, env) {
+    var _a;
+    var newInit;
+    var repeats;
+    try {
+        newInit = invokeInitFunc(initFunc, env);
+        if (deepEqual(newInit, stateCell.initialValue)) {
+            stateCell.unsettledResetCount = undefined;
+            stateCell.rejectedInitProbe = undefined;
+            return false;
+        }
+        repeats = deepEqual(invokeInitFunc(initFunc, env), newInit);
+    }
+    catch (_b) {
+        // initFunc can throw, e.g. if it tries to access loading $queries. Swallow here
+        // since we only care whether the init value changed, not error handling.
+        return false;
+    }
+    var reason;
+    if (!repeats) {
+        reason = "is not deterministic";
+    }
+    else {
+        var rejectedInitProbe = stateCell.rejectedInitProbe;
+        var reopened = rejectedInitProbe && deepEqual(newInit, rejectedInitProbe.value);
+        stateCell.unsettledResetCount = reopened
+            ? 1
+            : ((_a = stateCell.unsettledResetCount) !== null && _a !== void 0 ? _a : 0) + 1;
+        if (stateCell.unsettledResetCount > MAX_UNSETTLED_RESETS) {
+            reason = "keeps changing";
+        }
+    }
+    stateCell.rejectedInitProbe = reason ? { value: newInit } : undefined;
+    if (reason) {
+        warnUnstableInitFunc(stateCell, reason);
+    }
+    return !reason;
+}
 function useDollarState(specs) {
     var rest = [];
     for (var _i = 1; _i < arguments.length; _i++) {
@@ -2549,6 +2615,10 @@ function useDollarState(specs) {
     }
     var _a = extractDollarStateParametersBackwardCompatible.apply(void 0, __spreadArray([], __read(rest), false)), env = _a.env, opts = _a.opts;
     var _b = __read(React__default.useState(), 2), setState = _b[1];
+    // Set for the whole render pass and cleared by the layout effect, which applies
+    // registrations. One that arrives outside a render must schedule a render to be applied.
+    var rendering = React__default.useRef(false);
+    rendering.current = true;
     var mountedRef = React__default.useRef(false);
     var isMounted = React__default.useCallback(function () { return mountedRef.current; }, []);
     React__default.useEffect(function () {
@@ -2573,14 +2643,11 @@ function useDollarState(specs) {
             specTreeLeaves: getSpecTreeLeaves(rootSpecTree),
             stateValues: proxy({}),
             env: envFieldsAreNonNill(env),
-            specs: [],
-            registrationsQueue: [],
             stateInitializationEnv: { stack: [], visited: new Set() },
             initializedLeafPaths: new Set(),
         };
     })()).current;
     $$state.env = envFieldsAreNonNill(env);
-    $$state.specs = specs;
     var create$State = React__default.useCallback(function () {
         var $state = Object.assign(create$StateProxy($$state, function (stateCell) {
             var spec = stateCell.node.getSpec();
@@ -2606,24 +2673,21 @@ function useDollarState(specs) {
                 },
             };
         }), __assign({ registerInitFunc: function (pathStr, f, repetitionIndex, overrideEnv) {
-                var _a = findStateCell($$state.rootSpecTree, pathStr, repetitionIndex), node = _a.node, realPath = _a.realPath;
+                var realPath = findStateCell($$state.rootSpecTree, pathStr, repetitionIndex).realPath;
                 var stateCell = getStateCellFrom$StateRoot($state, realPath);
-                var innerEnv = overrideEnv
+                // The first initializer always applies, even if unstable, like the
+                // lazy initialization of a spec initFunc.
+                stateCell.pendingInit || (stateCell.pendingInit = !stateCell.initFunc);
+                stateCell.initFunc = f;
+                stateCell.overrideEnv = overrideEnv
                     ? envFieldsAreNonNill(overrideEnv)
-                    : $$state.env;
-                if (!deepEqual(stateCell.initialValue, f(__assign({ $state: $state }, innerEnv)))) {
-                    $$state.registrationsQueue.push({
-                        node: node,
-                        path: realPath,
-                        f: f,
-                        overrideEnv: overrideEnv
-                            ? envFieldsAreNonNill(overrideEnv)
-                            : undefined,
-                    });
-                    if (!pendingUpdate.current) {
-                        pendingUpdate.current = true;
-                        forceUpdate();
-                    }
+                    : undefined;
+                if (!rendering.current &&
+                    !pendingUpdate.current &&
+                    (stateCell.pendingInit ||
+                        initValueChanged($$state, stateCell, $state))) {
+                    pendingUpdate.current = true;
+                    forceUpdate();
                 }
             } }, ((opts === null || opts === void 0 ? void 0 : opts.inCanvas)
             ? {
@@ -2644,6 +2708,9 @@ function useDollarState(specs) {
                         }
                         stateCell.initFunc = newSpec.initFunc;
                         stateCell.initFuncHash = (_b = newSpec.initFuncHash) !== null && _b !== void 0 ? _b : "";
+                        stateCell.unsettledResetCount = undefined;
+                        stateCell.warnedUnstableInitFunc = undefined;
+                        stateCell.rejectedInitProbe = undefined;
                         var init = spec.valueProp
                             ? $$state.env.$props[spec.valueProp]
                             : spec.initFunc
@@ -2679,47 +2746,24 @@ function useDollarState(specs) {
             });
         }
     }
-    var reInitializeState = function (stateCell) {
-        var _a, _b;
-        var newInit = initializeStateValue($$state, stateCell, $state);
-        var spec = stateCell.node.getSpec();
-        if (spec.onChangeProp) {
-            (_b = (_a = $$state.env.$props)[spec.onChangeProp]) === null || _b === void 0 ? void 0 : _b.call(_a, newInit);
-        }
-    };
     useIsomorphicLayoutEffect(function () {
-        // For each spec with an initFunc, evaluate it and see if
-        // the init value has changed. If so, reset its state.
-        var resetSpecs = [];
-        getStateCells($state, $$state.rootSpecTree).forEach(function (stateCell) {
-            var _a;
-            if (stateCell.initFunc) {
-                try {
-                    var newInit = invokeInitFunc(stateCell.initFunc, __assign({ $state: $state }, ((_a = stateCell.overrideEnv) !== null && _a !== void 0 ? _a : envFieldsAreNonNill(env))));
-                    if (!deepEqual(newInit, stateCell.initialValue)) {
-                        resetSpecs.push({ stateCell: stateCell });
-                    }
-                }
-                catch (_b) {
-                    // Exception may be thrown from initFunc -- for example, if it tries to access $queries
-                    // that are still loading. We swallow those here, since we're only interested in
-                    // checking if the init value has changed, not in handling these errors.
-                }
-            }
+        rendering.current = false;
+        // Scan every cell before resetting any, so each initFunc sees the same
+        // pre-reset state.
+        var resetCells = getStateCells($state, $$state.rootSpecTree).filter(function (stateCell) {
+            return stateCell.pendingInit ||
+                (stateCell.initFunc &&
+                    shouldReInitialize(stateCell, stateCell.initFunc, initFuncEnv($$state, stateCell, $state)));
         });
-        resetSpecs.forEach(function (_a) {
-            var stateCell = _a.stateCell;
-            reInitializeState(stateCell);
+        resetCells.forEach(function (stateCell) {
+            var _a, _b;
+            stateCell.pendingInit = undefined;
+            var newInit = initializeStateValue($$state, stateCell, $state);
+            var spec = stateCell.node.getSpec();
+            if (spec.onChangeProp) {
+                (_b = (_a = $$state.env.$props)[spec.onChangeProp]) === null || _b === void 0 ? void 0 : _b.call(_a, newInit);
+            }
         });
-    }, [env.$props, $state, $$state, reInitializeState]);
-    useIsomorphicLayoutEffect(function () {
-        while ($$state.registrationsQueue.length) {
-            var _a = $$state.registrationsQueue.shift(), path = _a.path, f = _a.f, overrideEnv = _a.overrideEnv;
-            var stateCell = getStateCellFrom$StateRoot($state, path);
-            stateCell.initFunc = f;
-            stateCell.overrideEnv = overrideEnv;
-            reInitializeState(stateCell);
-        }
     });
     // immediately initialize exposed non-private states
     useIsomorphicLayoutEffect(function () {
@@ -2830,11 +2874,15 @@ function getStateCells($state, root) {
         try {
             for (var _c = __values(root.edges().entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
                 var _e = __read(_d.value, 2), key = _e[0], child = _e[1];
-                if (typeof key === "string" && key in $state) {
+                if (typeof key !== "string") {
+                    continue;
+                }
+                // A leaf cell can exist without a local value, e.g. a valueProp state.
+                if (key in stateCell) {
+                    stateCells.push(stateCell[key]);
+                }
+                else if (key in $state) {
                     stateCells.push.apply(stateCells, __spreadArray([], __read(getStateCells($state[key], child)), false));
-                    if (key in stateCell) {
-                        stateCells.push(stateCell[key]);
-                    }
                 }
             }
         }
@@ -2883,6 +2931,16 @@ function getCurrentInitialValue(obj, path) {
     }
     return (_a = tryGetStateCellFrom$StateRoot(obj, path)) === null || _a === void 0 ? void 0 : _a.initialValue;
 }
+/** Whether the runtime guard has detected instability in this initializer.
+ * Canvas edits clear the diagnostic when the initializer hash changes.
+ */
+function hasUnstableStateInitializer(obj, path) {
+    var _a;
+    if (!isPlasmicStateProxy(obj)) {
+        return false;
+    }
+    return !!((_a = tryGetStateCellFrom$StateRoot(obj, path)) === null || _a === void 0 ? void 0 : _a.warnedUnstableInitFunc);
+}
 function resetToInitialValue(obj, path) {
     var stateCell = tryGetStateCellFrom$StateRoot(obj, path);
     if (stateCell) {
@@ -4310,5 +4368,5 @@ function useTriggeredOverlay(plasmicClass, props, config, outerRef, isDismissabl
     };
 }
 
-export { DropdownMenu, PlasmicHead, PlasmicIcon, PlasmicImg, PlasmicLink, PlasmicPageGuard, PlasmicRootProvider, PlasmicSlot, SelectContext, Stack, Trans, TriggeredOverlayContext, classNames, createPlasmicElementProxy, createStyleTokensProvider, createUseGlobalVariants, createUseScreenVariants, createUseStyleTokens, deriveRenderOpts, ensureGlobalVariants, genTranslatableString, generateOnMutateForSpec, generateStateOnChangeProp, generateStateOnChangePropForCodeComponents, generateStateValueProp, getCurrentInitialValue, getDataProps, getStateCellsInPlasmicProxy, getStateSpecInPlasmicProxy, hasVariant, initializeCodeComponentStates, initializePlasmicStates, is$StateProxy, isPlasmicStateProxy, makeFragment, mergeVariantsWithStates, omit, pick, plasmicHeadMeta, renderPlasmicSlot, resetToInitialValue, set, setPlumeStrictMode, useButton, useCheckbox, useDollarState, useIsSSR, useMenu, useMenuButton, useMenuGroup, useMenuItem, usePlasmicTranslator, useSelect, useSelectOption, useSelectOptionGroup, useSwitch, useTextInput, useTrigger, useTriggeredOverlay, withPlasmicPageGuard, wrapWithClassName };
+export { DropdownMenu, PlasmicHead, PlasmicIcon, PlasmicImg, PlasmicLink, PlasmicPageGuard, PlasmicRootProvider, PlasmicSlot, SelectContext, Stack, Trans, TriggeredOverlayContext, classNames, createPlasmicElementProxy, createStyleTokensProvider, createUseGlobalVariants, createUseScreenVariants, createUseStyleTokens, deriveRenderOpts, ensureGlobalVariants, genTranslatableString, generateOnMutateForSpec, generateStateOnChangeProp, generateStateOnChangePropForCodeComponents, generateStateValueProp, getCurrentInitialValue, getDataProps, getStateCellsInPlasmicProxy, getStateSpecInPlasmicProxy, hasUnstableStateInitializer, hasVariant, initializeCodeComponentStates, initializePlasmicStates, is$StateProxy, isPlasmicStateProxy, makeFragment, mergeVariantsWithStates, omit, pick, plasmicHeadMeta, renderPlasmicSlot, resetToInitialValue, set, setPlumeStrictMode, useButton, useCheckbox, useDollarState, useIsSSR, useMenu, useMenuButton, useMenuGroup, useMenuItem, usePlasmicTranslator, useSelect, useSelectOption, useSelectOptionGroup, useSwitch, useTextInput, useTrigger, useTriggeredOverlay, withPlasmicPageGuard, wrapWithClassName };
 //# sourceMappingURL=react-web.esm.js.map