@askrjs/askr 0.0.52 → 0.0.54

package/dist/runtime/for-scopes.js

@@ -1,280 +0,0 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { getRuntimeRenderer } from "./access.js";
-import { captureChildScopeTransactionSnapshot, createChildScope, disposeChildScope } from "./child-scope.js";
-import { canProxyForItem, createForIndexSignal, createReactiveForItem, haveSameOwnKeys, notifyForSignalReaders, readForItemProperty, removeForParentReaders, scopeDirectlyReadsSource, scopeReadsSource, syncForIndexSignal } from "./for-signals.js";
-import "./for-bench.js";
-function enqueueForScopeUpdate(parent) {
-	parent?._enqueueRun?.();
-}
-const forStatesByScope = /* @__PURE__ */ new WeakMap();
-function enqueueForBoundaryScopeCommit() {
-	const forState = this.blueprintOwner ?? forStatesByScope.get(this);
-	if (!forState) return;
-	if (forState._enqueueBoundaryCommit) {
-		forState._enqueueBoundaryCommit();
-		return;
-	}
-	enqueueForScopeUpdate(forState.parentInstance);
-}
-function createForOwnedChildScope(forState, key) {
-	return createChildScope(forState.parentInstance, key, enqueueForBoundaryScopeCommit);
-}
-function captureForItemTransactionSnapshot(forState, itemInstance) {
-	const transaction = forState._transaction;
-	if (!transaction || transaction.itemSnapshots?.has(itemInstance)) return;
-	if (transaction.collectionSnapshotMode === "reset-empty" || transaction.items.get(itemInstance.key) !== itemInstance) return;
-	const itemSnapshots = transaction.itemSnapshots ??= /* @__PURE__ */ new Map();
-	const propertySignals = itemInstance.reactiveItemState?.propertySignals ?? null;
-	const itemSignal = itemInstance.reactiveItemState?.itemSignal ?? null;
-	const propertySnapshots = propertySignals && propertySignals.size > 0 ? new Map(Array.from(propertySignals, ([property, signal]) => [property, {
-		signal,
-		value: signal.peek(),
-		hasBeenRead: signal._hasBeenRead === true
-	}])) : null;
-	itemSnapshots.set(itemInstance, {
-		item: itemInstance.item,
-		itemSignalExists: itemSignal !== null,
-		itemSignalValue: itemSignal?.peek(),
-		itemSignalHasBeenRead: itemSignal?._hasBeenRead === true,
-		indexValue: itemInstance.indexSignal.peek(),
-		indexHasBeenRead: itemInstance.indexSignal._hasBeenRead === true,
-		propertySignalStore: propertySignals,
-		propertySignals: propertySnapshots,
-		scope: captureChildScopeTransactionSnapshot(itemInstance.scope)
-	});
-}
-function captureForFallbackTransactionSnapshot(forState, fallbackScope = forState.fallbackScope) {
-	const transaction = forState._transaction;
-	if (!transaction || !fallbackScope || transaction.fallbackScope !== fallbackScope || transaction.fallbackScopeSnapshot) return;
-	transaction.fallbackScopeSnapshot = captureChildScopeTransactionSnapshot(fallbackScope);
-}
-function stageForSignalEffect(forState, source, notify, skipInstance = null, skipOwnedBy = null) {
-	const transaction = forState._transaction;
-	if (!transaction) return false;
-	const effects = transaction.signalEffects ??= /* @__PURE__ */ new Map();
-	const existing = effects.get(source);
-	if (existing) {
-		existing.notify ||= notify;
-		if (existing.skipInstance !== skipInstance) existing.skipInstance = null;
-		if (existing.skipOwnedBy !== skipOwnedBy) existing.skipOwnedBy = null;
-	} else effects.set(source, {
-		parentInstance: forState.parentInstance,
-		notify,
-		skipInstance,
-		skipOwnedBy
-	});
-	return true;
-}
-function syncForItemIndex(forState, itemInstance, nextIndex) {
-	const indexSignal = itemInstance.indexSignal;
-	const previousIndex = indexSignal.peek();
-	if (previousIndex === nextIndex) return false;
-	if (indexSignal._hasBeenRead !== true) {
-		const transaction = forState._transaction;
-		if (transaction) {
-			const snapshots = transaction.unreadIndexSnapshots ??= /* @__PURE__ */ new Map();
-			if (!snapshots.has(indexSignal)) snapshots.set(indexSignal, previousIndex);
-		}
-		indexSignal.set(nextIndex, false);
-		return false;
-	}
-	captureForItemTransactionSnapshot(forState, itemInstance);
-	const scopeReadsIndex = scopeReadsSource(itemInstance.scope, indexSignal);
-	const scopeDirectlyReadsIndex = scopeDirectlyReadsSource(itemInstance.scope, indexSignal);
-	if (forState._transaction) {
-		const shouldNotify = indexSignal._hasBeenRead === true;
-		indexSignal.set(nextIndex, false);
-		stageForSignalEffect(forState, indexSignal, shouldNotify, scopeReadsIndex ? itemInstance.scope.componentInstance : null);
-		if (!scopeReadsIndex) return false;
-		if (scopeDirectlyReadsIndex) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
-		else itemInstance.scope.markDirty();
-		return true;
-	}
-	if (!scopeReadsIndex) {
-		syncForIndexSignal(indexSignal, nextIndex);
-		return false;
-	}
-	indexSignal.set(nextIndex, false);
-	notifyForSignalReaders(indexSignal, itemInstance.scope.componentInstance);
-	rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
-	return true;
-}
-function materializeItemVnode(forState, key, vnode) {
-	if (vnode && typeof vnode === "object" && "type" in vnode) {
-		const vn = vnode;
-		vn.key = key;
-		if (forState.parentInstance?.ssr && typeof vn.type === "string") {
-			if (!vn.props) vn.props = {};
-			if (vn.props["data-key"] === void 0) vn.props["data-key"] = String(key);
-			if (vn.props["data-askr-key-kind"] === void 0) vn.props["data-askr-key-kind"] = typeof key;
-		}
-	}
-}
-function renderItemScope(forState, scope, item, indexSignal, key) {
-	const vnode = scope.render(() => forState.renderFn(item, indexSignal));
-	materializeItemVnode(forState, key, vnode);
-	return vnode;
-}
-function disposeItemInstance(forState, itemInstance, domCleanup) {
-	const removedDom = itemInstance.scope.dom;
-	const removedRange = itemInstance.scope.range;
-	const transaction = forState._transaction;
-	if (transaction) {
-		(transaction.removedScopes ??= []).push(itemInstance.scope);
-		if (removedDom) forState.lastRemovedNodes.push(removedDom);
-		if (removedRange) forState.lastRemovedRanges.push(removedRange);
-		return;
-	}
-	try {
-		disposeChildScope(itemInstance.scope);
-	} catch (err) {
-		if (isDevelopmentEnvironment()) console.error("[For] Cleanup error:", err);
-	}
-	if (!removedDom) return;
-	if (removedDom instanceof Element) {
-		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
-	}
-	forState.lastRemovedNodes.push(removedDom);
-	if (removedRange) forState.lastRemovedRanges.push(removedRange);
-}
-function createItemInstance(key, item, index, forState) {
-	const indexSignal = createForIndexSignal(index);
-	const reactiveItemState = canProxyForItem(item) ? createReactiveForItem(item) : null;
-	const reactiveItem = reactiveItemState?.proxy ?? item;
-	const scope = createForOwnedChildScope(forState, key);
-	scope.blueprintOwner = forState;
-	try {
-		renderItemScope(forState, scope, reactiveItem, indexSignal, key);
-	} catch (error) {
-		disposeChildScope(scope);
-		throw error;
-	}
-	return {
-		key,
-		item,
-		reactiveItem,
-		reactiveItemState,
-		indexSignal,
-		scope
-	};
-}
-function rerenderItemInstance(forState, itemInstance, item) {
-	renderItemScope(forState, itemInstance.scope, item, itemInstance.indexSignal, itemInstance.key);
-}
-function updateItemInstance(forState, itemInstance, item) {
-	if (itemInstance.item === item) return false;
-	captureForItemTransactionSnapshot(forState, itemInstance);
-	const previousItem = itemInstance.item;
-	itemInstance.item = item;
-	const scope = itemInstance.scope;
-	let scopeReadsChangedSignal = false;
-	const reactiveItemState = itemInstance.reactiveItemState;
-	if (!reactiveItemState) {
-		rerenderItemInstance(forState, itemInstance, item);
-		return true;
-	}
-	const itemSignal = reactiveItemState.itemSignal;
-	reactiveItemState.currentItem = item;
-	const propertySignals = reactiveItemState.propertySignals;
-	const changedPropertySignals = [];
-	if (propertySignals && propertySignals.size > 0) for (const [prop, propertySignal] of propertySignals) {
-		const previousValue = readForItemProperty(previousItem, prop);
-		const nextValue = readForItemProperty(item, prop);
-		if (Object.is(previousValue, nextValue)) continue;
-		if (scopeReadsSource(scope, propertySignal)) scopeReadsChangedSignal = true;
-		changedPropertySignals.push([propertySignal, nextValue]);
-	}
-	if (itemSignal && scopeReadsSource(scope, itemSignal)) scopeReadsChangedSignal = true;
-	let coalescedPropertyChanged = false;
-	const coalescedProperties = reactiveItemState.coalescedProperties;
-	if (coalescedProperties !== null) if (Array.isArray(coalescedProperties)) {
-		for (const property of coalescedProperties) if (!Object.is(readForItemProperty(previousItem, property), readForItemProperty(item, property))) {
-			coalescedPropertyChanged = true;
-			break;
-		}
-	} else {
-		coalescedPropertyChanged = !Object.is(readForItemProperty(previousItem, coalescedProperties), readForItemProperty(item, coalescedProperties));
-		const secondProperty = reactiveItemState.coalescedProperty2;
-		if (secondProperty !== null && !coalescedPropertyChanged) coalescedPropertyChanged = !Object.is(readForItemProperty(previousItem, secondProperty), readForItemProperty(item, secondProperty));
-	}
-	const wholeItemChanged = itemSignal?._hasBeenRead === true && (reactiveItemState.wholeItemRead || coalescedPropertyChanged);
-	const itemShapeChanged = !wholeItemChanged && changedPropertySignals.length === 0 && !haveSameOwnKeys(previousItem, item);
-	const notifyReaders = !scopeReadsChangedSignal && (changedPropertySignals.length > 0 || itemShapeChanged || wholeItemChanged);
-	const visibleChange = scopeReadsChangedSignal || changedPropertySignals.length > 0 || itemShapeChanged || wholeItemChanged;
-	for (const [propertySignal, nextValue] of changedPropertySignals) if (stageForSignalEffect(forState, propertySignal, notifyReaders, null, itemInstance.scope.componentInstance)) propertySignal.set(nextValue, false);
-	else {
-		removeForParentReaders(forState.parentInstance, propertySignal);
-		propertySignal.set(nextValue, notifyReaders);
-	}
-	if (itemSignal && stageForSignalEffect(forState, itemSignal, notifyReaders, null, itemInstance.scope.componentInstance)) itemSignal.set(item, false);
-	else if (itemSignal) {
-		removeForParentReaders(forState.parentInstance, itemSignal);
-		itemSignal.set(item, notifyReaders);
-	}
-	if (scopeReadsChangedSignal) if (itemSignal !== null && scopeDirectlyReadsSource(scope, itemSignal) || changedPropertySignals.some(([propertySignal]) => scopeDirectlyReadsSource(scope, propertySignal))) rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);
-	else scope.markDirty();
-	return visibleChange;
-}
-const FOR_FALLBACK_SCOPE_KEY = "__for-fallback__";
-function disposeFallbackScope(forState, domCleanup) {
-	const fallbackScope = forState.fallbackScope;
-	if (!fallbackScope) return;
-	const removedDom = fallbackScope.dom;
-	const removedRange = fallbackScope.range;
-	const transaction = forState._transaction;
-	if (transaction) {
-		(transaction.removedScopes ??= []).push(fallbackScope);
-		if (removedRange) forState.lastRemovedRanges.push(removedRange);
-	} else disposeChildScope(fallbackScope);
-	forState.fallbackScope = null;
-	if (!removedDom) return;
-	if (removedDom instanceof Element) {
-		if (domCleanup === "teardown") getRuntimeRenderer().teardownNodeSubtree(removedDom);
-	}
-	forState.lastRemovedNodes.push(removedDom);
-	if (removedRange) forState.lastRemovedRanges.push(removedRange);
-}
-function renderFallbackScope(forState) {
-	if (forState.fallback == null || forState.fallback === false) {
-		if (forState.fallbackScope) disposeFallbackScope(forState, "none");
-		forState.orderedVNodes = [];
-		forState.orderedItems = [];
-		return [];
-	}
-	const fallbackScope = forState.fallbackScope ?? createForOwnedChildScope(forState, FOR_FALLBACK_SCOPE_KEY);
-	if (!forState.fallbackScope) forStatesByScope.set(fallbackScope, forState);
-	forState.fallbackScope = fallbackScope;
-	captureForFallbackTransactionSnapshot(forState, fallbackScope);
-	const fallbackVNode = forState.fallback;
-	const vnode = fallbackScope.render(() => fallbackVNode);
-	forState.orderedVNodes = vnode == null || vnode === false ? [] : [vnode];
-	forState.orderedItems = [];
-	return forState.orderedVNodes;
-}
-function disposeAllItems(forState, domCleanup) {
-	const { items, orderedKeys } = forState;
-	if (forState._transaction?.collectionSnapshotMode === "preserve-clear") {
-		const transaction = forState._transaction;
-		transaction.removeAllItems = true;
-		for (let index = 0; index < forState.orderedItems.length; index++) {
-			const removedDom = forState.orderedItems[index]?.scope.dom;
-			if (removedDom) forState.lastRemovedNodes.push(removedDom);
-			const range = forState.orderedItems[index]?.scope.range;
-			if (range) forState.lastRemovedRanges.push(range);
-		}
-		forState.items = /* @__PURE__ */ new Map();
-		forState.orderedKeys = [];
-		return;
-	}
-	for (let index = 0; index < orderedKeys.length; index += 1) {
-		const key = orderedKeys[index];
-		const itemInstance = items.get(key);
-		if (!itemInstance) continue;
-		disposeItemInstance(forState, itemInstance, domCleanup);
-		items.delete(key);
-	}
-	orderedKeys.length = 0;
-	forState.orderedKeys = orderedKeys;
-}
-//#endregion
-export { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot, createItemInstance, disposeAllItems, disposeFallbackScope, disposeItemInstance, renderFallbackScope, syncForItemIndex, updateItemInstance };

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

