@kasperrt/smolter 0.2.0 → 0.3.1

package/dist/core/environment.d.ts

@@ -0,0 +1,12 @@
+export interface ApplicationEnvironment {
+    resolveURL?: (url: URL) => URL;
+    isDocumentHandoff?: (from: URL, to: URL) => boolean;
+    leaveDocument?: (destination: URL) => void;
+    entryScript?: string;
+}
+export declare let applicationEnvironment: ApplicationEnvironment | undefined;
+/** Configure deployment-specific navigation before rendering or mounting. */
+export declare function configureApplication(environment: ApplicationEnvironment): void;
+export declare function resolveApplicationURL(url: URL): URL;
+export declare function handoffDocument(event: MouseEvent, destination: URL): void;
+export declare function leaveDocument(destination: URL): void;

package/dist/core/environment.js

@@ -0,0 +1,23 @@
+//#region .generated/core/environment.ts
+var applicationEnvironment;
+/** Configure deployment-specific navigation before rendering or mounting. */
+function configureApplication(environment) {
+	applicationEnvironment = environment;
+}
+function resolveApplicationURL(url) {
+	return applicationEnvironment?.resolveURL?.(url) ?? url;
+}
+function handoffDocument(event, destination) {
+	if (!applicationEnvironment?.isDocumentHandoff?.(new URL(location.href), destination)) return;
+	event.preventDefault();
+	leaveDocument(destination);
+}
+function leaveDocument(destination) {
+	if (applicationEnvironment?.leaveDocument) {
+		applicationEnvironment.leaveDocument(destination);
+		return;
+	}
+	location.assign(destination.href);
+}
+//#endregion
+export { applicationEnvironment, configureApplication, handoffDocument, leaveDocument, resolveApplicationURL };

package/dist/core/errors.js

@@ -0,0 +1,7 @@
+//#region .generated/core/errors.ts
+/** Resolve returned or rejected errors into Error values without losing their cause. */
+function safeWrapAsync(work) {
+	return Promise.resolve().then(work).then((data) => data instanceof Error ? { error: data } : { data }, (cause) => ({ error: Error(String(cause), { cause }) }));
+}
+//#endregion
+export { safeWrapAsync };

package/dist/{internal/core → core}/index.d.ts

@@ -1,6 +1,7 @@
 /** Framework-independent data routing. @module */
 export * from "./errors.ts";
 export * from "./match.ts";
+export * from "./navigation-router.ts";
 export * from "./router.ts";
 export * from "./serialize.ts";
 export * from "./types.ts";

package/dist/core/match.js

@@ -0,0 +1,33 @@
+//#region .generated/core/match.ts
+/** Associate a URL pattern with a module while retaining its inferred handler types. */
+function defineRoute(path, module) {
+	return {
+		...module,
+		path
+	};
+}
+/** Static segments, :params and a terminal * wildcard; first match wins. */
+function matchRoutes(routes, pathname) {
+	const segments = pathname.replace(/\/$/, "").split("/");
+	for (const route of routes) {
+		const parts = route.path.replace(/\/$/, "").split("/");
+		const params = {};
+		if ((parts.length === segments.length || parts.at(-1) === "*") && parts.every((part, index) => {
+			const value = segments[index];
+			if (part === "*") {
+				params["*"] = segments.slice(index).join("/");
+				return true;
+			}
+			if (part[0] === ":" && value) {
+				params[part.slice(1)] = new URLSearchParams(`=${value.replace(/[+&]/g, encodeURIComponent)}`).get("");
+				return true;
+			}
+			return part === value;
+		})) return {
+			route,
+			params
+		};
+	}
+}
+//#endregion
+export { defineRoute, matchRoutes };

package/dist/core/navigation-router.d.ts

