@askrjs/askr 0.2.4 → 0.3.0

package/dist/access-BucjYZcX.js

@@ -1,509 +0,0 @@
-import { a as clearCurrentComponentScope, y as restoreCurrentComponentScope } from "./component-scope-4I3yEMkb.js";
-//#region src/common/env.ts
-function normalizeEnv(source) {
-	if (!source) return {};
-	const normalized = {};
-	for (const [key, value] of Object.entries(source)) if (typeof value === "string") normalized[key] = value;
-	else if (typeof value === "boolean" || typeof value === "number") normalized[key] = String(value);
-	return normalized;
-}
-function getBuildTimeEnv() {
-	const metaEnv = import.meta.env;
-	const normalized = normalizeEnv(metaEnv);
-	if (normalized.NODE_ENV == null && metaEnv) {
-		if (typeof metaEnv.MODE === "string" && metaEnv.MODE.length > 0) normalized.NODE_ENV = metaEnv.MODE;
-		else if (metaEnv.PROD === true || metaEnv.PROD === "true") normalized.NODE_ENV = "production";
-		else if (metaEnv.DEV === true || metaEnv.DEV === "true") normalized.NODE_ENV = "development";
-	}
-	return normalized;
-}
-function resolveNodeEnv(processNodeEnv, buildNodeEnv) {
-	if (buildNodeEnv === "production") return "production";
-	if (processNodeEnv != null) return processNodeEnv;
-	if (buildNodeEnv === "development") return "development";
-	return buildNodeEnv === "test" ? void 0 : buildNodeEnv;
-}
-function getRuntimeEnv() {
-	const processEnv = globalThis.process?.env ?? {};
-	const buildTimeEnv = getBuildTimeEnv();
-	return {
-		...processEnv,
-		...buildTimeEnv,
-		NODE_ENV: resolveNodeEnv(processEnv.NODE_ENV, buildTimeEnv.NODE_ENV)
-	};
-}
-function isProductionEnvironment() {
-	return getRuntimeEnv().NODE_ENV === "production";
-}
-function isDevelopmentEnvironment() {
-	return !isProductionEnvironment();
-}
-//#endregion
-//#region src/common/invariant.ts
-/**
-* Invariant assertions shared by production runtime code.
-*/
-function invariant(condition, message, context) {
-	if (!condition) {
-		const contextStr = context ? "\n" + JSON.stringify(context, null, 2) : "";
-		throw new Error(`[Askr Invariant] ${message}${contextStr}`);
-	}
-}
-function assertSchedulingPrecondition(condition, violationMessage) {
-	invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
-}
-//#endregion
-//#region src/common/logger.ts
-/**
-* Shared logger interface for runtime and tooling code.
-*
-* Debug, info, and warn stay silent in production. Errors always log.
-*/
-function callConsole(method, args) {
-	const c = typeof console !== "undefined" ? console : void 0;
-	if (!c) return;
-	const fn = c[method];
-	if (typeof fn === "function") try {
-		fn.apply(console, args);
-	} catch {}
-}
-const logger = {
-	debug: (...args) => {
-		if (isProductionEnvironment()) return;
-		callConsole("debug", args);
-	},
-	info: (...args) => {
-		if (isProductionEnvironment()) return;
-		callConsole("info", args);
-	},
-	warn: (...args) => {
-		if (isProductionEnvironment()) return;
-		callConsole("warn", args);
-	},
-	error: (...args) => {
-		callConsole("error", args);
-	}
-};
-//#endregion
-//#region src/runtime/perf-metrics.ts
-const incrementPerfMetric = () => {};
-const addPerfDuration = () => {};
-//#endregion
-//#region src/runtime/scheduler.ts
-/**
-* Serialized update scheduler — safer design (no inline execution, explicit flush)
-*
-* Key ideas:
-* - Never execute a task inline from `enqueue`.
-* - `flush()` is explicit and non-reentrant.
-* - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks
-*   inline; it runs `fn` and then does an explicit `flush()`.
-* - `waitForFlush()` is race-free with a monotonic `flushVersion`.
-*/
-const MAX_FLUSH_DEPTH = 50;
-const SCHEDULER_LANES = [
-	"derived",
-	"component",
-	"reactive",
-	"post"
-];
-var Scheduler = class {
-	constructor() {
-		this.bulkCommitProbe = () => false;
-		this.lanes = {
-			derived: {
-				tasks: [],
-				head: 0
-			},
-			component: {
-				tasks: [],
-				head: 0
-			},
-			reactive: {
-				tasks: [],
-				head: 0
-			},
-			post: {
-				tasks: [],
-				head: 0
-			}
-		};
-		this.running = false;
-		this.inHandler = false;
-		this.depth = 0;
-		this.executionDepth = 0;
-		this.flushVersion = 0;
-		this.kickScheduled = false;
-		this.allowSyncProgress = false;
-		this.waiters = [];
-		this.taskCount = 0;
-	}
-	setBulkCommitProbe(probe) {
-		this.bulkCommitProbe = probe;
-	}
-	isBulkCommitActive() {
-		try {
-			return this.bulkCommitProbe();
-		} catch (e) {
-			return false;
-		}
-	}
-	hasPendingTasks() {
-		for (const lane of SCHEDULER_LANES) {
-			const queue = this.lanes[lane];
-			if (queue.head < queue.tasks.length) return true;
-		}
-		return false;
-	}
-	getPendingTaskCount() {
-		let total = 0;
-		for (const lane of SCHEDULER_LANES) {
-			const queue = this.lanes[lane];
-			total += queue.tasks.length - queue.head;
-		}
-		return total;
-	}
-	compactLane(queue) {
-		if (queue.head >= queue.tasks.length) {
-			queue.tasks.length = 0;
-			queue.head = 0;
-			return;
-		}
-		if (queue.head <= 0) return;
-		const remaining = queue.tasks.length - queue.head;
-		for (let i = 0; i < remaining; i++) queue.tasks[i] = queue.tasks[queue.head + i];
-		queue.tasks.length = remaining;
-		queue.head = 0;
-	}
-	scheduleFlushKick() {
-		if (this.running || this.kickScheduled || this.inHandler || this.allowSyncProgress || this.isBulkCommitActive() || !this.hasPendingTasks()) return;
-		this.kickScheduled = true;
-		queueMicrotask(() => {
-			this.kickScheduled = false;
-			if (this.running || this.isBulkCommitActive() || !this.hasPendingTasks()) return;
-			try {
-				this.flush();
-			} catch (err) {
-				setTimeout(() => {
-					throw err;
-				});
-			}
-		});
-	}
-	enqueue(task) {
-		this.enqueueInLane("component", task);
-	}
-	enqueueInLane(lane, task) {
-		assertSchedulingPrecondition(typeof task === "function", "enqueue() requires a function");
-		if (this.isBulkCommitActive() && !this.allowSyncProgress) {
-			if (isDevelopmentEnvironment()) throw new Error("[Scheduler] enqueue() during bulk commit (not allowed)");
-			return;
-		}
-		this.lanes[lane].tasks.push(task);
-		this.taskCount++;
-		this.scheduleFlushKick();
-	}
-	flush() {
-		invariant(!this.running, "[Scheduler] flush() called while already running");
-		if (isDevelopmentEnvironment()) {
-			if (this.isBulkCommitActive() && !this.allowSyncProgress) throw new Error("[Scheduler] flush() started during bulk commit (not allowed)");
-		}
-		this.running = true;
-		this.depth = 0;
-		const failures = [];
-		let executedTaskCount = 0;
-		const executionsByTask = isDevelopmentEnvironment() ? /* @__PURE__ */ new Map() : null;
-		try {
-			while (true) {
-				let didRunTask = false;
-				for (const lane of SCHEDULER_LANES) {
-					const laneQueue = this.lanes[lane];
-					let executedInLane = 0;
-					while (laneQueue.head < laneQueue.tasks.length) {
-						const task = laneQueue.tasks[laneQueue.head++];
-						if (executionsByTask) {
-							const taskExecutions = (executionsByTask.get(task) ?? 0) + 1;
-							executionsByTask.set(task, taskExecutions);
-							this.depth = Math.max(this.depth, taskExecutions);
-							if (taskExecutions > MAX_FLUSH_DEPTH) throw new Error(`[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`);
-						}
-						try {
-							this.executionDepth++;
-							task();
-						} catch (err) {
-							failures.push(err);
-						} finally {
-							if (this.executionDepth > 0) this.executionDepth--;
-							executedTaskCount++;
-							executedInLane++;
-							didRunTask = true;
-						}
-					}
-					if (executedInLane > 0) this.taskCount = Math.max(0, this.taskCount - executedInLane);
-				}
-				if (!didRunTask) break;
-			}
-		} finally {
-			this.running = false;
-			this.depth = 0;
-			this.executionDepth = 0;
-			for (const lane of SCHEDULER_LANES) {
-				const queue = this.lanes[lane];
-				if (queue.head > 0) this.compactLane(queue);
-			}
-			this.flushVersion++;
-			this.resolveWaiters();
-		}
-		if (failures.length === 1) throw failures[0];
-		if (failures.length > 1) throw new AggregateError(failures, "Scheduler task failures");
-	}
-	runWithSyncProgress(fn) {
-		const prev = this.allowSyncProgress;
-		this.allowSyncProgress = true;
-		const startVersion = this.flushVersion;
-		try {
-			const res = fn();
-			if (!this.running && this.hasPendingTasks()) this.flush();
-			if (isDevelopmentEnvironment()) {
-				if (!this.running && this.hasPendingTasks()) throw new Error("[Scheduler] tasks remain after runWithSyncProgress flush");
-			}
-			return res;
-		} finally {
-			try {
-				if (this.flushVersion === startVersion) {
-					this.flushVersion++;
-					this.resolveWaiters();
-				}
-			} catch (e) {}
-			this.allowSyncProgress = prev;
-		}
-	}
-	waitForFlush(targetVersion, timeoutMs = 2e3) {
-		const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
-		if (this.flushVersion >= target) return Promise.resolve();
-		return new Promise((resolve, reject) => {
-			const waiter = {
-				target,
-				resolve,
-				reject
-			};
-			waiter.timer = setTimeout(() => {
-				const index = this.waiters.indexOf(waiter);
-				if (index >= 0) this.waiters.splice(index, 1);
-				if (waiter.timer !== void 0) clearTimeout(waiter.timer);
-				const diag = {
-					flushVersion: this.flushVersion,
-					queueLen: this.getPendingTaskCount(),
-					running: this.running,
-					inHandler: this.inHandler,
-					bulk: this.isBulkCommitActive()
-				};
-				reject(/* @__PURE__ */ new Error(`waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`));
-			}, timeoutMs);
-			this.waiters.push(waiter);
-		});
-	}
-	getState() {
-		return {
-			queueLength: this.getPendingTaskCount(),
-			running: this.running,
-			depth: this.depth,
-			executionDepth: this.executionDepth,
-			taskCount: this.taskCount,
-			flushVersion: this.flushVersion,
-			laneQueues: {
-				derived: this.lanes.derived.tasks.length - this.lanes.derived.head,
-				component: this.lanes.component.tasks.length - this.lanes.component.head,
-				reactive: this.lanes.reactive.tasks.length - this.lanes.reactive.head,
-				post: this.lanes.post.tasks.length - this.lanes.post.head
-			},
-			inHandler: this.inHandler,
-			allowSyncProgress: this.allowSyncProgress
-		};
-	}
-	getFlushVersion() {
-		return this.flushVersion;
-	}
-	flushIfQueued() {
-		if (!this.running && this.hasPendingTasks()) this.flush();
-	}
-	runInHandlerScope(fn, flushMode = "defer") {
-		const prevInHandler = this.inHandler;
-		this.inHandler = true;
-		try {
-			return fn();
-		} finally {
-			this.inHandler = prevInHandler;
-			if (!this.inHandler) {
-				if (flushMode === "sync") this.flushIfQueued();
-				else this.scheduleFlushKick();
-			}
-		}
-	}
-	setInHandler(v) {
-		this.inHandler = v;
-		if (!v) this.scheduleFlushKick();
-	}
-	isInHandler() {
-		return this.inHandler;
-	}
-	isExecuting() {
-		return this.running || this.executionDepth > 0;
-	}
-	clearPendingSyncTasks() {
-		const remaining = this.getPendingTaskCount();
-		if (remaining <= 0) return 0;
-		if (this.running) {
-			for (const lane of SCHEDULER_LANES) {
-				const queue = this.lanes[lane];
-				queue.tasks.length = queue.head;
-			}
-			this.taskCount = Math.max(0, this.taskCount - remaining);
-			queueMicrotask(() => {
-				try {
-					this.flushVersion++;
-					this.resolveWaiters();
-				} catch (e) {}
-			});
-			return remaining;
-		}
-		for (const lane of SCHEDULER_LANES) {
-			const queue = this.lanes[lane];
-			queue.tasks.length = 0;
-			queue.head = 0;
-		}
-		this.taskCount = Math.max(0, this.taskCount - remaining);
-		this.flushVersion++;
-		this.resolveWaiters();
-		return remaining;
-	}
-	resolveWaiters() {
-		if (this.waiters.length === 0) return;
-		const ready = [];
-		const remaining = [];
-		for (const w of this.waiters) if (this.flushVersion >= w.target) {
-			if (w.timer !== void 0) clearTimeout(w.timer);
-			ready.push(w.resolve);
-		} else remaining.push(w);
-		this.waiters = remaining;
-		for (const r of ready) r();
-	}
-};
-const globalScheduler = new Scheduler();
-function scheduleEventHandler(handler) {
-	return (event) => {
-		try {
-			globalScheduler.runInHandlerScope(() => {
-				handler.call(null, event);
-			});
-		} catch (error) {
-			logger.error("[Askr] Event handler error:", error);
-		}
-	};
-}
-//#endregion
-//#region src/runtime/runtime.ts
-function createMissingRendererHost() {
-	const missing = (method) => {
-		throw new Error(`[Askr] renderer host is not configured; cannot call ${method}().`);
-	};
-	return {
-		evaluate() {
-			missing("evaluate");
-		},
-		cleanupInstancesUnder() {
-			missing("cleanupInstancesUnder");
-		},
-		replaceComponentRange() {
-			return missing("replaceComponentRange");
-		},
-		teardownNodeSubtree() {
-			missing("teardownNodeSubtree");
-		},
-		populateKeyMapForElement() {},
-		getKeyMapForElement() {},
-		isKeyedReorderFastPathEligible() {
-			return {
-				useFastPath: false,
-				totalKeyed: 0,
-				totalChildren: 0,
-				currentKeyCount: 0,
-				moveCount: 0,
-				lisLen: 0,
-				hasPropChanges: false,
-				isWholeKeyedList: false
-			};
-		},
-		markReactivePropsDirtySource() {}
-	};
-}
-/** A scheduler + renderer host pairing; owns scheduling and renderer wiring for an app instance. */
-var AskrRuntime = class {
-	constructor(options = {}) {
-		this.scheduler = options.scheduler ?? globalScheduler;
-		this.rendererHost = options.renderer ?? createMissingRendererHost();
-	}
-	get renderer() {
-		return this.rendererHost;
-	}
-	configureRenderer(renderer) {
-		this.rendererHost = renderer;
-	}
-};
-const defaultRuntime = new AskrRuntime({ scheduler: globalScheduler });
-/** Create a new {@link AskrRuntime} instance with its own scheduler/renderer wiring. */
-function createRuntime(options = {}) {
-	return new AskrRuntime(options);
-}
-/** Get the process-wide default {@link AskrRuntime}. */
-function getDefaultRuntime() {
-	return defaultRuntime;
-}
-function configureRuntimeRenderer(renderer, runtime = defaultRuntime) {
-	runtime.configureRenderer(renderer);
-}
-//#endregion
-//#region src/runtime/access.ts
-function getRuntimeScheduler() {
-	return getDefaultRuntime().scheduler;
-}
-function getDefaultRuntimeInstance() {
-	return getDefaultRuntime();
-}
-function getRuntimeRenderer() {
-	return getDefaultRuntime().renderer;
-}
-function enqueueRuntimeTask(task) {
-	getRuntimeScheduler().enqueue(task);
-}
-function enqueueRuntimeLane(lane, task) {
-	getRuntimeScheduler().enqueueInLane(lane, task);
-}
-function runRuntimeHandlerScope(fn, flushMode = "defer") {
-	const savedScope = clearCurrentComponentScope();
-	try {
-		return getRuntimeScheduler().runInHandlerScope(fn, flushMode);
-	} finally {
-		restoreCurrentComponentScope(savedScope);
-	}
-}
-function runRuntimeWithSyncProgress(fn) {
-	return getRuntimeScheduler().runWithSyncProgress(fn);
-}
-function isRuntimeSchedulerExecuting() {
-	return getRuntimeScheduler().isExecuting();
-}
-function getRuntimeFlushVersion() {
-	return getRuntimeScheduler().getFlushVersion();
-}
-function flushRuntimeScheduler() {
-	getRuntimeScheduler().flush();
-}
-function setRuntimeBulkCommitProbe(probe) {
-	getRuntimeScheduler().setBulkCommitProbe(probe);
-}
-function markRuntimeReactivePropsDirtySource(source) {
-	getRuntimeRenderer().markReactivePropsDirtySource(source);
-}
-//#endregion
-export { isProductionEnvironment as S, addPerfDuration as _, getRuntimeFlushVersion as a, getRuntimeEnv as b, markRuntimeReactivePropsDirtySource as c, setRuntimeBulkCommitProbe as d, AskrRuntime as f, scheduleEventHandler as g, getDefaultRuntime as h, getDefaultRuntimeInstance as i, runRuntimeHandlerScope as l, createRuntime as m, enqueueRuntimeTask as n, getRuntimeRenderer as o, configureRuntimeRenderer as p, flushRuntimeScheduler as r, isRuntimeSchedulerExecuting as s, enqueueRuntimeLane as t, runRuntimeWithSyncProgress as u, incrementPerfMetric as v, isDevelopmentEnvironment as x, logger as y };

