@askrjs/askr 0.0.52 → 0.0.54

package/dist/runtime/context.d.ts

@@ -1,72 +0,0 @@
-import { JSXElement } from "../common/jsx.js";
-import { RenderableChild } from "../common/vnode.js";
-
-//#region src/runtime/context.d.ts
-type ContextKey = symbol;
-type Renderable = RenderableChild;
-type ContextScopeChildren = Renderable | (() => Renderable);
-interface Context<T> {
-  readonly key: ContextKey;
-  readonly defaultValue: T;
-  readonly Scope: (props: {
-    value: T;
-    children?: ContextScopeChildren;
-  }) => JSXElement;
-}
-interface ContextFrame {
-  parent: ContextFrame | null;
-  values: Map<ContextKey, unknown> | null;
-}
-/** @internal Reuse immutable empty wrappers for the same provider snapshot. */
-declare function getExecutionContextFrame(parent: ContextFrame | null): ContextFrame;
-declare const CONTEXT_FRAME_SYMBOL: unique symbol;
-declare function getVNodeContextFrame(node: unknown): ContextFrame | undefined;
-declare function markVNodeWithContextFrame(node: unknown, frame: ContextFrame, overwrite?: boolean): void;
-declare function markVNodeTreeWithContextFrame(node: unknown, frame: ContextFrame | null, overwrite?: boolean): unknown;
-/**
- * Execute a function within a specific context frame.
- *
- * CORE PRIMITIVE for context restoration:
- * - Saves the current context
- * - Sets the provided frame as current
- * - Executes the function
- * - Restores the previous context in finally
- *
- * This ensures no context frame remains globally active across await.
- */
-declare function withContext<T>(frame: ContextFrame | null, fn: () => T): T;
-/** @internal Invoke a two-argument function without allocating a wrapper. */
-declare function callWithContext<TArgs, TContext, TResult>(frame: ContextFrame | null, fn: (args: TArgs, context: TContext) => TResult, args: TArgs, context: TContext): TResult;
-/**
- * Execute an async resource step within its frozen context snapshot.
- *
- * CRITICAL: This wrapper is applied only to synchronous execution steps of
- * an async resource (the initial call). We intentionally DO NOT restore
- * the resource frame for post-await continuations — continuations must not
- * observe or rely on a live resource frame. This keeps semantics simple and
- * deterministic: async resources see only their creation-time snapshot.
- */
-declare function withAsyncResourceContext<T>(frame: ContextFrame | null, fn: () => T): T;
-declare function defineContext<T>(defaultValue: T): Context<T>;
-declare function readContext<T>(context: Context<T>): T;
-/**
- * Push a new context frame (for render entry)
- * Called by component runtime when render starts
- */
-declare function pushContextFrame(): ContextFrame;
-/**
- * Pop context frame (for render exit)
- * Called by component runtime when render ends
- */
-declare function popContextFrame(): void;
-/**
- * Get the current context frame for inspection (used by tests/diagnostics only)
- */
-declare function getCurrentContextFrame(): ContextFrame | null;
-/**
- * Get the top of the context snapshot stack (used by runtime when deciding
- * how to link snapshots for async continuations). Returns null if stack empty.
- */
-declare function getTopContextSnapshot(): ContextFrame | null;
-//#endregion
-export { Context, ContextFrame, ContextKey, defineContext, readContext };

package/dist/runtime/context.js

