@kasperrt/smolter 0.2.0 → 0.3.1

package/.generated/client/deployment.ts

@@ -0,0 +1,161 @@
+import type { NavigationRouter } from "../core/index.ts";
+
+/** Build identity and the fresh, non-cacheable manifest URL emitted by deploymentPlugin. */
+export interface DeploymentOptions {
+  version: string;
+  manifestURL: string;
+  /** Maximum time to wait for the update check before continuing navigation. */
+  timeout?: number;
+  /** Override document navigation, for example to ask about unsaved changes. */
+  reload?: (destination: URL) => void;
+}
+
+/** Check for deployment changes before navigation. Returns a cleanup function. */
+export function watchDeployment(
+  router: NavigationRouter,
+  options: DeploymentOptions | null,
+): () => void {
+  if (!options || typeof window === "undefined") return () => {};
+
+  const { version, manifestURL, timeout = 2000 } = options;
+  const navigate = router.navigate;
+  const dispose = router.dispose;
+  const manifest = new URL(manifestURL, location.href);
+  const key = `smolter:deployment:${manifest.href}:${version}`;
+  let sequence = 0;
+  let stopped = false;
+  let replay = false;
+  let destination = new URL(location.href);
+  let pending: Promise<boolean> | undefined;
+  let controller: AbortController | undefined;
+
+  function changed() {
+    if (pending) return pending;
+
+    controller = new AbortController();
+    const timer = setTimeout(() => controller?.abort(), timeout);
+    pending = fetch(manifest, { cache: "no-store", signal: controller.signal })
+      .then(async (response) => {
+        if (!response.ok) return false;
+
+        const data: unknown = await response.json();
+
+        return (
+          typeof data === "object" &&
+          data !== null &&
+          "version" in data &&
+          typeof data.version === "string" &&
+          data.version.length > 0 &&
+          data.version !== version
+        );
+      })
+      .catch(() => false)
+      .finally(() => {
+        clearTimeout(timer);
+        pending = undefined;
+      });
+
+    return pending;
+  }
+
+  async function reload(target: URL) {
+    // If storage is unavailable, do not risk reloading the same cached document forever.
+    const allowed = await Promise.resolve()
+      .then(() => {
+        if (sessionStorage.getItem(key)) return false;
+
+        sessionStorage.setItem(key, "1");
+
+        return true;
+      })
+      .catch(() => false);
+
+    if (allowed && !stopped) {
+      if (options?.reload) options.reload(target);
+      if (!options?.reload) {
+        if (target.href === location.href) location.reload();
+        if (target.href !== location.href) location.assign(target.href);
+      }
+    }
+
+    return allowed && !stopped;
+  }
+
+  const guarded: NavigationRouter["navigate"] = async (href, operation) => {
+    const target = new URL(href, router.getSnapshot().url);
+    const currentURL = new URL(router.getSnapshot().url);
+    const current = ++sequence;
+    destination = target;
+
+    if (
+      target.origin === location.origin &&
+      (target.pathname !== currentURL.pathname ||
+        target.search !== currentURL.search) &&
+      (await changed())
+    ) {
+      if (current !== sequence || stopped || (await reload(target))) return;
+    }
+
+    if (current === sequence && !stopped) await navigate(href, operation);
+  };
+
+  const pop = (event: PopStateEvent) => {
+    if (replay) return;
+
+    const target = new URL(location.href);
+    const previous = new URL(router.getSnapshot().url);
+
+    if (
+      target.pathname === previous.pathname &&
+      target.search === previous.search
+    )
+      return;
+
+    event.stopImmediatePropagation();
+    const current = ++sequence;
+    destination = target;
+    void changed().then(async (updated) => {
+      if (stopped || current !== sequence) return;
+      if (updated && (await reload(target))) return;
+
+      replay = true;
+      window.dispatchEvent(
+        new PopStateEvent("popstate", { state: event.state }),
+      );
+      replay = false;
+    });
+  };
+
+  const preloadError = () => {
+    if (router.getSnapshot().state === "submitting") return;
+
+    const current = sequence;
+    const target = destination;
+    void changed().then((updated) => {
+      if (updated && current === sequence && !stopped) return reload(target);
+    });
+  };
+
+  function cleanup() {
+    stopped = true;
+    sequence++;
+    controller?.abort();
+    window.removeEventListener("popstate", pop, true);
+    window.removeEventListener("vite:preloadError", preloadError);
+
+    if (router.navigate === guarded) router.navigate = navigate;
+    if (router.dispose === guardedDispose) router.dispose = dispose;
+  }
+
+  function guardedDispose() {
+    cleanup();
+    dispose();
+  }
+
+  router.navigate = guarded;
+  router.dispose = guardedDispose;
+  window.addEventListener("popstate", pop, true);
+  window.addEventListener("vite:preloadError", preloadError);
+
+  return cleanup;
+}

