ignotum 0.0.16 → 0.0.18

package/src/client/route-boundaries.ts

@@ -1,184 +1 @@
-import { createElement as h, Fragment, type ComponentChildren, type ComponentType } from "preact";
-import { useErrorBoundary, useState } from "preact/hooks";
-import type {
-  ErrorBoundaryProps,
-  LoadedBranch,
-  RouterSnapshot,
-  RouterStore,
-} from "./router-store.js";
-import type { RouteLocation } from "./routes.js";
-
-export const DefaultError = ({ error, retry }: ErrorBoundaryProps): ComponentChildren =>
-  h(
-    "div",
-    { role: "alert" },
-    error instanceof Error ? error.message : "This page could not load or render. ",
-    h("button", { onClick: retry }, "Retry"),
-  );
-
-interface BoundaryProps {
-  readonly children: ComponentChildren;
-  readonly component: ComponentType<ErrorBoundaryProps>;
-  readonly branch: LoadedBranch;
-  readonly router: RouterStore;
-  readonly onRetry?: () => void;
-}
-const Boundary = ({
-  children,
-  component,
-  branch,
-  router,
-  onRetry,
-}: BoundaryProps): ComponentChildren => {
-  const [failure, setFailure] = useState<{
-    readonly branch: LoadedBranch;
-    readonly error: unknown;
-  }>();
-  const [, reset] = useErrorBoundary((error) => {
-    setFailure({ branch, error });
-    router.setRenderError(true);
-  });
-  return failure?.branch !== branch
-    ? children
-    : h(component, {
-        error: failure.error,
-        retry: () => {
-          router.setRenderError(false);
-          onRetry?.();
-          setFailure(undefined);
-          reset();
-        },
-      });
-};
-
-export const Branch = ({
-  branch,
-  location,
-  router,
-  failure,
-}: {
-  readonly branch: LoadedBranch;
-  readonly location: RouteLocation;
-  readonly router: RouterStore;
-  readonly failure: RouterSnapshot["failure"];
-}): ComponentChildren => {
-  const outcome = branch.outcome;
-  let child: ComponentChildren;
-  let lastLayout = branch.layouts.length - 1;
-  let boundaryOwner: number | undefined;
-  if (outcome._tag === "Matched" && branch.page !== undefined) {
-    child = h(branch.page, {
-      key: outcome.route.id,
-      params: outcome.params,
-      searchParams: outcome.searchParams,
-    });
-  } else if (outcome._tag === "Invalid" && branch.pageBoundaries?.invalid !== undefined) {
-    child = h(branch.pageBoundaries.invalid, { location, issues: outcome.issues });
-  } else {
-    child = h(
-      "main",
-      { "data-ignotum-outcome": outcome._tag },
-      outcome._tag === "Invalid" ? "Invalid URL" : "Page not found",
-    );
-    for (let index = lastLayout; index >= 0; index--) {
-      const layout = branch.layouts[index]!;
-      if (outcome._tag === "Invalid" && layout.invalid !== undefined) {
-        child = h(layout.invalid, { location, issues: outcome.issues });
-        lastLayout = index;
-        boundaryOwner = index;
-        break;
-      }
-      if (outcome._tag === "NotFound" && layout.notFound !== undefined) {
-        child = h(layout.notFound, { location });
-        lastLayout = index;
-        boundaryOwner = index;
-        break;
-      }
-    }
-  }
-  if (branch.pageBoundaries?.error !== undefined && outcome._tag === "Matched")
-    child = h(Boundary, {
-      key: "page-boundary",
-      component: branch.pageBoundaries.error,
-      branch,
-      router,
-      children: child,
-    });
-  let sharedLayouts = 0;
-  while (
-    sharedLayouts <= lastLayout &&
-    branch.layouts[sharedLayouts]?.id === failure?.branch?.layouts[sharedLayouts]?.id
-  )
-    sharedLayouts++;
-  const loadFailure =
-    failure === undefined
-      ? null
-      : h(LoadFailure, {
-          failure,
-          router,
-          layouts: branch.layouts.slice(0, sharedLayouts),
-        });
-  for (let index = lastLayout; index >= 0; index--) {
-    const layout = branch.layouts[index]!;
-    if (layout.error !== undefined && index !== boundaryOwner)
-      child = h(Boundary, {
-        key: layout.id,
-        component: layout.error,
-        branch,
-        router,
-        children: child,
-      });
-    child = h(layout.component, {
-      key: layout.id,
-      children: h(Fragment, {}, child, index === sharedLayouts - 1 ? loadFailure : null),
-    });
-  }
-  return h(Boundary, {
-    component: DefaultError,
-    branch,
-    router,
-    children: h(Fragment, {}, child, sharedLayouts === 0 ? loadFailure : null),
-  });
-};
-
-export const LoadFailure = ({
-  failure,
-  router,
-  layouts,
-}: {
-  readonly failure: NonNullable<RouterSnapshot["failure"]>;
-  readonly layouts?: LoadedBranch["layouts"];
-  readonly router: RouterStore;
-}): ComponentChildren => {
-  const branch = failure.branch;
-  if (branch === undefined)
-    return h("div", { "data-ignotum-load-error": "" }, h(DefaultError, failure));
-  let child: ComponentChildren = h(DefaultError, failure);
-  let found = false;
-  for (const layout of [...(layouts ?? branch.layouts)].reverse()) {
-    if (layout.error === undefined) continue;
-    if (!found) {
-      child = h(layout.error, { error: failure.error, retry: failure.retry });
-      found = true;
-    } else {
-      child = h(Boundary, {
-        component: layout.error,
-        branch,
-        router,
-        onRetry: failure.retry,
-        children: child,
-      });
-    }
-  }
-  return h(
-    "div",
-    { "data-ignotum-load-error": "" },
-    h(Boundary, {
-      component: DefaultError,
-      branch,
-      router,
-      onRetry: failure.retry,
-      children: child,
-    }),
-  );
-};
+export * from "@ignotum/platform/versions/1/browser/route-boundaries";