@@ -0,0 +1,15 @@
+import type { Route, Router, RouterOptions } from "./types.ts";
+/** Navigation and subscriptions without the loader/action engine. */
+export type NavigationRouter = Pick<Router, "routes" | "getSnapshot" | "subscribe" | "start" | "navigate" | "dispose">;
+/** Route modules for navigation only; data handlers require createDataRouter. */
+export type NavigationRoute = Route & {
+    loader?: never;
+    action?: never;
+    clientLoader?: never;
+    clientAction?: never;
+    shouldRevalidate?: never;
+};
+/** Initial URL and optional browser history for navigation-only routing. */
+export type NavigationRouterOptions = Pick<RouterOptions, "url" | "browser">;
+/** Create a route matcher and history store without data requests or fetchers. */
+export declare function createRouter(routes: readonly NavigationRoute[], options?: NavigationRouterOptions): NavigationRouter;

package/dist/core/navigation-router.js

@@ -0,0 +1,64 @@
+import { matchRoutes } from "./match.js";
+import { internalURL } from "./url.js";
+//#region .generated/core/navigation-router.ts
+/** Create a route matcher and history store without data requests or fetchers. */
+function createRouter(routes, options = {}) {
+	const browser = options.browser && typeof window !== "undefined";
+	const listeners = /* @__PURE__ */ new Set();
+	let users = 0;
+	const resolve = (url) => {
+		const match = matchRoutes(routes, url.pathname);
+		return {
+			url: url.href,
+			path: match?.route.path,
+			params: match?.params ?? {},
+			state: "idle",
+			loaded: true
+		};
+	};
+	let snapshot = resolve(new URL(options.url ?? (browser ? location.href : "/"), "http://localhost"));
+	const update = (url) => {
+		if (url.href === snapshot.url) return;
+		snapshot = resolve(url);
+		for (const listener of listeners) listener();
+	};
+	const pop = () => update(new URL(location.href));
+	return {
+		routes,
+		getSnapshot: () => snapshot,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		start() {
+			if (!users++ && browser) {
+				addEventListener("popstate", pop);
+				addEventListener("hashchange", pop);
+				pop();
+			}
+			return () => {
+				if (!--users && browser) {
+					removeEventListener("popstate", pop);
+					removeEventListener("hashchange", pop);
+				}
+			};
+		},
+		async navigate(href, operation) {
+			const url = internalURL(snapshot.url, href);
+			if (!url) return;
+			if (browser) history[operation?.replace ? "replaceState" : "pushState"](operation?.state ?? null, "", url);
+			update(url);
+		},
+		dispose() {
+			listeners.clear();
+			if (browser) {
+				removeEventListener("popstate", pop);
+				removeEventListener("hashchange", pop);
+			}
+		}
+	};
+}
+//#endregion
+export { createRouter };

package/dist/core/navigation.d.ts

@@ -0,0 +1,15 @@
+import type { Router } from "./types.ts";
+export type NavigationType = "POP" | "PUSH" | "REPLACE";
+export interface NavigationSnapshot {
+    type: NavigationType;
+    state: unknown;
+    key: string;
+    preventScrollReset: boolean;
+}
+export declare function scrollPositions(router: Router): Map<string, [number, number]>;
+export declare function navigationStore(router: Router): {
+    getSnapshot: () => NavigationSnapshot;
+    subscribe(listener: () => void): () => void;
+    update(next: NavigationSnapshot): void;
+};
+export declare function connectNavigation(router: Router): void;

package/dist/core/navigation.js

