@askrjs/askr 0.3.0 → 0.4.0

package/dist/hooks-BimKStr4.js

@@ -0,0 +1,202 @@
+import { F as logger, M as getOwner, N as runWithOwner, O as notifySource, a as getCurrentInstance, k as trackSource, r as claimHook, t as ComponentInstance } from "./instance-BAnfmXOR.js";
+//#region src/common/report-error.ts
+/**
+* Report an error the way the host reports an uncaught listener exception.
+*
+* `reportError` dispatches a window `error` event (so global handlers and
+* monitoring see it) and lets the caller continue, matching native listener
+* semantics. Hosts without it get the same outcome from an async rethrow.
+* A throwing host reporter never interrupts the caller; the original error
+* and the reporter's failure are logged instead.
+*/
+function reportUncaughtError(error) {
+	if (typeof globalThis.reportError === "function") {
+		try {
+			globalThis.reportError(error);
+		} catch (reportFailure) {
+			logger.error("[Askr] reportError failed:", error, reportFailure);
+		}
+		return;
+	}
+	queueMicrotask(() => {
+		throw error;
+	});
+}
+let deferredErrors;
+function flushDeferredErrors() {
+	const errors = deferredErrors;
+	deferredErrors = void 0;
+	for (const error of errors) reportUncaughtError(error);
+}
+/**
+* Report an error with `reportUncaughtError` once the current task finishes.
+*
+* Cleanup can fail in the middle of a render or commit. Deferring the report
+* keeps error handlers out of that work: they run after the DOM update, may
+* write state, and cannot interrupt or roll it back. Reports keep their order.
+*/
+function reportUncaughtErrorLater(error) {
+	if (deferredErrors) {
+		deferredErrors.push(error);
+		return;
+	}
+	deferredErrors = [error];
+	queueMicrotask(flushDeferredErrors);
+}
+//#endregion
+//#region src/common/render-depth.ts
+/**
+* Askr renders nested components recursively, so a very deep tree can exhaust
+* the JavaScript call stack. Replace the engine's bare RangeError with an
+* error that says what happened and how to fix it.
+*/
+const STACK_OVERFLOW = /maximum call stack|too much recursion/i;
+var RenderDepthError = class extends Error {
+	constructor(cause) {
+		super("[Askr] The JavaScript call stack overflowed while rendering. Either the component tree is too deep (Askr renders nested elements and components recursively; render long sequences as lists, for example with <For>, instead of nesting them) or a component or computation recurses without end. `cause` holds the original error.");
+		this.name = "RenderDepthError";
+		Object.defineProperty(this, "cause", {
+			value: cause,
+			writable: true,
+			configurable: true
+		});
+	}
+};
+/**
+* `error`, or a `RenderDepthError` when it is an engine stack overflow: a
+* `RangeError` in V8 and JavaScriptCore, an `InternalError` in Firefox.
+* Callers near the overflow may have too little stack left to convert; then
+* the original error is returned and a shallower caller converts it.
+*/
+function clarifyRenderOverflow(error) {
+	try {
+		if (error instanceof Error && (error instanceof RangeError || error.name === "InternalError") && STACK_OVERFLOW.test(error.message)) return new RenderDepthError(error);
+	} catch {}
+	return error;
+}
+//#endregion
+//#region src/core/component/errors.ts
+/**
+* Error boundaries. A component instance becomes a boundary by setting
+* `boundary`: a handler that accepts an error (returning true) and makes the
+* instance render its fallback on its next render.
+*/
+const errorOrigins = /* @__PURE__ */ new WeakMap();
+/** Remember the logical owner where an error first escaped rendering. */
+function noteErrorOrigin(owner, error) {
+	if (!owner || typeof error !== "object" && typeof error !== "function" || error === null) return;
+	try {
+		if (!errorOrigins.has(error)) errorOrigins.set(error, owner);
+	} catch {}
+}
+/**
+* Deliver `error` to the nearest boundary at or above `owner` and schedule it
+* to re-render. Returns false when no boundary accepted it.
+*/
+function deliverToBoundary(owner, error) {
+	for (let o = owner; o; o = o.parent) if (o instanceof ComponentInstance && o.boundary && !o.disposed) {
+		if (o.boundary(error)) {
+			o.computation.invalidate();
+			return true;
+		}
+	}
+	return false;
+}
+/** Deliver `error` to a boundary, or throw it to the caller. */
+function routeError(owner, error) {
+	const origin = error !== null && (typeof error === "object" || typeof error === "function") ? errorOrigins.get(error) : void 0;
+	if (origin && deliverToBoundary(origin, error)) return;
+	if (!deliverToBoundary(owner, error)) throw error;
+}
+/**
+* `caught`, or a `RenderDepthError` when it is a stack overflow. The new error
+* inherits the origin recorded on `caught` so routing still starts where the
+* overflow first escaped. This runs near an exhausted stack, so carrying the
+* origin is best-effort: the cheap lookup runs first, and if recording fails
+* the converted error is still returned without an origin.
+*/
+function clarifyRenderError(caught) {
+	let origin;
+	try {
+		origin = caught !== null && typeof caught === "object" ? errorOrigins.get(caught) : void 0;
+	} catch {
+		origin = void 0;
+	}
+	const error = clarifyRenderOverflow(caught);
+	if (error !== caught && origin) try {
+		errorOrigins.set(error, origin);
+	} catch {}
+	return error;
+}
+//#endregion
+//#region src/core/api/hooks.ts
+function currentComponent() {
+	return getCurrentInstance();
+}
+/**
+* Claim the next slot of `instance` for a hook of `kind`, creating its state
+* on the first render. Later renders get the same state back.
+*/
+function hookSlot(instance, kind, create) {
+	const index = claimHook(instance, kind);
+	if (!(index in instance.hooks)) instance.hooks[index] = create();
+	return instance.hooks[index];
+}
+/** The index the next hook claim would use (for keyed per-slot stores). */
+function claimHookIndex(instance, kind) {
+	return claimHook(instance, kind);
+}
+/** Run `fn` after the current render of `instance` commits. */
+function onCommit(instance, fn) {
+	instance.onCommit(() => {
+		const result = fn();
+		if (typeof result === "function") return result;
+		if (result && typeof result.then === "function") Promise.resolve(result).then((cleanup) => {
+			if (typeof cleanup !== "function") return;
+			if (!instance.disposed) {
+				instance.onCleanup(cleanup);
+				return;
+			}
+			try {
+				cleanup();
+			} catch (error) {
+				reportUncaughtError(error);
+			}
+		}, (error) => reportLifecycleError(instance, error));
+	});
+}
+/** The owner whose lifetime callbacks and handlers currently run under. */
+function currentOwner() {
+	return getOwner();
+}
+function withOwner(owner, fn) {
+	return runWithOwner(owner, fn);
+}
+/** Deliver a lifecycle failure to the nearest error boundary, else report it. */
+function reportLifecycleError(owner, error) {
+	if (!deliverToBoundary(owner, error)) reportUncaughtError(error);
+}
+function createSource() {
+	return { _observers: null };
+}
+/** Record that the running computation read `source`. */
+function readSource(source) {
+	trackSource(source);
+}
+/** Tell everything that read `source` that it changed. */
+function notify(source) {
+	notifySource(source);
+}
+const APP_RUNTIME = Symbol("askr.app-runtime");
+/**
+* Make `runtime` the application runtime for everything the rendering
+* component renders (undone if the render is discarded).
+*/
+function provideAppRuntime(runtime) {
+	getCurrentInstance()?.provide(APP_RUNTIME, runtime);
+}
+function currentAppRuntime() {
+	return getOwner()?.lookup(APP_RUNTIME);
+}
+//#endregion
+export { RenderDepthError as _, currentOwner as a, reportUncaughtErrorLater as b, onCommit as c, reportLifecycleError as d, withOwner as f, routeError as g, noteErrorOrigin as h, currentComponent as i, provideAppRuntime as l, deliverToBoundary as m, createSource as n, hookSlot as o, clarifyRenderError as p, currentAppRuntime as r, notify as s, claimHookIndex as t, readSource as u, clarifyRenderOverflow as v, reportUncaughtError as y };

