@askrjs/askr 0.3.0 → 0.4.0

package/dist/selector-BSPVkjKP.js

@@ -1,311 +0,0 @@
-import { b as ScheduledWork, f as requestRuntimeWork } from "./access-CEA2pOry.js";
-import { O as ownCleanup, f as getCurrentComponentInstance, i as claimHookIndex } from "./scope-Cq_iYbTR.js";
-import { _ as markReadableUsage, b as syncDerivedDependencySubscriptions, h as clearDerivedDependencySubscriptions, t as notifyReadableSource, v as recordReadableRead, x as withDerivedReadTracking } from "./notify-DxxuDPeY.js";
-//#region src/runtime/reactivity/selector-store.ts
-const dirtySelectorRecords = /* @__PURE__ */ new Set();
-let selectorWork;
-function markDirtySelectorRecord(record, flush) {
-	record._dirty = true;
-	if (!record._pending) {
-		record._pending = true;
-		dirtySelectorRecords.add(record);
-	}
-	requestRuntimeWork("derived", selectorWork ??= new ScheduledWork(flush));
-}
-function takeDirtySelectorRecords() {
-	if (dirtySelectorRecords.size === 0) return [];
-	const pending = Array.from(dirtySelectorRecords);
-	dirtySelectorRecords.clear();
-	return pending;
-}
-//#endregion
-//#region src/runtime/reactivity/selector.ts
-const selectorCells = /* @__PURE__ */ new WeakMap();
-const selectorRecords = /* @__PURE__ */ new WeakMap();
-function getSelectorStore(instance) {
-	const generation = instance.owner.identity;
-	let store = selectorCells.get(generation);
-	if (!store) {
-		store = /* @__PURE__ */ new Map();
-		selectorCells.set(generation, store);
-	}
-	return store;
-}
-function markSelectorRecordDirty(record) {
-	markDirtySelectorRecord(record, flushDirtySelectorRecords);
-}
-function flushDirtySelectorRecords() {
-	let failures = null;
-	for (const record of takeDirtySelectorRecords()) {
-		record._pending = false;
-		if (!record._dirty) continue;
-		try {
-			recomputeSelectorSourceRecord(record, true);
-		} catch (error) {
-			(failures ??= []).push(error);
-		}
-	}
-	if (failures?.length === 1) throw failures[0];
-	if (failures && failures.length > 1) throw new AggregateError(failures, "selector() recompute failures");
-}
-function isObjectCandidate(value) {
-	return typeof value === "object" && value !== null || typeof value === "function";
-}
-function isDefaultSelectorEquals(equals) {
-	return equals === Object.is;
-}
-function createCandidateSource(candidate) {
-	return { _candidate: candidate };
-}
-function getCandidateSource(lane, candidate) {
-	if (isObjectCandidate(candidate)) {
-		const cached = lane._objectCandidates.get(candidate);
-		if (cached) return cached;
-		const created = createCandidateSource(candidate);
-		lane._objectCandidates.set(candidate, created);
-		lane._objectCandidateSources.add(created);
-		return created;
-	}
-	const key = candidate;
-	const cached = lane._primitiveCandidates.get(key);
-	if (cached) return cached;
-	const created = createCandidateSource(candidate);
-	lane._primitiveCandidates.set(key, created);
-	return created;
-}
-function peekCandidateSource(lane, candidate) {
-	if (isObjectCandidate(candidate)) return lane._objectCandidates.get(candidate);
-	return lane._primitiveCandidates.get(candidate);
-}
-function getSelectorSourceRecord(source) {
-	const cached = selectorRecords.get(source);
-	if (cached) return cached;
-	const record = createSelectorSourceRecord(source);
-	selectorRecords.set(source, record);
-	return record;
-}
-function createSelectorSourceRecord(source) {
-	let record;
-	record = {
-		_source: source,
-		_value: void 0,
-		_hasValue: false,
-		_dirty: true,
-		_pending: false,
-		_evaluating: false,
-		_sources: /* @__PURE__ */ new Set(),
-		_lanes: /* @__PURE__ */ new Map(),
-		_markDirty: () => {
-			markSelectorRecordDirty(record);
-		},
-		_cleanup: () => {
-			record._pending = false;
-			record._dirty = false;
-			record._hasValue = false;
-			record._evaluating = false;
-			record._pendingDependencySources = void 0;
-			clearDerivedDependencySubscriptions(record, record._sources);
-			record._lanes.clear();
-			selectorRecords.delete(source);
-		}
-	};
-	return record;
-}
-function getSelectorLane(record, equals) {
-	const cached = record._lanes.get(equals);
-	if (cached) return cached;
-	const lane = createSelectorLane(record, equals);
-	record._lanes.set(equals, lane);
-	return lane;
-}
-function createSelectorLane(record, equals) {
-	const lane = {
-		_record: record,
-		_equals: equals,
-		_bindingCount: 0,
-		_primitiveCandidates: /* @__PURE__ */ new Map(),
-		_objectCandidates: /* @__PURE__ */ new WeakMap(),
-		_objectCandidateSources: /* @__PURE__ */ new Set(),
-		_cleanup: () => {
-			for (const sourceRef of lane._primitiveCandidates.values()) {
-				sourceRef._readers?.size;
-				sourceRef._readers?.clear();
-				sourceRef._derivedSubscribers?.clear();
-			}
-			for (const sourceRef of lane._objectCandidateSources) {
-				sourceRef._readers?.size;
-				sourceRef._readers?.clear();
-				sourceRef._derivedSubscribers?.clear();
-			}
-			lane._primitiveCandidates.clear();
-			lane._objectCandidates = /* @__PURE__ */ new WeakMap();
-			lane._objectCandidateSources.clear();
-		}
-	};
-	return lane;
-}
-function notifySelectorSource(source) {
-	notifyReadableSource(source, { skipCurrentDerivedSubscriber: true });
-}
-function notifyAllSelectorSources(lane) {
-	for (const source of lane._primitiveCandidates.values()) notifySelectorSource(source);
-	for (const source of lane._objectCandidateSources) notifySelectorSource(source);
-}
-function notifySelectorLaneValueChange(lane, prevValue, nextValue) {
-	if (!lane._bindingCount) return;
-	if (!isDefaultSelectorEquals(lane._equals)) {
-		if (lane._equals(prevValue, nextValue)) return;
-		notifyAllSelectorSources(lane);
-		return;
-	}
-	if (!Object.is(prevValue, nextValue)) {
-		const prevSource = peekCandidateSource(lane, prevValue);
-		if (prevSource) notifySelectorSource(prevSource);
-		const nextSource = peekCandidateSource(lane, nextValue);
-		if (nextSource) notifySelectorSource(nextSource);
-	}
-}
-function recomputeSelectorSourceRecord(record, notifyDownstream) {
-	if (record._evaluating) throw new Error("selector() cannot read itself recursively");
-	if (!record._dirty && record._hasValue) return record._value;
-	record._evaluating = true;
-	record._dirty = false;
-	record._pendingDependencySources = /* @__PURE__ */ new Set();
-	const prevSources = record._sources;
-	const hadValue = record._hasValue;
-	const prevValue = record._value;
-	let nextValue;
-	try {
-		nextValue = withDerivedReadTracking(record, record._source);
-	} catch (error) {
-		record._dirty = true;
-		record._pendingDependencySources = void 0;
-		throw error;
-	} finally {
-		record._evaluating = false;
-	}
-	const nextSources = record._pendingDependencySources ?? /* @__PURE__ */ new Set();
-	record._pendingDependencySources = void 0;
-	syncDerivedDependencySubscriptions(record, prevSources, nextSources);
-	record._sources = nextSources;
-	const valueChanged = !record._hasValue || !Object.is(prevValue, nextValue);
-	record._hasValue = true;
-	record._value = nextValue;
-	if (valueChanged && notifyDownstream && hadValue) for (const lane of Array.from(record._lanes.values())) notifySelectorLaneValueChange(lane, prevValue, nextValue);
-	return record._value;
-}
-function attachSelectorHookBinding(hook, source, equals) {
-	const record = getSelectorSourceRecord(source);
-	const lane = getSelectorLane(record, equals);
-	hook._source = source;
-	hook._equals = equals;
-	hook._record = record;
-	hook._lane = lane;
-	lane._bindingCount += 1;
-}
-function detachSelectorHookBinding(hook) {
-	const record = hook._record;
-	const lane = hook._lane;
-	hook._record = null;
-	hook._lane = null;
-	if (!record || !lane) return;
-	if (lane._bindingCount > 0) lane._bindingCount -= 1;
-	if (lane._bindingCount > 0) return;
-	lane._cleanup();
-	record._lanes.delete(lane._equals);
-	if (record._lanes.size === 0) record._cleanup();
-}
-function ensureSelectorHookBinding(hook) {
-	const record = hook._record;
-	const lane = hook._lane;
-	if (record && lane && lane._bindingCount > 0 && record._lanes.get(hook._equals) === lane && record._source === hook._source) return record;
-	if (hook._record || hook._lane) detachSelectorHookBinding(hook);
-	attachSelectorHookBinding(hook, hook._source, hook._equals);
-	return hook._record;
-}
-function createSelectorHook(instance, generation, store, hookIndex, source, equals) {
-	const hook = function selectorPredicate(candidate) {
-		const selectorHook = hook;
-		if (!selectorHook._active) return selectorHook._hasDisposedValue && selectorHook._equals(selectorHook._disposedValue, candidate);
-		const record = selectorHook._record ?? ensureSelectorHookBinding(selectorHook);
-		const lane = selectorHook._lane;
-		if (!lane) throw new Error("selector() binding could not be established.");
-		const sourceRef = getCandidateSource(lane, candidate);
-		recordReadableRead(sourceRef);
-		if (record._evaluating) throw new Error("selector() cannot read itself recursively");
-		const current = record._dirty || !record._hasValue ? recomputeSelectorSourceRecord(record, record._pending) : record._value;
-		return lane._equals(current, candidate);
-	};
-	hook._owner = instance;
-	hook._hookIndex = hookIndex;
-	hook._source = source;
-	hook._equals = equals;
-	hook._record = null;
-	hook._lane = null;
-	hook._active = true;
-	hook._disposedValue = void 0;
-	hook._hasDisposedValue = false;
-	hook._cleanup = () => {
-		if (!hook._active) return;
-		if (hook._record?._hasValue) {
-			hook._disposedValue = hook._record._value;
-			hook._hasDisposedValue = true;
-		}
-		hook._active = false;
-		detachSelectorHookBinding(hook);
-	};
-	attachSelectorHookBinding(hook, source, equals);
-	ownCleanup(instance.owner, () => {
-		try {
-			hook._cleanup();
-		} finally {
-			store.delete(hookIndex);
-			if (store.size === 0 && selectorCells.get(generation) === store) selectorCells.delete(generation);
-		}
-	});
-	return hook;
-}
-function getOrCreateSelectorHook(instance, hookIndex, source, equals) {
-	const store = getSelectorStore(instance);
-	const existing = store.get(hookIndex);
-	if (existing) {
-		if (existing._source !== source || existing._equals !== equals) {
-			if (existing._equals === equals && existing._record && existing._lane) {
-				const record = existing._record;
-				selectorRecords.delete(record._source);
-				record._source = source;
-				selectorRecords.set(source, record);
-				existing._source = source;
-				record._dirty = true;
-				recomputeSelectorSourceRecord(record, false);
-				ensureSelectorHookBinding(existing);
-			} else {
-				detachSelectorHookBinding(existing);
-				attachSelectorHookBinding(existing, source, equals);
-			}
-		} else ensureSelectorHookBinding(existing);
-		return existing;
-	}
-	const created = createSelectorHook(instance, instance.owner.identity, store, hookIndex, source, equals);
-	store.set(hookIndex, created);
-	return created;
-}
-/**
-* Creates a render-scoped predicate for keyed membership in reactive list rows.
-*
-* Use this when a `<For>` child needs to compare each stable item with a
-* changing selected value. Unlike a plain closure capture, the predicate
-* subscribes the affected rows and updates them without rebuilding the list.
-* Must be called during component render.
-*/
-function selector(source, equals = Object.is) {
-	markReadableUsage(source);
-	const instance = getCurrentComponentInstance();
-	if (!instance) throw new Error("selector() can only be called during component render execution. Move selector() calls to the top level of your component function.");
-	const hook = getOrCreateSelectorHook(instance, claimHookIndex(instance, "selector"), source, equals);
-	if (!hook._record) throw new Error("selector() record binding was not established.");
-	if (!hook._record._hasValue) recomputeSelectorSourceRecord(hook._record, false);
-	return hook;
-}
-//#endregion
-export { selector as t };

