pageturn 0.1.0 → 0.2.0

package/dist/dev/chunks/chunk-AEOAXMU3.js

@@ -0,0 +1,33 @@
+// src/common/page.ts
+var inBrowser = typeof document < "u", navigationEntry = () => performance.getEntriesByType("navigation")[0];
+function afterDomContentLoaded(run) {
+  let entry = navigationEntry();
+  (entry ? entry.domContentLoadedEventStart > 0 : document.readyState !== "loading") ? run() : document.addEventListener("DOMContentLoaded", run, { once: !0 });
+}
+var reduced;
+function reducesMotion() {
+  return reduced ??= matchMedia("(prefers-reduced-motion: reduce)"), reduced.matches;
+}
+function notShownAnew() {
+  window.pageturn && (window.pageturn.l = !0), delete document.documentElement.dataset.turnEntering;
+}
+var FOCUS_BACK = /* @__PURE__ */ Symbol.for("pageturn.focusBack"), shared = globalThis;
+function giveFocusTo(element, options) {
+  shared[FOCUS_BACK] = element;
+  try {
+    element.focus(options);
+  } finally {
+    delete shared[FOCUS_BACK];
+  }
+}
+var isFocusGivenBack = (element) => shared[FOCUS_BACK] === element;
+
+export {
+  inBrowser,
+  navigationEntry,
+  afterDomContentLoaded,
+  reducesMotion,
+  notShownAnew,
+  giveFocusTo,
+  isFocusGivenBack
+};

package/dist/dev/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/dev/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/dev/chunks/chunk-I4SBUABE.js

@@ -0,0 +1,175 @@
+import {
+  addressOf,
+  choose,
+  followArrival,
+  leave,
+  readSession,
+  returnArrival,
+  tellArrival,
+  turnOf,
+  warn,
+  writeSession
+} from "./chunk-3JAWIMHB.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;
+  try {
+    document.documentElement.matches(":active-view-transition") && warn(
+      "transition",
+      "the router plays its own view transition while pageturn plays a move: turn the router's view transitions off where pageturn plays."
+    );
+  } catch {
+  }
+  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/dev/chunks/chunk-U3XN54YY.js

