@mmstack/primitives 20.14.1 → 20.14.3

package/fesm2022/mmstack-primitives.mjs

@@ -1741,8 +1741,7 @@ function createImmutableObjectUpdater(source, key, vivifyFn) {
         return { ...vivified, [key]: next };
     });
 }
-function createUpdater(source, key, vivify) {
-    const sample = untracked(source);
+function createUpdaterFromSample(source, key, vivify, sample) {
     // fast path for when vivification is off
     if (!vivify) {
         if (Array.isArray(sample) && typeof key === 'number') {
@@ -1790,6 +1789,19 @@ function createUpdater(source, key, vivify) {
         ? createMutableObjectUpdater(source, key, vivifyFn)
         : createImmutableObjectUpdater(source, key, vivifyFn);
 }
+/**
+ * Selects the property updater once, on the first actual write. Construction must not sample the
+ * source: a writable derivation may currently throw, and reads still need a child producer that can
+ * subscribe and recover. The routing sample remains deliberately untracked, so deferring it adds no
+ * dependency to the caller.
+ */
+function createUpdater(source, key, vivify) {
+    let update;
+    return (next) => {
+        update ??= createUpdaterFromSample(source, key, vivify, untracked(source));
+        update(next);
+    };
+}
 function derived(source, optOrKey, opt) {
     const vivify = typeof optOrKey === 'object' ? false : (opt?.vivify ?? false);
     // With vivification the source may legitimately be null/undefined
@@ -4481,14 +4493,19 @@ function alwaysFalse() {
 function markAsLeaf(sig, value, vivifyEnabled, noUnionLeaves) {
     if (typeof sig[LEAF] !== 'function') {
         let memo;
+        let initialClassification;
         const probe = () => {
             if (memo)
                 return memo();
-            memo = noUnionLeaves
-                ? isLeafValue(untracked(value), vivifyEnabled)
-                    ? alwaysTrue
-                    : alwaysFalse
-                : computed(() => isLeafValue(value(), vivifyEnabled));
+            if (noUnionLeaves) {
+                initialClassification ??= computed(() => isLeafValue(value(), vivifyEnabled));
+                const result = initialClassification();
+                memo = result ? alwaysTrue : alwaysFalse;
+                initialClassification = undefined;
+            }
+            else {
+                memo = computed(() => isLeafValue(value(), vivifyEnabled));
+            }
             return memo();
         };
         Object.defineProperty(sig, LEAF, {
@@ -4562,21 +4579,19 @@ function mutableChildEqual(a, b) {
  * correct after it. The only place a child node is constructed — shared by every container kind.
  */
 function buildChildNode(target, prop, isMutableSource, options) {
-    const value = untracked(target);
-    const nodeVivify = resolveVivify(value, options.vivify);
-    const vivifyFn = createVivify(nodeVivify);
-    const equalFn = isMutableSource && (isRecord$1(value) || Array.isArray(value))
-        ? mutableChildEqual
-        : undefined;
+    let vivifyFn = options.vivify === false ? createVivify(false) : undefined;
+    const resolveVivifyFn = (sample) => (vivifyFn ??= createVivify(resolveVivify(sample, options.vivify)));
+    const lazyVivify = (value, key) => resolveVivifyFn(value)(value, key);
     const computation = derived(target, {
-        from: (v) => v?.[prop],
-        onChange: createFallbackOnChange(target, prop, vivifyFn, isMutableSource),
-        equal: equalFn,
+        from: (v) => {
+            resolveVivifyFn(v);
+            return v?.[prop];
+        },
+        onChange: createFallbackOnChange(target, prop, lazyVivify, isMutableSource),
+        equal: isMutableSource ? mutableChildEqual : undefined,
     });
-    const childSample = untracked(computation);
-    const childVivify = resolveVivify(childSample, options.vivify);
     const proxy = toStore(computation, options);
-    markAsLeaf(proxy, computation, childVivify !== false, options.noUnionLeaves);
+    markAsLeaf(proxy, computation, options.vivify !== false, options.noUnionLeaves);
     return proxy;
 }
 /**
@@ -4711,7 +4726,19 @@ function toStore(source, { injector, vivify = false, noUnionLeaves = false, ...r
                         [STORE_SHARED_GLOBALS]: STORE_OPTIONS[STORE_SHARED_GLOBALS],
                     }));
                 };
-            const k = untracked(kind);
+            if ((typeof prop === 'symbol' && prop !== Symbol.iterator) ||
+                (typeof prop === 'string' && SIGNAL_FN_PROP.has(prop)))
+                return target[prop];
+            const child = (key) => getCachedChild(target, prop, () => buildChildNode(target, key, isMutableSource, STORE_OPTIONS), STORE_OPTIONS[STORE_SHARED_GLOBALS].cache, STORE_OPTIONS[STORE_SHARED_GLOBALS].registry);
+            let k;
+            try {
+                k = untracked(kind);
+            }
+            catch (cause) {
+                if (typeof prop === 'string' && prop !== 'extend')
+                    return child(isIndexProp(prop) ? +prop : prop);
+                throw cause;
+            }
             if (prop === 'extend' && k !== 'array')
                 return (seed) => scopedStore(s, seed, isMutableSource
                     ? 'mutable'
@@ -4728,11 +4755,9 @@ function toStore(source, { injector, vivify = false, noUnionLeaves = false, ...r
                             yield receiver[i];
                     };
             }
-            if (typeof prop === 'symbol' || SIGNAL_FN_PROP.has(prop))
-                return target[prop];
             if (k === 'array' && !isIndexProp(prop))
                 return Reflect.get(target, prop, receiver);
-            return getCachedChild(target, prop, () => buildChildNode(target, k === 'array' ? +prop : prop, isMutableSource, STORE_OPTIONS), STORE_OPTIONS[STORE_SHARED_GLOBALS].cache, STORE_OPTIONS[STORE_SHARED_GLOBALS].registry);
+            return child(k === 'array' ? +prop : prop);
         },
     });
     return s;