package/{src/internal → .generated}/client/index.ts

@@ -16,6 +16,7 @@ export { deserialize } from "./deserialize.ts";
 
 /** Browser-safe route exports, excluding server implementation code. */
 export interface ClientRouteModule {
+  id?: string;
   default?: unknown;
   HydrateFallback?: unknown;
   ErrorBoundary?: unknown;
@@ -82,3 +83,5 @@ export function serverRoute<M extends RouteModule = RouteModule>(
     }),
   } as Route<M>;
 }
+
+export { type DeploymentOptions, watchDeployment } from "./deployment.ts";

package/.generated/core/environment.ts

@@ -0,0 +1,43 @@
+export interface ApplicationEnvironment {
+  resolveURL?: (url: URL) => URL;
+  isDocumentHandoff?: (from: URL, to: URL) => boolean;
+  leaveDocument?: (destination: URL) => void;
+  entryScript?: string;
+}
+
+// An absent configuration lets bundlers remove unused deployment callbacks.
+export let applicationEnvironment: ApplicationEnvironment | undefined;
+
+/** Configure deployment-specific navigation before rendering or mounting. */
+export function configureApplication(
+  environment: ApplicationEnvironment,
+): void {
+  applicationEnvironment = environment;
+}
+
+export function resolveApplicationURL(url: URL): URL {
+  return applicationEnvironment?.resolveURL?.(url) ?? url;
+}
+
+export function handoffDocument(event: MouseEvent, destination: URL): void {
+  if (
+    !applicationEnvironment?.isDocumentHandoff?.(
+      new URL(location.href),
+      destination,
+    )
+  )
+    return;
+
+  event.preventDefault();
+  leaveDocument(destination);
+}
+
+export function leaveDocument(destination: URL): void {
+  if (applicationEnvironment?.leaveDocument) {
+    applicationEnvironment.leaveDocument(destination);
+
+    return;
+  }
+
+  location.assign(destination.href);
+}

package/{src/internal → .generated}/core/errors.ts

@@ -8,6 +8,6 @@ export function safeWrapAsync<T>(
     .then(work)
     .then(
       (data) => (data instanceof Error ? { error: data } : { data }),
-      (cause: unknown) => ({ error: new Error(String(cause), { cause }) }),
+      (cause: unknown) => ({ error: Error(String(cause), { cause }) }),
     );
 }

package/{src/internal → .generated}/core/index.ts

@@ -2,6 +2,7 @@
 
 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/.generated/core/navigation-router.ts

@@ -0,0 +1,107 @@
+import { matchRoutes } from "./match.ts";
+import type {
+  NavigateOptions,
+  Route,
+  Router,
+  RouterOptions,
+  Snapshot,
+} from "./types.ts";
+import { internalURL } from "./url.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 function createRouter(
+  routes: readonly NavigationRoute[],
+  options: NavigationRouterOptions = {},
+): NavigationRouter {
+  const browser = options.browser && typeof window !== "undefined";
+  const listeners = new Set<() => void>();
+  let users = 0;
+  const resolve = (url: URL): Snapshot => {
+    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: 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: string, operation?: NavigateOptions) {
+      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);
+      }
+    },
+  };
+}

package/.generated/core/navigation.ts