@@ -0,0 +1,219 @@
+import {
+  STORE_VERSION,
+  addressOf,
+  choose,
+  followArrival,
+  leave,
+  stopFollowing,
+  tellArrival,
+  turnOf,
+  warn
+} from "./chunk-3JAWIMHB.js";
+import {
+  inBrowser,
+  reducesMotion
+} from "./chunk-AEOAXMU3.js";
+import {
+  registry
+} from "./chunk-YAL4MNCU.js";
+
+// src/kernel/kernel.ts
+var store, current = null, stuckTimer;
+function install() {
+  if (!inBrowser) return;
+  let published = window.pageturn?.j;
+  if (registry.g || published?.m !== STORE_VERSION) {
+    !registry.g && !window.pageturn && warn(
+      "head",
+      "the head script is not on this page, so links navigate with no move. Put it first in <head>, before any other script (see the README)."
+    );
+    return;
+  }
+  store = published, registry.g = !0, reducesMotion() && warn(
+    "motion",
+    "prefers-reduced-motion is on: pageturn plays nothing, and links navigate as they would without it."
+  ), addEventListener("click", putClickLast, !0), addEventListener("pointerdown", pressed, !0), addEventListener("pagehide", pageHidden, !0), addEventListener("pageshow", pageShown), followArrival();
+}
+function putClickLast() {
+  clickedAt = addressOf(location), removeEventListener("click", clicked), addEventListener("click", clicked);
+}
+var clickedAt = "";
+function linkIn(event) {
+  for (let target of event.composedPath()) {
+    if (target instanceof HTMLAnchorElement)
+      return target.hasAttribute("href") ? target : null;
+    if (target instanceof SVGAElement) return null;
+  }
+  return null;
+}
+function isEditable(event) {
+  let [target] = event.composedPath();
+  return target instanceof HTMLElement && target.isContentEditable;
+}
+function destinationOf(link) {
+  let target = link.target || document.querySelector("base[target]")?.getAttribute("target");
+  if (target && target !== "_self" || link.hasAttribute("download"))
+    return null;
+  let to = new URL(link.href), isThisPage = to.pathname === location.pathname && to.search === location.search;
+  return to.origin === location.origin && !isThisPage ? to : null;
+}
+function prefetch(to) {
+  registry.settings.prefetch && registry.u?.(to);
+}
+function pressed(event) {
+  if (event.button !== 0 || isEditable(event)) return;
+  let link = linkIn(event), to = link && destinationOf(link);
+  to && prefetch(to);
+}
+function watchRouter(event) {
+  let link = linkIn(event), to = link && new URL(link.href);
+  !to || to.origin !== location.origin || addressOf(to) === clickedAt || setTimeout(() => {
+    registry.w || addressOf(location) !== addressOf(to) || warn(
+      "router",
+      `a client router took the link to ${to.pathname}, so pageturn plays nothing on it. Use pageturn's adapter for that router (see the README), or pageturn/router.`
+    );
+  }, 300);
+}
+function clicked(event) {
+  if (event.defaultPrevented && watchRouter(event), event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || isEditable(event))
+    return;
+  let link = linkIn(event), to = link && destinationOf(link);
+  if (!link || !to) return;
+  if (current) {
+    event.preventDefault();
+    return;
+  }
+  if (store.n(), event.detail === 0 && prefetch(to), reducesMotion()) return;
+  let { a: native } = registry, visit = {
+    link,
+    via: "link",
+    from: new URL(location.href),
+    to,
+    canHandOver: store.q()
+  }, name = choose(visit);
+  if (name === null) {
+    native?.c(null);
+    return;
+  }
+  let turn = turnOf(visit, name);
+  if (!document.dispatchEvent(
+    new CustomEvent("pageturn:leaving", { cancelable: !0, detail: turn })
+  )) {
+    native?.c(null);
+    return;
+  }
+  if (name === registry.settings.defaultMove && !registry.b.get(name)?.leave && native?.v(name, to))
+    return;
+  event.preventDefault();
+  let playing = { turn };
+  current = playing, leave(turn, (played) => {
+    playing.turn = played;
+  }).then((handover) => depart(playing, handover));
+}
+function depart(playing, handover) {
+  if (current !== playing || playing.handover !== void 0) return;
+  let { turn } = playing;
+  playing.handover = handover, handover && handover.arriveAs !== null && store.h(
+    {
+      move: handover.arriveAs ?? turn.move,
+      data: handover.data ?? null,
+      from: location.pathname,
+      at: Date.now()
+    },
+    turn.to
+  ), playing.entry = handover?.returnAs ? {
+    move: turn.move,
+    to: turn.to.pathname,
+    returnAs: handover.returnAs,
+    remember: handover.remember ?? null
+  } : null, store.i(playing.entry), registry.a?.c(null), location.assign(turn.to.href), stuckTimer = setTimeout(
+    () => endWithoutDeparture(playing, "stuck"),
+    registry.settings.stuckTimeout
+  );
+}
+function endWithoutDeparture(playing, reason) {
+  if (current !== playing) return;
+  current = null, clearTimeout(stuckTimer), registry.a?.c(void 0), delete document.documentElement.dataset.turnLeaving;
+  let stay = { reason, handover: playing.handover ?? null };
+  try {
+    registry.b.get(playing.turn.move)?.stay?.(playing.turn, stay);
+  } catch (error) {
+    reportError(error);
+  }
+  document.dispatchEvent(
+    new CustomEvent("pageturn:stayed", {
+      detail: { turn: playing.turn, stay }
+    })
+  );
+}
+function pageHidden() {
+  clearTimeout(stuckTimer), stopFollowing();
+  let { e: report } = registry;
+  if (!report && !window.pageturn?.arrival) return;
+  let data = null;
+  try {
+    data = report?.({ decline: () => registry.f }) ?? null;
+  } catch (error) {
+    reportError(error);
+  }
+  let isNone = data === registry.f;
+  store.p({
+    from: location.pathname,
+    at: Date.now(),
+    data: isNone ? null : data,
+    ...isNone ? { none: !0 } : {}
+  });
+}
+function pageShown(event) {
+  if (!event.persisted) return;
+  registry.a?.c(void 0);
+  let playing = current, published = window.pageturn;
+  if (!published) return;
+  let entry = playing ? playing.entry ?? null : store.r(), arrival2 = store.s(entry, store.o());
+  published.arrival = arrival2, arrival2 && (published.t?.(arrival2), published.k?.skipTransition(), followArrival()), playing && endWithoutDeparture(playing, "returned"), arrival2 && tellArrival(arrival2);
+}
+
+// src/kernel/core.ts
+function defineMove(name, move) {
+  let stored = move;
+  registry.b.set(name, stored);
+  let reached = inBrowser ? window.pageturn?.arrival : null;
+  return reached?.move === name && stored.arrive && queueMicrotask(() => {
+    registry.b.get(name) === stored && tellArrival(reached);
+  }), () => {
+    registry.b.get(name) === stored && registry.b.delete(name);
+  };
+}
+function chooseMove(chooser) {
+  let stored = chooser;
+  return registry.d.push(stored), () => {
+    let index = registry.d.indexOf(stored);
+    index >= 0 && registry.d.splice(index, 1);
+  };
+}
+function arrival() {
+  return inBrowser && window.pageturn?.arrival || null;
+}
+function endArrival(move) {
+  inBrowser && window.pageturn?.endArrival(move);
+}
+function whenLeft(report) {
+  let stored = report;
+  return registry.e = stored, () => {
+    registry.e === stored && (registry.e = null);
+  };
+}
+function configure(settings) {
+  for (let [key, value] of Object.entries(settings))
+    value !== void 0 && Object.assign(registry.settings, { [key]: value });
+}
+install();
+
+export {
+  defineMove,
+  chooseMove,
+  arrival,
+  endArrival,
+  whenLeft,
+  configure
+};

