pageturn 0.1.0 → 0.2.0

package/dist/chunks/chunk-BOM5VXA5.js

@@ -0,0 +1,167 @@
+import {
+  addressOf,
+  choose,
+  followArrival,
+  leave,
+  readSession,
+  returnArrival,
+  tellArrival,
+  turnOf,
+  writeSession
+} from "./chunk-JHM7F4CH.js";
+import {
+  inBrowser,
+  reducesMotion
+} from "./chunk-AEOAXMU3.js";
+import {
+  registry
+} from "./chunk-YAL4MNCU.js";
+
+// src/router/router.ts
+var ENTRIES_KEY = "pageturn:router:entries", KEPT_ENTRIES = 50, CLICK_FRESH_MS = 1e3, INERT = {
+  left: Promise.resolve(),
+  swapped() {
+  },
+  cancelled() {
+  }
+}, current = null, shown = inBrowser ? location.href : "", lastClick = null;
+inBrowser && (registry.w = !0, addEventListener(
+  "click",
+  (event) => {
+    let link = event.composedPath().find((target) => target instanceof HTMLAnchorElement);
+    link && (lastClick = { link, at: Date.now() });
+  },
+  !0
+));
+function keyOf(url) {
+  let api = window.navigation, here = api?.currentEntry;
+  for (let entry of here ? [here, api.entries()[here.index - 1]] : [])
+    if (entry?.url && addressOf(new URL(entry.url)) === addressOf(url))
+      return entry.key;
+  return addressOf(url);
+}
+var readEntries = () => readSession(ENTRIES_KEY) ?? {};
+function writeEntry(key, entry) {
+  let { [key]: _, ...entries } = readEntries(), kept = Object.entries(entries).slice(1 - KEPT_ENTRIES);
+  writeSession(ENTRIES_KEY, {
+    ...Object.fromEntries(kept),
+    ...entry ? { [key]: entry } : {}
+  });
+}
+function reportOf(from) {
+  let { e: report } = registry;
+  if (!report && !window.pageturn?.arrival) return null;
+  let data = null;
+  try {
+    data = report?.({ decline: () => registry.f }) ?? null;
+  } catch (error) {
+    reportError(error);
+  }
+  let isNone = data === registry.f;
+  return {
+    from: from.pathname,
+    at: Date.now(),
+    data: isNone ? null : data,
+    ...isNone ? { none: !0 } : {}
+  };
+}
+function clickedTo(to) {
+  let click = lastClick;
+  return click && Date.now() - click.at < CLICK_FRESH_MS && addressOf(new URL(click.link.href)) === addressOf(to) ? click.link : null;
+}
+function startNavigation(start) {
+  if (!inBrowser) return INERT;
+  let to = new URL(start.to, location.href);
+  if (!window.pageturn || window.top !== window || reducesMotion() || // The same path and query: a place in the page (#…), not another page.
+  addressOf(to) === addressOf(new URL(shown)))
+    return shown = to.href, INERT;
+  current && end(current, "superseded");
+  let from = new URL(shown), playing = {
+    via: start.via,
+    to,
+    from,
+    leftKey: start.via === "history" ? "" : keyOf(from),
+    e: reportOf(from)
+  };
+  current = playing;
+  let drive = {
+    left: Promise.resolve(),
+    swapped: () => swapped(playing),
+    cancelled: () => {
+      current === playing && end(playing, "cancelled");
+    }
+  };
+  if (start.via === "history") return drive;
+  let clicked = start.via === "link" ? start.link ?? clickedTo(to) : null, visit = {
+    link: clicked ?? Object.assign(document.createElement("a"), { href: to.href }),
+    via: clicked ? "link" : "script",
+    from,
+    to,
+    canHandOver: !0
+  }, name = start.move !== void 0 ? start.move : clicked ? choose(visit) : registry.settings.defaultMove;
+  if (name === null) return drive;
+  let turn = turnOf(visit, name);
+  return document.dispatchEvent(
+    new CustomEvent("pageturn:leaving", { cancelable: !0, detail: turn })
+  ) ? (playing.turn = turn, {
+    ...drive,
+    left: leave(turn, (played) => {
+      playing.turn = played;
+    }).then((handover) => {
+      current === playing && (playing.handover = handover);
+    })
+  }) : drive;
+}
+function swapped(playing) {
+  if (current !== playing) return;
+  current = null;
+  let reached = new URL(location.href);
+  shown = reached.href;
+  let published = window.pageturn;
+  if (!published) return;
+  published.endArrival(), delete document.documentElement.dataset.turnLeaving;
+  let arrival = null;
+  if (playing.via === "history")
+    arrival = returnArrival(
+      readEntries()[keyOf(reached)] ?? null,
+      playing.e
+    );
+  else {
+    let { turn, handover } = playing;
+    turn && handover && handover.arriveAs !== null && (arrival = {
+      move: handover.arriveAs ?? turn.move,
+      via: "link",
+      from: playing.from.pathname,
+      data: handover.data ?? null,
+      remembered: null,
+      reported: null
+    }), writeEntry(
+      playing.leftKey,
+      turn && handover?.returnAs ? {
+        move: turn.move,
+        to: reached.pathname,
+        returnAs: handover.returnAs,
+        remember: handover.remember ?? null
+      } : null
+    ), document.documentElement.dataset.turnEntering = "";
+  }
+  published.arrival = arrival, arrival && published.t?.(arrival), followArrival(), arrival && tellArrival(arrival);
+}
+function end(playing, reason) {
+  current = null, delete document.documentElement.dataset.turnLeaving;
+  let { turn } = playing;
+  if (!turn) return;
+  let stay = { reason, handover: playing.handover ?? null };
+  try {
+    registry.b.get(turn.move)?.stay?.(turn, stay);
+  } catch (error) {
+    reportError(error);
+  }
+  document.dispatchEvent(
+    new CustomEvent("pageturn:stayed", { detail: { turn, stay } })
+  );
+}
+
+export {
+  startNavigation
+};