@@ -1,39 +0,0 @@
-import { ComponentInstance } from "./component-internal.js";
-import { ReadableSource } from "./readable.js";
-import { ChildScope } from "./child-scope.js";
-
-//#region src/runtime/for-signals.d.ts
-type ForItemSignal<T> = ReadableSource<T> & (() => T) & {
-  peek(): T;
-  set(newValue: T, notifyReaders?: boolean): void;
-};
-type ForItemPropertySignal = ReadableSource<unknown> & (() => unknown) & {
-  peek(): unknown;
-  set(newValue: unknown, notifyReaders?: boolean): void;
-};
-type ForIndexSignal = ReadableSource<number> & (() => number) & {
-  peek(): number;
-  set(newValue: number | ((prev: number) => number), notifyReaders?: boolean): void;
-};
-declare function notifyForSignalReaders(source: ReadableSource<unknown>, skipInstance?: ComponentInstance | null, skipOwnedBy?: ComponentInstance | null): void;
-declare function createForIndexSignal(initialIndex: number): ForIndexSignal;
-declare function syncForIndexSignal(indexSignal: ForIndexSignal, nextIndex: number): boolean;
-declare function createForItemSignal<T>(initialItem: T): ForItemSignal<T>;
-declare function readForItemProperty(item: unknown, prop: PropertyKey): unknown;
-declare function haveSameOwnKeys(previousItem: unknown, nextItem: unknown): boolean;
-declare function scopeReadsSource(scope: ChildScope, source: ReadableSource<unknown>): boolean;
-declare function scopeDirectlyReadsSource(scope: ChildScope, source: ReadableSource<unknown>): boolean;
-declare function removeForParentReaders(parentInstance: ComponentInstance | null, source: ReadableSource<unknown>): void;
-declare function canProxyForItem(item: unknown): item is object;
-interface ReactiveForItemState<T> {
-  currentItem: T;
-  itemSignal: ForItemSignal<T> | null;
-  propertySignals: Map<PropertyKey, ForItemPropertySignal> | null;
-  coalescedProperties: PropertyKey | PropertyKey[] | null;
-  coalescedProperty2: PropertyKey | null;
-  wholeItemRead: boolean;
-  proxy: T;
-}
-declare function createReactiveForItem<T>(item: T): ReactiveForItemState<T>;
-//#endregion
-export { ForIndexSignal, ForItemPropertySignal, ForItemSignal, ReactiveForItemState };