package/dist/dev/chunks/chunk-Y6TD2T53.js

@@ -0,0 +1,43 @@
+import {
+  startNavigation
+} from "./chunk-I4SBUABE.js";
+import {
+  inBrowser
+} from "./chunk-AEOAXMU3.js";
+
+// src/vue/vue.ts
+function pageturn(router, options = {}) {
+  if (!inBrowser) return () => {
+  };
+  let current = null, popped = !1, cancel = () => {
+    current?.cancelled(), current = null;
+  }, stops = [
+    // Back and Forward: the router's history says so before its guards run.
+    router.options.history.listen((_to, _from, info) => {
+      popped = info.type === "pop";
+    }),
+    router.beforeEach((to, from) => {
+      let via = popped ? "history" : "link";
+      popped = !1, from.matched.length !== 0 && (current = startNavigation({ to: router.resolve(to).href, via }));
+    }),
+    router.beforeResolve(() => current?.left),
+    router.afterEach((_to, _from, failure) => {
+      let turn = current;
+      if (current = null, !turn) return;
+      if (failure) {
+        turn.cancelled();
+        return;
+      }
+      let swap = () => turn.swapped();
+      options.whenShown ? options.whenShown(swap) : queueMicrotask(swap);
+    }),
+    router.onError(cancel)
+  ];
+  return () => {
+    for (let stop of stops) stop();
+  };
+}
+
+export {
+  pageturn
+};

package/dist/dev/chunks/chunk-YAL4MNCU.js

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

package/dist/dev/core.js

@@ -0,0 +1,19 @@
+import {
+  arrival,
+  chooseMove,
+  configure,
+  defineMove,
+  endArrival,
+  whenLeft
+} from "./chunks/chunk-U3XN54YY.js";
+import "./chunks/chunk-3JAWIMHB.js";
+import "./chunks/chunk-AEOAXMU3.js";
+import "./chunks/chunk-YAL4MNCU.js";
+export {
+  arrival,
+  chooseMove,
+  configure,
+  defineMove,
+  endArrival,
+  whenLeft
+};

package/dist/dev/index.js

@@ -0,0 +1,21 @@
+import "./chunks/chunk-FYSSNYA4.js";
+import "./chunks/chunk-C3T7BGNG.js";
+import {
+  arrival,
+  chooseMove,
+  configure,
+  defineMove,
+  endArrival,
+  whenLeft
+} from "./chunks/chunk-U3XN54YY.js";
+import "./chunks/chunk-3JAWIMHB.js";
+import "./chunks/chunk-AEOAXMU3.js";
+import "./chunks/chunk-YAL4MNCU.js";
+export {
+  arrival,
+  chooseMove,
+  configure,
+  defineMove,
+  endArrival,
+  whenLeft
+};

package/dist/dev/morph-markup.js

@@ -0,0 +1,34 @@
+import {
+  back,
+  defineMorph,
+  isDefined,
+  seen
+} from "./chunks/chunk-3SU4CIKL.js";
+import "./chunks/chunk-U3XN54YY.js";
+import "./chunks/chunk-3JAWIMHB.js";
+import {
+  afterDomContentLoaded,
+  inBrowser
+} from "./chunks/chunk-AEOAXMU3.js";
+import "./chunks/chunk-YAL4MNCU.js";
+
+// src/morph/markup.ts
+var ATTRIBUTE = "data-turn-morph";
+function morphsFromMarkup() {
+  let names = new Set(
+    [...document.querySelectorAll(`[${ATTRIBUTE}]`)].map(
+      (element) => element.getAttribute(ATTRIBUTE) ?? ""
+    )
+  );
+  for (let name of names) {
+    if (!name || isDefined(name)) continue;
+    let selector = `[${ATTRIBUTE}="${CSS.escape(name)}"]`;
+    defineMorph(name, {
+      from: (link) => link.querySelector(selector) ?? link.closest(selector),
+      to: selector,
+      find: seen(),
+      use: [back()]
+    });
+  }
+}
+inBrowser && afterDomContentLoaded(morphsFromMarkup);