@@ -0,0 +1,147 @@
+import {
+  handoffDocument,
+  leaveDocument,
+  resolveApplicationURL,
+} from "./environment.ts";
+import { createStore } from "./store.ts";
+import type { NavigateOptions, Router } from "./types.ts";
+import { navigationClick } from "./url.ts";
+
+export type NavigationType = "POP" | "PUSH" | "REPLACE";
+
+export interface NavigationSnapshot {
+  type: NavigationType;
+  state: unknown;
+  key: string;
+  preventScrollReset: boolean;
+}
+
+const scrollHistory = new WeakMap<Router, Map<string, [number, number]>>();
+
+export function scrollPositions(router: Router) {
+  let positions = scrollHistory.get(router);
+
+  if (!positions) {
+    positions = new Map();
+    scrollHistory.set(router, positions);
+  }
+
+  return positions;
+}
+
+const stores = new WeakMap<Router, ReturnType<typeof createNavigationStore>>();
+
+function createNavigationStore() {
+  return createStore<NavigationSnapshot>({
+    type: "POP",
+    state: typeof history === "undefined" ? null : history.state?.state,
+    key:
+      typeof history === "undefined"
+        ? "initial"
+        : (history.state?.key ?? "initial"),
+    preventScrollReset: false,
+  });
+}
+
+export function navigationStore(router: Router) {
+  let store = stores.get(router);
+
+  if (!store) {
+    store = createNavigationStore();
+    stores.set(router, store);
+  }
+
+  return store;
+}
+
+export function connectNavigation(router: Router) {
+  const store = navigationStore(router);
+  const navigate = router.navigate;
+  let sequence = 0;
+  let pending: NavigationSnapshot | undefined;
+  const committed = () => {
+    if (!pending || router.getSnapshot().state !== "idle") return;
+
+    const next = pending;
+    pending = undefined;
+
+    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: NavigateOptions = {}) => {
+    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,
+    };
+    // Retained views may commit after navigate resolves; the subscription waits
+    // for that final idle snapshot rather than starting another listener.
+    await navigate(href, options);
+    committed();
+  };
+
+  const pop = () => {
+    rememberScroll();
+    pending = {
+      ...history.state,
+      type: "POP",
+      key: history.state?.key ?? "initial",
+      preventScrollReset: false,
+    };
+    committed();
+  };
+
+  const handoff = (event: MouseEvent) => {
+    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 = undefined;
+    unsubscribe();
+    window.removeEventListener("popstate", pop);
+
+    if (typeof document !== "undefined")
+      document.removeEventListener("click", handoff);
+
+    dispose();
+  };
+}

package/.generated/core/presentation.ts

@@ -0,0 +1,108 @@
+import type { NavigateOptions, Route, Router, Snapshot } from "./types.ts";
+
+interface ResolvableRoute extends Route {
+  resolveComponent?: () => unknown;
+}
+
+type CommitView = (update: () => void) => void;
+
+const pending = new WeakMap<Router, () => Snapshot>();
+
+export function pendingLocation(router: Router) {
+  const snapshot = pending.get(router)?.();
+
+  return snapshot?.state !== "idle" && snapshot?.url
+    ? new URL(snapshot.url)
+    : undefined;
+}
+
+// Keep the committed route's view and data together while navigation loads.
+// The underlying router still owns cancellation, redirects and fetcher state.
+export function retainRoute(router: Router, commitView: CommitView) {
+  const read = router.getSnapshot;
+  pending.set(router, read);
+  let viewTransition: boolean | undefined;
+  const navigate = router.navigate;
+  router.navigate = (href, options: NavigateOptions = {}) => {
+    viewTransition = options.viewTransition;
+
+    return navigate(href, options);
+  };
+  let visible = read();
+  let revision = 0;
+  const listeners = new Set<() => void>();
+
+  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: string | undefined) => {
+      const route = router.routes.find((item) => item.path === path) as
+        | ResolvableRoute
+        | undefined;
+
+      return route?.resolveComponent?.() ?? route?.default;
+    };
+    const previousComponent = component(visible.path);
+    const sharedView =
+      previousComponent && previousComponent === component(next.path);
+    const animate =
+      changed &&
+      visible.loaded &&
+      viewTransition !== false &&
+      !sharedView &&
+      previousURL.pathname !== nextURL.pathname &&
+      typeof document !== "undefined" &&
+      typeof document.startViewTransition === "function" &&
+      !matchMedia("(prefers-reduced-motion: reduce)").matches;
+
+    if (animate) {
+      const transition = document.startViewTransition(commit);
+      void transition.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();
+  };
+}

package/.generated/core/resource-types.ts

@@ -0,0 +1,44 @@
+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;
+}