@@ -0,0 +1,92 @@
+import { navigationClick } from "./url.js";
+import { handoffDocument, leaveDocument, resolveApplicationURL } from "./environment.js";
+import { createStore } from "./store.js";
+//#region .generated/core/navigation.ts
+var scrollHistory = /* @__PURE__ */ new WeakMap();
+function scrollPositions(router) {
+	let positions = scrollHistory.get(router);
+	if (!positions) {
+		positions = /* @__PURE__ */ new Map();
+		scrollHistory.set(router, positions);
+	}
+	return positions;
+}
+var stores = /* @__PURE__ */ new WeakMap();
+function createNavigationStore() {
+	return createStore({
+		type: "POP",
+		state: typeof history === "undefined" ? null : history.state?.state,
+		key: typeof history === "undefined" ? "initial" : history.state?.key ?? "initial",
+		preventScrollReset: false
+	});
+}
+function navigationStore(router) {
+	let store = stores.get(router);
+	if (!store) {
+		store = createNavigationStore();
+		stores.set(router, store);
+	}
+	return store;
+}
+function connectNavigation(router) {
+	const store = navigationStore(router);
+	const navigate = router.navigate;
+	let sequence = 0;
+	let pending;
+	const committed = () => {
+		if (!pending || router.getSnapshot().state !== "idle") return;
+		const next = pending;
+		pending = void 0;
+		if (next.type !== "POP") history.replaceState(next, "", location.href);
+		store.update(next);
+	};
+	const unsubscribe = router.subscribe(committed);
+	const rememberScroll = () => {
+		scrollPositions(router).set(store.getSnapshot().key, [window.scrollX, window.scrollY]);
+	};
+	router.navigate = async (href, options = {}) => {
+		const destination = resolveApplicationURL(new URL(href, router.getSnapshot().url));
+		if (destination.origin !== location.origin) {
+			leaveDocument(destination);
+			return;
+		}
+		rememberScroll();
+		const current = ++sequence;
+		pending = {
+			type: options.replace ? "REPLACE" : "PUSH",
+			state: options.state ?? null,
+			key: `${Date.now().toString(36)}-${current}`,
+			preventScrollReset: options.preventScrollReset ?? false
+		};
+		await navigate(href, options);
+		committed();
+	};
+	const pop = () => {
+		rememberScroll();
+		pending = {
+			...history.state,
+			type: "POP",
+			key: history.state?.key ?? "initial",
+			preventScrollReset: false
+		};
+		committed();
+	};
+	const handoff = (event) => {
+		const anchor = event.target instanceof Element ? event.target.closest("a[href]") : null;
+		if (!(anchor instanceof HTMLAnchorElement) || !navigationClick(event, anchor)) return;
+		const target = resolveApplicationURL(new URL(anchor.href));
+		handoffDocument(event, target);
+	};
+	if (typeof document !== "undefined") document.addEventListener("click", handoff);
+	window.addEventListener("popstate", pop);
+	const dispose = router.dispose;
+	router.dispose = () => {
+		pending = void 0;
+		unsubscribe();
+		window.removeEventListener("popstate", pop);
+		if (typeof document !== "undefined") document.removeEventListener("click", handoff);
+		dispose();
+	};
+}
+//#endregion
+export { connectNavigation, navigationStore, scrollPositions };

package/dist/core/presentation.d.ts

@@ -0,0 +1,5 @@
+import type { Router } from "./types.ts";
+type CommitView = (update: () => void) => void;
+export declare function pendingLocation(router: Router): URL | undefined;
+export declare function retainRoute(router: Router, commitView: CommitView): void;
+export {};

package/dist/core/presentation.js

