@askrjs/askr 0.3.0 → 0.4.0

package/dist/navigation.d.ts

@@ -1,4 +1,4 @@
-import './core.js';
+import { RouteDestination } from './core.js';
 /** Scroll behavior for programmatic navigations (`navigate()`). */
 type NavigationScrollBehavior = 'top' | 'preserve';
 /** Scroll behavior for browser back/forward (popstate) navigations. */
@@ -16,8 +16,17 @@ type NavigateOptions = {
   /** Entry-local browser history state. It is not serialized into the URL or sent to the server. */
   state?: unknown;
 };
-/** Navigate the client-side router to `path` using the History API. */
-declare function navigate(path: string, options?: NavigateOptions): void;
+/**
+ * Navigate the client-side router using the History API.
+ *
+ * A string is a logical path: a root-relative path gains the registry
+ * `basePath`. A typed destination from `to()` already carries its public href.
+ * A target on another origin is handed to the browser.
+ */
+declare function navigate(
+  target: string | RouteDestination,
+  options?: NavigateOptions
+): void;
 export {
   ScrollRestorationOptions,
   NavigationScrollBehavior,

package/dist/peer-types.d.ts

@@ -0,0 +1,8 @@
+// @askrjs/auth and @askrjs/schema are optional, type-only peers. Every
+// published declaration reaches them through this module so an app that never
+// installs them still typechecks with `skipLibCheck: false`; their types
+// degrade to `any` until the app installs the peer it uses.
+// @ts-ignore -- optional peer: resolves only when @askrjs/auth is installed.
+export type { AuthContext, AuthRequirement } from '@askrjs/auth';
+// @ts-ignore -- optional peer: resolves only when @askrjs/schema is installed.
+export type { InferSchema, ObjectSchema } from '@askrjs/schema';

package/dist/portal-DuOKfnLa.js

@@ -0,0 +1,349 @@
+import { M as getOwner, T as Signal, d as recordUndo, o as getRenderHost } from "./instance-BAnfmXOR.js";
+import { t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
+import { i as currentComponent, m as deliverToBoundary } from "./hooks-BimKStr4.js";
+import { n as getActiveRenderContext } from "./render-context-DGHnEveC.js";
+import { i as OWNED_TYPE, n as holdUntilBoundaryRecovers, r as nearestErrorBoundary, t as ErrorBoundary } from "./error-boundary-Bpwofwps.js";
+//#region src/common/portal.ts
+/**
+* Internal marker used to defer server portal host output until all writes in
+* the current render root are known.
+*
+* @internal
+*/
+const SSR_PORTAL_HOST = Symbol.for("askr.ssr-portal-host");
+/** Compare writer positions in their owner trees, independent of activation order. */
+function comparePortalWriterOrder(left, right, leftSourceOrder, rightSourceOrder) {
+	if (leftSourceOrder !== void 0 && rightSourceOrder !== void 0) return leftSourceOrder - rightSourceOrder;
+	const leftPath = portalWriterOrder(left);
+	const rightPath = portalWriterOrder(right);
+	const length = Math.min(leftPath.length, rightPath.length);
+	for (let index = 0; index < length; index++) if (leftPath[index] !== rightPath[index]) return leftPath[index] - rightPath[index];
+	return leftPath.length - rightPath.length;
+}
+function portalWriterOrder(owner) {
+	if (!owner) return [-1];
+	const path = [];
+	for (let current = owner; current; current = current.parent) path.push(current.ownedIndex);
+	return path.reverse();
+}
+const SSR_PORTAL_HOST_PREFIX = "askr-portal:";
+const SSR_PORTAL_ANCHOR_PREFIX = "askr-portal-anchor:";
+function createSSRPortalHostToken(id) {
+	return `<!--${SSR_PORTAL_HOST_PREFIX}${id}-->`;
+}
+function createSSRPortalAnchorToken(id) {
+	return `<!--${SSR_PORTAL_ANCHOR_PREFIX}${id}-->`;
+}
+function isSSRPortalMarkerData(data, prefix) {
+	if (!data.startsWith(prefix)) return false;
+	const id = data.slice(prefix.length);
+	return id.length > 0 && Array.from(id).every((char) => char >= "0" && char <= "9");
+}
+function isSSRPortalHydrationAnchor(node) {
+	if (typeof node !== "object" || node === null || node.nodeType !== 8) return false;
+	const data = node.data;
+	return typeof data === "string" && (isSSRPortalMarkerData(data, SSR_PORTAL_HOST_PREFIX) || isSSRPortalMarkerData(data, SSR_PORTAL_ANCHOR_PREFIX));
+}
+function isSSRPortalWriterAnchor(node) {
+	return isSSRPortalHydrationAnchor(node) && node.data.startsWith(SSR_PORTAL_ANCHOR_PREFIX);
+}
+//#endregion
+//#region src/common/ssr-portals.ts
+const DEFAULT_SSR_PORTAL_KEY = {};
+const IMPERATIVE_WRITER = {};
+function getSSRPortalSlot(key) {
+	const context = getActiveRenderContext();
+	if (context?.mode !== "ssr") return null;
+	let slot = context.ssrPortals.slots.get(key);
+	if (!slot) {
+		slot = {
+			hasValue: false,
+			value: void 0,
+			writers: /* @__PURE__ */ new Map(),
+			hosts: []
+		};
+		context.ssrPortals.slots.set(key, slot);
+	}
+	return {
+		context,
+		slot
+	};
+}
+function createSSRPortalHost(key, automatic, defaultPortal = false) {
+	const current = getSSRPortalSlot(key);
+	if (!current) return null;
+	const token = createSSRPortalHostToken(current.context.ssrPortals.nextHostId++);
+	current.slot.hosts.push({
+		token,
+		automatic,
+		defaultPortal
+	});
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: SSR_PORTAL_HOST,
+		props: { token }
+	};
+}
+function writeSSRPortal(key, children, owner) {
+	const current = getSSRPortalSlot(key);
+	if (!current) return false;
+	const writer = owner ?? IMPERATIVE_WRITER;
+	const previous = current.slot.writers.get(writer);
+	const entry = {
+		owner: owner ?? null,
+		value: children,
+		order: previous?.order ?? current.context.ssrPortals.nextWriteOrder++
+	};
+	current.slot.writers.set(writer, entry);
+	current.slot.hasValue = true;
+	current.slot.value = children;
+	current.slot.owner = owner;
+	return true;
+}
+//#endregion
+//#region src/core/api/portal.ts
+/**
+* Portals: content written in one place and rendered at a host elsewhere.
+*
+* A channel holds ordered writer records. Each writer's content commits to
+* its own record and renders at the host's position, owned by that writer, so
+* the content lives and dies with the writer and reads the writer's scopes.
+*
+* Each application root provides a default channel; `<Portal>` writes to it
+* and `<DefaultPortal>` (or the automatic host a root appends) renders it.
+*/
+let nextWriteId = 0;
+function createWrite(owner, children) {
+	return {
+		owner,
+		id: ++nextWriteId,
+		children: new Signal(children)
+	};
+}
+function createPortalChannel() {
+	return {
+		writes: new Signal([]),
+		explicitHosts: new Signal(0)
+	};
+}
+function renderWrite(writes) {
+	return [...writes].sort(compareWrites).map((write) => ({
+		$$typeof: ELEMENT_TYPE,
+		type: OWNED_TYPE,
+		props: {
+			owner: write.owner,
+			children: {
+				$$typeof: ELEMENT_TYPE,
+				type: PortalLayer,
+				props: { write }
+			}
+		},
+		key: `portal:${write.id}`
+	}));
+}
+function PortalLayer(props) {
+	const children = props.write.children.read();
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: ErrorBoundary,
+		props: {
+			children,
+			fallback: (error) => {
+				if (deliverToBoundary(props.write.owner, error)) return null;
+				throw error;
+			}
+		}
+	};
+}
+/** Record `children` as `channel`'s content once the current render commits. */
+function writeChannel(channel, children) {
+	if (writeSSRPortal(ssrKey(channel), children, getOwner())) return;
+	const instance = currentComponent();
+	if (!instance) {
+		let write = imperativeWriters.get(channel);
+		if (!write) {
+			write = createWrite(null, children);
+			imperativeWriters.set(channel, write);
+			addWrite(channel, write);
+		} else write.children.write(children);
+		return;
+	}
+	if (instance.server) return;
+	let owned = writers.get(instance);
+	if (!owned) writers.set(instance, owned = /* @__PURE__ */ new Map());
+	let write = owned.get(channel);
+	const created = !write;
+	const previousChildren = write?.children.peek();
+	if (!write) {
+		write = createWrite(instance, children);
+		owned.set(channel, write);
+	}
+	const record = write;
+	const apply = () => {
+		addWrite(channel, record);
+		record.children.write(children);
+	};
+	if (getRenderHost()?.isHydrating()) {
+		apply();
+		recordUndo(() => {
+			if (created) {
+				removeWrite(channel, record);
+				owned.delete(channel);
+			} else record.children.write(previousChildren);
+		});
+	}
+	if (created) instance.onCleanup(() => {
+		owned.delete(channel);
+		removeWrite(channel, record);
+	});
+	instance.onCommitSync(() => {
+		apply();
+	});
+}
+const writers = /* @__PURE__ */ new WeakMap();
+const imperativeWriters = /* @__PURE__ */ new WeakMap();
+function addWrite(channel, write) {
+	if (channel.writes.peek().some((item) => item === write)) return;
+	channel.writes.write([...channel.writes.peek(), write].sort(compareWrites));
+}
+function compareWrites(left, right) {
+	const leftPosition = sourcePosition(left.owner);
+	const rightPosition = sourcePosition(right.owner);
+	if (leftPosition && rightPosition) {
+		if (leftPosition.container === rightPosition.container) {
+			const length = Math.min(leftPosition.path.length, rightPosition.path.length);
+			for (let index = 0; index < length; index++) if (leftPosition.path[index] !== rightPosition.path[index]) return leftPosition.path[index] - rightPosition.path[index];
+			if (leftPosition.path.length !== rightPosition.path.length) return leftPosition.path.length - rightPosition.path.length;
+		} else {
+			const relation = leftPosition.container.compareDocumentPosition(rightPosition.container);
+			if (relation & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+			if (relation & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+		}
+	}
+	return comparePortalWriterOrder(left.owner, right.owner);
+}
+function sourcePosition(owner) {
+	if (!owner || typeof Node === "undefined") return null;
+	let node = owner.view;
+	const path = [];
+	while (node?.parent) {
+		const parent = node.parent;
+		if ("children" in parent && Array.isArray(parent.children)) path.unshift(parent.children.indexOf(node));
+		if ("el" in parent && parent.el instanceof Element) return {
+			container: parent.el,
+			path
+		};
+		node = parent;
+	}
+	return null;
+}
+function removeWrite(channel, write) {
+	const writes = channel.writes.peek();
+	if (!writes.includes(write)) return;
+	channel.writes.write(writes.filter((item) => item !== write));
+}
+function definePortal() {
+	const channel = createPortalChannel();
+	function PortalHost() {
+		const ssr = createSSRPortalHost(channel, false);
+		if (ssr) return ssr;
+		deferWhileHydrating();
+		return renderWrite(channel.writes.read());
+	}
+	PortalHost.render = (props) => {
+		writeChannel(channel, props.children);
+		return null;
+	};
+	portalChannels.set(PortalHost, channel);
+	return PortalHost;
+}
+const portalChannels = /* @__PURE__ */ new WeakMap();
+const DEFAULT_CHANNEL = Symbol("askr.default-portal");
+let fallbackChannel = null;
+let fallbackAdoptable = false;
+const rootChannels = /* @__PURE__ */ new Map();
+/** Give everything rendered under `owner` its own default portal. */
+function provideDefaultPortal(owner, root) {
+	const channel = root && rootChannels.size === 0 && fallbackAdoptable && fallbackChannel ? fallbackChannel : createPortalChannel();
+	if (root) {
+		rootChannels.set(root, channel);
+		fallbackChannel = null;
+		fallbackAdoptable = false;
+		owner.onCleanup(() => {
+			if (rootChannels.get(root) === channel) rootChannels.delete(root);
+		});
+	}
+	(owner.context ??= /* @__PURE__ */ new Map()).set(DEFAULT_CHANNEL, channel);
+	return channel;
+}
+/** Server renders collect default-portal writes under one key. */
+function ssrKey(channel) {
+	return channel === serverDefaultChannel ? DEFAULT_SSR_PORTAL_KEY : channel;
+}
+const serverDefaultChannel = createPortalChannel();
+function defaultChannel() {
+	if (currentComponent()?.server) return serverDefaultChannel;
+	const provided = getOwner()?.lookup(DEFAULT_CHANNEL);
+	if (provided) return provided;
+	let connected = null;
+	for (const [root, channel] of rootChannels) {
+		if (!root.isConnected) continue;
+		if (connected) {
+			fallbackAdoptable = false;
+			return fallbackChannel ?? (fallbackChannel = createPortalChannel());
+		}
+		connected = channel;
+	}
+	if (connected) return connected;
+	fallbackAdoptable = rootChannels.size === 0;
+	return fallbackChannel ?? (fallbackChannel = createPortalChannel());
+}
+/** Write `children` to the default portal. */
+function Portal(props) {
+	writeChannel(defaultChannel(), props.children);
+	return null;
+}
+/** Render the default portal's content here. */
+function DefaultPortal(props) {
+	const automatic = props?.__askrAutoDefaultPortal === true;
+	if (currentComponent()?.server) return createSSRPortalHost(DEFAULT_SSR_PORTAL_KEY, automatic, true);
+	const channel = defaultChannel();
+	if (automatic) {
+		if (channel.explicitHosts.read() > 0) return null;
+		deferWhileHydrating();
+		return renderWrite(channel.writes.read());
+	}
+	const instance = currentComponent();
+	if (instance && !instance.server && !explicitHosts.has(instance)) {
+		explicitHosts.add(instance);
+		channel.explicitHosts.write(channel.explicitHosts.peek() + 1);
+		let counted = true;
+		recordUndo(() => {
+			counted = false;
+			explicitHosts.delete(instance);
+			channel.explicitHosts.write(channel.explicitHosts.peek() - 1);
+		});
+		const boundary = nearestErrorBoundary(instance);
+		instance.onCleanup(() => {
+			if (!counted) return;
+			counted = false;
+			const release = () => channel.explicitHosts.write(channel.explicitHosts.peek() - 1);
+			if (!boundary || !holdUntilBoundaryRecovers(boundary, release)) release();
+		});
+	}
+	deferWhileHydrating();
+	return renderWrite(channel.writes.read());
+}
+const explicitHosts = /* @__PURE__ */ new WeakSet();
+/** A host rendered before its content: claim the server content later. */
+function deferWhileHydrating() {
+	const instance = currentComponent();
+	if (instance?.mounted === false) getRenderHost()?.deferHydration(instance);
+}
+/** `DefaultPortal.render()` writes to the default portal, like `<Portal>`. */
+DefaultPortal.render = (props) => {
+	writeChannel(defaultChannel(), props.children);
+	return null;
+};
+//#endregion
+export { SSR_PORTAL_HOST as a, isSSRPortalHydrationAnchor as c, provideDefaultPortal as i, isSSRPortalWriterAnchor as l, Portal as n, comparePortalWriterOrder as o, definePortal as r, createSSRPortalAnchorToken as s, DefaultPortal as t };

package/dist/promise-Dz8iIHAm.js

@@ -0,0 +1,16 @@
+//#region src/common/promise.ts
+function isPromiseLike(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+/**
+* Components must return synchronously; async work belongs in `resource()`.
+*
+* The rule was previously enforced by ten hand-written throws carrying three
+* different messages. It is one rule, so it has one message and one guard.
+*/
+const ASYNC_COMPONENT_MESSAGE = "Async components are not supported. Use resource() for async work.";
+function assertSyncComponentResult(result) {
+	if (isPromiseLike(result)) throw new Error(ASYNC_COMPONENT_MESSAGE);
+}
+//#endregion
+export { isPromiseLike as n, assertSyncComponentResult as t };