package/dist/ssr-EPjwJH5R.js

@@ -1,29 +0,0 @@
-import { P as isPromiseLike } from "./instance-VAFYVJOa.js";
-//#region src/common/ssr.ts
-/**
-* Common call contracts: SSR types
-*/
-function escapedStyleRawText(value) {
-	return value.replace(/<\//gi, "<\\/");
-}
-function validateDocumentStyleRegistrations(html, styles, apiName, validation) {
-	if (validation === "off" || !styles || styles.length === 0) return;
-	const dropped = styles.filter(({ cssText }) => !html.includes(cssText) && !html.includes(escapedStyleRawText(cssText)));
-	if (dropped.length === 0) return;
-	const registrations = dropped.map(({ id }) => JSON.stringify(id)).join(", ");
-	const message = `${apiName} document() dropped ${dropped.length} registered SSR style${dropped.length === 1 ? "" : "s"}: ${registrations}. Serialize context.styles into the returned document, or set styleRegistrationValidation to "off" when omission is intentional.`;
-	if (validation === "error") throw new Error(message);
-	console.warn(message);
-}
-function renderDocument(document, args, apiName, styleRegistrationValidation = "warn") {
-	const html = document(args);
-	if (typeof html !== "string") {
-		const received = isPromiseLike(html) ? "a Promise-like value" : html === null ? "null" : Array.isArray(html) ? "an array" : typeof html;
-		throw new Error(`${apiName} document() must synchronously return a string; received ${received}.`);
-	}
-	validateDocumentStyleRegistrations(html, args.context.styles, apiName, styleRegistrationValidation);
-	return html;
-}
-const SSR_RENDER_DATA_ATTR = "data-askr-render-data";
-//#endregion
-export { renderDocument as n, SSR_RENDER_DATA_ATTR as t };

package/dist/state-BXJfudq1.js

@@ -1,91 +0,0 @@
-import { T as isProductionEnvironment } from "./access-CEA2pOry.js";
-import { f as getCurrentComponentInstance, i as claimHookIndex } from "./scope-Cq_iYbTR.js";
-import { a as deferCommitNotification, t as notifyReadableSource, v as recordReadableRead } from "./notify-DxxuDPeY.js";
-//#region src/runtime/reactivity/state.ts
-/**
-* State primitive for Askr components
-* Optimized for minimal overhead and fast updates
-*
-* INVARIANTS ENFORCED:
-* - state() only callable during component render (currentInstance exists)
-* - state() called at top-level only (indices must be monotonically increasing)
-* - state values persist across re-renders (stored in stateValues array)
-* - state.set() cannot be called during render (causes infinite loops)
-* - state.set() always enqueues through scheduler (never direct mutation)
-* - state.set() callback (notifyUpdate) always available
-*/
-/**
-* Creates a local state value for a component
-* Optimized for:
-* - O(1) read performance
-* - Minimal allocation per state
-* - Fast scheduler integration
-*
-* IMPORTANT: state() must be called during component render execution.
-* It captures the current component instance from context.
-* Calling outside a component function will throw an error.
-*
-* @example
-* ```ts
-* // ✅ Correct: called during render
-* export function Counter() {
-*   const [count, setCount] = state(0);
-*   return { type: 'button', children: [count()] };
-* }
-*
-* // ❌ Wrong: called outside component
-* const count = state(0);
-* export function BadComponent() {
-*   return { type: 'div' };
-* }
-* ```
-*/
-function state(initialValue) {
-	const instance = getCurrentComponentInstance();
-	if (!instance) throw new Error("state() can only be called during component render execution. Move state() calls to the top level of your component function.");
-	const index = claimHookIndex(instance, "state");
-	const stateValues = instance.stateValues ??= [];
-	if (stateValues[index]) {
-		const existing = stateValues[index];
-		if (existing._owner !== instance) throw new Error(`State ownership violation: state() called at index ${index} is owned by a different component instance. State ownership is positional and immutable.`);
-		return existing;
-	}
-	const cell = createStateCell(initialValue, instance);
-	stateValues[index] = cell;
-	return cell;
-}
-/**
-* Internal helper: create the backing state cell (value + readers + set semantics)
-* This extraction makes it easier to later split hook wiring from storage.
-*/
-function createStateCell(initialValue, instance) {
-	let value = initialValue;
-	const readers = /* @__PURE__ */ new Map();
-	function read() {
-		read._hasBeenRead = true;
-		recordReadableRead(read);
-		return value;
-	}
-	read._readers = readers;
-	read._unusedStateDiagnosticEligible = !isProductionEnvironment();
-	read._owner = instance;
-	read.set = (newValueOrUpdater) => {
-		if (getCurrentComponentInstance() !== null) throw new Error("[Askr] state.set() cannot be called during component render. State mutations during render break the actor model and cause infinite loops. Move state updates to event handlers or use conditional rendering instead.");
-		let newValue;
-		if (typeof newValueOrUpdater === "function") newValue = newValueOrUpdater(value);
-		else newValue = newValueOrUpdater;
-		if (Object.is(value, newValue)) return;
-		value = newValue;
-		if (!deferCommitNotification(read, notify)) notify();
-	};
-	function notify() {
-		notifyReadableSource(read);
-	}
-	read[Symbol.iterator] = function* () {
-		yield read;
-		yield read.set;
-	};
-	return read;
-}
-//#endregion
-export { state as t };