foldkit-primitives 0.15.3 → 0.16.0

package/dist/dom/scroll-settle.d.ts

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const ScrollSettled: Schema.TaggedStruct<"ScrollSettled", {
+  /** The item whose start lies nearest the scroller's start, from 0. */
+  readonly index: Schema.Number;
+}>;
+export type ScrollSettled = typeof ScrollSettled.Type;
+/** How long a scroll must be still to count as settled, where `scrollend` is missing. */
+export declare const SETTLE_QUIET = 120;
+/**
+ * Hears a scroller come to rest, as a Mount: after a swipe, a fling, a
+ * trackpad or a scroll a Command made, it reports which of its items starts
+ * nearest its own start (inside its `scroll-padding`), the start being the
+ * right edge right to left. A snapping carousel reads it as the slide shown.
+ *
+ * At insert it first scrolls, at once, to item `start` (the Mount's args are
+ * read only then, so this is where a redrawn or restored scroller begins),
+ * and reports where it lies, since a scroller drawn already at rest sends no
+ * `scrollend`. It listens for `scrollend` where the browser has it, and
+ * otherwise for a scroll that is quiet for `SETTLE_QUIET` milliseconds.
+ */
+export declare const ScrollSettle: Mount.MountDefinitionWithArgs<"ScrollSettle", {
+  /** Which children are the items; default every child. */
+  item: Schema.optional<Schema.String>;
+  /** Default `inline`, the row a carousel scrolls along. */
+  axis: Schema.optional<Schema.Literals<readonly ["inline", "block"]>>;
+  /** The item to scroll to at insert; default the first, which needs no scroll. */
+  start: Schema.optional<Schema.Number>;
+}, {
+  readonly _tag: "ScrollSettled";
+  readonly index: number;
+}>;
+//# sourceMappingURL=scroll-settle.d.ts.map

package/dist/dom/scroll-settle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-settle.d.ts","names":[],"sources":["../../src/dom/scroll-settle.ts"],"mappings":";;qBAGa,eAAa,OAAA;;;;YAId,uBAAuB,cAAc;;qBAGpC;;;;;;;;;;;;;qBAcA,cAAY,MAAA"}

package/dist/dom/scroll-settle.js

@@ -0,0 +1,84 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/dom/scroll-settle.ts
+const ScrollSettled = Schema.TaggedStruct("ScrollSettled", { 
+/** The item whose start lies nearest the scroller's start, from 0. */
+index: Schema.Number });
+/** How long a scroll must be still to count as settled, where `scrollend` is missing. */
+const SETTLE_QUIET = 120;
+/**
+* Hears a scroller come to rest, as a Mount: after a swipe, a fling, a
+* trackpad or a scroll a Command made, it reports which of its items starts
+* nearest its own start (inside its `scroll-padding`), the start being the
+* right edge right to left. A snapping carousel reads it as the slide shown.
+*
+* At insert it first scrolls, at once, to item `start` (the Mount's args are
+* read only then, so this is where a redrawn or restored scroller begins),
+* and reports where it lies, since a scroller drawn already at rest sends no
+* `scrollend`. It listens for `scrollend` where the browser has it, and
+* otherwise for a scroll that is quiet for `SETTLE_QUIET` milliseconds.
+*/
+const ScrollSettle = Mount.defineStream("ScrollSettle", {
+	messages: [ScrollSettled],
+	args: {
+		/** Which children are the items; default every child. */
+		item: Schema.optional(Schema.String),
+		/** Default `inline`, the row a carousel scrolls along. */
+		axis: Schema.optional(Schema.Literals(["inline", "block"])),
+		/** The item to scroll to at insert; default the first, which needs no scroll. */
+		start: Schema.optional(Schema.Number)
+	},
+	execute: ({ element, item, axis = "inline", start = 0 }) => Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const items = () => Array.from(item === void 0 ? element.children : element.querySelectorAll(`:scope > ${item}`));
+		/** How far `child`'s start lies past the scroller's start, along the axis. */
+		const offsetOf = (child) => {
+			const style = getComputedStyle(element);
+			const box = element.getBoundingClientRect();
+			const own = child.getBoundingClientRect();
+			if (axis === "block") return own.top - box.top - (parseFloat(style.scrollPaddingBlockStart) || 0);
+			const padding = parseFloat(style.scrollPaddingInlineStart) || 0;
+			return style.direction === "rtl" ? box.right - padding - own.right : own.left - box.left - padding;
+		};
+		const report = () => {
+			let nearest = -1;
+			let distance = Infinity;
+			items().forEach((child, index) => {
+				const away = Math.abs(offsetOf(child));
+				if (away < distance) {
+					nearest = index;
+					distance = away;
+				}
+			});
+			if (nearest >= 0) Queue.offerUnsafe(queue, ScrollSettled.make({ index: nearest }));
+		};
+		const first = items()[start];
+		const before = element.scrollLeft + element.scrollTop;
+		if (start > 0 && first !== void 0) {
+			const by = offsetOf(first);
+			const rtl = axis === "inline" && getComputedStyle(element).direction === "rtl";
+			element.scrollTo(axis === "block" ? {
+				top: element.scrollTop + by,
+				behavior: "instant"
+			} : {
+				left: element.scrollLeft + (rtl ? -by : by),
+				behavior: "instant"
+			});
+		}
+		if (element.scrollLeft + element.scrollTop === before) report();
+		let quiet;
+		const hasEnd = "onscrollend" in element;
+		const listener = hasEnd ? report : () => {
+			clearTimeout(quiet);
+			quiet = setTimeout(report, 120);
+		};
+		const type = hasEnd ? "scrollend" : "scroll";
+		element.addEventListener(type, listener);
+		return () => {
+			clearTimeout(quiet);
+			element.removeEventListener(type, listener);
+		};
+	}), (detach) => Effect.sync(detach)))
+});
+export { SETTLE_QUIET, ScrollSettle, ScrollSettled };
+
+//# sourceMappingURL=scroll-settle.js.map