@@ -1,236 +0,0 @@
-import { ELEMENT_TYPE, STATIC_CHILDREN } from "../common/jsx.js";
-import { getCurrentComponentInstance } from "./component-scope.js";
-import "./component.js";
-//#region src/runtime/context.ts
-const ROOT_EXECUTION_FRAME = {
-	parent: null,
-	values: null
-};
-const executionFramesByParent = /* @__PURE__ */ new WeakMap();
-/** @internal Reuse immutable empty wrappers for the same provider snapshot. */
-function getExecutionContextFrame(parent) {
-	if (!parent) return ROOT_EXECUTION_FRAME;
-	let frame = executionFramesByParent.get(parent);
-	if (!frame) {
-		frame = {
-			parent,
-			values: null
-		};
-		executionFramesByParent.set(parent, frame);
-	}
-	return frame;
-}
-const CONTEXT_FRAME_SYMBOL = Symbol("__tempoContextFrame__");
-const vnodeContextFrames = /* @__PURE__ */ new WeakMap();
-function getVNodeContextFrame(node) {
-	if (typeof node !== "object" || node === null) return;
-	const objectNode = node;
-	return vnodeContextFrames.get(node) ?? objectNode[CONTEXT_FRAME_SYMBOL];
-}
-function markVNodeWithContextFrame(node, frame, overwrite = false) {
-	if (typeof node !== "object" || node === null) return;
-	if (!overwrite && getVNodeContextFrame(node)) return;
-	const objectNode = node;
-	if (Object.prototype.hasOwnProperty.call(node, CONTEXT_FRAME_SYMBOL)) try {
-		objectNode[CONTEXT_FRAME_SYMBOL] = frame;
-		return;
-	} catch {}
-	if (Object.isExtensible(node)) try {
-		Object.defineProperty(node, CONTEXT_FRAME_SYMBOL, {
-			value: frame,
-			writable: true,
-			enumerable: true,
-			configurable: true
-		});
-		return;
-	} catch {}
-	vnodeContextFrames.set(node, frame);
-}
-function isVNodeLike(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const objectValue = value;
-	if (objectValue.$$typeof === ELEMENT_TYPE) return true;
-	return "type" in objectValue && ("props" in objectValue || "children" in objectValue);
-}
-function markContextPropValue(value, frame, overwrite) {
-	if (Array.isArray(value)) {
-		for (const item of value) markContextPropValue(item, frame, overwrite);
-		return;
-	}
-	if (isVNodeLike(value)) markVNodeTreeWithContextFrame(value, frame, overwrite);
-}
-function markVNodeTreeWithContextFrame(node, frame, overwrite = false) {
-	if (!frame) return node;
-	if (Array.isArray(node)) {
-		for (const child of node) markVNodeTreeWithContextFrame(child, frame, overwrite);
-		return node;
-	}
-	if (typeof node !== "object" || node === null) return node;
-	markVNodeWithContextFrame(node, frame, overwrite);
-	const objectNode = node;
-	const props = typeof objectNode.props === "object" && objectNode.props !== null ? objectNode.props : null;
-	const children = props?.children ?? objectNode.children;
-	if (Array.isArray(children)) for (const child of children) markVNodeTreeWithContextFrame(child, frame, overwrite);
-	else if (children) markVNodeTreeWithContextFrame(children, frame, overwrite);
-	if (props) {
-		for (const key in props) if (key !== "children") markContextPropValue(props[key], frame, overwrite);
-	}
-	return node;
-}
-let currentContextFrame = null;
-let currentAsyncResourceFrame = null;
-/**
-* Execute a function within a specific context frame.
-*
-* CORE PRIMITIVE for context restoration:
-* - Saves the current context
-* - Sets the provided frame as current
-* - Executes the function
-* - Restores the previous context in finally
-*
-* This ensures no context frame remains globally active across await.
-*/
-function withContext(frame, fn) {
-	const oldFrame = currentContextFrame;
-	currentContextFrame = frame;
-	try {
-		return fn();
-	} finally {
-		currentContextFrame = oldFrame;
-	}
-}
-/** @internal Invoke a two-argument function without allocating a wrapper. */
-function callWithContext(frame, fn, args, context) {
-	const oldFrame = currentContextFrame;
-	currentContextFrame = frame;
-	try {
-		return fn(args, context);
-	} finally {
-		currentContextFrame = oldFrame;
-	}
-}
-/**
-* Execute an async resource step within its frozen context snapshot.
-*
-* CRITICAL: This wrapper is applied only to synchronous execution steps of
-* an async resource (the initial call). We intentionally DO NOT restore
-* the resource frame for post-await continuations — continuations must not
-* observe or rely on a live resource frame. This keeps semantics simple and
-* deterministic: async resources see only their creation-time snapshot.
-*/
-function withAsyncResourceContext(frame, fn) {
-	const oldFrame = currentAsyncResourceFrame;
-	currentAsyncResourceFrame = frame;
-	try {
-		return fn();
-	} finally {
-		currentAsyncResourceFrame = oldFrame;
-	}
-}
-function defineContext(defaultValue) {
-	const key = Symbol("AskrContext");
-	return {
-		key,
-		defaultValue,
-		Scope: (props) => {
-			const value = props.value;
-			return {
-				$$typeof: ELEMENT_TYPE,
-				type: ContextScopeComponent,
-				props: {
-					key,
-					value,
-					children: props.children
-				},
-				key: null
-			};
-		}
-	};
-}
-function preserveStaticChildrenMarker(source, target) {
-	if (source[STATIC_CHILDREN] === true) Object.defineProperty(target, STATIC_CHILDREN, {
-		value: true,
-		enumerable: false,
-		configurable: true
-	});
-	return target;
-}
-function isPresentRenderable(value) {
-	return value !== null && value !== void 0 && value !== false;
-}
-function readContext(context) {
-	const frame = currentContextFrame || currentAsyncResourceFrame;
-	if (!frame) throw new Error("readContext() can only be called during component render or async resource execution. Ensure you are calling this from inside your component or resource function.");
-	let current = frame;
-	while (current) {
-		const values = current.values;
-		if (values && values.has(context.key)) return values.get(context.key);
-		current = current.parent;
-	}
-	return context.defaultValue;
-}
-/**
-* Internal component that manages context frame
-* Used by Context.Scope to provide shadowed value to children
-*/
-function ContextScopeComponent(props) {
-	const key = props["key"];
-	const value = props["value"];
-	const children = props["children"];
-	const instance = getCurrentComponentInstance();
-	const newFrame = {
-		parent: (() => {
-			if (currentContextFrame) return currentContextFrame;
-			if (instance && instance.ownerFrame) return instance.ownerFrame;
-			return null;
-		})(),
-		values: /* @__PURE__ */ new Map([[key, value]])
-	};
-	function createFunctionChildInvoker(fn, frame, owner) {
-		return {
-			type: ContextFunctionChildInvoker,
-			props: {
-				fn,
-				__frame: frame,
-				__owner: owner
-			}
-		};
-	}
-	if (Array.isArray(children)) return preserveStaticChildrenMarker(children, children.map((child) => {
-		if (typeof child === "function") return createFunctionChildInvoker(child, newFrame, getCurrentComponentInstance());
-		return markWithFrame(child, newFrame);
-	}));
-	else if (typeof children === "function") return createFunctionChildInvoker(children, newFrame, getCurrentComponentInstance());
-	else if (isPresentRenderable(children)) return markWithFrame(children, newFrame);
-	return null;
-}
-/**
-* Internal: Mark a vnode with a context frame
-* The renderer will restore this frame before executing component functions
-*/
-function markWithFrame(node, frame) {
-	return markVNodeTreeWithContextFrame(node, frame, true);
-}
-/**
-* Internal helper component: executes a function-child lazily inside the
-* provided frame and marks the returned subtree with that frame so later
-* component executions will restore the correct context frame.
-*
-* SNAPSHOT SEMANTIC: The frame passed here is the snapshot captured at render
-* time. Any resources created during this execution will observe this frozen
-* snapshot, ensuring deterministic behavior.
-*/
-function ContextFunctionChildInvoker(props) {
-	const { fn, __frame } = props;
-	const res = withContext(__frame, () => fn());
-	if (isPresentRenderable(res)) return markWithFrame(res, __frame);
-	return null;
-}
-/**
-* Get the current context frame for inspection (used by tests/diagnostics only)
-*/
-function getCurrentContextFrame() {
-	return currentContextFrame;
-}
-//#endregion
-export { CONTEXT_FRAME_SYMBOL, callWithContext, defineContext, getCurrentContextFrame, getExecutionContextFrame, getVNodeContextFrame, markVNodeTreeWithContextFrame, markVNodeWithContextFrame, readContext, withAsyncResourceContext, withContext };