package/dist/index.d.ts

@@ -1,121 +1,58 @@
-export {
-  createDOMRendererHost,
-  DOMComponentOwner,
-  DOMChildScope,
-  DOMReactiveSource,
-  DOMRendererRange,
-  DOMRendererEvaluation,
-  DOMRendererCleanup,
-  DOMRendererScopes,
-  DOMRendererKeys,
-  DOMRendererReactivity,
-  DOMRendererHost,
-} from './dom-renderer.js';
 import {
   cspNonce,
   selector,
-  Show,
   configureRenderDiagnostics,
-  ShowProps,
-  For,
-  CaseProps,
   StateSetter,
-  Match,
   StateTuple,
   registerSSRStyle,
-  MatchProps,
   state,
-  ForProps,
-  createQuery,
   createRef,
   RenderDiagnosticsOptions,
   derive,
   defineScope,
-  QueryCollection,
-  RuntimeKeyedReorderDecision,
-  defineServerQueries,
-  QueryCollectionOptions,
-  getDefaultRuntime,
-  dehydrateDataRuntime,
-  createQueryCollection,
-  serveQuery,
-  QueryPrefetchContext,
   Derived,
-  Case,
   State,
   CspNonceScope,
-  QueryCollectionEntry,
-  RuntimeRendererHost,
-  prefetchQuery,
-  AskrRuntime,
-  hydrateDataRuntime,
-  QueryDefinition,
   getSignal,
-  AskrRuntimeOptions,
-  DataRuntime,
-  defineQuery,
-  QueryCollectionKey,
-  createRuntime,
-  ServerQueryHandler,
   Ref,
   readScope,
   Scope,
   Selector,
 } from './core.js';
 import { Props, Fragment } from './elements.js';
-import { jsxs, jsx } from './jsx.js';
+import { createElement, jsxs, jsx } from './jsx.js';
+/**
+ * Thrown when the JavaScript call stack overflows during a render, usually
+ * because the component tree is too deep. `cause` is the engine's error.
+ */
+declare class RenderDepthError extends Error {
+  readonly cause: unknown;
+  constructor(cause: unknown);
+}
 export {
-  AskrRuntime,
-  type AskrRuntimeOptions,
-  Case,
-  type CaseProps,
   CspNonceScope,
-  type DataRuntime,
   type Derived,
-  For,
-  type ForProps,
   Fragment,
-  Match,
-  type MatchProps,
   type Props,
-  type QueryCollection,
-  type QueryCollectionEntry,
-  type QueryCollectionKey,
-  type QueryCollectionOptions,
-  type QueryDefinition,
-  type QueryPrefetchContext,
+  RenderDepthError,
   type Ref,
   type RenderDiagnosticsOptions,
-  type RuntimeKeyedReorderDecision,
-  type RuntimeRendererHost,
   type Scope,
   type Selector,
-  type ServerQueryHandler,
-  Show,
-  type ShowProps,
   type State,
   type StateSetter,
   type StateTuple,
   configureRenderDiagnostics,
-  createQuery,
-  createQueryCollection,
+  createElement,
   createRef,
-  createRuntime,
   cspNonce,
-  defineQuery,
   defineScope,
-  defineServerQueries,
-  dehydrateDataRuntime,
   derive,
-  getDefaultRuntime,
   getSignal,
-  hydrateDataRuntime,
   jsx,
   jsxs,
-  prefetchQuery,
   readScope,
   registerSSRStyle,
   selector,
-  serveQuery,
   state,
 };