@askrjs/askr 0.0.52 → 0.0.54

package/dist/runtime/component-commit.js

@@ -1,167 +0,0 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { logger } from "../common/logger.js";
-import { enqueueRuntimeTask, getRuntimeRenderer } from "./access.js";
-import { getExecutionContextFrame, withContext } from "./context.js";
-import { incDevCounter, setDevValue } from "./dev-namespace.js";
-import { beginRenderTracking, enterDomCommitScope, restoreDomCommitScope } from "./component-scope.js";
-import { isPromiseLike } from "../common/promise.js";
-import { tryRuntimeFastLaneSync } from "./fastlane.js";
-import { discardCommitOperations } from "./lifecycle-operation-settlement.js";
-import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, flushLifecycleCommitBatch } from "./lifecycle-batch.js";
-import { commitLifecycleForInstance } from "./component-lifecycle.js";
-//#region src/runtime/component-commit.ts
-function runScheduledComponent(instance, host) {
-	instance.notifyUpdate = instance._enqueueRun;
-	beginRenderTracking(instance);
-	let result;
-	try {
-		result = host.execute(instance);
-	} catch (err) {
-		discardCommitOperations(instance);
-		throw err;
-	}
-	if (isPromiseLike(result)) throw new Error("Async components are not supported. Components must be synchronous.");
-	try {
-		if (tryRuntimeFastLaneSync(instance, result)) {
-			host.warnUnusedStateReads(instance);
-			return;
-		}
-	} catch (err) {
-		if (isDevelopmentEnvironment()) throw err;
-	}
-	enqueueRuntimeTask(() => {
-		if (!instance.target && instance._placeholder) {
-			commitPlaceholderReplacement(instance, result, host);
-			return;
-		}
-		if (instance.target) commitToTarget(instance, result, host);
-	});
-}
-function commitPlaceholderReplacement(instance, result, host) {
-	if (result === null || result === void 0) {
-		host.finalizeReadSubscriptions(instance);
-		host.warnUnusedStateReads(instance);
-		host.commitRenderedComponent(instance);
-		return;
-	}
-	const placeholder = instance._placeholder;
-	const parent = placeholder.parentNode;
-	if (!parent) {
-		logger.warn("[Askr] placeholder no longer in DOM, cannot render component");
-		return;
-	}
-	const renderer = getRuntimeRenderer();
-	const hostElement = document.createElement("div");
-	const executionFrame = getExecutionContextFrame(instance.ownerFrame);
-	const oldInstance = enterDomCommitScope(instance);
-	const lifecycleBatch = beginLifecycleCommitBatch();
-	try {
-		try {
-			withContext(executionFrame, () => {
-				renderer.evaluate(result, hostElement);
-			});
-			const onlyChild = hostElement.childNodes.length === 1 ? hostElement.firstChild : null;
-			const replacement = onlyChild instanceof Element ? onlyChild : hostElement;
-			if (replacement === hostElement) hostElement.__ASKR_WRAPPER_HOST = true;
-			parent.replaceChild(replacement, placeholder);
-			instance.target = replacement;
-			const instanceHost = replacement;
-			const instances = instanceHost.__ASKR_INSTANCES ?? [];
-			if (!instances.includes(instance)) instances.push(instance);
-			instanceHost.__ASKR_INSTANCES = instances;
-			instanceHost.__ASKR_INSTANCE = instances[0] ?? instance;
-		} catch (err) {
-			discardLifecycleCommitBatch(lifecycleBatch);
-			throw err;
-		}
-		instance._placeholder = void 0;
-		host.finalizeReadSubscriptions(instance);
-		host.warnUnusedStateReads(instance);
-		host.commitRenderedComponent(instance);
-		flushLifecycleCommitBatch(lifecycleBatch);
-	} finally {
-		restoreDomCommitScope(oldInstance);
-	}
-}
-function commitToTarget(instance, result, host) {
-	const renderer = getRuntimeRenderer();
-	const target = instance.target;
-	let oldChildren = [];
-	let restoredOldChildren = false;
-	try {
-		const wasFirstMount = !instance.mounted;
-		const oldInstance = enterDomCommitScope(instance);
-		const executionFrame = getExecutionContextFrame(instance.ownerFrame);
-		oldChildren = Array.from(target.childNodes);
-		const lifecycleBatch = beginLifecycleCommitBatch();
-		try {
-			try {
-				withContext(executionFrame, () => {
-					renderer.evaluate(result, target, void 0, instance);
-				});
-			} catch (err) {
-				discardLifecycleCommitBatch(lifecycleBatch);
-				throw err;
-			}
-		} catch (err) {
-			cleanupFailedCommitChildren(renderer, target, oldChildren);
-			try {
-				incDevCounter("__DOM_REPLACE_COUNT");
-				setDevValue("__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE", (/* @__PURE__ */ new Error()).stack);
-			} catch (devErr) {}
-			target.replaceChildren(...oldChildren);
-			restoredOldChildren = true;
-			throw err;
-		} finally {
-			restoreDomCommitScope(oldInstance);
-		}
-		host.finalizeReadSubscriptions(instance);
-		host.warnUnusedStateReads(instance);
-		instance.mounted = true;
-		commitLifecycleForInstance(instance, wasFirstMount);
-		flushLifecycleCommitBatch(lifecycleBatch);
-	} catch (renderError) {
-		discardCommitOperations(instance);
-		cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren);
-		const rollbackErrors = [];
-		try {
-			incDevCounter("__DOM_REPLACE_COUNT");
-			setDevValue("__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK", (/* @__PURE__ */ new Error()).stack);
-			target.replaceChildren(...oldChildren);
-		} catch (rollbackError) {
-			rollbackErrors.push(rollbackError);
-		}
-		if (rollbackErrors.length > 0) logger.error("[Askr] component rollback failed after render error:", new AggregateError(rollbackErrors, "Component rollback failed"));
-		throw renderError;
-	}
-}
-function cleanupFailedCommitChildren(renderer, target, oldChildren) {
-	try {
-		const newChildren = Array.from(target.childNodes);
-		const preservedChildren = new Set(oldChildren);
-		for (const node of newChildren) {
-			if (preservedChildren.has(node)) continue;
-			try {
-				renderer.cleanupInstancesUnder(node);
-			} catch (err) {
-				logger.warn("[Askr] error cleaning up failed commit children:", err);
-			}
-		}
-	} catch (err) {}
-}
-function cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren) {
-	try {
-		const currentChildren = Array.from(target.childNodes);
-		const preservedChildren = restoredOldChildren ? new Set(oldChildren) : null;
-		for (const node of currentChildren) {
-			if (preservedChildren?.has(node)) continue;
-			try {
-				renderer.cleanupInstancesUnder(node);
-			} catch (err) {
-				logger.warn("[Askr] error cleaning up partial children during rollback:", err);
-			}
-		}
-	} catch (err) {}
-}
-//#endregion
-export { runScheduledComponent };