package/dist/runtime/control.d.ts

@@ -1,62 +0,0 @@
-import { ComponentInstance } from "./component-internal.js";
-import { DOMRange } from "../common/dom-range.js";
-import { ChildScope, ChildScopeTransactionSnapshot } from "./child-scope.js";
-import { ForState } from "./for-internal.js";
-import { VNode } from "../common/vnode.js";
-
-//#region src/runtime/control.d.ts
-interface MatchBranch {
-  key: string | number;
-  render: () => VNode;
-  when: unknown;
-}
-interface BranchControlStateBase {
-  activeKey: string | number | null;
-  activeScope: ChildScope | null;
-  activeVNodes: VNode[];
-  lastRemovedNodes: Node[];
-  lastRemovedRanges: DOMRange[];
-  parentInstance: ComponentInstance | null;
-  _enqueueBoundaryCommit?: (() => void) | null;
-  _hasPendingBoundaryCommit?: boolean;
-  _transaction?: ControlTransaction | null;
-}
-interface ShowState extends BranchControlStateBase {
-  kind: 'show';
-  fallbackScope: ChildScope | null;
-  renderFallback: (() => VNode) | null;
-  renderTruthy: ((value: unknown) => VNode) | (() => VNode);
-  selectedValue: unknown;
-  truthyScope: ChildScope | null;
-}
-interface CaseState extends BranchControlStateBase {
-  kind: 'case';
-  fallback: (() => VNode) | null;
-  matches: MatchBranch[];
-}
-type ControlBoundaryState = ForState<unknown> | ShowState | CaseState;
-type BranchStateSnapshot = {
-  activeKey: string | number | null;
-  activeScope: ChildScope | null;
-  activeVNodes: VNode[];
-  lastRemovedNodes: Node[];
-  lastRemovedRanges: DOMRange[];
-  scopeSnapshots: Map<ChildScope, ChildScopeTransactionSnapshot>;
-  fallbackScope?: ChildScope | null;
-  truthyScope?: ChildScope | null;
-};
-interface ControlTransaction {
-  state: ShowState | CaseState;
-  snapshot: BranchStateSnapshot;
-  removedScopes: ChildScope[];
-  shouldClearDomUpdateState: boolean;
-  registered: boolean;
-}
-declare function createShowState(value: unknown, renderTruthy: ShowState['renderTruthy'], renderFallback: ShowState['renderFallback']): ShowState;
-declare function evaluateShowState(state: ShowState): VNode[];
-declare function clearShowDomUpdateState(state: ShowState): void;
-declare function createCaseState(matches: MatchBranch[], fallback: (() => VNode) | null): CaseState;
-declare function evaluateCaseState(state: CaseState): VNode[];
-declare function clearCaseDomUpdateState(state: CaseState): void;
-//#endregion
-export { CaseState, ControlBoundaryState, ControlTransaction, MatchBranch, ShowState };

