pageturn 0.1.0 → 0.2.0

package/dist/chunks/{chunk-QJ7GGFM4.js → chunk-YAL4MNCU.js}

@@ -1,22 +1,20 @@
 // src/common/registry.ts
-var KEY = /* @__PURE__ */ Symbol.for("pageturn.registry");
-var holder = globalThis;
+var KEY = /* @__PURE__ */ Symbol.for("pageturn.registry"), holder = globalThis;
 holder[KEY] ??= {
   b: /* @__PURE__ */ new Map(),
   d: [],
   e: null,
   settings: {
     defaultMove: "page",
-    prefetch: true,
+    prefetch: !0,
     leaveTimeout: 4e3,
     stuckTimeout: 4e3,
     arrivalEnds: "animations"
   },
-  k: false,
+  g: !1,
   f: Object.freeze({})
 };
-var registry = holder[KEY];
-var isDeclined = (answer) => answer === registry.f || answer === false;
+var registry = holder[KEY], isDeclined = (answer) => answer === registry.f;
 
 export {
   registry,

package/dist/core.js

@@ -5,9 +5,10 @@ import {
   defineMove,
   endArrival,
   whenLeft
-} from "./chunks/chunk-7LMNJ25V.js";
-import "./chunks/chunk-YBAP3PHO.js";
-import "./chunks/chunk-QJ7GGFM4.js";
+} from "./chunks/chunk-6FXXBNAF.js";
+import "./chunks/chunk-JHM7F4CH.js";
+import "./chunks/chunk-AEOAXMU3.js";
+import "./chunks/chunk-YAL4MNCU.js";
 export {
   arrival,
   chooseMove,

package/dist/dev/chunks/chunk-3JAWIMHB.js

@@ -0,0 +1,184 @@
+import {
+  afterDomContentLoaded
+} from "./chunk-AEOAXMU3.js";
+import {
+  isDeclined,
+  registry
+} from "./chunk-YAL4MNCU.js";
+
+// src/common/dev.ts
+var said = /* @__PURE__ */ new Set();
+function warn(key, message) {
+  said.has(key) || (said.add(key), console.warn(`pageturn: ${message}`));
+}
+
+// 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;
+    isFirst && running.length === 0 && arrival?.via === "history" && warn(
+      `return:${arrival.move}`,
+      `this page was returned to under "${arrival.move}" with no animation: Back cannot play a leave, so the page left goes at once and this one shows at once. Animate it in, as html[data-turn-arriving="${arrival.move}"] main { animation: \u2026 }.`
+    );
+    let 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 {
+  warn,
+  followArrival,
+  tellArrival,
+  stopFollowing,
+  readSession,
+  writeSession,
+  removeSession,
+  STORE_VERSION,
+  addressOf,
+  returnArrival,
+  choose,
+  turnOf,
+  leave
+};