package/dist/dom/scroll-settle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-settle.js","names":[],"sources":["../../src/dom/scroll-settle.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const ScrollSettled = Schema.TaggedStruct('ScrollSettled', {\n  /** The item whose start lies nearest the scroller's start, from 0. */\n  index: Schema.Number,\n})\nexport type ScrollSettled = typeof ScrollSettled.Type\n\n/** How long a scroll must be still to count as settled, where `scrollend` is missing. */\nexport const SETTLE_QUIET = 120\n\n/**\n * Hears a scroller come to rest, as a Mount: after a swipe, a fling, a\n * trackpad or a scroll a Command made, it reports which of its items starts\n * nearest its own start (inside its `scroll-padding`), the start being the\n * right edge right to left. A snapping carousel reads it as the slide shown.\n *\n * At insert it first scrolls, at once, to item `start` (the Mount's args are\n * read only then, so this is where a redrawn or restored scroller begins),\n * and reports where it lies, since a scroller drawn already at rest sends no\n * `scrollend`. It listens for `scrollend` where the browser has it, and\n * otherwise for a scroll that is quiet for `SETTLE_QUIET` milliseconds.\n */\nexport const ScrollSettle = Mount.defineStream('ScrollSettle', {\n  messages: [ScrollSettled],\n  args: {\n    /** Which children are the items; default every child. */\n    item: Schema.optional(Schema.String),\n    /** Default `inline`, the row a carousel scrolls along. */\n    axis: Schema.optional(Schema.Literals(['inline', 'block'])),\n    /** The item to scroll to at insert; default the first, which needs no scroll. */\n    start: Schema.optional(Schema.Number),\n  },\n  execute: ({ element, item, axis = 'inline', start = 0 }) =>\n    Stream.callback<ScrollSettled>(queue =>\n      Effect.acquireRelease(\n        Effect.sync(() => {\n          const items = () =>\n            Array.from(\n              item === undefined ? element.children : element.querySelectorAll(`:scope > ${item}`),\n            )\n          /** How far `child`'s start lies past the scroller's start, along the axis. */\n          const offsetOf = (child: Element): number => {\n            const style = getComputedStyle(element)\n            const box = element.getBoundingClientRect()\n            const own = child.getBoundingClientRect()\n            if (axis === 'block') {\n              return own.top - box.top - (parseFloat(style.scrollPaddingBlockStart) || 0)\n            }\n            const padding = parseFloat(style.scrollPaddingInlineStart) || 0\n            return style.direction === 'rtl'\n              ? box.right - padding - own.right\n              : own.left - box.left - padding\n          }\n          const report = () => {\n            let nearest = -1\n            let distance = Infinity\n            items().forEach((child, index) => {\n              const away = Math.abs(offsetOf(child))\n              if (away < distance) {\n                nearest = index\n                distance = away\n              }\n            })\n            if (nearest >= 0) Queue.offerUnsafe(queue, ScrollSettled.make({ index: nearest }))\n          }\n          const first = items()[start]\n          const before = element.scrollLeft + element.scrollTop\n          if (start > 0 && first !== undefined) {\n            const by = offsetOf(first)\n            const rtl = axis === 'inline' && getComputedStyle(element).direction === 'rtl'\n            // A larger `scrollLeft` moves the content toward the start either way, so right to\n            // left the way to an item's start is the other sign. To a position, not by a\n            // distance: a relative scroll stops at every `scroll-snap-stop: always` on the way.\n            element.scrollTo(\n              axis === 'block'\n                ? { top: element.scrollTop + by, behavior: 'instant' }\n                : { left: element.scrollLeft + (rtl ? -by : by), behavior: 'instant' },\n            )\n          }\n          // A scroll just made reports itself when it ends; one that moved nothing never ends.\n          if (element.scrollLeft + element.scrollTop === before) report()\n          let quiet: ReturnType<typeof setTimeout> | undefined\n          const hasEnd = 'onscrollend' in element\n          const listener = hasEnd\n            ? report\n            : () => {\n                clearTimeout(quiet)\n                quiet = setTimeout(report, SETTLE_QUIET)\n              }\n          const type = hasEnd ? 'scrollend' : 'scroll'\n          element.addEventListener(type, listener)\n          return () => {\n            clearTimeout(quiet)\n            element.removeEventListener(type, listener)\n          }\n        }),\n        detach => Effect.sync(detach),\n      ),\n    ),\n})\n"],"mappings":";;;AAGA,MAAa,gBAAgB,OAAO,aAAa,iBAAiB;;AAEhE,OAAO,OAAO,OAChB,CAAC;;AAID,MAAa,eAAe;;;;;;;;;;;;;AAc5B,MAAa,eAAe,MAAM,aAAa,gBAAgB;CAC7D,UAAU,CAAC,aAAa;CACxB,MAAM;;EAEJ,MAAM,OAAO,SAAS,OAAO,MAAM;;EAEnC,MAAM,OAAO,SAAS,OAAO,SAAS,CAAC,UAAU,OAAO,CAAC,CAAC;;EAE1D,OAAO,OAAO,SAAS,OAAO,MAAM;CACtC;CACA,UAAU,EAAE,SAAS,MAAM,OAAO,UAAU,QAAQ,QAClD,OAAO,UAAwB,UAC7B,OAAO,eACL,OAAO,WAAW;EAChB,MAAM,cACJ,MAAM,KACJ,SAAS,KAAA,IAAY,QAAQ,WAAW,QAAQ,iBAAiB,YAAY,MAAM,CACrF;;EAEF,MAAM,YAAY,UAA2B;GAC3C,MAAM,QAAQ,iBAAiB,OAAO;GACtC,MAAM,MAAM,QAAQ,sBAAsB;GAC1C,MAAM,MAAM,MAAM,sBAAsB;GACxC,IAAI,SAAS,SACX,OAAO,IAAI,MAAM,IAAI,OAAO,WAAW,MAAM,uBAAuB,KAAK;GAE3E,MAAM,UAAU,WAAW,MAAM,wBAAwB,KAAK;GAC9D,OAAO,MAAM,cAAc,QACvB,IAAI,QAAQ,UAAU,IAAI,QAC1B,IAAI,OAAO,IAAI,OAAO;EAC5B;EACA,MAAM,eAAe;GACnB,IAAI,UAAU;GACd,IAAI,WAAW;GACf,MAAM,CAAC,CAAC,SAAS,OAAO,UAAU;IAChC,MAAM,OAAO,KAAK,IAAI,SAAS,KAAK,CAAC;IACrC,IAAI,OAAO,UAAU;KACnB,UAAU;KACV,WAAW;IACb;GACF,CAAC;GACD,IAAI,WAAW,GAAG,MAAM,YAAY,OAAO,cAAc,KAAK,EAAE,OAAO,QAAQ,CAAC,CAAC;EACnF;EACA,MAAM,QAAQ,MAAM,CAAC,CAAC;EACtB,MAAM,SAAS,QAAQ,aAAa,QAAQ;EAC5C,IAAI,QAAQ,KAAK,UAAU,KAAA,GAAW;GACpC,MAAM,KAAK,SAAS,KAAK;GACzB,MAAM,MAAM,SAAS,YAAY,iBAAiB,OAAO,CAAC,CAAC,cAAc;GAIzE,QAAQ,SACN,SAAS,UACL;IAAE,KAAK,QAAQ,YAAY;IAAI,UAAU;GAAU,IACnD;IAAE,MAAM,QAAQ,cAAc,MAAM,CAAC,KAAK;IAAK,UAAU;GAAU,CACzE;EACF;EAEA,IAAI,QAAQ,aAAa,QAAQ,cAAc,QAAQ,OAAO;EAC9D,IAAI;EACJ,MAAM,SAAS,iBAAiB;EAChC,MAAM,WAAW,SACb,eACM;GACJ,aAAa,KAAK;GAClB,QAAQ,WAAW,QAAA,GAAoB;EACzC;EACJ,MAAM,OAAO,SAAS,cAAc;EACpC,QAAQ,iBAAiB,MAAM,QAAQ;EACvC,aAAa;GACX,aAAa,KAAK;GAClB,QAAQ,oBAAoB,MAAM,QAAQ;EAC5C;CACF,CAAC,IACD,WAAU,OAAO,KAAK,MAAM,CAC9B,CACF;AACJ,CAAC"}

package/dist/dom/scroll.d.ts

@@ -0,0 +1,21 @@
+import { Stream } from "effect";
+/** How `keepScroll` remembers and restores each history entry's offset. */
+export interface KeepScrollOptions {
+  /** The `sessionStorage` key holding entry offsets. Default `'foldkit:scroll'`. */
+  readonly storageKey?: string | undefined;
+  /** Entries remembered at most: the oldest are forgotten first. Default 50. */
+  readonly kept?: number | undefined;
+  /**
+   * How long a restore holds its place while the next screen settles, in
+   * milliseconds. Default 2000.
+   */
+  readonly patience?: number | undefined;
+}
+/**
+ * Keeps the window's scroll across same-document navigations: a pushed entry
+ * starts at the top, and Back, Forward or a reload return where that entry
+ * was. Without a window the stream is empty instead of throwing. Lift with
+ * `Subscription.persistentEntry`; the stream sends no Messages.
+ */
+export declare const keepScroll: (options?: KeepScrollOptions) => Stream.Stream<never>;
+//# sourceMappingURL=scroll.d.ts.map

package/dist/dom/scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.d.ts","names":[],"sources":["../../src/dom/scroll.ts"],"mappings":";;iBAkCiB;;WAEN;;WAEA;;;;;WAKA;;;;;;;;qBAuHE,aAAU,UAAa,sBAAyB,OAAO"}

package/dist/dom/scroll.js

@@ -0,0 +1,141 @@
+import { Effect, Option, Stream } from "effect";
+// src/dom/scroll.ts
+/**
+* Where the window is scrolled, across an application's own navigations, as
+* a stream. Left to itself, a browser keeps the scroll of the entry it
+* leaves when a link pushes a new one, and on Back restores the old offset
+* before the application has drawn the entry it returns to, so the offset is
+* clamped to a page still loading. Here a pushed entry starts at the top,
+* and Back, Forward or a reload return where that entry was, once the page
+* is tall enough to hold it.
+*
+* Three rules, each found the slow way:
+*
+* 1. The offset is taken when the reader acts. The next screen is drawn
+*    before a Navigate Command pushes the address, so by the time the URL
+*    changes the window is already clamped to the new, shorter page. The
+*    scroll is recorded at the reader's click or key (capture phase), and at
+*    the start of Back and Forward, which begin in the browser before
+*    anything is drawn.
+* 2. A restore holds its place while the next screen settles. A restore made
+*    when the entry changes is undone by the loading state drawn right after
+*    it, so the target is held on each frame for a moment, until the reader
+*    scrolls, touches or types, or another navigation starts.
+* 3. Entries are keyed by the Navigation API's entry key, which a reload and
+*    a full navigation keep; offsets rest in `sessionStorage`, so Back into
+*    another document restores too. Where the browser has no Navigation API
+*    the stream attaches nothing and leaves the browser's own behaviour
+*    alone.
+*
+* Lift with `Subscription.persistentEntry`; the stream sends no Messages. Only
+* the window scrolls: a nested container is the route graph's to know, when
+* `Site.transition` arrives.
+*/
+const navigationTypeOf = (event) => "navigationType" in event ? Option.some(event.navigationType) : Option.none();
+const readSaved = (storageKey) => {
+	try {
+		const stored = JSON.parse(sessionStorage.getItem(storageKey) ?? "[]");
+		return new Map(Array.isArray(stored) ? stored.filter((pair) => Array.isArray(pair) && typeof pair[0] === "string" && typeof pair[1] === "number") : []);
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+};
+/** Starts keeping the scroll; the release undoes everything it installed. */
+const attach = (storageKey, kept, patience) => {
+	const navigation = window.navigation;
+	if (navigation === void 0) return () => {};
+	const restoration = window.history.scrollRestoration;
+	window.history.scrollRestoration = "manual";
+	const saved = readSaved(storageKey);
+	const detaches = [];
+	const on = (target, type, listener, capture) => {
+		target.addEventListener(type, listener, capture);
+		detaches.push(() => target.removeEventListener(type, listener, capture));
+	};
+	const keyOf = () => Option.fromNullOr(navigation.currentEntry).pipe(Option.map((entry) => entry.key));
+	/** Where the current entry was left, if it has been. */
+	const savedHere = () => Option.flatMap(keyOf(), (key) => Option.fromUndefinedOr(saved.get(key)));
+	const remember = () => {
+		const key = keyOf();
+		if (Option.isNone(key)) return;
+		saved.delete(key.value);
+		saved.set(key.value, window.scrollY);
+		for (const old of saved.keys()) {
+			if (saved.size <= kept) break;
+			saved.delete(old);
+		}
+	};
+	let settling = new AbortController();
+	/**
+	* Holds the window at `top` while the next screen settles, whenever the page
+	* can hold it, until the reader scrolls, touches or types, or another
+	* navigation starts.
+	*/
+	const settle = (top) => {
+		settling.abort();
+		settling = new AbortController();
+		const { signal } = settling;
+		for (const input of [
+			"wheel",
+			"touchstart",
+			"keydown",
+			"pointerdown"
+		]) window.addEventListener(input, () => settling.abort(), {
+			passive: true,
+			signal
+		});
+		const until = performance.now() + patience;
+		const step = () => {
+			if (signal.aborted) return;
+			if (document.documentElement.scrollHeight - window.innerHeight >= top && Math.round(window.scrollY) !== top) window.scrollTo({
+				top,
+				behavior: "instant"
+			});
+			if (performance.now() < until) requestAnimationFrame(step);
+			else settling.abort();
+		};
+		step();
+	};
+	const acted = () => remember();
+	for (const input of ["click", "keydown"]) on(window, input, acted, true);
+	const traversing = (event) => {
+		if (Option.contains(navigationTypeOf(event), "traverse")) remember();
+	};
+	on(navigation, "navigate", traversing);
+	const changed = (event) => {
+		const type = navigationTypeOf(event);
+		if (Option.contains(type, "push")) settle(0);
+		else if (Option.contains(type, "traverse")) settle(Option.getOrElse(savedHere(), () => 0));
+	};
+	on(navigation, "currententrychange", changed);
+	const hidden = () => {
+		remember();
+		try {
+			sessionStorage.setItem(storageKey, JSON.stringify([...saved]));
+		} catch {}
+	};
+	on(window, "pagehide", hidden);
+	const here = savedHere();
+	if (Option.isSome(here)) settle(here.value);
+	return () => {
+		settling.abort();
+		for (const detach of detaches) detach();
+		window.history.scrollRestoration = restoration;
+	};
+};
+/**
+* Keeps the window's scroll across same-document navigations: a pushed entry
+* starts at the top, and Back, Forward or a reload return where that entry
+* was. Without a window the stream is empty instead of throwing. Lift with
+* `Subscription.persistentEntry`; the stream sends no Messages.
+*/
+const keepScroll = (options = {}) => {
+	if (typeof window === "undefined") return Stream.empty;
+	const storageKey = options.storageKey ?? "foldkit:scroll";
+	const kept = options.kept ?? 50;
+	const patience = options.patience ?? 2e3;
+	return Stream.callback(() => Effect.acquireRelease(Effect.sync(() => attach(storageKey, kept, patience)), (detach) => Effect.sync(detach)));
+};
+export { keepScroll };
+
+//# sourceMappingURL=scroll.js.map

package/dist/dom/scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.js","names":[],"sources":["../../src/dom/scroll.ts"],"sourcesContent":["/**\n * Where the window is scrolled, across an application's own navigations, as\n * a stream. Left to itself, a browser keeps the scroll of the entry it\n * leaves when a link pushes a new one, and on Back restores the old offset\n * before the application has drawn the entry it returns to, so the offset is\n * clamped to a page still loading. Here a pushed entry starts at the top,\n * and Back, Forward or a reload return where that entry was, once the page\n * is tall enough to hold it.\n *\n * Three rules, each found the slow way:\n *\n * 1. The offset is taken when the reader acts. The next screen is drawn\n *    before a Navigate Command pushes the address, so by the time the URL\n *    changes the window is already clamped to the new, shorter page. The\n *    scroll is recorded at the reader's click or key (capture phase), and at\n *    the start of Back and Forward, which begin in the browser before\n *    anything is drawn.\n * 2. A restore holds its place while the next screen settles. A restore made\n *    when the entry changes is undone by the loading state drawn right after\n *    it, so the target is held on each frame for a moment, until the reader\n *    scrolls, touches or types, or another navigation starts.\n * 3. Entries are keyed by the Navigation API's entry key, which a reload and\n *    a full navigation keep; offsets rest in `sessionStorage`, so Back into\n *    another document restores too. Where the browser has no Navigation API\n *    the stream attaches nothing and leaves the browser's own behaviour\n *    alone.\n *\n * Lift with `Subscription.persistentEntry`; the stream sends no Messages. Only\n * the window scrolls: a nested container is the route graph's to know, when\n * `Site.transition` arrives.\n */\nimport { Effect, Option, Stream } from 'effect'\n\n/** How `keepScroll` remembers and restores each history entry's offset. */\nexport interface KeepScrollOptions {\n  /** The `sessionStorage` key holding entry offsets. Default `'foldkit:scroll'`. */\n  readonly storageKey?: string | undefined\n  /** Entries remembered at most: the oldest are forgotten first. Default 50. */\n  readonly kept?: number | undefined\n  /**\n   * How long a restore holds its place while the next screen settles, in\n   * milliseconds. Default 2000.\n   */\n  readonly patience?: number | undefined\n}\n\nconst navigationTypeOf = (event: Event): Option.Option<unknown> =>\n  'navigationType' in event ? Option.some(event.navigationType) : Option.none()\n\nconst readSaved = (storageKey: string): Map<string, number> => {\n  try {\n    const stored: unknown = JSON.parse(sessionStorage.getItem(storageKey) ?? '[]')\n    return new Map(\n      Array.isArray(stored)\n        ? stored.filter(\n            (pair): pair is [string, number] =>\n              Array.isArray(pair) && typeof pair[0] === 'string' && typeof pair[1] === 'number',\n          )\n        : [],\n    )\n  } catch {\n    // Storage blocked, or something else wrote the key: nothing is remembered.\n    return new Map()\n  }\n}\n\n/** Starts keeping the scroll; the release undoes everything it installed. */\nconst attach = (storageKey: string, kept: number, patience: number): (() => void) => {\n  // TypeScript's DOM library declares it on every window; a browser without\n  // the Navigation API has none.\n  const navigation: Navigation | undefined = window.navigation\n  if (navigation === undefined) return () => {}\n  const restoration = window.history.scrollRestoration\n  window.history.scrollRestoration = 'manual'\n  const saved = readSaved(storageKey)\n  const detaches: Array<() => void> = []\n  const on = (target: EventTarget, type: string, listener: EventListener, capture?: boolean) => {\n    target.addEventListener(type, listener, capture)\n    detaches.push(() => target.removeEventListener(type, listener, capture))\n  }\n  const keyOf = () =>\n    Option.fromNullOr(navigation.currentEntry).pipe(Option.map(entry => entry.key))\n  /** Where the current entry was left, if it has been. */\n  const savedHere = () => Option.flatMap(keyOf(), key => Option.fromUndefinedOr(saved.get(key)))\n  const remember = () => {\n    const key = keyOf()\n    if (Option.isNone(key)) return\n    // Moved to the end, so it is the last to be forgotten.\n    saved.delete(key.value)\n    saved.set(key.value, window.scrollY)\n    for (const old of saved.keys()) {\n      if (saved.size <= kept) break\n      saved.delete(old)\n    }\n  }\n\n  let settling = new AbortController()\n  /**\n   * Holds the window at `top` while the next screen settles, whenever the page\n   * can hold it, until the reader scrolls, touches or types, or another\n   * navigation starts.\n   */\n  const settle = (top: number) => {\n    settling.abort()\n    settling = new AbortController()\n    const { signal } = settling\n    for (const input of ['wheel', 'touchstart', 'keydown', 'pointerdown'])\n      window.addEventListener(input, () => settling.abort(), { passive: true, signal })\n    const until = performance.now() + patience\n    const step = () => {\n      if (signal.aborted) return\n      const room = document.documentElement.scrollHeight - window.innerHeight\n      if (room >= top && Math.round(window.scrollY) !== top)\n        window.scrollTo({ top, behavior: 'instant' })\n      if (performance.now() < until) requestAnimationFrame(step)\n      else settling.abort()\n    }\n    step()\n  }\n\n  // Remembered where the reader acts, before the application does: by the time\n  // it pushes an address it has drawn the next screen, and the window is\n  // already clamped to it. Back and Forward start in the browser, before\n  // anything is drawn, so they are remembered as they begin.\n  const acted = () => remember()\n  for (const input of ['click', 'keydown']) on(window, input, acted, true)\n  const traversing = (event: Event) => {\n    if (Option.contains(navigationTypeOf(event), 'traverse')) remember()\n  }\n  on(navigation, 'navigate', traversing)\n  const changed = (event: Event) => {\n    const type = navigationTypeOf(event)\n    if (Option.contains(type, 'push')) settle(0)\n    else if (Option.contains(type, 'traverse')) settle(Option.getOrElse(savedHere(), () => 0))\n    // A replace is the same entry, narrowed or selected in place: it stays where it is.\n  }\n  on(navigation, 'currententrychange', changed)\n  const hidden = () => {\n    remember()\n    try {\n      sessionStorage.setItem(storageKey, JSON.stringify([...saved]))\n    } catch {\n      // Storage blocked: the next document starts at the top.\n    }\n  }\n  on(window, 'pagehide', hidden)\n  // A reload, or Back into this document from another: where this entry was.\n  const here = savedHere()\n  if (Option.isSome(here)) settle(here.value)\n  return () => {\n    settling.abort()\n    for (const detach of detaches) detach()\n    window.history.scrollRestoration = restoration\n  }\n}\n\n/**\n * Keeps the window's scroll across same-document navigations: a pushed entry\n * starts at the top, and Back, Forward or a reload return where that entry\n * was. Without a window the stream is empty instead of throwing. Lift with\n * `Subscription.persistentEntry`; the stream sends no Messages.\n */\nexport const keepScroll = (options: KeepScrollOptions = {}): Stream.Stream<never> => {\n  if (typeof window === 'undefined') return Stream.empty\n  const storageKey = options.storageKey ?? 'foldkit:scroll'\n  const kept = options.kept ?? 50\n  const patience = options.patience ?? 2000\n  return Stream.callback<never>(() =>\n    Effect.acquireRelease(\n      Effect.sync(() => attach(storageKey, kept, patience)),\n      detach => Effect.sync(detach),\n    ),\n  )\n}\n"],"mappings":"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"}

package/dist/dom/share.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+import { Command } from "foldkit/command";
+export declare const ShareData: Schema.Struct<{
+  readonly title: Schema.optional<Schema.String>;
+  readonly text: Schema.optional<Schema.String>;
+  readonly url: Schema.optional<Schema.String>;
+}>;
+export type ShareData = typeof ShareData.Type;
+export declare const ShareMessage: import("foldkit/message").MessageUnion<{
+  readonly Shared: {};
+  readonly Dismissed: {};
+  readonly ShareFailed: {
+    message: Schema.String;
+  };
+}>;
+export type ShareMessage = typeof ShareMessage.Type;
+/** Shares data through the platform sheet. */
+export declare const share: (data: ShareData) => Command<ShareMessage, never, never>;
+//# sourceMappingURL=share.d.ts.map

package/dist/dom/share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share.d.ts","names":[],"sources":["../../src/dom/share.ts"],"mappings":";;qBAWa,WAAS,OAAA;;;;;YAKV,mBAAmB,UAAU;qBAE5B,wCAAY;;;;IAGR,SAAO,OAAA;;;YAEZ,sBAAsB,aAAa;;qBAUlC,QAAK,MAAU,cAAY,QAAQ"}

package/dist/dom/share.js

@@ -0,0 +1,41 @@
+import { Effect, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/dom/share.ts
+/**
+* Web Share as a Command: runs in `update` beside any bundle, yields
+* `Shared` on success. Dismissal is its own outcome, not a failure — the
+* application tells a cancelled sheet apart from a broken one. Without a
+* share API (desktop, insecure context) it yields `ShareFailed` instead of
+* throwing, so `update` handles every outcome as a Message.
+*/
+const ShareData = Schema.Struct({
+	title: Schema.optional(Schema.String),
+	text: Schema.optional(Schema.String),
+	url: Schema.optional(Schema.String)
+});
+const ShareMessage = defineMessageUnion({
+	Shared: {},
+	Dismissed: {},
+	ShareFailed: { message: Schema.String }
+});
+const failMessage = (error) => error instanceof Error ? error.message : String(error);
+const isDismissal = (error) => typeof error?.name === "string" && error.name === "AbortError";
+/** Shares data through the platform sheet. */
+const share = (data) => ({
+	name: "Share.share",
+	args: { data },
+	effect: typeof navigator !== "undefined" && typeof navigator.share === "function" ? Effect.matchEffect(Effect.tryPromise({
+		try: () => navigator.share({
+			...data.title !== void 0 ? { title: data.title } : {},
+			...data.text !== void 0 ? { text: data.text } : {},
+			...data.url !== void 0 ? { url: data.url } : {}
+		}),
+		catch: (error) => error
+	}), {
+		onFailure: (error) => Effect.succeed(isDismissal(error) ? ShareMessage.Dismissed() : ShareMessage.ShareFailed({ message: failMessage(error) })),
+		onSuccess: () => Effect.succeed(ShareMessage.Shared())
+	}) : Effect.succeed(ShareMessage.ShareFailed({ message: "share is unavailable" }))
+});
+export { ShareData, ShareMessage, share };
+
+//# sourceMappingURL=share.js.map

package/dist/dom/share.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"share.js","names":[],"sources":["../../src/dom/share.ts"],"sourcesContent":["/**\n * Web Share as a Command: runs in `update` beside any bundle, yields\n * `Shared` on success. Dismissal is its own outcome, not a failure — the\n * application tells a cancelled sheet apart from a broken one. Without a\n * share API (desktop, insecure context) it yields `ShareFailed` instead of\n * throwing, so `update` handles every outcome as a Message.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ShareData = Schema.Struct({\n  title: Schema.optional(Schema.String),\n  text: Schema.optional(Schema.String),\n  url: Schema.optional(Schema.String),\n})\nexport type ShareData = typeof ShareData.Type\n\nexport const ShareMessage = defineMessageUnion({\n  Shared: {},\n  Dismissed: {},\n  ShareFailed: { message: Schema.String },\n})\nexport type ShareMessage = typeof ShareMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst isDismissal = (error: unknown): boolean =>\n  typeof (error as { readonly name?: unknown } | null)?.name === 'string' &&\n  (error as { readonly name: string }).name === 'AbortError'\n\n/** Shares data through the platform sheet. */\nexport const share = (data: ShareData): Command<ShareMessage, never, never> => ({\n  name: 'Share.share',\n  args: { data },\n  effect:\n    typeof navigator !== 'undefined' && typeof navigator.share === 'function'\n      ? Effect.matchEffect(\n          Effect.tryPromise({\n            // Omit absent fields: the platform type rejects explicit\n            // undefined under exactOptionalPropertyTypes.\n            try: () =>\n              navigator.share({\n                ...(data.title !== undefined ? { title: data.title } : {}),\n                ...(data.text !== undefined ? { text: data.text } : {}),\n                ...(data.url !== undefined ? { url: data.url } : {}),\n              }),\n            catch: (error: unknown) => error,\n          }),\n          {\n            onFailure: error =>\n              Effect.succeed(\n                isDismissal(error)\n                  ? ShareMessage.Dismissed()\n                  : ShareMessage.ShareFailed({ message: failMessage(error) }),\n              ),\n            onSuccess: () => Effect.succeed(ShareMessage.Shared()),\n          },\n        )\n      : Effect.succeed(ShareMessage.ShareFailed({ message: 'share is unavailable' })),\n})\n"],"mappings":";;;;;;;;;;AAWA,MAAa,YAAY,OAAO,OAAO;CACrC,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,MAAM,OAAO,SAAS,OAAO,MAAM;CACnC,KAAK,OAAO,SAAS,OAAO,MAAM;AACpC,CAAC;AAGD,MAAa,eAAe,mBAAmB;CAC7C,QAAQ,CAAC;CACT,WAAW,CAAC;CACZ,aAAa,EAAE,SAAS,OAAO,OAAO;AACxC,CAAC;AAGD,MAAM,eAAe,UACnB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAEvD,MAAM,eAAe,UACnB,OAAQ,OAA8C,SAAS,YAC9D,MAAoC,SAAS;;AAGhD,MAAa,SAAS,UAA0D;CAC9E,MAAM;CACN,MAAM,EAAE,KAAK;CACb,QACE,OAAO,cAAc,eAAe,OAAO,UAAU,UAAU,aAC3D,OAAO,YACL,OAAO,WAAW;EAGhB,WACE,UAAU,MAAM;GACd,GAAI,KAAK,UAAU,KAAA,IAAY,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;GACxD,GAAI,KAAK,SAAS,KAAA,IAAY,EAAE,MAAM,KAAK,KAAK,IAAI,CAAC;GACrD,GAAI,KAAK,QAAQ,KAAA,IAAY,EAAE,KAAK,KAAK,IAAI,IAAI,CAAC;EACpD,CAAC;EACH,QAAQ,UAAmB;CAC7B,CAAC,GACD;EACE,YAAW,UACT,OAAO,QACL,YAAY,KAAK,IACb,aAAa,UAAU,IACvB,aAAa,YAAY,EAAE,SAAS,YAAY,KAAK,EAAE,CAAC,CAC9D;EACF,iBAAiB,OAAO,QAAQ,aAAa,OAAO,CAAC;CACvD,CACF,IACA,OAAO,QAAQ,aAAa,YAAY,EAAE,SAAS,uBAAuB,CAAC,CAAC;AACpF"}

package/dist/dom/swipe.d.ts

@@ -0,0 +1,121 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const SwipeStarted: Schema.TaggedStruct<"SwipeStarted", {
+  readonly pointerId: Schema.Number;
+  readonly pointerType: Schema.String;
+  /** The border box of what `measure` names (the element itself by default), as the swipe starts. */
+  readonly width: Schema.Number;
+  readonly height: Schema.Number;
+}>;
+export type SwipeStarted = typeof SwipeStarted.Type;
+export declare const Swiped: Schema.TaggedStruct<"Swiped", {
+  readonly pointerId: Schema.Number;
+  /** From where the pointer went down, in CSS pixels. */
+  readonly deltaX: Schema.Number;
+  readonly deltaY: Schema.Number;
+}>;
+export type Swiped = typeof Swiped.Type;
+export declare const SwipeEnded: Schema.TaggedStruct<"SwipeEnded", {
+  readonly pointerId: Schema.Number;
+  /** From where the pointer went down to where it came up, in CSS pixels. */
+  readonly deltaX: Schema.Number;
+  readonly deltaY: Schema.Number;
+  /**
+   * How fast the pointer was moving as it came up, in pixels a millisecond,
+   * over the last `SWIPE_WINDOW` milliseconds: 0 when it rested there first.
+   */
+  readonly velocityX: Schema.Number;
+  readonly velocityY: Schema.Number;
+  /** `false` when the pointer was cancelled or capture was lost. */
+  readonly completed: Schema.Boolean;
+}>;
+export type SwipeEnded = typeof SwipeEnded.Type;
+export type SwipeFact = SwipeStarted | Swiped | SwipeEnded;
+/** How far back, in milliseconds, the release velocity looks. */
+export declare const SWIPE_WINDOW = 100;
+/**
+ * What a swipe never starts on when its element `scrolls`: a field whose own
+ * drag selects text or moves a thumb, and anything marked `data-no-swipe`.
+ */
+export declare const NO_SWIPE = "input, textarea, select, [contenteditable=\"\"], [contenteditable=\"true\"], [data-no-swipe]";
+interface Sample {
+  readonly at: number;
+  readonly x: number;
+  readonly y: number;
+}
+/**
+ * The velocity of the samples within `SWIPE_WINDOW` of the last: the way
+ * from the oldest of them to the last over the time between. A pointer that
+ * came to rest before the last sample has no recent way to measure, so 0.
+ */
+export declare const velocityOf: (samples: ReadonlyArray<Sample>) => {
+  x: number;
+  y: number;
+};
+/**
+ * Whether anything from `target` up to `root` can still scroll along `axis`
+ * the way a finger moving `along` (positive is down or right) pulls it: a
+ * finger going down scrolls content toward its start.
+ */
+export declare const canScroll: (target: Element, root: Element, axis: 'x' | 'y', along: number) => boolean;
+/**
+ * `Move` with the speed of its release, for a gesture that a flick ends
+ * (a sheet dragged to dismiss, a card swiped away): a primary-button pointer
+ * down (or, given a `slop`, its first move past it) captures the pointer,
+ * each move reports the delta from where it was pressed, and up reports the
+ * last delta with the velocity over the last `SWIPE_WINDOW` milliseconds, by
+ * the events' own time stamps. Cancel or lost capture ends it incomplete.
+ * The start reports the size of what is moved, so a distance can be read as
+ * a share of it. What a delta or a speed means is the parent's `update`.
+ * Capture is released with the Mount.
+ *
+ * Given `scrolls`, the element holds content that scrolls (a sheet's panel),
+ * and a touch is followed by touch events, whose move can still refuse the
+ * browser's scroll once the touch is under way, where a pointer's cannot:
+ * past the slop, a touch that runs along the axis and finds nothing under it
+ * that can scroll further its way swipes, and the browser scrolls any other.
+ * A touch inside an element with a Swipe of its own (a handle in the panel)
+ * is that one's, and none starts on a field or on `data-no-swipe`
+ * (`NO_SWIPE`).
+ */
+export declare const Swipe: Mount.MountDefinitionWithArgs<"Swipe", {
+  /**
+   * The nearest ancestor matching this selector is measured as the swipe
+   * starts, for what the swipe moves (a sheet's panel, dragged by its
+   * handle). Default: the element itself.
+   */
+  measure: Schema.optional<Schema.String>;
+  /**
+   * How far, in pixels, a press must move before it is a swipe. Until
+   * then nothing is captured or reported, so a press that stays put is
+   * still a click on whatever is under it (a tab inside a drag grip).
+   * Default 0: the press itself starts the swipe; with `scrolls`, the
+   * first move decides.
+   */
+  slop: Schema.optional<Schema.Number>;
+  /** The axis the element's content scrolls along, which a touch yields to; see above. */
+  scrolls: Schema.optional<Schema.Literals<readonly ["x", "y"]>>;
+  /** Follows touches alone: a mouse or a pen is left to the page (and to a handle's own Swipe). */
+  touchOnly: Schema.optional<Schema.Boolean>;
+}, {
+  readonly _tag: "SwipeStarted";
+  readonly pointerId: number;
+  readonly pointerType: string;
+  readonly width: number;
+  readonly height: number;
+} | {
+  readonly _tag: "Swiped";
+  readonly pointerId: number;
+  readonly deltaX: number;
+  readonly deltaY: number;
+} | {
+  readonly _tag: "SwipeEnded";
+  readonly pointerId: number;
+  readonly deltaX: number;
+  readonly deltaY: number;
+  readonly velocityX: number;
+  readonly velocityY: number;
+  readonly completed: boolean;
+}>;
+export {};
+//# sourceMappingURL=swipe.d.ts.map

package/dist/dom/swipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipe.d.ts","names":[],"sources":["../../src/dom/swipe.ts"],"mappings":";;qBAGa,cAAY,OAAA;;;;;;;YAOb,sBAAsB,aAAa;qBAElC,QAAM,OAAA;;;;;;YAMP,gBAAgB,OAAO;qBAEtB,YAAU,OAAA;;;;;;;;;;;;;;YAcX,oBAAoB,WAAW;YAE/B,YAAY,eAAe,SAAS;;qBAGnC;;;;;qBAMA;UAgBH;WACC;WACA;WACA;;;;;;;qBAmBE,aAAU,SAAa,cAAc;EAAY;EAAW;;;;;;;qBAe5D,YAAS,QACZ,SAAO,MACT,SAAO,iBACE;;;;;;;;;;;;;;;;;;;;;qBAoCJ,OAAK,MAAA"}