package/dist/chunks/chunk-C3T7BGNG.js

@@ -0,0 +1,30 @@
+import {
+  inBrowser
+} from "./chunk-AEOAXMU3.js";
+import {
+  registry
+} from "./chunk-YAL4MNCU.js";
+
+// src/default-move/native.ts
+var nextSwap;
+!registry.a && inBrowser && (addEventListener("pageswap", (event) => {
+  let transition = event.viewTransition;
+  nextSwap === null ? transition?.skipTransition() : nextSwap && transition?.types.add(nextSwap), nextSwap = void 0;
+}), registry.a = {
+  v(move, to) {
+    let store = window.pageturn?.j;
+    return store && window.pageturn?.a && "CSSViewTransitionRule" in window && getComputedStyle(document.documentElement).getPropertyValue("--pageturn-native").trim() !== "" ? (store.h(
+      {
+        move,
+        data: null,
+        from: location.pathname,
+        at: Date.now(),
+        a: !0
+      },
+      to
+    ), store.i(null), nextSwap = move, !0) : !1;
+  },
+  c: (value) => {
+    nextSwap = value;
+  }
+});

package/dist/chunks/chunk-FYSSNYA4.js

@@ -0,0 +1,17 @@
+import {
+  registry
+} from "./chunk-YAL4MNCU.js";
+
+// src/prefetch/prefetch.ts
+var asked = /* @__PURE__ */ new Set();
+registry.u ??= (to) => {
+  let address = to.href.split("#")[0] ?? to.href;
+  if (asked.has(address)) return;
+  let connection = navigator.connection;
+  if (connection?.saveData || /2g/.test(connection?.effectiveType ?? ""))
+    return;
+  asked.add(address);
+  let link = document.createElement("link");
+  link.relList.supports("prefetch") ? (link.rel = "prefetch", link.href = address, document.head.append(link)) : fetch(address, { priority: "low" }).catch(() => {
+  });
+};

package/dist/chunks/chunk-JHM7F4CH.js

