@blac/react 2.1.1 → 2.1.2

package/dist/index.js

@@ -76,6 +76,44 @@ function collectGetters(proto) {
 	gettersByProto.set(proto, getters);
 	return getters;
 }
+var BlocHandler = class {
+	constructor(getters, tracksState, trackedStateRef, onDepHandle) {
+		this.getters = getters;
+		this.tracksState = tracksState;
+		this.trackedStateRef = trackedStateRef;
+		this.onDepHandle = onDepHandle;
+		this.boundMethods = void 0;
+	}
+	get(target, key) {
+		const getter = this.getters.get(key);
+		if (getter !== void 0) {
+			const tracked = this.trackedStateRef.current;
+			return this.wrapDepHandle(tracked == null || !this.tracksState ? getter.call(target) : target[WITH_TRACKED_STATE](tracked, getter, this.onDepHandle));
+		}
+		const value = Reflect.get(target, key, target);
+		if (typeof value === "function") {
+			const fn = value;
+			this.boundMethods ??= /* @__PURE__ */ new Map();
+			let cached = this.boundMethods.get(key);
+			if (cached === void 0 || cached.fn !== fn) {
+				cached = {
+					fn,
+					bound: fn.bind(target)
+				};
+				this.boundMethods.set(key, cached);
+			}
+			return this.wrapDepHandle(cached.bound);
+		}
+		return this.wrapDepHandle(value);
+	}
+	set(target, key, value) {
+		return Reflect.set(target, key, value, target);
+	}
+	wrapDepHandle(value) {
+		if (this.onDepHandle !== void 0 && (typeof value === "function" || typeof value === "object") && value !== null && value[DEP_BRAND] !== void 0) return this.onDepHandle(value);
+		return value;
+	}
+};
 /**
 * Build a per-consumer proxy for a bloc instance.
 *
@@ -93,68 +131,12 @@ function collectGetters(proto) {
 *   Must cache wrappers per handle to avoid re-allocation.
 */
 function buildTrackedProxy(instance, trackedStateRef, onDepHandle) {
-	const getters = collectGetters(Object.getPrototypeOf(instance));
-	const tracksState = supportsTrackedState(instance);
-	const boundMethods = /* @__PURE__ */ new Map();
-	const wrapDepHandle = (value) => {
-		if (onDepHandle !== void 0 && (typeof value === "function" || typeof value === "object") && value !== null && value[DEP_BRAND] !== void 0) return onDepHandle(value);
-		return value;
-	};
-	return { proxy: new Proxy(instance, {
-		get(target, key) {
-			const getter = getters.get(key);
-			if (getter !== void 0) {
-				const tracked = trackedStateRef.current;
-				return wrapDepHandle(tracked == null || !tracksState ? getter.call(target) : target[WITH_TRACKED_STATE](tracked, getter, onDepHandle));
-			}
-			const value = Reflect.get(target, key, target);
-			if (typeof value === "function") {
-				const fn = value;
-				let cached = boundMethods.get(key);
-				if (cached === void 0 || cached.fn !== fn) {
-					cached = {
-						fn,
-						bound: fn.bind(target)
-					};
-					boundMethods.set(key, cached);
-				}
-				return wrapDepHandle(cached.bound);
-			}
-			return wrapDepHandle(value);
-		},
-		set(target, key, value) {
-			return Reflect.set(target, key, value, target);
-		}
-	}) };
-}
-//#endregion
-//#region src/expandWithAncestors.ts
-/**
-* Add an ancestor-watch id for every ancestor of every tracked leaf, so a
-* `patch` that replaces a parent atomically (e.g. the array `items`) wakes a
-* consumer that read a child (`items.length`).
-*
-* Ancestor-watch ids only match marks the source emits for atomic
-* replacements, never a plain-object pulse-up: `{'user.email'}` does not wake
-* when a sibling `user.name` changes. The `''` root is never added; a root
-* change already marks `ALL_PATHS`.
-*
-* Returns `paths` itself when no leaf has an ancestor.
-*/
-function expandWithAncestors(paths, interner) {
-	if (paths === ALL_PATHS) return ALL_PATHS;
-	const leafPaths = paths;
-	let expanded;
-	for (const id of leafPaths) {
-		const watch = interner.ancestorWatchIds(id);
-		if (watch.length === 0) continue;
-		expanded ??= new Set(leafPaths);
-		for (let i = 0; i < watch.length; i++) expanded.add(watch[i]);
-	}
-	return expanded ?? paths;
+	const handler = new BlocHandler(collectGetters(Object.getPrototypeOf(instance)), supportsTrackedState(instance), trackedStateRef, onDepHandle);
+	return new Proxy(instance, handler);
 }
 //#endregion
 //#region src/depSession.ts