@@ -0,0 +1,69 @@
+//#region .generated/core/presentation.ts
+var pending = /* @__PURE__ */ new WeakMap();
+function pendingLocation(router) {
+	const snapshot = pending.get(router)?.();
+	return snapshot?.state !== "idle" && snapshot?.url ? new URL(snapshot.url) : void 0;
+}
+function retainRoute(router, commitView) {
+	const read = router.getSnapshot;
+	pending.set(router, read);
+	let viewTransition;
+	const navigate = router.navigate;
+	router.navigate = (href, options = {}) => {
+		viewTransition = options.viewTransition;
+		return navigate(href, options);
+	};
+	let visible = read();
+	let revision = 0;
+	const listeners = /* @__PURE__ */ new Set();
+	const publish = () => {
+		for (const listener of listeners) listener();
+	};
+	const unsubscribe = router.subscribe(() => {
+		const next = read();
+		const current = ++revision;
+		if (next.state !== "idle" && visible.loaded) {
+			visible = {
+				...visible,
+				state: next.state
+			};
+			publish();
+			return;
+		}
+		const commit = () => {
+			if (current !== revision) return;
+			commitView(() => {
+				visible = next;
+				publish();
+			});
+		};
+		const previousURL = new URL(visible.url);
+		const nextURL = new URL(next.url);
+		const changed = previousURL.pathname + previousURL.search !== nextURL.pathname + nextURL.search;
+		const component = (path) => {
+			const route = router.routes.find((item) => item.path === path);
+			return route?.resolveComponent?.() ?? route?.default;
+		};
+		const previousComponent = component(visible.path);
+		const sharedView = previousComponent && previousComponent === component(next.path);
+		if (changed && visible.loaded && viewTransition !== false && !sharedView && previousURL.pathname !== nextURL.pathname && typeof document !== "undefined" && typeof document.startViewTransition === "function" && !matchMedia("(prefers-reduced-motion: reduce)").matches) {
+			document.startViewTransition(commit).ready.catch(() => {});
+			return;
+		}
+		commit();
+	});
+	router.getSnapshot = () => visible;
+	router.subscribe = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const dispose = router.dispose;
+	router.dispose = () => {
+		unsubscribe();
+		pending.delete(router);
+		listeners.clear();
+		dispose();
+	};
+}
+//#endregion
+export { pendingLocation, retainRoute };

package/dist/core/resource-types.d.ts

@@ -0,0 +1,37 @@
+export type Params = Readonly<Record<string, string>>;
+export interface LoaderFunctionArgs {
+    params: Params;
+    signal: AbortSignal;
+}
+export interface ActionFunctionArgs<Input = unknown> {
+    input: Input;
+    params: Params;
+    signal: AbortSignal;
+}
+export interface DataResult<Data> {
+    data: Data | null;
+    error: string;
+    unexpected?: true;
+}
+export interface ResourceModule {
+    action?: (args: ActionFunctionArgs) => Promise<DataResult<unknown>>;
+    loader?: (args: LoaderFunctionArgs) => Promise<DataResult<unknown>>;
+    shouldRevalidate?: (args: ShouldRevalidateFunctionArgs) => boolean;
+}
+export interface ShouldRevalidateFunctionArgs {
+    actionResult: DataResult<unknown>;
+    defaultShouldRevalidate: boolean;
+    params: Params;
+}
+export type NavigationState = "idle" | "loading" | "submitting";
+export interface RouteState {
+    actionData: unknown;
+    actionError: string;
+    actionState: "idle" | "submitting";
+    loaderData: unknown;
+    loaderError: string;
+    loaderInitialized: boolean;
+    loaderState: "idle" | "loading";
+    navigationState: NavigationState;
+    unexpectedError: boolean;
+}

package/dist/core/resources.d.ts

@@ -0,0 +1,19 @@
+import type { DataResult, Params, ResourceModule, RouteState } from "./resource-types.ts";
+export declare class ResourceRouter {
+    #private;
+    constructor(routes: ReadonlyMap<string, ResourceModule>);
+    dispose(): void;
+    getRoute(routeId: string): ResourceModule | null;
+    getSnapshot(routeId: string, params: Params): RouteState;
+    hydrateRoute<Data>(routeId: string, data: Data, params?: Params): void;
+    persist(routeId: string, params?: Params): void;
+    disposeRoute(routeId: string, params?: Params): void;
+    load<Data>(routeId: string, params?: Params, force?: boolean): Promise<DataResult<Data>>;
+    subscribe(routeId: string, params: Params, listener: () => void): () => void;
+    submit<Data>(routeId: string, input: unknown, params?: Params): Promise<DataResult<Data>>;
+    fetchLoader<Data>(routeId: string, params: Params, signal: AbortSignal): Promise<DataResult<Data>>;
+    fetchAction<Data>(routeId: string, input: unknown, params: Params, signal: AbortSignal): Promise<DataResult<Data>>;
+    retry(routeId: string, params: Params): Promise<DataResult<unknown>>;
+    reportUnexpected(routeId: string, params: Params): void;
+}
+export declare function createResourceRouter(routes: ReadonlyMap<string, ResourceModule>): ResourceRouter;