@@ -0,0 +1,172 @@
+import {
+  afterDomContentLoaded
+} from "./chunk-AEOAXMU3.js";
+import {
+  isDeclined,
+  registry
+} from "./chunk-YAL4MNCU.js";
+
+// src/kernel/cap.ts
+function capOf(property, ceiling) {
+  let value = getComputedStyle(document.documentElement).getPropertyValue(
+    property
+  ), max = Number.parseFloat(value) * (/ms\s*$/.test(value) ? 1 : 1e3);
+  return max >= 0 ? Math.min(max, ceiling) : ceiling;
+}
+var isEnding = (animation) => animation.effect?.getTiming().iterations !== 1 / 0, untilEnded = (animations, milliseconds) => Promise.race([
+  Promise.allSettled(animations.map((animation) => animation.finished)),
+  new Promise((resolve) => setTimeout(resolve, milliseconds))
+]);
+
+// src/kernel/arrival.ts
+var root = () => document.documentElement, watching = null, endedBy = null, ARRIVE_MAX_MS = 1e4, isArriving = () => "turnArriving" in root().dataset || "turnEntering" in root().dataset, nextFrame = () => new Promise((resolve) => requestAnimationFrame(resolve));
+function endArrivalBy(by) {
+  isArriving() && (endedBy = by, window.pageturn?.endArrival());
+}
+function followArrival() {
+  if (stopFollowing(), !isArriving()) return;
+  let move = root().dataset.turnArriving ?? null, entering = "turnEntering" in root().dataset, isCut = !1;
+  endedBy = null;
+  let watch = new MutationObserver(() => {
+    if (move = root().dataset.turnArriving ?? move, entering && !("turnEntering" in root().dataset) && window.pageturn?.l ? entering = !1 : endedBy === null && (isCut = !0), isArriving() || (watch.disconnect(), watching === watch && (watching = null), !entering && move === null)) return;
+    let isManual = registry.settings.arrivalEnds === "manually", whole = endedBy !== "leave" && (isManual || endedBy === "settled" && !isCut);
+    document.dispatchEvent(
+      new CustomEvent("pageturn:arrived", {
+        detail: { move, entering, whole }
+      })
+    );
+  });
+  watching = watch, watch.observe(root(), {
+    attributeFilter: ["data-turn-arriving", "data-turn-entering"]
+  }), afterDomContentLoaded(async () => {
+    await nextFrame(), await nextFrame(), watching === watch && registry.settings.arrivalEnds !== "manually" && waitForAnimations(watch);
+  });
+}
+async function waitForAnimations(watch) {
+  let until = performance.now() + capOf("--turn-arrive-max", ARRIVE_MAX_MS);
+  for (let isFirst = !0; ; isFirst = !1) {
+    let running = document.getAnimations().filter(
+      (animation) => animation.playState === "running" && // A hover's transition is not part of an arrival.
+      !(typeof CSSTransition < "u" && animation instanceof CSSTransition) && isEnding(animation)
+    ), arrival = window.pageturn?.arrival, left = until - performance.now();
+    if (running.length === 0 || left <= 0) break;
+    if (await untilEnded(running, left), await nextFrame(), watching !== watch) return;
+  }
+  watching === watch && endArrivalBy("settled");
+}
+function tellArrival(arrival) {
+  try {
+    registry.b.get(arrival.move)?.arrive?.(arrival);
+  } catch (error) {
+    reportError(error);
+  }
+}
+function stopFollowing() {
+  watching?.disconnect(), watching = null;
+}
+
+// src/common/session.ts
+function readSession(key) {
+  try {
+    let text = sessionStorage.getItem(key);
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return null;
+  }
+}
+function writeSession(key, value) {
+  try {
+    return sessionStorage.setItem(key, JSON.stringify(value)), !0;
+  } catch {
+    return !1;
+  }
+}
+function removeSession(key) {
+  try {
+    sessionStorage.getItem(key) !== null && sessionStorage.removeItem(key);
+  } catch {
+  }
+}
+
+// src/head/storage.ts
+var STORE_VERSION = 2;
+var addressOf = (place) => place.pathname + place.search;
+function returnArrival(entry, report) {
+  return !entry?.returnAs || !report || report.none || report.from !== entry.to ? null : {
+    move: entry.returnAs,
+    via: "history",
+    from: report.from,
+    data: null,
+    remembered: entry.remember ?? null,
+    reported: report.data ?? null
+  };
+}
+
+// src/kernel/leaving.ts
+function playCssLeave(name, timeout) {
+  let root2 = document.documentElement, before = new Set(document.getAnimations());
+  root2.dataset.turnLeaving = name;
+  let started = document.getAnimations().filter((animation) => !before.has(animation) && isEnding(animation));
+  return started.length === 0 ? Promise.resolve() : untilEnded(started, capOf("--turn-leave-max", timeout)).then(
+    () => {
+    }
+  );
+}
+
+// src/kernel/turn.ts
+function choose(visit) {
+  let named = visit.link.closest("[data-turn]")?.getAttribute("data-turn");
+  if (named) return named === "none" ? null : named;
+  try {
+    for (let chooser of registry.d) {
+      let name = chooser(visit);
+      if (name !== void 0) return name;
+    }
+    for (let [name, move] of registry.b)
+      if (move.match?.(visit)) return name;
+  } catch (error) {
+    reportError(error);
+  }
+  return registry.settings.defaultMove;
+}
+function turnOf(visit, move) {
+  let leaving;
+  return {
+    ...visit,
+    move,
+    leaving: () => (leaving || endArrivalBy("leave"), leaving ??= playCssLeave(move, registry.settings.leaveTimeout), leaving),
+    decline: () => registry.f
+  };
+}
+function leave(turn, played) {
+  let timedOut = new Promise(
+    (resolve) => setTimeout(resolve, registry.settings.leaveTimeout, null)
+  );
+  return Promise.race([run(turn, played).catch(() => null), timedOut]);
+}
+async function run(turn, played) {
+  played(turn);
+  let outcome = await registry.b.get(turn.move)?.leave?.(turn);
+  if (isDeclined(outcome)) {
+    let fallback = registry.settings.defaultMove;
+    if (fallback === null) return null;
+    if (fallback !== turn.move) return run(turnOf(turn, fallback), played);
+  } else if (outcome)
+    return outcome;
+  return await turn.leaving(), {};
+}
+
+export {
+  followArrival,
+  tellArrival,
+  stopFollowing,
+  readSession,
+  writeSession,
+  removeSession,
+  STORE_VERSION,
+  addressOf,
+  returnArrival,
+  choose,
+  turnOf,
+  leave
+};