@askrjs/askr 0.0.52 → 0.0.54

package/dist/runtime/for-reconcile.js

@@ -1,442 +0,0 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { flushBenchMetrics, isBenchBuildEnabled, recordBenchEvent, recordBenchFastLane, recordBenchTiming, resetBenchMetrics } from "./for-bench.js";
-import { createItemInstance, disposeAllItems, disposeFallbackScope, disposeItemInstance, renderFallbackScope, syncForItemIndex, updateItemInstance } from "./for-scopes.js";
-//#region src/runtime/for-reconcile.ts
-const BENCH_BUILD_ENABLED = isBenchBuildEnabled();
-function failForValidation(message) {
-	throw new Error(message);
-}
-function validateForKeys(forState, newArray) {
-	if (!isDevelopmentEnvironment()) return;
-	const seen = /* @__PURE__ */ new Set();
-	const keyKinds = /* @__PURE__ */ new Map();
-	for (let i = 0; i < newArray.length; i++) {
-		const key = forState.byFn(newArray[i], i);
-		if (key === null || key === void 0) failForValidation("[askr] Invalid For key detected. Keys should be stable, non-null, and unique within a For list.");
-		if (seen.has(key)) failForValidation(`[askr] Duplicate For key detected: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`);
-		seen.add(key);
-		const keyKind = typeof key;
-		const previousKeyKind = forState.devKeyKinds?.get(key);
-		if (previousKeyKind && previousKeyKind !== keyKind) failForValidation(`[askr] For key type changed for ${String(key)}. Keys must remain consistently typed across renders.`);
-		keyKinds.set(key, keyKind);
-	}
-	forState.devKeyKinds = keyKinds;
-}
-function reconcileForItems(forState, newArray) {
-	forState.currentItems = newArray;
-	validateForKeys(forState, newArray);
-	if (BENCH_BUILD_ENABLED) resetBenchMetrics();
-	const reconcileStartMs = BENCH_BUILD_ENABLED ? performance.now() : 0;
-	const { items, orderedKeys, byFn } = forState;
-	const oldLen = orderedKeys.length;
-	const newLen = newArray.length;
-	forState.lastRemovedNodes = [];
-	forState.lastRemovedRanges = [];
-	if (newLen === 0) {
-		if (oldLen > 0) disposeAllItems(forState, forState.fallback ? "teardown" : "none");
-		recordBenchFastLane("TRUNCATE");
-		forState.lastCommitStrategy = "TRUNCATE";
-		forState.pendingDirtyIndices = null;
-		forState.pendingSwapIndices = null;
-		forState.pendingMoveOnly = false;
-		if (BENCH_BUILD_ENABLED) {
-			recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-			flushBenchMetrics();
-		}
-		return renderFallbackScope(forState);
-	}
-	if (forState.fallbackScope) disposeFallbackScope(forState, "none");
-	if (newLen === oldLen + 1) {
-		let oldIndex = 0;
-		let insertedIndex = -1;
-		let insertedKey = null;
-		for (let newIndex = 0; newIndex < newLen; newIndex++) {
-			const item = newArray[newIndex];
-			const key = byFn(item, newIndex);
-			const expectedKey = orderedKeys[oldIndex];
-			if (oldIndex < oldLen && key === expectedKey) {
-				const existing = items.get(key);
-				if (!existing || existing.item !== item || existing.scope.needsDomUpdate || oldIndex !== newIndex && existing.indexSignal._hasBeenRead) {
-					insertedIndex = -2;
-					break;
-				}
-				oldIndex++;
-			} else if (insertedIndex === -1 && !items.has(key)) {
-				insertedIndex = newIndex;
-				insertedKey = key;
-			} else {
-				insertedIndex = -2;
-				break;
-			}
-		}
-		if (insertedIndex >= 0 && oldIndex === oldLen && insertedKey !== null) {
-			const insertedItem = createItemInstance(insertedKey, newArray[insertedIndex], insertedIndex, forState);
-			const resultVNodes = forState.orderedVNodes.slice();
-			const resultItems = forState.orderedItems.slice();
-			const resultKeys = orderedKeys.slice();
-			resultVNodes.splice(insertedIndex, 0, insertedItem.scope.vnode);
-			resultItems.splice(insertedIndex, 0, insertedItem);
-			resultKeys.splice(insertedIndex, 0, insertedKey);
-			items.set(insertedKey, insertedItem);
-			recordBenchFastLane("INSERT_ONE");
-			recordBenchEvent("itemReused", oldLen);
-			forState.lastCommitStrategy = "INSERT_ONE";
-			forState.orderedKeys = resultKeys;
-			forState.orderedItems = resultItems;
-			forState.orderedVNodes = resultVNodes;
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			forState.pendingInsertedIndex = insertedIndex;
-			if (BENCH_BUILD_ENABLED) {
-				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-				flushBenchMetrics();
-			}
-			return resultVNodes;
-		}
-	}
-	if (oldLen < newLen) {
-		let canUseAppendPath = true;
-		let canSkipCommittedPrefix = true;
-		for (let i = 0; i < oldLen; i++) {
-			const key = byFn(newArray[i], i);
-			if (key !== orderedKeys[i]) {
-				canUseAppendPath = false;
-				break;
-			}
-			const existing = forState.orderedItems[i] ?? items.get(key);
-			if (!existing || existing.item !== newArray[i] || existing.scope.needsDomUpdate || existing.scope.hydrationPending) canSkipCommittedPrefix = false;
-		}
-		if (canUseAppendPath) {
-			if (BENCH_BUILD_ENABLED) recordBenchFastLane("APPEND");
-			forState.lastCommitStrategy = "APPEND";
-			const resultVNodes = forState.orderedVNodes;
-			const resultItems = forState.orderedItems;
-			resultVNodes.length = newLen;
-			resultItems.length = newLen;
-			if (!canSkipCommittedPrefix) for (let i = 0; i < oldLen; i++) {
-				const item = newArray[i];
-				const key = orderedKeys[i];
-				const existing = resultItems[i] ?? items.get(key);
-				updateItemInstance(forState, existing, item);
-				resultItems[i] = existing;
-				resultVNodes[i] = existing.scope.vnode;
-			}
-			if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused", oldLen);
-			for (let i = oldLen; i < newLen; i++) {
-				const item = newArray[i];
-				const key = byFn(item, i);
-				const itemInstance = createItemInstance(key, item, i, forState);
-				items.set(key, itemInstance);
-				resultItems[i] = itemInstance;
-				resultVNodes[i] = itemInstance.scope.vnode;
-				orderedKeys[i] = key;
-			}
-			if (BENCH_BUILD_ENABLED) {
-				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-				flushBenchMetrics();
-			}
-			forState.orderedVNodes = resultVNodes;
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			forState.pendingAppendStart = canSkipCommittedPrefix ? oldLen : 0;
-			return resultVNodes;
-		}
-	}
-	if (newLen < oldLen) {
-		if (oldLen === newLen + 1) {
-			let removedIndex = -1;
-			for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-				removedIndex = i;
-				break;
-			}
-			if (removedIndex !== -1) {
-				let canUseRemoveOnePath = true;
-				for (let i = removedIndex; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i + 1]) {
-					canUseRemoveOnePath = false;
-					break;
-				}
-				if (canUseRemoveOnePath) {
-					if (BENCH_BUILD_ENABLED) recordBenchFastLane("REMOVE_ONE");
-					forState.lastCommitStrategy = "NO_REORDER";
-					const previousOrderedItems = forState.orderedItems.slice();
-					const resultVNodes = forState.orderedVNodes;
-					const resultItems = forState.orderedItems;
-					resultVNodes.length = newLen;
-					resultItems.length = newLen;
-					const dirtyIndices = [];
-					for (let i = 0; i < newLen; i++) {
-						const item = newArray[i];
-						const key = i < removedIndex ? orderedKeys[i] : orderedKeys[i + 1];
-						const existing = items.get(key);
-						const scopeNeedsDomUpdate = existing.scope.needsDomUpdate;
-						const itemChanged = existing.item !== item;
-						const indexChanged = existing.indexSignal.peek() !== i;
-						if (itemChanged) updateItemInstance(forState, existing, item);
-						const indexVisibleChange = indexChanged ? syncForItemIndex(forState, existing, i) : false;
-						if (itemChanged || indexVisibleChange || scopeNeedsDomUpdate) dirtyIndices.push(i);
-						resultItems[i] = existing;
-						resultVNodes[i] = existing.scope.vnode;
-					}
-					if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused", newLen);
-					const removedKey = orderedKeys[removedIndex];
-					const removedItem = items.get(removedKey);
-					if (removedItem) {
-						disposeItemInstance(forState, removedItem, "teardown");
-						items.delete(removedKey);
-					}
-					const nextOrderedKeys = orderedKeys.slice(0, newLen);
-					const nextOrderedItems = previousOrderedItems.slice(0, newLen);
-					for (let i = removedIndex; i < newLen; i++) {
-						nextOrderedKeys[i] = orderedKeys[i + 1];
-						nextOrderedItems[i] = previousOrderedItems[i + 1];
-					}
-					forState.orderedKeys = nextOrderedKeys;
-					forState.orderedItems = nextOrderedItems;
-					if (BENCH_BUILD_ENABLED) {
-						recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-						flushBenchMetrics();
-					}
-					forState.pendingDirtyIndices = dirtyIndices;
-					forState.pendingSwapIndices = null;
-					forState.pendingMoveOnly = false;
-					return resultVNodes;
-				}
-			}
-		}
-		let canUseTruncatePath = true;
-		for (let i = 0; i < newLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-			canUseTruncatePath = false;
-			break;
-		}
-		if (canUseTruncatePath) {
-			recordBenchFastLane("TRUNCATE");
-			forState.lastCommitStrategy = "TRUNCATE";
-			const resultVNodes = forState.orderedVNodes;
-			const resultItems = forState.orderedItems;
-			resultVNodes.length = newLen;
-			resultItems.length = newLen;
-			const isFullClear = newLen === 0;
-			for (let i = 0; i < newLen; i++) {
-				const item = newArray[i];
-				const key = orderedKeys[i];
-				const existing = items.get(key);
-				updateItemInstance(forState, existing, item);
-				resultItems[i] = existing;
-				resultVNodes[i] = existing.scope.vnode;
-			}
-			recordBenchEvent("itemReused", newLen);
-			for (let i = newLen; i < oldLen; i++) {
-				const key = orderedKeys[i];
-				const itemInstance = items.get(key);
-				if (itemInstance) {
-					disposeItemInstance(forState, itemInstance, isFullClear ? "full-clear" : "teardown");
-					items.delete(key);
-				}
-			}
-			orderedKeys.length = newLen;
-			forState.orderedKeys = orderedKeys;
-			forState.orderedItems.length = newLen;
-			if (BENCH_BUILD_ENABLED) {
-				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-				flushBenchMetrics();
-			}
-			forState.orderedVNodes = resultVNodes;
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			return resultVNodes;
-		}
-	}
-	if (oldLen === newLen) {
-		let canUseNoReorderPath = true;
-		for (let i = 0; i < oldLen; i++) if (byFn(newArray[i], i) !== orderedKeys[i]) {
-			canUseNoReorderPath = false;
-			break;
-		}
-		if (canUseNoReorderPath) {
-			recordBenchFastLane("NO_REORDER");
-			forState.lastCommitStrategy = "NO_REORDER";
-			const resultVNodes = forState.orderedVNodes;
-			const resultItems = forState.orderedItems;
-			resultVNodes.length = oldLen;
-			resultItems.length = oldLen;
-			const dirtyIndices = [];
-			for (let i = 0; i < oldLen; i++) {
-				const item = newArray[i];
-				const key = orderedKeys[i];
-				const existing = items.get(key);
-				if (existing.item !== item) updateItemInstance(forState, existing, item);
-				if (existing.scope.needsDomUpdate) dirtyIndices.push(i);
-				resultItems[i] = existing;
-				resultVNodes[i] = existing.scope.vnode;
-			}
-			recordBenchEvent("itemReused", oldLen);
-			if (BENCH_BUILD_ENABLED) {
-				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-				flushBenchMetrics();
-			}
-			forState.pendingDirtyIndices = dirtyIndices;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = false;
-			return resultVNodes;
-		}
-		let firstMismatch = -1;
-		let secondMismatch = -1;
-		let firstMismatchKey = null;
-		let secondMismatchKey = null;
-		let mismatchCount = 0;
-		let canUseSwapPath = true;
-		for (let i = 0; i < oldLen; i++) {
-			const item = newArray[i];
-			const key = byFn(newArray[i], i);
-			if (key === orderedKeys[i]) {
-				const existing = items.get(key);
-				if (existing && existing.item !== item) {
-					canUseSwapPath = false;
-					break;
-				}
-				continue;
-			}
-			mismatchCount++;
-			if (firstMismatch === -1) {
-				firstMismatch = i;
-				firstMismatchKey = key;
-				continue;
-			}
-			if (secondMismatch === -1) {
-				secondMismatch = i;
-				secondMismatchKey = key;
-				continue;
-			}
-			mismatchCount = 3;
-			break;
-		}
-		if (canUseSwapPath && mismatchCount === 2 && firstMismatch !== -1 && secondMismatch !== -1 && firstMismatchKey === orderedKeys[secondMismatch] && secondMismatchKey === orderedKeys[firstMismatch]) {
-			recordBenchFastLane("SWAP");
-			recordBenchEvent("itemMoved");
-			recordBenchEvent("itemMoved");
-			forState.lastCommitStrategy = "SWAP";
-			const nextOrderedKeys = orderedKeys.slice();
-			nextOrderedKeys[firstMismatch] = firstMismatchKey;
-			nextOrderedKeys[secondMismatch] = secondMismatchKey;
-			const resultVNodes = forState.orderedVNodes;
-			const firstExisting = items.get(firstMismatchKey);
-			const secondExisting = items.get(secondMismatchKey);
-			const firstItem = newArray[firstMismatch];
-			const secondItem = newArray[secondMismatch];
-			const nextOrderedItems = forState.orderedItems.slice();
-			nextOrderedItems[firstMismatch] = secondExisting;
-			nextOrderedItems[secondMismatch] = firstExisting;
-			if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused");
-			recordBenchEvent("itemReused");
-			if (firstExisting.item !== firstItem) updateItemInstance(forState, firstExisting, firstItem);
-			if (secondExisting.item !== secondItem) updateItemInstance(forState, secondExisting, secondItem);
-			syncForItemIndex(forState, firstExisting, firstMismatch);
-			syncForItemIndex(forState, secondExisting, secondMismatch);
-			resultVNodes[firstMismatch] = firstExisting.scope.vnode;
-			resultVNodes[secondMismatch] = secondExisting.scope.vnode;
-			forState.orderedKeys = nextOrderedKeys;
-			forState.orderedItems = nextOrderedItems;
-			if (BENCH_BUILD_ENABLED) {
-				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-				flushBenchMetrics();
-			}
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = [firstMismatch, secondMismatch];
-			forState.pendingMoveOnly = true;
-			return resultVNodes;
-		}
-		let canUseMoveOnlyPath = true;
-		const moveOnlyKeys = [];
-		const moveOnlyItems = [];
-		const moveOnlyVNodes = [];
-		for (let i = 0; i < oldLen; i++) {
-			const item = newArray[i];
-			const key = byFn(item, i);
-			const existing = items.get(key);
-			if (!existing || existing.item !== item || existing.indexSignal._hasBeenRead && existing.indexSignal.peek() !== i) {
-				canUseMoveOnlyPath = false;
-				break;
-			}
-			moveOnlyKeys[i] = key;
-			moveOnlyItems[i] = existing;
-			moveOnlyVNodes[i] = existing.scope.vnode;
-			recordBenchEvent("itemReused");
-		}
-		if (canUseMoveOnlyPath) {
-			if (BENCH_BUILD_ENABLED) recordBenchFastLane("FULL_KEYED");
-			forState.lastCommitStrategy = "FULL_KEYED";
-			for (let i = 0; i < moveOnlyItems.length; i++) {
-				syncForItemIndex(forState, moveOnlyItems[i], i);
-				moveOnlyVNodes[i] = moveOnlyItems[i].scope.vnode;
-			}
-			forState.orderedKeys = moveOnlyKeys;
-			forState.orderedItems = moveOnlyItems;
-			forState.orderedVNodes = moveOnlyVNodes;
-			if (BENCH_BUILD_ENABLED) {
-				recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-				flushBenchMetrics();
-			}
-			forState.pendingDirtyIndices = null;
-			forState.pendingSwapIndices = null;
-			forState.pendingMoveOnly = true;
-			return moveOnlyVNodes;
-		}
-	}
-	if (BENCH_BUILD_ENABLED) recordBenchFastLane("FULL_KEYED");
-	forState.lastCommitStrategy = "FULL_KEYED";
-	const toRemove = new Set(orderedKeys);
-	const newOrderedKeys = [];
-	const newOrderedItems = [];
-	const resultVNodes = [];
-	let moveOnly = toRemove.size === newArray.length;
-	for (let i = 0; i < newArray.length; i++) {
-		const item = newArray[i];
-		const key = byFn(item, i);
-		if (BENCH_BUILD_ENABLED) recordBenchEvent("keyLookup");
-		toRemove.delete(key);
-		newOrderedKeys.push(key);
-		const existing = items.get(key);
-		if (BENCH_BUILD_ENABLED) recordBenchEvent(existing ? "keyHit" : "keyMiss");
-		if (!existing) {
-			const itemInstance = createItemInstance(key, item, i, forState);
-			items.set(key, itemInstance);
-			newOrderedItems.push(itemInstance);
-			resultVNodes.push(itemInstance.scope.vnode);
-		} else {
-			if (BENCH_BUILD_ENABLED) recordBenchEvent("itemReused");
-			const itemChanged = existing.item !== item;
-			const indexChanged = existing.indexSignal.peek() !== i;
-			if (itemChanged) {
-				moveOnly = false;
-				updateItemInstance(forState, existing, item);
-			}
-			if (indexChanged) syncForItemIndex(forState, existing, i);
-			newOrderedItems.push(existing);
-			resultVNodes.push(existing.scope.vnode);
-		}
-	}
-	for (const key of toRemove) {
-		moveOnly = false;
-		const itemInstance = items.get(key);
-		if (itemInstance) {
-			disposeItemInstance(forState, itemInstance, "none");
-			items.delete(key);
-		}
-	}
-	forState.orderedKeys = newOrderedKeys;
-	forState.orderedItems = newOrderedItems;
-	if (BENCH_BUILD_ENABLED) {
-		recordBenchTiming("reconcile", performance.now() - reconcileStartMs);
-		flushBenchMetrics();
-	}
-	forState.orderedVNodes = resultVNodes;
-	forState.pendingDirtyIndices = null;
-	forState.pendingSwapIndices = null;
-	forState.pendingMoveOnly = moveOnly;
-	return resultVNodes;
-}
-//#endregion
-export { reconcileForItems };

package/dist/runtime/for-scopes.d.ts

@@ -1,26 +0,0 @@
-import { ChildScope } from "./child-scope.js";
-import { ForIndexSignal, ReactiveForItemState } from "./for-signals.js";
-import { ForState } from "./for-internal.js";
-import { VNode } from "../common/vnode.js";
-
-//#region src/runtime/for-scopes.d.ts
-interface ForItemInstance<T> {
-  key: string | number;
-  item: T;
-  reactiveItem: T;
-  reactiveItemState: ReactiveForItemState<T> | null;
-  indexSignal: ForIndexSignal;
-  scope: ChildScope;
-}
-type RemovedDomCleanupMode = 'none' | 'teardown' | 'full-clear';
-declare function captureForItemTransactionSnapshot<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>): void;
-declare function captureForFallbackTransactionSnapshot<T>(forState: ForState<T>, fallbackScope?: ChildScope | null): void;
-declare function syncForItemIndex<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>, nextIndex: number): boolean;
-declare function disposeItemInstance<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>, domCleanup: RemovedDomCleanupMode): void;
-declare function createItemInstance<T>(key: string | number, item: T, index: number, forState: ForState<T>): ForItemInstance<T>;
-declare function updateItemInstance<T>(forState: ForState<T>, itemInstance: ForItemInstance<T>, item: T): boolean;
-declare function disposeFallbackScope<T>(forState: ForState<T>, domCleanup: RemovedDomCleanupMode): void;
-declare function renderFallbackScope<T>(forState: ForState<T>): VNode[];
-declare function disposeAllItems<T>(forState: ForState<T>, domCleanup: RemovedDomCleanupMode): void;
-//#endregion
-export { ForItemInstance, RemovedDomCleanupMode };