package/src/client/router-history.ts

@@ -1,152 +1 @@
-import * as Versioned from "@ignotum/contracts/versioned";
-import { Deferred, Effect, Schema } from "effect";
-
-const HistoryEntryV1 = Schema.Struct({ formatVersion: Schema.Literal(1), key: Schema.String });
-const HistoryEntryV2 = Schema.Struct({
-  formatVersion: Schema.Literal(2),
-  key: Schema.String,
-  index: Schema.NullOr(Schema.Int),
-});
-const HistoryEntry = Versioned.upgrade(
-  Versioned.initial(HistoryEntryV1),
-  HistoryEntryV2,
-  (old) => ({
-    formatVersion: 2 as const,
-    key: old.key,
-    index: null,
-  }),
-);
-const HistoryState = Schema.Struct({ __ignotumRouter: HistoryEntry });
-const StateObject = Schema.Record(Schema.String, Schema.Unknown);
-export interface HistoryPosition {
-  readonly key: string;
-  readonly index: number;
-  readonly href: string;
-}
-const hrefOf = (browser: Window) =>
-  `${browser.location.pathname}${browser.location.search}${browser.location.hash}`;
-
-/** Serializes router corrections to native traversal without adding duplicate entries. */
-export class RouterHistory {
-  committed: HistoryPosition;
-  private actual: HistoryPosition;
-  private readonly positions = new Map<string, number>();
-  private seeking: { position: HistoryPosition; done: Deferred.Deferred<boolean> } | undefined;
-  private readonly originalScrollRestoration;
-  private direction = -1;
-  private scrollPending = false;
-  private expectedKey: string | undefined;
-  readonly scroll = new Map<string, { x: number; y: number }>();
-  constructor(
-    private readonly browser: Window,
-    private readonly onTraversal: (position: HistoryPosition) => void,
-  ) {
-    const parsed = Schema.decodeUnknownOption(HistoryState)(browser.history.state);
-    const entry = parsed._tag === "Some" ? parsed.value.__ignotumRouter : undefined;
-    this.actual = this.committed = {
-      key: entry?.key ?? browser.crypto.randomUUID(),
-      index: entry?.index ?? 0,
-      href: hrefOf(browser),
-    };
-    this.write(this.actual, false);
-    this.originalScrollRestoration = browser.history.scrollRestoration;
-    browser.history.scrollRestoration = "manual";
-    browser.addEventListener("popstate", this.onPop);
-    browser.addEventListener("scroll", this.saveScroll);
-  }
-  private write(position: HistoryPosition, push: boolean): void {
-    const parsed = Schema.decodeUnknownOption(StateObject)(this.browser.history.state);
-    const owned = {
-      __ignotumRouter: Schema.encodeSync(HistoryEntry)({
-        formatVersion: 2,
-        key: position.key,
-        index: position.index,
-      }),
-    };
-    const state = parsed._tag === "Some" ? { ...parsed.value, ...owned } : owned;
-    if (push) this.browser.history.pushState(state, "", position.href);
-    else this.browser.history.replaceState(state, "", position.href);
-    this.positions.set(position.key, position.index);
-  }
-  saveScroll = (): void => {
-    if (this.scrollPending) return;
-    this.scroll.set(this.committed.key, { x: this.browser.scrollX, y: this.browser.scrollY });
-  };
-  captureScroll(): { x: number; y: number } {
-    this.saveScroll();
-    this.scrollPending = true;
-    return (
-      this.scroll.get(this.committed.key) ?? { x: this.browser.scrollX, y: this.browser.scrollY }
-    );
-  }
-  finishScroll(): void {
-    this.scrollPending = false;
-    this.saveScroll();
-  }
-  restoreSourceScroll(): void {
-    if (!this.scrollPending) return;
-    const saved = this.scroll.get(this.committed.key);
-    if (saved !== undefined) this.browser.scrollTo(saved.x, saved.y);
-    this.finishScroll();
-  }
-  private onPop = (): void => {
-    const parsed = Schema.decodeUnknownOption(HistoryState)(this.browser.history.state);
-    const entry = parsed._tag === "Some" ? parsed.value.__ignotumRouter : undefined;
-    const key = entry?.key ?? this.browser.crypto.randomUUID();
-    const index = entry?.index ?? this.positions.get(key) ?? this.actual.index + this.direction;
-    this.actual = { key, index, href: hrefOf(this.browser) };
-    this.write(this.actual, false);
-    const expected = this.expectedKey;
-    this.expectedKey = undefined;
-    const seeking = this.seeking;
-    if (seeking !== undefined && (expected === key || seeking.position.key === key)) {
-      this.advanceSeek();
-      return;
-    }
-    if (seeking !== undefined) {
-      this.seeking = undefined;
-      Effect.runSync(Deferred.succeed(seeking.done, false));
-    }
-    this.onTraversal(this.actual);
-  };
-  private advanceSeek(): void {
-    const seeking = this.seeking;
-    if (seeking === undefined || this.expectedKey !== undefined) return;
-    if (this.actual.key === seeking.position.key) {
-      this.seeking = undefined;
-      Effect.runSync(Deferred.succeed(seeking.done, true));
-    } else {
-      this.expectedKey = seeking.position.key;
-      this.browser.history.go(seeking.position.index - this.actual.index);
-    }
-  }
-  seek(position: HistoryPosition): Promise<boolean> {
-    if (this.seeking !== undefined) {
-      if (this.seeking.position.key === position.key)
-        return Effect.runPromise(Deferred.await(this.seeking.done));
-      Effect.runSync(Deferred.succeed(this.seeking.done, false));
-    }
-    const done = Deferred.makeUnsafe<boolean>();
-    this.seeking = { position, done };
-    this.advanceSeek();
-    return Effect.runPromise(Deferred.await(done));
-  }
-  commit(position: HistoryPosition, kind: "initial" | "push" | "replace" | "traverse"): void {
-    if (kind === "push" || kind === "replace") this.write(position, kind === "push");
-    this.actual = this.committed = position;
-  }
-  back = (): void => {
-    this.direction = -1;
-    this.browser.history.back();
-  };
-  forward = (): void => {
-    this.direction = 1;
-    this.browser.history.forward();
-  };
-  dispose(): void {
-    this.browser.removeEventListener("popstate", this.onPop);
-    this.browser.removeEventListener("scroll", this.saveScroll);
-    this.browser.history.scrollRestoration = this.originalScrollRestoration;
-    if (this.seeking !== undefined) Effect.runSync(Deferred.succeed(this.seeking.done, false));
-  }
-}
+export * from "@ignotum/platform/versions/1/browser/router-history";