@askrjs/askr 0.0.51 → 0.0.53

package/dist/fastlane-Dw8SOBr9.js

@@ -0,0 +1,343 @@
+import { b as isDevelopmentEnvironment, l as runRuntimeWithSyncProgress, n as enqueueRuntimeTask, o as getRuntimeRenderer, s as markRuntimeReactivePropsDirtySource, u as setRuntimeBulkCommitProbe } from "./access-Bg4RJNC8.js";
+import { n as Fragment } from "./jsx-CUpRxrLH.js";
+import { p as getCurrentInstance } from "./component-scope-CC3cojX9.js";
+//#region src/runtime/dev-namespace.ts
+/**
+* Set a value in the dev namespace (no-op in production).
+*/
+const setDevValue = () => {};
+/**
+* Increment a counter in the dev namespace (no-op in production).
+* Safely handles non-number values by resetting to 1.
+*/
+const incDevCounter = () => {};
+//#endregion
+//#region src/runtime/readable.ts
+const DEVELOPMENT_BUILD_ENABLED = false;
+function markReadableUsage(source) {
+	if (source && typeof source === "function" && ("_hasBeenRead" in source || "_readers" in source)) {
+		const readable = source;
+		readable._hasBeenRead = true;
+	}
+}
+let currentDerivedSubscriber = null;
+let suppressComponentReadTrackingDepth = 0;
+let currentFineGrainedReadCollector = null;
+function scheduleReadableInstanceUpdate(instance) {
+	if (instance.hasPendingUpdate) return;
+	instance.hasPendingUpdate = true;
+	const task = instance._pendingFlushTask;
+	if (task) {
+		enqueueRuntimeTask(task);
+		return;
+	}
+	enqueueRuntimeTask(() => {
+		instance.hasPendingUpdate = false;
+		instance.notifyUpdate?.();
+	});
+}
+function recordReadableRead(source) {
+	if (currentFineGrainedReadCollector) {
+		const first = currentFineGrainedReadCollector._pendingFineGrainedReadSource;
+		if (!first) currentFineGrainedReadCollector._pendingFineGrainedReadSource = source;
+		else if (first !== source) {
+			let sources = currentFineGrainedReadCollector._pendingFineGrainedReadSources;
+			if (!sources) currentFineGrainedReadCollector._pendingFineGrainedReadSources = source;
+			else if (Array.isArray(sources)) {
+				if (!sources.includes(source)) sources.push(source);
+			} else if (sources instanceof Set) sources.add(source);
+			else if (sources !== source) currentFineGrainedReadCollector._pendingFineGrainedReadSources = [
+				first,
+				sources,
+				source
+			];
+		}
+		return;
+	}
+	if (currentDerivedSubscriber) {
+		if (!currentDerivedSubscriber._pendingDependencySources) currentDerivedSubscriber._pendingDependencySources = /* @__PURE__ */ new Set();
+		currentDerivedSubscriber._pendingDependencySources.add(source);
+	}
+	if (suppressComponentReadTrackingDepth > 0) return;
+	const inst = getCurrentInstance();
+	if (!inst || inst._currentRenderToken === void 0) return;
+	if (!inst._pendingReadSources) inst._pendingReadSources = /* @__PURE__ */ new Set();
+	inst._pendingReadSources.add(source);
+	const sourceVersion = source._version ?? 0;
+	let pendingVersions = inst._pendingReadSourceVersions;
+	if (!pendingVersions) {
+		pendingVersions = /* @__PURE__ */ new Map();
+		inst._pendingReadSourceVersions = pendingVersions;
+	}
+	pendingVersions.set(source, sourceVersion);
+}
+function withFineGrainedReadTracking(collector, fn) {
+	const previousCollector = currentFineGrainedReadCollector;
+	currentFineGrainedReadCollector = collector;
+	try {
+		return fn.call(collector);
+	} finally {
+		currentFineGrainedReadCollector = previousCollector;
+	}
+}
+/** @internal Whether the active grouped effect coalesces item-property reads. */
+function shouldCoalesceFineGrainedItemReads() {
+	return (currentFineGrainedReadCollector?._owner)?._coalesceForItemReads === true;
+}
+function finalizeReadableSubscriptions(instance) {
+	const newSet = instance._pendingReadSources;
+	const token = instance._currentRenderToken;
+	const pendingVersions = instance._pendingReadSourceVersions;
+	finalizeReadableSubscriptionsFromSnapshot(instance, token, newSet, pendingVersions);
+	instance._pendingReadSources = void 0;
+	instance._currentRenderToken = void 0;
+	instance._pendingReadSourceVersions = void 0;
+}
+function finalizeReadableSubscriptionsFromSnapshot(instance, token, newSet, pendingReadSourceVersions = instance._pendingReadSourceVersions) {
+	if (token === void 0) return;
+	const oldSet = instance._lastReadSources;
+	const pendingVersions = pendingReadSourceVersions;
+	let needsFollowUpUpdate = false;
+	if (oldSet) {
+		for (const source of oldSet) if (!newSet?.has(source)) {
+			if ((source._readers?.get(instance))?.generation === instance._ownershipGeneration) {
+				if (source._readers?.delete(instance) && DEVELOPMENT_BUILD_ENABLED);
+			}
+		}
+	}
+	instance.lastRenderToken = token;
+	if (newSet) for (const source of newSet) {
+		if (pendingVersions && (!oldSet || oldSet.has(source))) {
+			const sourceVersion = source._version ?? 0;
+			const readVersion = pendingVersions.get(source);
+			if (readVersion !== void 0 && sourceVersion !== readVersion) needsFollowUpUpdate = true;
+		}
+		let readers = source._readers;
+		if (!readers) {
+			readers = /* @__PURE__ */ new Map();
+			source._readers = readers;
+		}
+		readers.has(instance);
+		readers.set(instance, {
+			token: instance.lastRenderToken ?? 0,
+			generation: instance._ownershipGeneration
+		});
+	}
+	instance._lastReadSources = newSet?.size ? newSet : void 0;
+	if (needsFollowUpUpdate) scheduleReadableInstanceUpdate(instance);
+}
+function cleanupReadableSubscriptions(instance, generation = instance._ownershipGeneration) {
+	const sources = instance._lastReadSources;
+	if (!sources || sources.size === 0) {
+		instance._pendingReadSources = void 0;
+		instance._pendingReadSourceVersions = void 0;
+		return;
+	}
+	cleanupReadableSubscriptionSources(instance, sources, generation);
+	instance._lastReadSources = void 0;
+	instance._pendingReadSources = void 0;
+	instance._pendingReadSourceVersions = void 0;
+}
+/** @internal Detach an exact committed read set without mutating another live generation. */
+function cleanupReadableSubscriptionSources(instance, sources, generation) {
+	if (!sources) return;
+	for (const source of sources) if ((source._readers?.get(instance))?.generation === generation) {
+		if (source._readers?.delete(instance) && DEVELOPMENT_BUILD_ENABLED);
+	}
+}
+function withDerivedReadTracking(subscriber, fn) {
+	const prevDerivedSubscriber = currentDerivedSubscriber;
+	currentDerivedSubscriber = subscriber;
+	suppressComponentReadTrackingDepth += 1;
+	try {
+		return fn();
+	} finally {
+		suppressComponentReadTrackingDepth -= 1;
+		currentDerivedSubscriber = prevDerivedSubscriber;
+	}
+}
+function syncDerivedDependencySubscriptions(subscriber, prevSources, nextSources) {
+	for (const source of prevSources) if (!nextSources.has(source)) source._derivedSubscribers?.delete(subscriber);
+	for (const source of nextSources) {
+		let subscribers = source._derivedSubscribers;
+		if (!subscribers) {
+			subscribers = /* @__PURE__ */ new Set();
+			source._derivedSubscribers = subscribers;
+		}
+		subscribers.add(subscriber);
+	}
+}
+function clearDerivedDependencySubscriptions(subscriber, sources) {
+	for (const source of sources) source._derivedSubscribers?.delete(subscriber);
+	sources.clear();
+}
+function markReadableDerivedSubscribersDirty(source) {
+	const subscribers = source._derivedSubscribers;
+	if (!subscribers || subscribers.size === 0) return;
+	for (const subscriber of subscribers) subscriber._markDirty();
+}
+function markReactivePropsDirtySource(source) {
+	try {
+		markRuntimeReactivePropsDirtySource(source);
+	} catch {}
+}
+function notifyReadableReaders(source, skipInstance, skipOwnedBy) {
+	source._version = (source._version ?? 0) + 1;
+	const readers = source._readers;
+	let didScheduleUpdate = false;
+	if (!readers || readers.size === 0) return false;
+	for (const [instance, reader] of readers) {
+		if (skipInstance && instance === skipInstance) continue;
+		if (skipOwnedBy) {
+			let owner = instance;
+			let isOwned = false;
+			while (owner) {
+				if (owner === skipOwnedBy) {
+					isOwned = true;
+					break;
+				}
+				owner = owner.parentInstance;
+			}
+			if (isOwned) continue;
+		}
+		if (instance._ownershipGeneration !== reader.generation || instance.lastRenderToken !== reader.token) continue;
+		if (instance.hasPendingUpdate) continue;
+		scheduleReadableInstanceUpdate(instance);
+		didScheduleUpdate = true;
+	}
+	return didScheduleUpdate;
+}
+//#endregion
+//#region src/runtime/fastlane.ts
+let _bulkCommitActive = false;
+let _appliedParents = null;
+function enterBulkCommit() {
+	_bulkCommitActive = true;
+	_appliedParents = /* @__PURE__ */ new WeakSet();
+}
+function exitBulkCommit() {
+	_bulkCommitActive = false;
+	_appliedParents = null;
+}
+function isBulkCommitActive() {
+	return _bulkCommitActive;
+}
+function markFastPathApplied(parent) {
+	if (!_appliedParents) return;
+	try {
+		_appliedParents.add(parent);
+	} catch (e) {}
+}
+function finalizeReadSubscriptions(instance) {
+	finalizeReadableSubscriptions(instance);
+}
+/**
+* Attempt to execute a runtime fast-lane for a single component's synchronous
+* render result. Returns true if the fast-lane was used and commit was done.
+*
+* Preconditions (checked conservatively):
+* - The render result is an intrinsic element root with keyed children
+* - The renderer's fast-path heuristics indicate to use the fast-path
+* - No mount operations are pending on the component instance
+* - No child vnodes are component functions (avoid async/component mounts)
+*/
+function unwrapFragmentForFastPath(vnode) {
+	if (!vnode || typeof vnode !== "object" || !("type" in vnode)) return vnode;
+	const v = vnode;
+	if (typeof v.type === "symbol" && (v.type === Fragment || String(v.type) === "Symbol(askr.fragment)")) {
+		const children = v.props?.children ?? v.children;
+		if (Array.isArray(children) && children.length > 0) {
+			for (const child of children) if (child && typeof child === "object" && "type" in child) {
+				if (typeof child.type === "string") return child;
+			}
+		}
+	}
+	return vnode;
+}
+function classifyUpdate(instance, result) {
+	const unwrappedResult = unwrapFragmentForFastPath(result);
+	if (!unwrappedResult || typeof unwrappedResult !== "object" || !("type" in unwrappedResult)) return {
+		useFastPath: false,
+		reason: "not-vnode"
+	};
+	const vnode = unwrappedResult;
+	if (vnode == null || typeof vnode.type !== "string") return {
+		useFastPath: false,
+		reason: "not-intrinsic"
+	};
+	const parent = instance.target;
+	if (!parent) return {
+		useFastPath: false,
+		reason: "no-root"
+	};
+	const firstChild = parent.children[0];
+	if (!firstChild) return {
+		useFastPath: false,
+		reason: "no-first-child"
+	};
+	if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase()) return {
+		useFastPath: false,
+		reason: "root-tag-mismatch"
+	};
+	const children = vnode.props?.children ?? vnode.children;
+	if (!Array.isArray(children)) return {
+		useFastPath: false,
+		reason: "no-children-array"
+	};
+	for (const c of children) if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") return {
+		useFastPath: false,
+		reason: "component-child-present"
+	};
+	if ((instance.mountOperations?.length ?? 0) > 0) return {
+		useFastPath: false,
+		reason: "pending-mounts"
+	};
+	if ((instance.commitOperations?.length ?? 0) > 0) return {
+		useFastPath: false,
+		reason: "pending-lifecycle-commits"
+	};
+	const renderer = getRuntimeRenderer();
+	try {
+		renderer.populateKeyMapForElement(firstChild);
+	} catch {}
+	const oldKeyMap = renderer.getKeyMapForElement(firstChild);
+	const decision = renderer.isKeyedReorderFastPathEligible(firstChild, children, oldKeyMap);
+	if (!decision.useFastPath || decision.totalKeyed < 128) return {
+		...decision,
+		useFastPath: false,
+		reason: "renderer-declined"
+	};
+	return {
+		...decision,
+		useFastPath: true
+	};
+}
+function commitReorderOnly(instance, result) {
+	const renderer = getRuntimeRenderer();
+	enterBulkCommit();
+	try {
+		runRuntimeWithSyncProgress(() => {
+			renderer.evaluate(result, instance.target);
+			try {
+				finalizeReadSubscriptions(instance);
+			} catch (e) {
+				if (isDevelopmentEnvironment()) throw e;
+			}
+		});
+		return true;
+	} finally {
+		exitBulkCommit();
+	}
+}
+function tryRuntimeFastLaneSync(instance, result) {
+	if (!classifyUpdate(instance, result).useFastPath) return false;
+	try {
+		return commitReorderOnly(instance, result);
+	} catch (err) {
+		if (isDevelopmentEnvironment()) throw err;
+		return false;
+	}
+}
+setRuntimeBulkCommitProbe(isBulkCommitActive);
+//#endregion
+export { withFineGrainedReadTracking as _, cleanupReadableSubscriptions as a, finalizeReadableSubscriptionsFromSnapshot as c, markReadableUsage as d, notifyReadableReaders as f, withDerivedReadTracking as g, syncDerivedDependencySubscriptions as h, cleanupReadableSubscriptionSources as i, markReactivePropsDirtySource as l, shouldCoalesceFineGrainedItemReads as m, markFastPathApplied as n, clearDerivedDependencySubscriptions as o, recordReadableRead as p, tryRuntimeFastLaneSync as r, finalizeReadableSubscriptions as s, isBulkCommitActive as t, markReadableDerivedSubscribersDirty as u, incDevCounter as v, setDevValue as y };