package/dist/activity-DooIuxQO.d.ts

@@ -1,14 +0,0 @@
-import { $t as RouteSnapshot, zt as RouteParams } from "./index-Dgjbo2gU.js";
-//#region src/router/activity.d.ts
-/** Options for {@link onRouteChange}. */
-interface RouteChangeOptions {
-  immediate?: boolean;
-}
-/** Optional cleanup returned by an {@link onRouteChange} callback, run before the next change. */
-type RouteChangeCleanup = void | (() => void);
-/** Register a callback to run whenever the active route changes, with optional cleanup. */
-declare function onRouteChange(fn: (current: RouteSnapshot, previous: RouteSnapshot | null) => RouteChangeCleanup, options?: RouteChangeOptions): void;
-/** Read the currently active route's {@link RouteSnapshot}; reactive during component render. */
-declare function currentRoute<TParams extends RouteParams = RouteParams, TState = unknown>(): RouteSnapshot<TParams, TState>;
-//#endregion
-export { onRouteChange as i, RouteChangeOptions as n, currentRoute as r, RouteChangeCleanup as t };

package/dist/benchmark.d.ts

@@ -1,26 +0,0 @@
-import "./jsx-runtime-Cg7GqY1S.js";
-//#region src/bench/components/benchmark-row.d.ts
-interface BenchmarkRowData {
-  id: number;
-  label: string;
-}
-//#endregion
-//#region src/bench/benchmark-entry.d.ts
-type RowData = BenchmarkRowData;
-interface BenchmarkMetadata {
-  packageName: string;
-  packageVersion: string;
-  buildLabel: string;
-}
-declare const benchmarkMetadata: BenchmarkMetadata;
-declare function getBenchmarkMetadata(): BenchmarkMetadata;
-declare function mountBenchmark(root: Element, initialRows?: RowData[]): {
-  setRows(rows: RowData[]): void;
-  setSelected(id: number | null): void;
-  cleanup(): void;
-};
-declare const _default: {
-  mountBenchmark: typeof mountBenchmark;
-};
-//#endregion
-export { BenchmarkMetadata, benchmarkMetadata, _default as default, getBenchmarkMetadata, mountBenchmark };