package/dist/runtime/for-signals.js

@@ -1,213 +0,0 @@
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead, shouldCoalesceFineGrainedItemReads } from "./readable.js";
-//#region src/runtime/for-signals.ts
-function peekForSignal() {
-	return this._value;
-}
-function setForValueSignal(newValue, notifyReaders = true) {
-	if (Object.is(this._value, newValue)) return;
-	this._value = newValue;
-	if (notifyReaders) notifyForSignalReaders(this);
-}
-function setForIndexValue(newValue, notifyReaders = true) {
-	const nextValue = typeof newValue === "function" ? newValue(this._value) : newValue;
-	if (nextValue === this._value) return;
-	this._value = nextValue;
-	if (notifyReaders) notifyForSignalReaders(this);
-}
-function notifyForSignalReaders(source, skipInstance, skipOwnedBy) {
-	markReadableDerivedSubscribersDirty(source);
-	markReactivePropsDirtySource(source);
-	notifyReadableReaders(source, skipInstance, skipOwnedBy);
-}
-function createForIndexSignal(initialIndex) {
-	function readIndexSignal() {
-		const signal = readIndexSignal;
-		signal._hasBeenRead = true;
-		recordReadableRead(signal);
-		return signal._value;
-	}
-	const indexSignal = readIndexSignal;
-	indexSignal._value = initialIndex;
-	indexSignal.peek = peekForSignal;
-	indexSignal.set = setForIndexValue;
-	indexSignal._hasBeenRead = false;
-	return indexSignal;
-}
-function syncForIndexSignal(indexSignal, nextIndex) {
-	if (indexSignal.peek() === nextIndex) return false;
-	indexSignal.set(nextIndex, indexSignal._hasBeenRead);
-	return indexSignal._hasBeenRead === true;
-}
-function createForItemSignal(initialItem) {
-	function readItemSignal() {
-		const signal = readItemSignal;
-		signal._hasBeenRead = true;
-		recordReadableRead(signal);
-		return signal._value;
-	}
-	const itemSignal = readItemSignal;
-	itemSignal._value = initialItem;
-	itemSignal.peek = peekForSignal;
-	itemSignal.set = setForValueSignal;
-	itemSignal._hasBeenRead = false;
-	return itemSignal;
-}
-function createForItemPropertySignal(initialValue) {
-	function readPropertySignal() {
-		const signal = readPropertySignal;
-		signal._hasBeenRead = true;
-		recordReadableRead(signal);
-		return signal._value;
-	}
-	const propertySignal = readPropertySignal;
-	propertySignal._value = initialValue;
-	propertySignal.peek = peekForSignal;
-	propertySignal.set = setForValueSignal;
-	propertySignal._hasBeenRead = false;
-	return propertySignal;
-}
-function readForItemProperty(item, prop) {
-	return Reflect.get(Object(item), prop);
-}
-function haveSameOwnKeys(previousItem, nextItem) {
-	const previousKeys = Reflect.ownKeys(Object(previousItem));
-	const nextKeys = Reflect.ownKeys(Object(nextItem));
-	if (previousKeys.length !== nextKeys.length) return false;
-	for (let i = 0; i < previousKeys.length; i += 1) if (previousKeys[i] !== nextKeys[i]) return false;
-	return true;
-}
-function scopeReadsSource(scope, source) {
-	const readers = source._readers;
-	if (!readers || readers.size === 0) return false;
-	for (const reader of readers.keys()) {
-		let current = reader;
-		while (current) {
-			if (current === scope.componentInstance) return true;
-			current = current.parentInstance;
-		}
-	}
-	return false;
-}
-function scopeDirectlyReadsSource(scope, source) {
-	return source._readers?.has(scope.componentInstance) ?? false;
-}
-function isForParentReader(parentInstance, reader) {
-	let current = parentInstance;
-	while (current) {
-		if (current === reader) return true;
-		current = current.parentInstance;
-	}
-	return false;
-}
-function removeForParentReaders(parentInstance, source) {
-	const readers = source._readers;
-	if (!readers || readers.size === 0) return;
-	for (const reader of readers.keys()) if (isForParentReader(parentInstance, reader)) readers.delete(reader);
-}
-function getOrCreateForItemPropertySignal(state, prop) {
-	const item = state.currentItem;
-	const propertySignals = state.propertySignals ?? (state.propertySignals = /* @__PURE__ */ new Map());
-	const existingSignal = propertySignals.get(prop);
-	if (existingSignal) return existingSignal;
-	const propertySignal = createForItemPropertySignal(readForItemProperty(item, prop));
-	propertySignals.set(prop, propertySignal);
-	return propertySignal;
-}
-function canProxyForItem(item) {
-	return typeof item === "function" || typeof item === "object" && item !== null && !Array.isArray(item);
-}
-function createReactiveForItem(item) {
-	const target = Object.create(null);
-	const state = {
-		currentItem: item,
-		itemSignal: null,
-		propertySignals: null,
-		coalescedProperties: null,
-		coalescedProperty2: null,
-		wholeItemRead: false,
-		proxy: void 0
-	};
-	target[REACTIVE_FOR_ITEM_STATE] = state;
-	state.proxy = new Proxy(target, REACTIVE_FOR_ITEM_PROXY_HANDLER);
-	return state;
-}
-const REACTIVE_FOR_ITEM_STATE = Symbol("askr.reactive-for-item-state");
-function getReactiveForItemState(target) {
-	return target[REACTIVE_FOR_ITEM_STATE];
-}
-function getWholeItemSignal(state) {
-	let signal = state.itemSignal;
-	if (!signal) {
-		signal = createForItemSignal(state.currentItem);
-		state.itemSignal = signal;
-	}
-	return signal;
-}
-const REACTIVE_FOR_ITEM_PROXY_HANDLER = {
-	get(target, prop, receiver) {
-		if (prop !== REACTIVE_FOR_ITEM_STATE && prop in target) return Reflect.get(target, prop, receiver);
-		const metadata = getReactiveForItemState(target);
-		const currentItem = metadata.currentItem;
-		if (typeof prop !== "symbol") {
-			if (shouldCoalesceFineGrainedItemReads()) {
-				const properties = metadata.coalescedProperties;
-				if (properties === null) metadata.coalescedProperties = prop;
-				else if (Array.isArray(properties)) {
-					if (!properties.includes(prop)) properties.push(prop);
-				} else if (properties !== prop && metadata.coalescedProperty2 !== prop) if (metadata.coalescedProperty2 === null) metadata.coalescedProperty2 = prop;
-				else {
-					metadata.coalescedProperties = [
-						properties,
-						metadata.coalescedProperty2,
-						prop
-					];
-					metadata.coalescedProperty2 = null;
-				}
-				let itemSignal = metadata.itemSignal;
-				if (!itemSignal) {
-					itemSignal = createForItemSignal(currentItem);
-					metadata.itemSignal = itemSignal;
-				}
-				itemSignal();
-				return readForItemProperty(currentItem, prop);
-			}
-			return getOrCreateForItemPropertySignal(metadata, prop)();
-		}
-		metadata.wholeItemRead = true;
-		recordReadableRead(getWholeItemSignal(metadata));
-		return Reflect.get(Object(currentItem), prop, receiver);
-	},
-	has(target, prop) {
-		if (prop === REACTIVE_FOR_ITEM_STATE) return false;
-		const metadata = getReactiveForItemState(target);
-		metadata.wholeItemRead = true;
-		recordReadableRead(getWholeItemSignal(metadata));
-		return prop in target || prop in Object(metadata.currentItem);
-	},
-	ownKeys(target) {
-		const metadata = getReactiveForItemState(target);
-		metadata.wholeItemRead = true;
-		recordReadableRead(getWholeItemSignal(metadata));
-		const keys = /* @__PURE__ */ new Set();
-		for (const key of Reflect.ownKeys(target)) if (key !== REACTIVE_FOR_ITEM_STATE) keys.add(key);
-		for (const key of Reflect.ownKeys(Object(metadata.currentItem))) keys.add(key);
-		return Array.from(keys);
-	},
-	getOwnPropertyDescriptor(target, prop) {
-		if (prop === REACTIVE_FOR_ITEM_STATE) return;
-		const metadata = getReactiveForItemState(target);
-		metadata.wholeItemRead = true;
-		recordReadableRead(getWholeItemSignal(metadata));
-		const ownDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-		if (ownDescriptor) return ownDescriptor;
-		return Object.getOwnPropertyDescriptor(Object(metadata.currentItem), prop);
-	},
-	getPrototypeOf(target) {
-		const metadata = getReactiveForItemState(target);
-		metadata.wholeItemRead = true;
-		recordReadableRead(getWholeItemSignal(metadata));
-		return Object.getPrototypeOf(Object(metadata.currentItem));
-	}
-};
-//#endregion
-export { canProxyForItem, createForIndexSignal, createForItemSignal, createReactiveForItem, haveSameOwnKeys, notifyForSignalReaders, readForItemProperty, removeForParentReaders, scopeDirectlyReadsSource, scopeReadsSource, syncForIndexSignal };

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

@@ -1,8 +0,0 @@
-import { VNode } from "../common/vnode.js";
-
-//#region src/runtime/for-types.d.ts
-type ForEachSource<T> = T[] | (() => T[]);
-type ForKeySelector<T> = (item: T, index: number) => string | number;
-type ForRenderItem<T> = (item: T, index: () => number) => VNode;
-//#endregion
-export { ForEachSource, ForKeySelector, ForRenderItem };

package/dist/runtime/for.d.ts

@@ -1,4 +0,0 @@
-import { ForItemInstance } from "./for-scopes.js";
-import { reconcileForItems } from "./for-reconcile.js";
-import { ForCommitStrategy, ForItemTransactionSnapshot, ForState, ForTransaction } from "./for-internal.js";
-export { ForCommitStrategy, ForItemTransactionSnapshot, ForState, ForTransaction, reconcileForItems };

package/dist/runtime/for.js

@@ -1,5 +0,0 @@
-import { isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "./for-bench.js";
-import { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot } from "./for-scopes.js";
-import { reconcileForItems } from "./for-reconcile.js";
-import { beginForStateTransaction, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, registerForStateTransaction, rollbackForStateTransaction, useForState } from "./for-internal.js";
-export { beginForStateTransaction, captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, isBenchMetricScopeActive, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, registerForStateTransaction, rollbackForStateTransaction, useForState, withBenchMetricScope };

package/dist/runtime/index.d.ts

@@ -1,24 +0,0 @@
-import { State, StateSetter, StateTuple, state } from "./state.js";
-import { Context, ContextFrame, ContextKey, defineContext, readContext } from "./context.js";
-import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { ComponentInstance } from "./component-internal.js";
-import { getSignal } from "./component-scope.js";
-import { DerivedSubscriber, FineGrainedReadCollector, ReadableSource } from "./readable.js";
-import { Scheduler, SchedulerLane, scheduleEventHandler } from "./scheduler.js";
-import { AskrRuntime, AskrRuntimeOptions, RuntimeKeyedReorderDecision, RuntimeRendererHost, createRuntime, getDefaultRuntime } from "./runtime.js";
-import { ChildScope, ChildScopeTransactionSnapshot } from "./child-scope.js";
-import { ForItemInstance } from "./for-scopes.js";
-import { CreateFineGrainedEffectOptions, FineGrainedEffectHandle } from "./effect.js";
-import { ForEachSource, ForKeySelector, ForRenderItem } from "./for-types.js";
-import { reconcileForItems } from "./for-reconcile.js";
-import { ForCommitStrategy, ForItemTransactionSnapshot, ForState, ForTransaction } from "./for-internal.js";
-import { CaseState, ControlBoundaryState, ControlTransaction, MatchBranch, ShowState } from "./control.js";
-import { Derived, derive } from "./derive.js";
-import { DelegatedEventMap } from "./events.js";
-import { ExecutionModel } from "./execution-model.js";
-import { ResourceResult, resource } from "./resource-operation.js";
-import { ActivityPredicate, TimerOptions, capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "./lifecycle-operations.js";
-import { DefaultPortal, Portal, PortalProps, definePortal } from "./portal.js";
-import { Selector, selector } from "./selector.js";
-import { ComponentFunction } from "../common/component.js";
-export { type ActivityPredicate, AskrRuntime, AskrRuntimeOptions, CaseState, ChildScope, ChildScopeTransactionSnapshot, type ComponentFunction, type ComponentInstance, Context, ContextFrame, ContextKey, ControlBoundaryState, ControlTransaction, CreateFineGrainedEffectOptions, DefaultPortal, DelegatedEventMap, Derived, DerivedSubscriber, ExecutionModel, FineGrainedEffectHandle, FineGrainedReadCollector, ForCommitStrategy, type ForEachSource, ForItemTransactionSnapshot, ForState, ForTransaction, MatchBranch, Portal, PortalProps, ReadableSource, type ResourceResult, RuntimeKeyedReorderDecision, RuntimeRendererHost, Selector, ShowState, State, StateSetter, StateTuple, type TimerOptions, capture, createRuntime, defineContext, definePortal, derive, documentVisible, getDefaultRuntime, getSignal, on, readContext, reconcileForItems, resource, routeActive, scheduleEventHandler, selector, state, stream, task, timer, windowFocused };

package/dist/runtime/index.js

@@ -1,33 +0,0 @@
-import { addPerfDuration, getPerfMetricsStore, incrementPerfMetric, recordSchedulerFlushTaskCount } from "./perf-metrics.js";
-import { scheduleEventHandler } from "./scheduler.js";
-import { AskrRuntime, configureRuntimeRenderer, createRuntime, defaultRuntime, getDefaultRuntime } from "./runtime.js";
-import { enqueueRuntimeLane, enqueueRuntimeTask, flushRuntimeScheduler, getDefaultRuntimeInstance, getRuntimeFlushVersion, getRuntimeRenderer, getRuntimeScheduler, getRuntimeSchedulerState, isRuntimeSchedulerExecuting, markRuntimeReactivePropsDirtySource, runRuntimeHandlerScope, runRuntimeWithSyncProgress, setRuntimeBulkCommitProbe } from "./access.js";
-import { CONTEXT_FRAME_SYMBOL, callWithContext, defineContext, getCurrentContextFrame, getExecutionContextFrame, getVNodeContextFrame, markVNodeTreeWithContextFrame, markVNodeWithContextFrame, readContext, withAsyncResourceContext, withContext } from "./context.js";
-import { cleanupReadableSubscriptions, clearDerivedDependencySubscriptions, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, notifyReadableReaders, recordReadableRead, shouldCoalesceFineGrainedItemReads, syncDerivedDependencySubscriptions, withDerivedReadTracking, withFineGrainedReadTracking } from "./readable.js";
-import { getDevNamespace, getDevValue, incDevCounter, setDevValue } from "./dev-namespace.js";
-import { claimHookIndex, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, restoreDomCommitScope, setCurrentComponentInstance } from "./component-scope.js";
-import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { classifyUpdate, commitReorderOnly, enterBulkCommit, exitBulkCommit, isBulkCommitActive, markFastPathApplied, tryRuntimeFastLaneSync } from "./fastlane.js";
-import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, drainLifecycleCommitErrors, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
-import "./component-lifecycle.js";
-import { captureInlineRenderSnapshot, createComponentInstance, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
-import "./component.js";
-import { captureChildScopeTransactionSnapshot, createChildScope, disposeChildScope, rerenderChildScope, restoreChildScopeTransactionSnapshot } from "./child-scope.js";
-import { clearCaseDomUpdateState, clearShowDomUpdateState, createCaseState, createShowState, evaluateCaseState, evaluateShowState } from "./control.js";
-import { derive } from "./derive.js";
-import { createFineGrainedEffect, createOwnedFineGrainedEffect, markFineGrainedEffectsDirtySource } from "./effect.js";
-import { createBoundaryReset, reportBoundaryError } from "./error-boundary.js";
-import { addDelegatedListener, addFreshDelegatedListener, clearDelegatedHandlersForElement, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener } from "./events.js";
-import { assertExecutionModel, getExecutionModel } from "./execution-model.js";
-import { isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "./for-bench.js";
-import { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot } from "./for-scopes.js";
-import { reconcileForItems } from "./for-reconcile.js";
-import { beginForStateTransaction, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, registerForStateTransaction, rollbackForStateTransaction, useForState } from "./for-internal.js";
-import "./for.js";
-import { state } from "./state.js";
-import { resource } from "./resource-operation.js";
-import { capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "./lifecycle-operations.js";
-import "./operations.js";
-import { DefaultPortal, Portal, clearDefaultPortalForInstance, definePortal, disposeDefaultPortalScope } from "./portal.js";
-import { selector } from "./selector.js";
-export { AskrRuntime, CONTEXT_FRAME_SYMBOL, DefaultPortal, Portal, addDelegatedListener, addFreshDelegatedListener, addPerfDuration, assertExecutionModel, beginForStateTransaction, beginLifecycleCommitBatch, callWithContext, capture, captureChildScopeTransactionSnapshot, captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot, captureInlineRenderSnapshot, claimHookIndex, classifyUpdate, cleanupComponent, cleanupReadableSubscriptions, clearCaseDomUpdateState, clearDefaultPortalForInstance, clearDelegatedHandlersForElement, clearDerivedDependencySubscriptions, clearForDomUpdateState, clearShowDomUpdateState, commitForStateTransaction, commitReorderOnly, configureRuntimeRenderer, createBoundaryReset, createCaseState, createChildScope, createComponentInstance, createFineGrainedEffect, createForState, createOwnedFineGrainedEffect, createRuntime, createShowState, defaultRuntime, defineContext, definePortal, derive, discardLifecycleCommitBatch, disposeChildScope, disposeDefaultPortalScope, documentVisible, drainLifecycleCommitErrors, enqueueRuntimeLane, enqueueRuntimeTask, enterBulkCommit, enterDomCommitScope, evaluateCaseState, evaluateForState, evaluateShowState, exitBulkCommit, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot, flushLifecycleCommitBatch, flushRuntimeScheduler, getCurrentComponentInstance, getCurrentContextFrame, getCurrentInstance, getCurrentLifecycleCommitBatch, getCurrentPortalScope, getCurrentStateIndex, getDefaultRuntime, getDefaultRuntimeInstance, getDelegatedHandlerForElement, getDelegatedHandlersForElement, getDevNamespace, getDevValue, getExecutionContextFrame, getExecutionModel, getPerfMetricsStore, getRuntimeFlushVersion, getRuntimeRenderer, getRuntimeScheduler, getRuntimeSchedulerState, getSignal, getVNodeContextFrame, incDevCounter, incrementPerfMetric, isBenchMetricScopeActive, isBulkCommitActive, isDelegatedEvent, isEventDelegationEnabled, isRuntimeSchedulerExecuting, markFastPathApplied, markFineGrainedEffectsDirtySource, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, markRuntimeReactivePropsDirtySource, markVNodeTreeWithContextFrame, markVNodeWithContextFrame, mountComponent, mountInstanceInline, notifyReadableReaders, on, readContext, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, recordReadableRead, recordSchedulerFlushTaskCount, registerCommitOperation, registerForStateTransaction, registerLifecycleRollback, registerLifecycleTransaction, registerOwnedChildScope, removeDelegatedListener, renderComponentInline, renderScopedComponent, reportBoundaryError, rerenderChildScope, resource, restoreChildScopeTransactionSnapshot, restoreDomCommitScope, rollbackForStateTransaction, routeActive, runRuntimeHandlerScope, runRuntimeWithSyncProgress, scheduleEventHandler, selector, setCurrentComponentInstance, setDevValue, setRuntimeBulkCommitProbe, shouldCoalesceFineGrainedItemReads, state, stream, syncDerivedDependencySubscriptions, task, timer, tryRuntimeFastLaneSync, unregisterOwnedChildScope, updateDelegatedListener, useForState, warnUnusedStateReads, windowFocused, withAsyncResourceContext, withBenchMetricScope, withContext, withDerivedReadTracking, withFineGrainedReadTracking };