package/dist/runtime/component-facade.d.ts

@@ -1,5 +0,0 @@
-import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { ComponentInstance } from "./component-internal.js";
-import { getSignal } from "./component-scope.js";
-import { ComponentFunction } from "../common/component.js";
-export { type ComponentFunction, type ComponentInstance, getSignal };

package/dist/runtime/component-facade.js

@@ -1,6 +0,0 @@
-import { claimHookIndex, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, restoreDomCommitScope, setCurrentComponentInstance } from "./component-scope.js";
-import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
-import "./component-lifecycle.js";
-import { captureInlineRenderSnapshot, createComponentInstance, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
-export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentLifecycleCommitBatch, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerLifecycleRollback, registerLifecycleTransaction, registerOwnedChildScope, renderComponentInline, renderScopedComponent, restoreDomCommitScope, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };

package/dist/runtime/component-internal.d.ts

@@ -1,105 +0,0 @@
-import { Props } from "../common/props.js";
-import { State } from "./state.js";
-import { ContextFrame } from "./context.js";
-import { OwnedChildScope, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { LifecycleOperation } from "./lifecycle-batch.js";
-import { ReadableSource } from "./readable.js";
-import { ComponentFunction } from "../common/component.js";
-
-//#region src/runtime/component-internal.d.ts
-interface ComponentInstance {
-  id: string;
-  fn: ComponentFunction;
-  props: Props;
-  target: Element | null;
-  parentInstance: ComponentInstance | null;
-  portalScope: object | null;
-  mounted: boolean;
-  abortController: AbortController | null;
-  ssr?: boolean;
-  cleanupStrict?: boolean;
-  stateValues?: State<unknown>[];
-  evaluationGeneration: number;
-  notifyUpdate: (() => void) | null;
-  _pendingFlushTask?: () => void;
-  _pendingRunTask?: () => void;
-  _enqueueRun?: () => void;
-  stateIndexCheck: number;
-  expectedStateIndices?: number[];
-  firstRenderComplete: boolean;
-  mountOperations: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
-  commitOperations: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
-  cleanupFns: Array<() => void>;
-  lifecycleSlots?: unknown[];
-  lifecycleGeneration: number;
-  hasPendingUpdate: boolean;
-  ownerFrame: ContextFrame | null;
-  isRoot?: boolean;
-  _rootComponentFn?: ComponentFunction;
-  _vnodeOwner?: object;
-  _vnodeParent?: ComponentInstance | null;
-  _vnodeKey?: string | number;
-  _vnodePosition?: number;
-  _wrapperDepth?: number;
-  _currentRenderToken?: number;
-  lastRenderToken?: number;
-  _pendingReadSources?: Set<ReadableSource<unknown>>;
-  _pendingReadSourceVersions?: Map<ReadableSource<unknown>, number>;
-  _lastReadSources?: Set<ReadableSource<unknown>>;
-  devWarningsEmitted?: Set<string>;
-  _placeholder?: Comment;
-  _ownedChildScopes?: Set<OwnedChildScope>;
-  errorBoundaryState?: {
-    error: unknown | null;
-    resetKey: unknown;
-    notified: boolean;
-  };
-}
-declare function createComponentInstance(id: string, fn: ComponentFunction, props: Props, target: Element | null): ComponentInstance;
-/**
- * Register a mount operation that will run after the component is mounted
- * Used by operations (task, on, timer, etc) to execute after render completes
- */
-declare function captureInlineRenderSnapshot(instance: ComponentInstance): void;
-declare function registerMountOperation(operation: LifecycleOperation): void;
-declare function registerCommitOperation(operation: LifecycleOperation): void;
-declare function commitRenderedComponent(instance: ComponentInstance): void;
-declare function mountInstanceInline(instance: ComponentInstance, target: Element | null): void;
-/**
- * Run a component synchronously: execute function, handle result
- * This is the internal workhorse that manages async continuations and generation tracking.
- * Must always be called through the scheduler.
- *
- * ACTOR INVARIANT: This function is enqueued as a task, never called directly.
- */
-declare function renderScopedComponent<T>(instance: ComponentInstance, startStateIndex: number, render: () => T): T;
-/**
- * Execute a component's render function synchronously.
- * Returns either a vnode/promise immediately (does NOT render).
- * Rendering happens separately through the scheduled commit helper.
- */
-declare function renderComponentInline(instance: ComponentInstance): unknown | Promise<unknown>;
-declare function warnUnusedStateReads(instance: ComponentInstance): void;
-/**
- * Public entry point: Execute component with full lifecycle (execute + render)
- * Handles both initial mount and re-execution. Always enqueues through scheduler.
- * Single entry point to avoid lifecycle divergence.
- */
-declare function executeComponent(instance: ComponentInstance): void;
-/**
- * Finalize read subscriptions for an instance after a successful commit.
- * - Update per-state readers map to point to this instance's last committed token
- * - Remove this instance from states it no longer reads
- * This is deterministic and runs synchronously with commit to ensure
- * subscribers are only notified when they actually read a state in their
- * last committed render.
- */
-declare function finalizeReadSubscriptions(instance: ComponentInstance): void;
-/**
- * Mount a component instance.
- * This is just an alias to executeComponent() to maintain API compatibility.
- * All lifecycle logic is unified in executeComponent().
- */
-declare function mountComponent(instance: ComponentInstance): void;
-//#endregion
-export { type ComponentFunction, ComponentInstance, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };

package/dist/runtime/component-internal.js

@@ -1,237 +0,0 @@
-import { isDevelopmentEnvironment, isProductionEnvironment } from "../common/env.js";
-import { logger } from "../common/logger.js";
-import { enqueueRuntimeTask } from "./access.js";
-import { callWithContext, getExecutionContextFrame, withContext } from "./context.js";
-import { finalizeReadableSubscriptions } from "./readable.js";
-import { incDevCounter } from "./dev-namespace.js";
-import { beginRenderTracking, captureInlineComponentScope, captureInlineRenderTracking, clearRenderTracking, enterComponentExecutionScope, enterRenderScopedComponent, exitComponentExecutionScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getSignalForInstance, resetRenderState, restoreInlineComponentScope, restoreInlineRenderTracking, restoreRenderScopedComponent } from "./component-scope.js";
-import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { discardCommitOperations } from "./lifecycle-operation-settlement.js";
-import { captureInlineRenderSnapshot as captureInlineRenderSnapshot$1, finalizeInlineReadSubscriptions } from "./lifecycle-batch.js";
-import { commitLifecycleForInstance, commitRenderedComponent as commitRenderedComponent$1, registerCommitOperationForInstance } from "./component-lifecycle.js";
-import { runScheduledComponent } from "./component-commit.js";
-//#region src/runtime/component-internal.ts
-const PRODUCTION_BUILD_ENABLED = isProductionEnvironment();
-function ensurePendingRunTask(instance) {
-	const existing = instance._pendingRunTask;
-	if (existing) return existing;
-	const task = () => {
-		instance.hasPendingUpdate = false;
-		if (instance.notifyUpdate === null) return;
-		runScheduledComponent(instance, {
-			execute: executeComponentSync,
-			finalizeReadSubscriptions,
-			warnUnusedStateReads,
-			commitRenderedComponent
-		});
-	};
-	instance._pendingRunTask = task;
-	if (!instance._pendingFlushTask) instance._pendingFlushTask = task;
-	return task;
-}
-function enqueueComponentRun() {
-	if (this.hasPendingUpdate) return;
-	this.hasPendingUpdate = true;
-	enqueueRuntimeTask(ensurePendingRunTask(this));
-}
-var ComponentExecutionContext = class {
-	constructor(instance) {
-		this.instance = instance;
-	}
-	get signal() {
-		return getSignalForInstance(this.instance);
-	}
-};
-function createComponentInstance(id, fn, props, target) {
-	const parentInstance = getCurrentInstance();
-	const instance = {
-		id,
-		fn,
-		props,
-		target,
-		parentInstance,
-		portalScope: parentInstance?.portalScope ?? getCurrentPortalScope() ?? null,
-		mounted: false,
-		abortController: null,
-		stateValues: void 0,
-		evaluationGeneration: 0,
-		notifyUpdate: null,
-		_pendingFlushTask: void 0,
-		_pendingRunTask: void 0,
-		_enqueueRun: void 0,
-		stateIndexCheck: -1,
-		expectedStateIndices: void 0,
-		firstRenderComplete: false,
-		mountOperations: [],
-		commitOperations: [],
-		cleanupFns: [],
-		lifecycleSlots: void 0,
-		lifecycleGeneration: 0,
-		hasPendingUpdate: false,
-		ownerFrame: null,
-		ssr: false,
-		cleanupStrict: false,
-		isRoot: false,
-		_currentRenderToken: void 0,
-		lastRenderToken: 0,
-		_pendingReadSources: void 0,
-		_pendingReadSourceVersions: void 0,
-		_lastReadSources: void 0,
-		devWarningsEmitted: void 0
-	};
-	instance._enqueueRun = enqueueComponentRun;
-	return instance;
-}
-/**
-* Register a mount operation that will run after the component is mounted
-* Used by operations (task, on, timer, etc) to execute after render completes
-*/
-function captureInlineRenderSnapshot(instance) {
-	captureInlineRenderSnapshot$1(instance);
-}
-function registerCommitOperation(operation) {
-	registerCommitOperationForInstance(getCurrentComponentInstance(), operation);
-}
-function commitRenderedComponent(instance) {
-	commitRenderedComponent$1(instance);
-}
-function mountInstanceInline(instance, target) {
-	instance.target = target;
-	try {
-		if (target instanceof Element) {
-			const host = target;
-			const instances = host.__ASKR_INSTANCES;
-			if (!instances) {
-				host.__ASKR_INSTANCES = [instance];
-				host.__ASKR_INSTANCE = instance;
-			} else if (instances[instances.length - 1] !== instance) {
-				const nextInstances = instances.indexOf(instance) === -1 ? instances.slice() : instances.filter((entry) => entry !== instance);
-				nextInstances.push(instance);
-				host.__ASKR_INSTANCES = nextInstances;
-				host.__ASKR_INSTANCE = nextInstances[0] ?? instance;
-			}
-		}
-	} catch (err) {}
-	instance.notifyUpdate = instance._enqueueRun;
-	const wasFirstMount = !instance.mounted;
-	instance.mounted = true;
-	commitLifecycleForInstance(instance, wasFirstMount);
-}
-/**
-* Run a component synchronously: execute function, handle result
-* This is the internal workhorse that manages async continuations and generation tracking.
-* Must always be called through the scheduler.
-*
-* ACTOR INVARIANT: This function is enqueued as a task, never called directly.
-*/
-function renderScopedComponent(instance, startStateIndex, render) {
-	instance.notifyUpdate = instance._enqueueRun;
-	resetRenderState(instance);
-	beginRenderTracking(instance);
-	const savedScope = enterRenderScopedComponent(instance, startStateIndex);
-	let didComplete = false;
-	try {
-		const result = withContext(getExecutionContextFrame(instance.ownerFrame), render);
-		didComplete = true;
-		return result;
-	} finally {
-		if (!didComplete) clearRenderTracking(instance);
-		restoreRenderScopedComponent(savedScope);
-	}
-}
-/**
-* Execute a component's render function synchronously.
-* Returns either a vnode/promise immediately (does NOT render).
-* Rendering happens separately through the scheduled commit helper.
-*/
-function renderComponentInline(instance) {
-	instance.notifyUpdate = instance._enqueueRun;
-	const trackingSnapshot = captureInlineRenderTracking(instance);
-	const scopeSnapshot = captureInlineComponentScope();
-	const hadToken = trackingSnapshot.currentRenderToken !== void 0;
-	if (!hadToken) beginRenderTracking(instance);
-	try {
-		const result = executeComponentSync(instance);
-		if (!hadToken) finalizeInlineReadSubscriptions(instance, instance._currentRenderToken, instance._pendingReadSources, instance._pendingReadSourceVersions);
-		commitRenderedComponent(instance);
-		return result;
-	} finally {
-		restoreInlineRenderTracking(instance, trackingSnapshot);
-		restoreInlineComponentScope(scopeSnapshot);
-	}
-}
-function warnUnusedStateReads(instance) {
-	const stateValues = instance.stateValues;
-	if (!stateValues) return;
-	for (let i = 0; i < stateValues.length; i++) {
-		const state = stateValues[i];
-		const hasCommittedUsage = (state?._readers?.size ?? 0) > 0 || (state?._derivedSubscribers?.size ?? 0) > 0;
-		if (state && !state._hasBeenRead && !state._hasEverBeenRead && !hasCommittedUsage) try {
-			const name = instance.fn?.name || "<anonymous>";
-			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`);
-		} catch {
-			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected. State should be read during render or removed.`);
-		}
-	}
-}
-function executeComponentSync(instance) {
-	resetRenderState(instance);
-	incDevCounter("componentRuns");
-	incDevCounter("componentReruns");
-	const savedPortalScope = enterComponentExecutionScope(instance);
-	let didComplete = false;
-	try {
-		const trackRenderTime = !PRODUCTION_BUILD_ENABLED && isDevelopmentEnvironment();
-		const renderStartTime = trackRenderTime ? Date.now() : 0;
-		const context = new ComponentExecutionContext(instance);
-		const result = callWithContext(getExecutionContextFrame(instance.ownerFrame), instance.fn, instance.props, context);
-		if (trackRenderTime) {
-			const renderTime = Date.now() - renderStartTime;
-			if (renderTime > 5) warnInstanceOnce(instance, "slow-render", `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`);
-		}
-		if (!instance.firstRenderComplete) instance.firstRenderComplete = true;
-		didComplete = true;
-		return result;
-	} finally {
-		if (!didComplete) discardCommitOperations(instance);
-		exitComponentExecutionScope(savedPortalScope);
-	}
-}
-/**
-* Public entry point: Execute component with full lifecycle (execute + render)
-* Handles both initial mount and re-execution. Always enqueues through scheduler.
-* Single entry point to avoid lifecycle divergence.
-*/
-function executeComponent(instance) {
-	instance.abortController = null;
-	instance.notifyUpdate = instance._enqueueRun;
-	enqueueRuntimeTask(ensurePendingRunTask(instance));
-}
-/**
-* Finalize read subscriptions for an instance after a successful commit.
-* - Update per-state readers map to point to this instance's last committed token
-* - Remove this instance from states it no longer reads
-* This is deterministic and runs synchronously with commit to ensure
-* subscribers are only notified when they actually read a state in their
-* last committed render.
-*/
-function finalizeReadSubscriptions(instance) {
-	finalizeReadableSubscriptions(instance);
-}
-/**
-* Mount a component instance.
-* This is just an alias to executeComponent() to maintain API compatibility.
-* All lifecycle logic is unified in executeComponent().
-*/
-function mountComponent(instance) {
-	executeComponent(instance);
-}
-function warnInstanceOnce(instance, key, message) {
-	if (isProductionEnvironment()) return;
-	const warnings = instance.devWarningsEmitted ??= /* @__PURE__ */ new Set();
-	if (warnings.has(key)) return;
-	warnings.add(key);
-	logger.warn(message);
-}
-//#endregion
-export { captureInlineRenderSnapshot, cleanupComponent, commitRenderedComponent, createComponentInstance, executeComponent, finalizeReadSubscriptions, mountComponent, mountInstanceInline, registerCommitOperation, registerOwnedChildScope, renderComponentInline, renderScopedComponent, unregisterOwnedChildScope, warnUnusedStateReads };