package/dist/runtime/control.js

@@ -1,239 +0,0 @@
-import { getCurrentInstance } from "./component-scope.js";
-import { registerLifecycleTransaction } from "./lifecycle-batch.js";
-import "./component-lifecycle.js";
-import "./component.js";
-import { captureChildScopeTransactionSnapshot, createChildScope, disposeChildScope, restoreChildScopeTransactionSnapshot } from "./child-scope.js";
-//#region src/runtime/control.ts
-const SHOW_TRUTHY_KEY = "__show-truthy__";
-const SHOW_FALLBACK_KEY = "__show-fallback__";
-const CASE_FALLBACK_KEY = "__case-fallback__";
-function getBranchScopes(state) {
-	const scopes = [];
-	if (state.activeScope) scopes.push(state.activeScope);
-	if (state instanceof Object && "fallbackScope" in state) {
-		if (state.fallbackScope) scopes.push(state.fallbackScope);
-	}
-	if (state instanceof Object && "truthyScope" in state) {
-		if (state.truthyScope) scopes.push(state.truthyScope);
-	}
-	return scopes;
-}
-function beginControlTransaction(state) {
-	if (state._transaction) return state._transaction;
-	const scopeSnapshots = /* @__PURE__ */ new Map();
-	for (const scope of getBranchScopes(state)) scopeSnapshots.set(scope, captureChildScopeTransactionSnapshot(scope));
-	const transaction = {
-		state,
-		snapshot: {
-			activeKey: state.activeKey,
-			activeScope: state.activeScope,
-			activeVNodes: state.activeVNodes.slice(),
-			lastRemovedNodes: state.lastRemovedNodes.slice(),
-			lastRemovedRanges: state.lastRemovedRanges.slice(),
-			scopeSnapshots,
-			fallbackScope: "fallbackScope" in state ? state.fallbackScope : void 0,
-			truthyScope: "truthyScope" in state ? state.truthyScope : void 0
-		},
-		removedScopes: [],
-		shouldClearDomUpdateState: false,
-		registered: false
-	};
-	state._transaction = transaction;
-	transaction.registered = registerLifecycleTransaction(transaction, () => commitControlTransaction(state, transaction), () => rollbackControlTransaction(state, transaction));
-	return transaction;
-}
-function stageBranchRemoval(state, scope) {
-	if (!scope) return;
-	const transaction = state._transaction;
-	if (transaction && !transaction.removedScopes.includes(scope)) transaction.removedScopes.push(scope);
-	else if (!transaction) disposeChildScope(scope);
-	const removedDom = scope.dom;
-	if (removedDom) state.lastRemovedNodes.push(removedDom);
-	if (scope.range) state.lastRemovedRanges.push(scope.range);
-}
-function commitControlTransaction(state, transaction) {
-	if (state._transaction !== transaction) return;
-	const errors = [];
-	for (const scope of transaction.removedScopes) try {
-		disposeChildScope(scope);
-	} catch (error) {
-		errors.push(error);
-	}
-	if (transaction.shouldClearDomUpdateState) {
-		if ("truthyScope" in state && state.truthyScope) state.truthyScope.needsDomUpdate = false;
-		if ("fallbackScope" in state && state.fallbackScope) state.fallbackScope.needsDomUpdate = false;
-		if (state.activeScope) state.activeScope.needsDomUpdate = false;
-		state.lastRemovedNodes = [];
-		state.lastRemovedRanges = [];
-	}
-	state._transaction = null;
-	if (errors.length > 0) throw new AggregateError(errors, "Control branch cleanup failed");
-}
-function rollbackControlTransaction(state, transaction) {
-	if (state._transaction !== transaction) return;
-	const committedScopes = new Set(transaction.snapshot.scopeSnapshots.keys());
-	const currentScopes = getBranchScopes(state);
-	const errors = [];
-	for (const scope of currentScopes) {
-		if (committedScopes.has(scope)) continue;
-		try {
-			disposeChildScope(scope);
-		} catch (error) {
-			errors.push(error);
-		}
-	}
-	state.activeKey = transaction.snapshot.activeKey;
-	state.activeScope = transaction.snapshot.activeScope;
-	state.activeVNodes = transaction.snapshot.activeVNodes;
-	state.lastRemovedNodes = transaction.snapshot.lastRemovedNodes;
-	state.lastRemovedRanges = transaction.snapshot.lastRemovedRanges;
-	if ("truthyScope" in state) state.truthyScope = transaction.snapshot.truthyScope ?? null;
-	if ("fallbackScope" in state) state.fallbackScope = transaction.snapshot.fallbackScope ?? null;
-	for (const [scope, snapshot] of transaction.snapshot.scopeSnapshots) restoreChildScopeTransactionSnapshot(scope, snapshot);
-	state._transaction = null;
-	if (errors.length > 0) throw new AggregateError(errors, "Control branch rollback cleanup failed");
-}
-function finishImmediateControlTransaction(state, transaction) {
-	if (state._transaction === transaction && !transaction.registered) commitControlTransaction(state, transaction);
-}
-function createBranchScope(state, key) {
-	return createChildScope(state.parentInstance, key, () => {
-		if (state._enqueueBoundaryCommit) {
-			state._enqueueBoundaryCommit();
-			return;
-		}
-		state.parentInstance?._enqueueRun?.();
-	});
-}
-function createShowState(value, renderTruthy, renderFallback) {
-	return {
-		kind: "show",
-		activeKey: null,
-		activeScope: null,
-		activeVNodes: [],
-		fallbackScope: null,
-		lastRemovedNodes: [],
-		lastRemovedRanges: [],
-		parentInstance: getCurrentInstance(),
-		_enqueueBoundaryCommit: null,
-		_hasPendingBoundaryCommit: false,
-		_transaction: null,
-		renderFallback,
-		renderTruthy,
-		selectedValue: value,
-		truthyScope: null
-	};
-}
-function evaluateShowState(state) {
-	const transaction = beginControlTransaction(state);
-	state.lastRemovedNodes = [];
-	state.lastRemovedRanges = [];
-	try {
-		if (state.selectedValue) {
-			if (state.fallbackScope) {
-				stageBranchRemoval(state, state.fallbackScope);
-				state.fallbackScope = null;
-			}
-			const truthyScope = state.truthyScope ?? createBranchScope(state, SHOW_TRUTHY_KEY);
-			state.truthyScope = truthyScope;
-			state.activeScope = truthyScope;
-			state.activeKey = SHOW_TRUTHY_KEY;
-			const vnode = truthyScope.render(() => state.renderTruthy(state.selectedValue));
-			state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
-		} else {
-			if (state.truthyScope) {
-				stageBranchRemoval(state, state.truthyScope);
-				state.truthyScope = null;
-			}
-			if (!state.renderFallback) {
-				if (state.fallbackScope) {
-					stageBranchRemoval(state, state.fallbackScope);
-					state.fallbackScope = null;
-				}
-				state.activeKey = null;
-				state.activeScope = null;
-				state.activeVNodes = [];
-			} else {
-				const fallbackScope = state.fallbackScope ?? createBranchScope(state, SHOW_FALLBACK_KEY);
-				state.fallbackScope = fallbackScope;
-				state.activeScope = fallbackScope;
-				state.activeKey = SHOW_FALLBACK_KEY;
-				const vnode = fallbackScope.render(state.renderFallback);
-				state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
-			}
-		}
-		finishImmediateControlTransaction(state, transaction);
-		return state.activeVNodes;
-	} catch (error) {
-		rollbackControlTransaction(state, transaction);
-		throw error;
-	}
-}
-function clearShowDomUpdateState(state) {
-	if (state.truthyScope) state.truthyScope.needsDomUpdate = false;
-	if (state.fallbackScope) state.fallbackScope.needsDomUpdate = false;
-	if (state._transaction) {
-		state._transaction.shouldClearDomUpdateState = true;
-		return;
-	}
-	state.lastRemovedNodes = [];
-	state.lastRemovedRanges = [];
-}
-function createCaseState(matches, fallback) {
-	return {
-		kind: "case",
-		activeKey: null,
-		activeScope: null,
-		activeVNodes: [],
-		fallback,
-		lastRemovedNodes: [],
-		lastRemovedRanges: [],
-		matches,
-		parentInstance: getCurrentInstance(),
-		_enqueueBoundaryCommit: null,
-		_hasPendingBoundaryCommit: false,
-		_transaction: null
-	};
-}
-function evaluateCaseState(state) {
-	const transaction = beginControlTransaction(state);
-	state.lastRemovedNodes = [];
-	state.lastRemovedRanges = [];
-	try {
-		const selectedMatch = state.matches.find((candidate) => Boolean(candidate.when)) ?? null;
-		const nextKey = selectedMatch?.key ?? (state.fallback ? CASE_FALLBACK_KEY : null);
-		if (nextKey === null) {
-			if (state.activeScope) stageBranchRemoval(state, state.activeScope);
-			state.activeKey = null;
-			state.activeScope = null;
-			state.activeVNodes = [];
-		} else {
-			if (state.activeScope && state.activeKey !== nextKey) {
-				stageBranchRemoval(state, state.activeScope);
-				state.activeScope = null;
-			}
-			const activeScope = state.activeScope ?? createBranchScope(state, nextKey);
-			state.activeKey = nextKey;
-			state.activeScope = activeScope;
-			const renderBranch = selectedMatch?.render ?? state.fallback;
-			const vnode = renderBranch ? activeScope.render(renderBranch) : null;
-			state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];
-		}
-		finishImmediateControlTransaction(state, transaction);
-		return state.activeVNodes;
-	} catch (error) {
-		rollbackControlTransaction(state, transaction);
-		throw error;
-	}
-}
-function clearCaseDomUpdateState(state) {
-	if (state.activeScope) state.activeScope.needsDomUpdate = false;
-	if (state._transaction) {
-		state._transaction.shouldClearDomUpdateState = true;
-		return;
-	}
-	state.lastRemovedNodes = [];
-	state.lastRemovedRanges = [];
-}
-//#endregion
-export { clearCaseDomUpdateState, clearShowDomUpdateState, createCaseState, createShowState, evaluateCaseState, evaluateShowState };

package/dist/runtime/derive.d.ts

@@ -1,16 +0,0 @@
-import { ReadableSource } from "./readable.js";
-import { SnapshotSourceBrand } from "./snapshot-source.js";
-
-//#region src/runtime/derive.d.ts
-interface Derived<T> extends ReadableSource<T> {
-  (): T;
-}
-type SnapshotSource<T> = {
-  value: T | null;
-  pending?: boolean;
-  error?: Error | null;
-} & SnapshotSourceBrand;
-declare function derive<TOut>(fn: () => TOut): Derived<TOut>;
-declare function derive<TIn, TOut>(source: SnapshotSource<TIn> | TIn | (() => TIn), map: (value: TIn) => TOut): Derived<TOut | null>;
-//#endregion
-export { Derived, derive };