+const NO_PATHS$1 = emptyPathSet();
 /**
 * The containers one `useBloc` consumer reads during a render: its primary
 * bloc plus every dep reached through `this.<handle>.track()`.
@@ -168,61 +150,91 @@ var DepSession = class {
 	constructor(consumerId, onChange) {
 		this.consumerId = consumerId;
 		this.onChange = onChange;
-		this.entries = /* @__PURE__ */ new Map();
-		this.subs = /* @__PURE__ */ new Map();
-		this.lastReconciled = null;
-		this.refId = `useBloc@${consumerId}:dep`;
+		this.primary = null;
+		this.primaryPaths = NO_PATHS$1;
+		this.entries = null;
+		this.subs = null;
+		this.reconciled = false;
+		this.lastPrimary = null;
+		this.lastPrimaryPaths = NO_PATHS$1;
+		this.lastEntries = null;
+		this.disarms = null;
+	}
+	get refId() {
+		return `useBloc@${this.consumerId}:dep`;
 	}
 	begin(primary, paths) {
-		this.entries.clear();
-		this.entries.set(primary, {
-			kind: "primary",
-			paths
-		});
+		this.entries?.clear();
+		if (this.disarms !== null) this.disarms.length = 0;
+		this.primary = primary;
+		this.primaryPaths = paths;
 	}