package/dist/runtime/component-lifecycle.d.ts

@@ -1,10 +0,0 @@
-import { LifecycleCommitBatch, LifecycleOperation, LifecycleTransaction } from "./lifecycle-batch.js";
-import { ComponentInstance } from "./component-internal.js";
-
-//#region src/runtime/component-lifecycle.d.ts
-declare function registerMountOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
-declare function registerCommitOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
-declare function commitLifecycleForInstance(instance: ComponentInstance, wasFirstMount: boolean): void;
-declare function commitRenderedComponent(instance: ComponentInstance): void;
-//#endregion
-export type { LifecycleOperation };

package/dist/runtime/component-lifecycle.js

@@ -1,33 +0,0 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { isBulkCommitActive } from "./fastlane.js";
-import { discardCommitOperations, executeCommittedLifecycleOperations } from "./lifecycle-operation-settlement.js";
-import { beginLifecycleCommitBatch, captureInlineRenderSnapshot, discardLifecycleCommitBatch, drainLifecycleCommitErrors, enqueueLifecycleCommitForInstance, finalizeInlineReadSubscriptions, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
-//#region src/runtime/component-lifecycle.ts
-function registerMountOperationForInstance(instance, operation) {
-	if (instance) {
-		if (isBulkCommitActive()) {
-			if (isDevelopmentEnvironment()) throw new Error("registerMountOperation called during bulk commit fast-lane");
-			return;
-		}
-		instance.mountOperations.push(operation);
-	}
-}
-function registerCommitOperationForInstance(instance, operation) {
-	if (instance) {
-		if (isBulkCommitActive()) {
-			if (isDevelopmentEnvironment()) throw new Error("registerCommitOperation called during bulk commit fast-lane");
-			return;
-		}
-		instance.commitOperations.push(operation);
-	}
-}
-function commitLifecycleForInstance(instance, wasFirstMount) {
-	if ((instance.mountOperations?.length ?? 0) === 0 && (instance.commitOperations?.length ?? 0) === 0) return;
-	if (enqueueLifecycleCommitForInstance(instance, wasFirstMount)) return;
-	executeCommittedLifecycleOperations(instance, wasFirstMount);
-}
-function commitRenderedComponent(instance) {
-	if (instance.mounted && (instance.commitOperations?.length ?? 0) > 0) commitLifecycleForInstance(instance, false);
-}
-//#endregion
-export { beginLifecycleCommitBatch, captureInlineRenderSnapshot, commitLifecycleForInstance, commitRenderedComponent, discardCommitOperations, discardLifecycleCommitBatch, drainLifecycleCommitErrors, finalizeInlineReadSubscriptions, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch, registerCommitOperationForInstance, registerLifecycleRollback, registerLifecycleTransaction, registerMountOperationForInstance };

package/dist/runtime/component-scope.d.ts

@@ -1,54 +0,0 @@
-import { ComponentInstance } from "./component-internal.js";
-import { ReadableSource } from "./readable.js";
-
-//#region src/runtime/component-scope.d.ts
-type ComponentScopeSnapshot = {
-  instance: ComponentInstance | null;
-  portalScope: object | null;
-  stateIndex: number;
-};
-type InstancePortalScopeSnapshot = {
-  instance: ComponentInstance | null;
-  portalScope: object | null;
-};
-type InlineRenderTrackingSnapshot = {
-  currentRenderToken: number | undefined;
-  pendingReadSources: Set<ReadableSource<unknown>> | undefined;
-  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined;
-};
-declare function getCurrentComponentInstance(): ComponentInstance | null;
-declare function getCurrentInstance(): ComponentInstance | null;
-declare function setCurrentComponentInstance(instance: ComponentInstance | null): void;
-declare function getCurrentPortalScope(): object | null;
-declare function getSignalForInstance(instance: ComponentInstance): AbortSignal;
-/**
- * Get the abort signal for the current component.
- *
- * The signal is guaranteed to be aborted when:
- * - Component unmounts
- * - Navigation occurs (different route)
- * - Parent is destroyed
- */
-declare function getSignal(): AbortSignal;
-declare function resetRenderState(instance: ComponentInstance): void;
-declare function beginRenderTracking(instance: ComponentInstance): void;
-declare function clearRenderTracking(instance: ComponentInstance): void;
-declare function captureInlineRenderTracking(instance: ComponentInstance): InlineRenderTrackingSnapshot;
-declare function restoreInlineRenderTracking(instance: ComponentInstance, snapshot: InlineRenderTrackingSnapshot): void;
-declare function enterRenderScopedComponent(instance: ComponentInstance, startStateIndex: number): ComponentScopeSnapshot | null;
-declare function restoreRenderScopedComponent(snapshot: ComponentScopeSnapshot | null): void;
-declare function captureInlineComponentScope(): InstancePortalScopeSnapshot;
-declare function restoreInlineComponentScope(snapshot: InstancePortalScopeSnapshot): void;
-declare function enterComponentExecutionScope(instance: ComponentInstance): object | null;
-declare function exitComponentExecutionScope(savedPortalScope: object | null): void;
-declare function enterDomCommitScope(instance: ComponentInstance): ComponentInstance | null;
-declare function restoreDomCommitScope(previousInstance: ComponentInstance | null): void;
-declare function clearCurrentComponentScope(): ComponentScopeSnapshot;
-declare function restoreCurrentComponentScope(snapshot: ComponentScopeSnapshot): void;
-declare function getNextStateIndex(): number;
-declare function claimHookIndex(instance: ComponentInstance, hookName: string): number;
-declare function getCurrentStateIndex(): number;
-declare function resetStateIndex(): void;
-declare function setStateIndex(value: number): void;
-//#endregion
-export { getSignal };

package/dist/runtime/component.d.ts

@@ -1,5 +0,0 @@
-import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { ComponentInstance } from "./component-internal.js";
-import { getSignal } from "./component-scope.js";
-import { ComponentFunction } from "../common/component.js";
-export { type ComponentFunction, type ComponentInstance, getSignal };

package/dist/runtime/component.js

@@ -1,6 +0,0 @@
-import { claimHookIndex, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, restoreDomCommitScope, setCurrentComponentInstance } from "./component-scope.js";
-import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
-import { captureInlineRenderSnapshot, createComponentInstance, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
-import "./component-facade.js";
-export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentLifecycleCommitBatch, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerLifecycleRollback, registerLifecycleTransaction, registerOwnedChildScope, renderComponentInline, renderScopedComponent, restoreDomCommitScope, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };