@askrjs/askr 0.0.52 → 0.0.54

package/dist/deferred-DklLG4qM.js

@@ -0,0 +1,386 @@
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-CUpRxrLH.js";
+import { h as readScope, u as defineScope } from "./component-internal-D9PLuFUc.js";
+import { d as getCurrentAppRenderRuntime } from "./component-scope-CC3cojX9.js";
+import { m as isPromiseLike } from "./component-lifecycle-C7lnU9Bt.js";
+import { n as getActiveRenderContext, r as getCurrentRenderData } from "./render-context-Clw3rFiO.js";
+import { t as resource } from "./resource-operation-BNY29MVH.js";
+import { t as ROUTE_ROOT_COMPONENT } from "./router-internal-BC0w1_xk.js";
+import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-CQIT4mXr.js";
+import { E as getRouteRecords, h as getActiveRouteAuthOptions, i as getMatchingRouteRecord, o as buildRouteContext, s as buildRouteContextBase } from "./route-matching-vJpvLVbX.js";
+//#region src/router/rendering.ts
+const outletScope = defineScope(null);
+function Outlet() {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children: readScope(outletScope) },
+		key: null
+	};
+}
+function applyPageChain(pageChain, params, content, deferComponents = false) {
+	let nextContent = content;
+	for (let i = pageChain.length - 1; i >= 0; i--) nextContent = outletScope({
+		value: nextContent,
+		children: deferComponents ? createRouteComponentVNode(pageChain[i].component, params) : pageChain[i].component(params)
+	});
+	return nextContent;
+}
+function createRouteComponentVNode(component, params, routeRoot = false) {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: component,
+		props: params,
+		key: null,
+		...routeRoot ? { [ROUTE_ROOT_COMPONENT]: true } : {}
+	};
+}
+function createRouteHandler(component, pageChain, layoutChain, deferComponents = false) {
+	return (params) => {
+		let content = deferComponents ? createRouteComponentVNode(component, params, true) : component(params);
+		content = applyPageChain(pageChain, params, content, deferComponents);
+		for (let i = layoutChain.length - 1; i >= 0; i--) {
+			const layout = layoutChain[i].component;
+			content = layout({ children: content });
+		}
+		return content;
+	};
+}
+function getRenderHandler(record) {
+	return record.renderHandler ?? createRouteHandler(record.component, record.pageChain, record.layoutChain, true);
+}
+//#endregion
+//#region src/common/page-render-envelope.ts
+const PAGE_RENDER_ENVELOPE_VERSION = 1;
+function ownedRecord(value) {
+	return Object.freeze({ ...value });
+}
+function createPageRenderEnvelope(input = {}) {
+	return Object.freeze({
+		version: PAGE_RENDER_ENVELOPE_VERSION,
+		resources: ownedRecord(input.resources),
+		route: input.route,
+		framework: ownedRecord(input.framework)
+	});
+}
+function isPageRenderEnvelope(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const candidate = value;
+	return candidate.version === PAGE_RENDER_ENVELOPE_VERSION && Boolean(candidate.resources && typeof candidate.resources === "object" && !Array.isArray(candidate.resources)) && Boolean(candidate.framework && typeof candidate.framework === "object" && !Array.isArray(candidate.framework));
+}
+function pageRenderEnvelope(value, fallback = {}) {
+	if (isPageRenderEnvelope(value)) return value;
+	return createPageRenderEnvelope({
+		...fallback,
+		route: value ?? fallback.route
+	});
+}
+function replacePageRoute(value, route) {
+	const current = pageRenderEnvelope(value);
+	return createPageRenderEnvelope({
+		resources: current.resources,
+		route,
+		framework: current.framework
+	});
+}
+function isEmptyPageRenderEnvelope(value) {
+	return value.route === void 0 && Object.keys(value.resources).length === 0 && Object.keys(value.framework).length === 0;
+}
+//#endregion
+//#region src/router/auth.ts
+let clientAuth = Object.freeze({
+	authenticated: false,
+	principal: null,
+	session: null,
+	tenant: null
+});
+/** Return the identity resolved for the route currently being rendered. */
+function currentAuth() {
+	return getActiveRenderContext()?.authContext ?? clientAuth;
+}
+/** @internal Updated atomically with route resolution. */
+function setCurrentAuth(context) {
+	clientAuth = context;
+	const render = getActiveRenderContext();
+	if (render) render.authContext = context;
+}
+//#endregion
+//#region src/router/resolution.ts
+const anonymous = () => ({
+	authenticated: false,
+	principal: null,
+	session: null,
+	tenant: null
+});
+const routeRenderContexts = /* @__PURE__ */ new WeakMap();
+const routeRenderData = /* @__PURE__ */ new WeakMap();
+function getRouteRenderContext(result) {
+	return routeRenderContexts.get(result);
+}
+function getRouteRenderData(result) {
+	return routeRenderData.get(result);
+}
+function createRouteRenderResult(record, params, context, handler) {
+	const result = {
+		kind: "render",
+		handler,
+		params
+	};
+	Object.defineProperty(result, "record", {
+		value: record,
+		enumerable: false
+	});
+	routeRenderContexts.set(result, context);
+	return result;
+}
+function getDefaultRouteMode() {
+	return typeof window !== "undefined" ? "spa" : "ssr";
+}
+/** @internal Bind resolved loader output to one route subtree and its hydration envelope. */
+function bindResolvedRouteData(handler, data) {
+	return (params, context) => {
+		const renderContext = getActiveRenderContext();
+		if (renderContext) {
+			const envelope = replacePageRoute(renderContext.renderData, data);
+			renderContext.renderData = envelope;
+			renderContext.hydrationData = envelope;
+		}
+		return handler(params, context);
+	};
+}
+function hasRouteRenderData(result) {
+	return routeRenderData.has(result);
+}
+function buildRenderResult(record, params, context, request, telemetry, load) {
+	const renderHandler = getRenderHandler(record);
+	const loader = context.mode !== "ssg" && load ? record.options?.loader : void 0;
+	const preload = record.options?.preload;
+	const active = getActiveRenderContext();
+	const prefetch = active?.queryPrefetch ?? createQueryPrefetchContext({
+		mode: context.mode === "ssg" ? "ssr" : context.mode,
+		request,
+		signal: context.signal,
+		runtime: active?.dataRuntime,
+		telemetry
+	});
+	const runPreload = preload ? Promise.resolve(preload({
+		...context,
+		params,
+		request,
+		data: prefetch
+	})).then(() => void 0) : void 0;
+	if (loader) {
+		const load = () => withTelemetry(telemetry?.loader, { route: record.path }, () => loader({
+			...context,
+			params,
+			request
+		}));
+		const loaded = runPreload ? runPreload.then(load) : load();
+		const finalize = (data) => {
+			const result = createRouteRenderResult(record, params, context, bindResolvedRouteData(renderHandler, data));
+			routeRenderData.set(result, data);
+			return result;
+		};
+		return isPromiseLike(loaded) ? Promise.resolve(loaded).then(finalize) : finalize(loaded);
+	}
+	if (runPreload) return runPreload.then(() => createRouteRenderResult(record, params, context, renderHandler));
+	return createRouteRenderResult(record, params, context, renderHandler);
+}
+function runPolicies(policies, context, record, params, request, telemetry, load, start = 0) {
+	for (let index = start; index < policies.length; index += 1) {
+		const result = policies[index](context);
+		if (isPromiseLike(result)) return Promise.resolve(result).then((decision) => decision.kind === "allow" ? runPolicies(policies, context, record, params, request, telemetry, load, index + 1) : decision);
+		if (result.kind !== "allow") return result;
+	}
+	return buildRenderResult(record, params, context, request, telemetry, load);
+}
+function resolvePath(value, fallback, context) {
+	return typeof value === "function" ? value(context) : value ?? fallback;
+}
+function appendNext(path, href) {
+	const target = new URL(path, "http://localhost");
+	target.searchParams.set("next", href);
+	return `${target.pathname}${target.search}${target.hash}`;
+}
+function mapAuthDecision(decision, context, options) {
+	if (decision.allowed) return { kind: "allow" };
+	if (decision.reason === "forbidden") return {
+		kind: "deny",
+		status: 403
+	};
+	const target = resolvePath(decision.reason === "unauthenticated" ? options?.loginPath : options?.authenticatedRedirectTo, decision.reason === "unauthenticated" ? "/login" : "/", context);
+	const finalize = (path) => ({
+		kind: "redirect",
+		to: decision.reason === "unauthenticated" ? appendNext(path, context.href) : path,
+		replace: decision.reason === "unauthenticated" ? context.mode === "spa" : true
+	});
+	return isPromiseLike(target) ? Promise.resolve(target).then(finalize) : finalize(target);
+}
+function resolveMatchedRoute(record, params, context, authOptions, request, telemetry, load) {
+	const continueResolution = (decision) => {
+		if (decision) {
+			const access = mapAuthDecision(decision, context, authOptions);
+			if (isPromiseLike(access)) return Promise.resolve(access).then((next) => next.kind === "allow" ? runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load) : next);
+			if (access.kind !== "allow") return access;
+		}
+		return runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load);
+	};
+	if (!record.options.auth) return continueResolution();
+	const decision = record.options.auth(context.auth);
+	return isPromiseLike(decision) ? Promise.resolve(decision).then(continueResolution) : continueResolution(decision);
+}
+function resolveRouteRequest(target, options = {}) {
+	return withTelemetry(options.telemetry?.routeMatch, {}, () => {
+		const match = getMatchingRouteRecord(target, options.manifest?.records ?? getRouteRecords());
+		if (!match) return null;
+		const mode = options.mode ?? getDefaultRouteMode();
+		const signal = options.signal ?? getActiveRenderContext()?.signal ?? new AbortController().signal;
+		const authOptions = getActiveRouteAuthOptions(options.auth ?? options.manifest?.auth);
+		const base = buildRouteContextBase(target, match.params, {
+			mode,
+			signal
+		});
+		const finalize = (authContext) => {
+			setCurrentAuth(authContext);
+			return resolveMatchedRoute(match.record, match.params, buildRouteContext(target, match.params, {
+				mode,
+				signal,
+				authContext
+			}), authOptions, options.request, options.telemetry, options.load !== false);
+		};
+		if (options.authContext) return finalize(options.authContext);
+		if (!authOptions?.resolve) return finalize(anonymous());
+		const resolved = authOptions.resolve(base);
+		return isPromiseLike(resolved) ? Promise.resolve(resolved).then(finalize) : finalize(resolved);
+	});
+}
+//#endregion
+//#region src/router/deferred.tsx
+const DEFERRED_VALUE = Symbol.for("@askrjs/askr/deferred-value");
+const DEFERRED_BOUNDARY = Symbol.for("@askrjs/askr/deferred-boundary");
+function defer(promise) {
+	let state = "pending";
+	let value;
+	let error;
+	const normalized = Promise.resolve(promise);
+	normalized.then((resolved) => {
+		state = "fulfilled";
+		value = resolved;
+	}, (reason) => {
+		state = "rejected";
+		error = reason;
+	});
+	return Object.freeze(Object.defineProperties({}, {
+		state: {
+			enumerable: true,
+			get: () => state
+		},
+		value: {
+			enumerable: true,
+			get: () => value
+		},
+		error: {
+			enumerable: true,
+			get: () => error
+		},
+		promise: { value: normalized },
+		[DEFERRED_VALUE]: { value: true }
+	}));
+}
+function isDeferred(value) {
+	return Boolean(value && typeof value === "object" && value[DEFERRED_VALUE] === true);
+}
+/** @internal Reconstruct settled server data without starting loader work. */
+function reviveDeferredValue(state, value, error) {
+	const promise = state === "fulfilled" ? Promise.resolve(value) : Promise.reject(error);
+	if (state === "rejected") promise.catch(() => void 0);
+	return Object.freeze(Object.defineProperties({}, {
+		state: {
+			enumerable: true,
+			value: state
+		},
+		value: {
+			enumerable: true,
+			value
+		},
+		error: {
+			enumerable: true,
+			value: error
+		},
+		promise: { value: promise },
+		[DEFERRED_VALUE]: { value: true }
+	}));
+}
+function abortError() {
+	const error = /* @__PURE__ */ new Error("Deferred route data was aborted.");
+	error.name = "AbortError";
+	return error;
+}
+function awaitWithSignal(promise, signal) {
+	if (!signal) return promise;
+	if (signal.aborted) return Promise.reject(abortError());
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(abortError());
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", abort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", abort);
+			reject(error);
+		});
+	});
+}
+async function resolveDeferredValues(input, signal) {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = async (value) => {
+		if (!value || typeof value !== "object") return;
+		if (isDeferred(value)) {
+			const resolved = await awaitWithSignal(value.promise, signal);
+			await visit(resolved);
+			return;
+		}
+		if (seen.has(value)) return;
+		seen.add(value);
+		const children = Array.isArray(value) ? value : Object.values(value);
+		await Promise.all(children.map(visit));
+	};
+	await visit(input);
+	return input;
+}
+function routeData() {
+	const envelope = getCurrentRenderData();
+	if (envelope) return envelope.route;
+	const runtime = getCurrentAppRenderRuntime();
+	if (!runtime?.hasRoute) throw new Error("routeData() can only be read while rendering a route with loader data.");
+	return runtime.route;
+}
+function rejectedChild(props, error) {
+	return typeof props.rejected === "function" ? props.rejected(error) : props.rejected ?? null;
+}
+function Resolve(props) {
+	if (props.value.state === "fulfilled") return props.children(props.value.value);
+	if (props.value.state === "rejected") return rejectedChild(props, props.value.error);
+	const renderContext = getActiveRenderContext();
+	if (renderContext) {
+		const id = `d:${renderContext.deferredBoundaries.length}`;
+		renderContext.deferredBoundaries.push({
+			id,
+			promise: props.value.promise,
+			fulfilled: (value) => props.children(value),
+			rejected: (error) => rejectedChild(props, error)
+		});
+		return {
+			type: DEFERRED_BOUNDARY,
+			props: {
+				id,
+				pending: props.pending ?? null
+			}
+		};
+	}
+	const result = resource(() => props.value.promise, [props.value]);
+	if (result.error) return rejectedChild(props, result.error);
+	if (result.pending || result.value === null) return props.pending ?? null;
+	return props.children(result.value);
+}
+//#endregion
+export { pageRenderEnvelope as _, resolveDeferredValues as a, getRenderHandler as b, bindResolvedRouteData as c, hasRouteRenderData as d, resolveRouteRequest as f, isPageRenderEnvelope as g, isEmptyPageRenderEnvelope as h, isDeferred as i, getRouteRenderContext as l, createPageRenderEnvelope as m, Resolve as n, reviveDeferredValue as o, currentAuth as p, defer as r, routeData as s, DEFERRED_BOUNDARY as t, getRouteRenderData as u, Outlet as v, createRouteHandler as y };

package/dist/{runtime/effect.js → effect-BwnIvLah.js}

@@ -1,6 +1,6 @@
-import { enqueueRuntimeLane } from "./access.js";
-import { withFineGrainedReadTracking } from "./readable.js";
-import "./dev-namespace.js";
+import { t as enqueueRuntimeLane } from "./access-Bg4RJNC8.js";
+import { _ as withFineGrainedReadTracking } from "./fastlane-Dw8SOBr9.js";
+//#region src/runtime/effect.ts
 const SOURCE_EFFECTS = Symbol("askr.source-effects");
 const effectSources = /* @__PURE__ */ new WeakMap();
 const dirtyEffectsByLane = {
@@ -257,4 +257,4 @@ function createOwnedFineGrainedEffect(lane, compute, commit, equals, onError, ow
 	return effect;
 }
 //#endregion
-export { createFineGrainedEffect, createOwnedFineGrainedEffect, markFineGrainedEffectsDirtySource };
+export { createOwnedFineGrainedEffect as n, markFineGrainedEffectsDirtySource as r, createFineGrainedEffect as t };