-	record(dep, paths, Type, key, args) {
-		const existing = this.entries.get(dep);
+	record(dep, paths, Type, key, args, disarm) {
+		(this.disarms ??= []).push(disarm);
+		if (dep === this.primary) {
+			this.primaryPaths = unionPaths(this.primaryPaths, paths);
+			return;
+		}
+		const entries = this.entries ??= /* @__PURE__ */ new Map();
+		const existing = entries.get(dep);
 		if (existing !== void 0) existing.paths = unionPaths(existing.paths, paths);
-		else this.entries.set(dep, {
-			kind: "dep",
+		else entries.set(dep, {
 			paths,
 			Type,
 			key,
 			args
 		});
 	}
+	/** Stops every dep tracked this render from recording further reads. */
+	disarm() {
+		const disarms = this.disarms;
+		if (disarms === null) return;
+		for (const disarm of disarms) disarm();
+		disarms.length = 0;
+	}
 	/** Forces the next `reconcile` to run in full. */
 	invalidate() {
-		this.lastReconciled = null;
+		this.reconciled = false;
 	}
 	isUnchanged() {
-		const last = this.lastReconciled;
-		if (last === null || last.size !== this.entries.size) return false;
-		for (const [container, entry] of this.entries) {
+		if (!this.reconciled || this.lastPrimary !== this.primary || !pathSetEquals(this.lastPrimaryPaths, this.primaryPaths)) return false;
+		const last = this.lastEntries;
+		const entries = this.entries;
+		if ((last?.size ?? 0) !== (entries?.size ?? 0)) return false;
+		if (last === null || entries === null) return true;
+		for (const [container, entry] of entries) {
 			const prev = last.get(container);
 			if (prev === void 0 || !sameEntry(prev, entry)) return false;
 		}
 		return true;
 	}
 	reconcile(registry) {
-		const { consumerId, refId, subs, entries } = this;
-		for (const [dep, sub] of subs) if (!entries.has(dep)) {
-			this.drop(dep, sub);
-			subs.delete(dep);
+		const { consumerId } = this;
+		const entries = this.entries;
+		this.reconciled = true;
+		this.lastPrimary = this.primary;
+		this.lastPrimaryPaths = this.primaryPaths;
+		this.lastEntries = entries === null || entries.size === 0 ? null : new Map(entries);
+		const subs = this.subs;
+		if (subs !== null) {
+			for (const [dep, sub] of subs) if (entries?.has(dep) !== true) {
+				this.drop(dep, sub);
+				subs.delete(dep);
+			}
 		}
+		if (entries === null) return;
 		for (const [dep, entry] of entries) {
-			if (entry.kind === "primary") continue;
 			if (dep.$blac.disposed) {
 				this.onChange();
 				continue;
 			}
-			const interest = expandWithAncestors(entry.paths, dep.interner);
 			dep.registerConsumerPaths(consumerId, entry.paths);
-			const existing = subs.get(dep);
+			const existing = subs?.get(dep);
 			if (existing) {
-				existing.interestRef.current = interest;
+				existing.subscription.setInterest(entry.paths);
 				continue;
 			}
+			const refId = this.refId;
 			if (registry.acquire(entry.Type, entry.key, {
 				canCreate: true,
 				countRef: true,
@@ -233,33 +245,32 @@ var DepSession = class {
 				this.onChange();
 				continue;
 			}
-			const interestRef = { current: interest };
-			const unsubscribe = dep.channel.subscribe(() => interestRef.current, this.onChange);
-			subs.set(dep, {
-				unsubscribe,
-				interestRef,
+			const subscription = dep.subscribePaths(this.onChange);
+			subscription.setInterest(entry.paths);
+			(this.subs ??= /* @__PURE__ */ new Map()).set(dep, {
+				subscription,
 				registry,
 				Type: entry.Type,
 				key: entry.key
 			});
 		}
-		this.lastReconciled = new Map(entries);
 	}
 	dispose() {
-		for (const [dep, sub] of this.subs) this.drop(dep, sub);
-		this.subs.clear();
-		this.lastReconciled = null;
+		const subs = this.subs;
+		if (subs !== null) {
+			for (const [dep, sub] of subs) this.drop(dep, sub);
+			subs.clear();
+		}
+		this.reconciled = false;
 	}
 	drop(dep, sub) {
-		sub.unsubscribe();
+		sub.subscription.unsubscribe();
 		dep.unregisterConsumer(this.consumerId);
 		sub.registry.release(sub.Type, sub.key, false, this.refId);
 	}
 };
 function sameEntry(a, b) {
-	if (a.kind !== b.kind || !pathSetEquals(a.paths, b.paths)) return false;
-	if (a.kind === "primary" || b.kind === "primary") return true;
-	return a.key === b.key && Object.is(a.args, b.args);
+	return pathSetEquals(a.paths, b.paths) && a.key === b.key && Object.is(a.args, b.args);
 }
 function unionPaths(a, b) {
 	if (a === ALL_PATHS || b === ALL_PATHS) return ALL_PATHS;
@@ -305,11 +316,11 @@ function makeDepWrapper(handle, registry, session, tracked, onDepHandle) {
 				const ref = { current: result.value };
 				cache = {
 					ref,
-					proxy: buildTrackedProxy(dep, ref, onDepHandle).proxy
+					proxy: buildTrackedProxy(dep, ref, onDepHandle)
 				};
 				perDep.set(dep, cache);
 			} else cache.ref.current = result.value;
-			session.record(dep, result.paths, brand.Type, key, args);
+			session.record(dep, result.paths, brand.Type, key, args, result.disarm);
 			return [result.value, cache.proxy];
 		}
 	};
@@ -378,7 +389,6 @@ function useBloc(BlocClass, options) {
 	const registry = useRegistry();
 	const consumerRef = useRef(null);
 	const consumer = consumerRef.current ??= createConsumer();
-	const consumerId = consumer.id;
 	consumer.select = options?.select;
 	consumer.onMount = options?.onMount;
 	consumer.onUnmount = options?.onUnmount;
@@ -386,94 +396,18 @@ function useBloc(BlocClass, options) {
 	consumer.providerArgs = useProvidedArgs(BlocClass);
 	const effectiveArgs = resolveEffectiveArgs(consumer);
 	const instanceKey = registry.resolveKey(BlocClass, void 0, effectiveArgs);
-	const rebindNonce = consumer.rebindNonce;
-	const { bloc, trackedBloc } = useMemo(() => {
-		const instance = registry.acquire(BlocClass, instanceKey, {
-			canCreate: true,
-			countRef: false,
-			args: effectiveArgs,
-			sweepIfUnowned: true
-		});
-		const depWrappers = /* @__PURE__ */ new Map();
-		const onDepHandle = (handle) => {
-			const cached = depWrappers.get(handle);
-			if (cached !== void 0) return cached;
-			const wrapper = makeDepWrapper(handle, registry, consumer.deps, consumer.tracked, onDepHandle);
-			depWrappers.set(handle, wrapper);
-			return wrapper;
-		};
-		const { proxy } = buildTrackedProxy(instance, consumer.tracked, onDepHandle);
-		return {
-			bloc: instance,
-			trackedBloc: proxy
-		};
-	}, [
-		BlocClass,
-		instanceKey,
-		rebindNonce,
-		registry
-	]);
-	consumer.container = bloc;
-	useSyncExternalStore(useMemo(() => (onStoreChange) => {
-		consumer.notify = onStoreChange;
-		const container = consumer.container;
-		const unsubscribe = container.channel.subscribe(() => consumer.interest, () => {
-			if (consumer.isSelectMode) {
-				const select = consumer.select;
-				if (select) {
-					const next = select(container.state, container);
-					const prev = consumer.selection;
-					if (prev !== null && shallowArrayEqual(prev, next)) return;
-					consumer.selection = next;
-				}
-			}
-			consumer.bump();
-		});
-		container.registerConsumerPaths(consumerId, consumer.paths);
-		return () => {
-			consumer.notify = noop;
-			unsubscribe();
-			container.unregisterConsumer(consumerId);
-		};
-	}, [
-		BlocClass,
-		instanceKey,
-		consumerId,
-		rebindNonce,
-		registry
-	]), consumer.getSnapshot, consumer.getServerSnapshot);
-	useLayoutEffect(() => {
-		const live = registry.acquire(BlocClass, instanceKey, {
-			canCreate: true,
-			countRef: true,
-			refId: consumer.primaryRefId,
-			args: resolveEffectiveArgs(consumer)
-		});
-		consumer.ownedBloc = live;
-		consumer.onMount?.(live);
-		if (live !== bloc) {
-			consumer.rebindNonce++;
-			consumer.bump();
-		}
-		return () => {
-			consumer.onUnmount?.(consumer.ownedBloc ?? bloc);
-			registry.release(BlocClass, instanceKey, false, consumer.primaryRefId);
-		};
-	}, [
-		BlocClass,
-		instanceKey,
-		consumerId,
-		registry
-	]);
+	if (consumer.BlocClass !== BlocClass || consumer.instanceKey !== instanceKey || consumer.registry !== registry || consumer.boundNonce !== consumer.rebindNonce) bind(consumer, BlocClass, instanceKey, registry, effectiveArgs);
+	useSyncExternalStore(consumer.subscribe, consumer.getSnapshot, consumer.getSnapshot);
 	const container = consumer.container;
 	const rawState = container.state;
+	consumer.renderedState = rawState;
 	const select = consumer.select;
 	consumer.isSelectMode = select !== void 0;
 	let state;
 	if (select !== void 0) {
 		state = rawState;
-		consumer.selection = select(rawState, bloc);
-		consumer.interest = ALL_PATHS;
+		consumer.selection = select(rawState, container);
+		setInterest(consumer, ALL_PATHS);
 	} else {
 		const tracked = trackRender(rawState, container.interner, consumer.proxyCache ??= new ProxyCache());
 		state = tracked.value;
@@ -482,34 +416,27 @@ function useBloc(BlocClass, options) {
 		consumer.disarm = tracked.disarm;
 		consumer.deps.begin(container, tracked.paths);
 	}
-	useLayoutEffect(() => {
-		consumer.tracked.current = null;
-		const disarm = consumer.disarm;
-		if (disarm !== null) {
-			consumer.disarm = null;
-			disarm();
-		}
-		const deps = consumer.deps;
-		if (consumer.isSelectMode) {
-			deps.invalidate();
-			return;
-		}
-		if (deps.isUnchanged()) return;
-		const primary = consumer.container;
-		primary.registerConsumerPaths(consumerId, consumer.paths);
-		consumer.interest = expandWithAncestors(consumer.paths, primary.interner);
-		deps.reconcile(registry);
-	});
-	useEffect(() => () => consumer.deps.dispose(), [consumerId]);
-	return [state, trackedBloc];
+	useLayoutEffect(consumer.commit);
+	useLayoutEffect(consumer.mount, NO_DEPS);
+	return [state, consumer.trackedBloc];
 }
 const noop = () => {};
+const NO_PATHS = emptyPathSet();
+const NO_DEPS = [];
 function createConsumer() {
 	const id = `useBloc-${nextConsumerId++}`;
 	const consumer = {
 		id,
 		primaryRefId: `useBloc@${id}`,
+		BlocClass: null,
+		instanceKey: "",
+		registry: null,
 		container: null,
+		trackedBloc: null,
+		subscribe: null,
+		boundNonce: 0,
+		rebindNonce: 0,
+		renderedState: void 0,
 		version: 0,
 		notify: noop,
 		bump: () => {
@@ -517,12 +444,17 @@ function createConsumer() {
 			consumer.notify();
 		},
 		getSnapshot: () => consumer.version,
-		getServerSnapshot: () => consumer.version,
-		interest: emptyPathSet(),
-		paths: emptyPathSet(),
+		onChange: () => onChange(consumer),
+		unsubscribe: () => unsubscribe(consumer),
+		commit: () => commit(consumer),
+		mount: () => teardown,
+		interest: NO_PATHS,
+		subscription: null,
+		subscribedTo: null,
+		paths: NO_PATHS,
 		isSelectMode: false,
 		selection: null,
-		deps: new DepSession(id, () => consumer.bump()),
+		deps: null,
 		select: void 0,
 		onMount: void 0,
 		onUnmount: void 0,
@@ -531,11 +463,125 @@ function createConsumer() {
 		tracked: { current: null },
 		disarm: null,
 		proxyCache: null,
-		rebindNonce: 0,
+		ownedClass: null,
+		ownedKey: "",
+		ownedRegistry: null,
 		ownedBloc: null
 	};
+	const teardown = () => {
+		release(consumer);
+		consumer.deps.dispose();
+	};
+	consumer.deps = new DepSession(id, consumer.bump);
 	return consumer;
 }
+function bind(consumer, BlocClass, instanceKey, registry, args) {
+	const instance = registry.acquire(BlocClass, instanceKey, {
+		canCreate: true,
+		countRef: false,
+		args,
+		sweepIfUnowned: true
+	});
+	let depWrappers;
+	const onDepHandle = (handle) => {
+		depWrappers ??= /* @__PURE__ */ new Map();
+		const cached = depWrappers.get(handle);
+		if (cached !== void 0) return cached;
+		const wrapper = makeDepWrapper(handle, registry, consumer.deps, consumer.tracked, onDepHandle);
+		depWrappers.set(handle, wrapper);
+		return wrapper;
+	};
+	consumer.BlocClass = BlocClass;
+	consumer.instanceKey = instanceKey;
+	consumer.registry = registry;
+	consumer.boundNonce = consumer.rebindNonce;
+	consumer.container = instance;
+	consumer.trackedBloc = buildTrackedProxy(instance, consumer.tracked, onDepHandle);
+	consumer.subscribe = (onStoreChange) => subscribe(consumer, onStoreChange);
+}
+function subscribe(consumer, onStoreChange) {
+	consumer.notify = onStoreChange;
+	const container = consumer.container;
+	const subscription = container.subscribePaths(consumer.onChange);
+	subscription.setInterest(consumer.interest);
+	consumer.subscription = subscription;
+	consumer.subscribedTo = container;
+	container.registerConsumerPaths(consumer.id, consumer.paths);
+	return consumer.unsubscribe;
+}
+function unsubscribe(consumer) {
+	consumer.notify = noop;
+	consumer.subscription?.unsubscribe();
+	consumer.subscription = null;
+	consumer.subscribedTo?.unregisterConsumer(consumer.id);
+	consumer.subscribedTo = null;
+}
+function onChange(consumer) {
+	if (consumer.isSelectMode) {
+		const select = consumer.select;
+		const container = consumer.subscribedTo;
+		if (select && container !== null) {
+			const next = select(container.state, container);
+			const prev = consumer.selection;
+			if (prev !== null && shallowArrayEqual(prev, next)) return;
+			consumer.selection = next;
+		}
+	}
+	consumer.bump();
+}
+function claim(consumer) {
+	const { BlocClass, instanceKey, registry } = consumer;
+	if (consumer.ownedClass === BlocClass && consumer.ownedKey === instanceKey && consumer.ownedRegistry === registry) return;
+	release(consumer);
+	const live = registry.acquire(BlocClass, instanceKey, {
+		canCreate: true,
+		countRef: true,
+		refId: consumer.primaryRefId,
+		args: resolveEffectiveArgs(consumer)
+	});
+	consumer.ownedClass = BlocClass;
+	consumer.ownedKey = instanceKey;
+	consumer.ownedRegistry = registry;
+	consumer.ownedBloc = live;
+	consumer.onMount?.(live);
+	if (live !== consumer.container) {
+		consumer.rebindNonce++;
+		consumer.bump();
+	}
+}
+function release(consumer) {
+	const { ownedClass, ownedRegistry } = consumer;
+	if (ownedClass === null || ownedRegistry === null) return;
+	consumer.onUnmount?.(consumer.ownedBloc);
+	consumer.ownedClass = null;
+	consumer.ownedRegistry = null;
+	ownedRegistry.release(ownedClass, consumer.ownedKey, false, consumer.primaryRefId);
+}
+function commit(consumer) {
+	claim(consumer);
+	consumer.tracked.current = null;
+	const disarm = consumer.disarm;
+	if (disarm !== null) {
+		consumer.disarm = null;
+		disarm();
+	}
+	const deps = consumer.deps;
+	deps.disarm();
+	if (consumer.isSelectMode) {
+		deps.invalidate();
+		return;
+	}
+	const primary = consumer.container;
+	if (primary.state !== consumer.renderedState) consumer.bump();
+	if (deps.isUnchanged()) return;
+	primary.registerConsumerPaths(consumer.id, consumer.paths);
+	setInterest(consumer, consumer.paths);
+	deps.reconcile(consumer.registry);
+}
+const setInterest = (consumer, interest) => {
+	consumer.interest = interest;
+	consumer.subscription?.setInterest(interest);
+};
 const resolveEffectiveArgs = (consumer) => consumer.ownArgs !== void 0 ? consumer.ownArgs : consumer.providerArgs;
 const shallowArrayEqual = (a, b) => {
 	if (a === b) return true;