@kestack/web-platform 0.0.0-stage → 0.0.0

package/dist/input/gesture/zones/zone/index.d.ts

@@ -0,0 +1,3 @@
+import { Pointer, Pointers } from "./motion-pointers.js";
+import { Direction, Directions, GestureEnd, GestureOptions, GestureProvider, GestureState, GestureZone, GestureZoneProps, useGesture } from "./zone.js";
+export { type Direction, type Directions, type GestureEnd, type GestureOptions, GestureProvider, type GestureState, GestureZone, type GestureZoneProps, type Pointer, type Pointers, useGesture };

package/dist/input/gesture/zones/zone/index.js

@@ -0,0 +1,2 @@
+import { GestureProvider, GestureZone, useGesture } from "./zone.js";
+export { GestureProvider, GestureZone, useGesture };

package/dist/input/gesture/zones/zone/motion-pointers.d.ts

@@ -0,0 +1,33 @@
+import { Target } from "../touch-input/touch-input.js";
+import "../touch-input/index.js";
+import { MotionValue } from "motion/react";
+import { Pointer as Pointer$1, Pointers as Pointers$1 } from "@kestack/use-gesture";
+//#region src/input/gesture/zones/zone/motion-pointers.d.ts
+type Sample = Pointer$1<Target>['start'];
+/**
+ * One finger of a Gesture, from landing until the Gesture ends. `target` is
+ * the element it landed on. `x` and `y` are where it is now, in viewport px;
+ * `dx` and `dy` how far it is from where it landed. They follow it while it
+ * is down and keep where it lifted after. `end` is set once it lifts.
+ */
+export type Pointer = {
+  readonly id: number;
+  readonly target: Target;
+  readonly start: Sample;
+  readonly x: MotionValue<number>;
+  readonly y: MotionValue<number>;
+  readonly dx: MotionValue<number>;
+  readonly dy: MotionValue<number>;
+  readonly end?: Sample;
+};
+/** Every finger of a Gesture, by id, in the order they landed. */
+export type Pointers = ReadonlyMap<number, Pointer>;
+/**
+ * The core's Pointers as motion values, for one Gesture Provider: each
+ * finger keeps its own motion values for its Gesture, set as the core's
+ * Pointer changes, so movement never re-renders React. The map changes only
+ * as a finger lands or lifts, as the core's does on those.
+ */
+export declare const createMotionPointers: () => (next: Pointers$1<Target>) => Pointers;
+//#endregion
+//# sourceMappingURL=motion-pointers.d.ts.map

package/dist/input/gesture/zones/zone/motion-pointers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-pointers.d.ts","names":["CorePointer","CorePointers"],"sources":["../../../../../src/input/gesture/zones/zone/motion-pointers.ts"],"mappings":";;;;;KAOK,SAASA,UAAY;;;;;;;YAQd;WACD;WACA,QAAQ;WACR,OAAO;WACP,GAAG;WACH,GAAG;WACH,IAAI;WACJ,IAAI;WACJ,MAAM;;;YAIL,WAAW,oBAAoB;;;;;;;qBAQ9B,6BAAoB,MAIjBC,WAAa,YAAU"}

package/dist/input/gesture/zones/zone/motion-pointers.js

@@ -0,0 +1,52 @@
+import { motionValue } from "motion/react";
+//#region src/input/gesture/zones/zone/motion-pointers.ts
+/**
+* The core's Pointers as motion values, for one Gesture Provider: each
+* finger keeps its own motion values for its Gesture, set as the core's
+* Pointer changes, so movement never re-renders React. The map changes only
+* as a finger lands or lifts, as the core's does on those.
+*/
+const createMotionPointers = () => {
+	let source;
+	let mirrored = /* @__PURE__ */ new Map();
+	return (next) => {
+		if (next === source) return mirrored;
+		source = next;
+		let changed = next.size !== mirrored.size;
+		const pointers = /* @__PURE__ */ new Map();
+		for (const [id, pointer] of next) {
+			let own = mirrored.get(id);
+			if (own === void 0 || own.start !== pointer.start) {
+				own = {
+					id,
+					target: pointer.target,
+					start: pointer.start,
+					x: motionValue(pointer.x),
+					y: motionValue(pointer.y),
+					dx: motionValue(pointer.dx),
+					dy: motionValue(pointer.dy)
+				};
+				changed = true;
+			} else {
+				own.x.set(pointer.x);
+				own.y.set(pointer.y);
+				own.dx.set(pointer.dx);
+				own.dy.set(pointer.dy);
+			}
+			if (pointer.end !== void 0 && own.end === void 0) {
+				own = {
+					...own,
+					end: pointer.end
+				};
+				changed = true;
+			}
+			pointers.set(id, own);
+		}
+		if (changed) mirrored = pointers;
+		return mirrored;
+	};
+};
+//#endregion
+export { createMotionPointers };
+
+//# sourceMappingURL=motion-pointers.js.map

package/dist/input/gesture/zones/zone/motion-pointers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-pointers.js","names":[],"sources":["../../../../../src/input/gesture/zones/zone/motion-pointers.ts"],"sourcesContent":["import { type MotionValue, motionValue } from 'motion/react';\nimport type {\n  Pointer as CorePointer,\n  Pointers as CorePointers,\n} from '@kestack/use-gesture';\nimport type { Target } from '../touch-input/index.ts';\n\ntype Sample = CorePointer<Target>['start'];\n\n/**\n * One finger of a Gesture, from landing until the Gesture ends. `target` is\n * the element it landed on. `x` and `y` are where it is now, in viewport px;\n * `dx` and `dy` how far it is from where it landed. They follow it while it\n * is down and keep where it lifted after. `end` is set once it lifts.\n */\nexport type Pointer = {\n  readonly id: number;\n  readonly target: Target;\n  readonly start: Sample;\n  readonly x: MotionValue<number>;\n  readonly y: MotionValue<number>;\n  readonly dx: MotionValue<number>;\n  readonly dy: MotionValue<number>;\n  readonly end?: Sample;\n};\n\n/** Every finger of a Gesture, by id, in the order they landed. */\nexport type Pointers = ReadonlyMap<number, Pointer>;\n\n/**\n * The core's Pointers as motion values, for one Gesture Provider: each\n * finger keeps its own motion values for its Gesture, set as the core's\n * Pointer changes, so movement never re-renders React. The map changes only\n * as a finger lands or lifts, as the core's does on those.\n */\nexport const createMotionPointers = () => {\n  let source: CorePointers<Target> | undefined;\n  let mirrored: Pointers = new Map();\n\n  return (next: CorePointers<Target>): Pointers => {\n    if (next === source) return mirrored;\n    source = next;\n    let changed = next.size !== mirrored.size;\n    const pointers = new Map<number, Pointer>();\n    for (const [id, pointer] of next) {\n      let own = mirrored.get(id);\n      // The same finger keeps its `start` for the whole Gesture.\n      if (own === undefined || own.start !== pointer.start) {\n        own = {\n          id,\n          target: pointer.target,\n          start: pointer.start,\n          x: motionValue(pointer.x),\n          y: motionValue(pointer.y),\n          dx: motionValue(pointer.dx),\n          dy: motionValue(pointer.dy),\n        };\n        changed = true;\n      } else {\n        own.x.set(pointer.x);\n        own.y.set(pointer.y);\n        own.dx.set(pointer.dx);\n        own.dy.set(pointer.dy);\n      }\n      if (pointer.end !== undefined && own.end === undefined) {\n        own = { ...own, end: pointer.end };\n        changed = true;\n      }\n      pointers.set(id, own);\n    }\n    if (changed) mirrored = pointers;\n    return mirrored;\n  };\n};\n"],"mappings":";;;;;;;;AAmCA,MAAa,6BAA6B;CACxC,IAAI;CACJ,IAAI,2BAAqB,IAAI,IAAI;CAEjC,QAAQ,SAAyC;EAC/C,IAAI,SAAS,QAAQ,OAAO;EAC5B,SAAS;EACT,IAAI,UAAU,KAAK,SAAS,SAAS;EACrC,MAAM,2BAAW,IAAI,IAAqB;EAC1C,KAAK,MAAM,CAAC,IAAI,YAAY,MAAM;GAChC,IAAI,MAAM,SAAS,IAAI,EAAE;GAEzB,IAAI,QAAQ,KAAA,KAAa,IAAI,UAAU,QAAQ,OAAO;IACpD,MAAM;KACJ;KACA,QAAQ,QAAQ;KAChB,OAAO,QAAQ;KACf,GAAG,YAAY,QAAQ,CAAC;KACxB,GAAG,YAAY,QAAQ,CAAC;KACxB,IAAI,YAAY,QAAQ,EAAE;KAC1B,IAAI,YAAY,QAAQ,EAAE;IAC5B;IACA,UAAU;GACZ,OAAO;IACL,IAAI,EAAE,IAAI,QAAQ,CAAC;IACnB,IAAI,EAAE,IAAI,QAAQ,CAAC;IACnB,IAAI,GAAG,IAAI,QAAQ,EAAE;IACrB,IAAI,GAAG,IAAI,QAAQ,EAAE;GACvB;GACA,IAAI,QAAQ,QAAQ,KAAA,KAAa,IAAI,QAAQ,KAAA,GAAW;IACtD,MAAM;KAAE,GAAG;KAAK,KAAK,QAAQ;IAAI;IACjC,UAAU;GACZ;GACA,SAAS,IAAI,IAAI,GAAG;EACtB;EACA,IAAI,SAAS,WAAW;EACxB,OAAO;CACT;AACF"}

package/dist/input/gesture/zones/zone/zone.d.ts

@@ -0,0 +1,93 @@
+import { Pointer, Pointers } from "./motion-pointers.js";
+import { ComponentProps, ReactNode } from "react";
+import { MotionValue } from "motion/react";
+import { Direction, Direction as Direction$1, Directions, Directions as Directions$1, GestureEnd, GestureEnd as GestureEnd$1 } from "@kestack/use-gesture";
+//#region src/input/gesture/zones/zone/zone.d.ts
+/**
+ * Tracks every Gesture in the Gesture Zones inside it: the one place its
+ * fingers are followed. Put one at the app's root; separate sections may
+ * each have their own, and each then runs its own Gesture. One inside
+ * another does nothing: its zones join the outer one, so nested screens
+ * share one Gesture.
+ */
+export declare function GestureProvider(props: {
+  readonly children?: ReactNode;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+export type GestureZoneProps = ComponentProps<'div'> & {
+  /**
+   * Whether Gestures that start in it stay in it, rather than also reaching
+   * the zones around it. It never keeps a touch from the browser. False by
+   * default. Read as a Gesture starts.
+   */
+  readonly trapped?: boolean;
+};
+/**
+ * An area where the app can own touch, read with `useGesture` by any
+ * component inside it, shown or hidden. A Gesture starting in it is heard
+ * here and by each zone around it up to the first trapped one; sibling
+ * zones never hear each other. At the first movement one of them takes it,
+ * if a listener wants it; otherwise the browser scrolls. Zones nest, and
+ * must be inside a GestureProvider.
+ */
+export declare function GestureZone({ ref, style, children, trapped, ...props }: GestureZoneProps): import("react").JSX.Element;
+export type GestureOptions = {
+  /** Whether it takes the next Gesture: true by default. Read as its first finger lands. */
+  readonly enabled?: boolean;
+  /** The first finger landed. */
+  readonly onStart?: (pointers: Pointers) => void;
+  /** A finger landed or lifted; `pointer` is that finger. */
+  readonly onPointer?: (pointer: Pointer, pointers: Pointers) => void;
+  /**
+   * The last finger lifted: every finger of the Gesture, lifted ones
+   * included. Also when the browser or another zone took it, `interrupted`.
+   */
+  readonly onEnd?: (pointers: Pointers, end: GestureEnd$1) => void;
+  /**
+   * The Directions it takes touches in: `['left', 'right']`, or `'all'`. An
+   * element under the finger that can still scroll that way keeps it
+   * instead. Read at the touch's first movement. Without `directions` or
+   * `captures` it only watches, and never keeps a touch from the browser,
+   * apart from the edge it `guardsEdge`.
+   */
+  readonly directions?: Directions$1;
+  /** The Gesture first moved in `direction`: read once, for every listener. */
+  readonly onDirection?: (direction: Direction$1) => void;
+  /**
+   * Whether it captures a touch whose first finger landed at `point`, in
+   * viewport px, whichever way it moves, even over an element that could
+   * scroll it. Read at the touch's first movement; taps are never affected.
+   */
+  readonly captures?: (point: {
+    readonly x: number;
+    readonly y: number;
+  }) => boolean;
+  /**
+   * A side edge it keeps from the browser's edge swipe (back and forward on
+   * iOS) while it is enabled, even when it would not take a touch there. It
+   * neither captures nor wants anything, so it never changes who takes a
+   * Gesture. Read as a touch lands.
+   */
+  readonly guardsEdge?: 'left' | 'right';
+};
+export type GestureState = {
+  /**
+   * Every finger of the Gesture under way, by id, lifted ones included;
+   * empty between Gestures. It changes as a finger lands or lifts; each
+   * finger's own motion values follow it as it moves.
+   */
+  readonly pointers: MotionValue<Pointers>;
+  /** True from the first finger landing until the last one lifts. */
+  readonly active: boolean;
+};
+/**
+ * Reads every Gesture its nearest Gesture Zone hears: each that starts in
+ * it, or in a zone inside it that is not trapped, until another zone takes
+ * it, unless it only watches. It reports each finger
+ * that lands between the first landing and the last lifting, with where,
+ * when and on what it landed and motion values that follow it. It never
+ * classifies anything; what a Gesture means is up to the caller.
+ */
+export declare function useGesture(options?: GestureOptions): GestureState;
+//#endregion
+export type { Direction, Directions, GestureEnd, Pointer, Pointers };
+//# sourceMappingURL=zone.d.ts.map

package/dist/input/gesture/zones/zone/zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone.d.ts","names":["GestureEnd","Directions","Direction"],"sources":["../../../../../src/input/gesture/zones/zone/zone.tsx"],"mappings":";;;;;;;;;;;;wBAkEgB,gBAAgB;WAAkB,WAAW;yDAAW,IAAA,UAAA,SAAA,aAAA,6CAAA,SAAA,6BAAA,+CAAA,8CAAA;YAgC5D,mBAAmB;;;;;;WAMpB;;;;;;;;;;wBAmBK,cACd,KACA,OACA,UACA,YACG,SACF,mCAAgB,IAAA;YA6DP;;WAED;;WAEA,WAAW,UAAU;;WAErB,aAAa,SAAS,SAAS,UAAU;;;;;WAKzC,SAAS,UAAU,UAAU,KAAKA;;;;;;;;WAQlC,aAAaC;;WAEb,eAAe,WAAWC;;;;;;WAM1B,YAAY;aACV;aACA;;;;;;;;WAQF;;YAGC;;;;;;WAMD,UAAU,YAAY;;WAEtB;;;;;;;;;;wBAWK,WAAW,UAAS,iBAAsB"}

package/dist/input/gesture/zones/zone/zone.js

@@ -0,0 +1,169 @@
+import { DOM_ZONES, createTouchInput } from "../touch-input/touch-input.js";
+import { createMotionPointers } from "./motion-pointers.js";
+import { createContext, useCallback, useContext, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useMotionValue } from "motion/react";
+import { createGestureProvider } from "@kestack/use-gesture";
+//#region src/input/gesture/zones/zone/zone.tsx
+const ProviderContext = createContext(void 0);
+const ZoneContext = createContext(void 0);
+const assignRef = (ref, value) => {
+	if (typeof ref === "function") ref(value);
+	else if (ref !== null && ref !== void 0) ref.current = value;
+};
+/**
+* Tracks every Gesture in the Gesture Zones inside it: the one place its
+* fingers are followed. Put one at the app's root; separate sections may
+* each have their own, and each then runs its own Gesture. One inside
+* another does nothing: its zones join the outer one, so nested screens
+* share one Gesture.
+*/
+function GestureProvider(props) {
+	return useContext(ProviderContext) === void 0 ? /* @__PURE__ */ jsx(Provider, { children: props.children }) : props.children;
+}
+function Provider(props) {
+	const [provided] = useState(() => {
+		const tracker = createGestureProvider(DOM_ZONES);
+		const input = typeof window === "undefined" ? void 0 : createTouchInput(window, tracker.sink);
+		return {
+			tracker,
+			motion: createMotionPointers(),
+			input,
+			bindZone: (element) => input?.bindZone(element) ?? (() => {})
+		};
+	});
+	useEffect(() => {
+		provided.input?.start();
+		return () => provided.input?.stop();
+	}, [provided]);
+	return /* @__PURE__ */ jsx(ProviderContext, {
+		value: provided,
+		children: props.children
+	});
+}
+const ZONE_STYLE = {
+	userSelect: "none",
+	WebkitUserSelect: "none",
+	WebkitTouchCallout: "none"
+};
+/**
+* An area where the app can own touch, read with `useGesture` by any
+* component inside it, shown or hidden. A Gesture starting in it is heard
+* here and by each zone around it up to the first trapped one; sibling
+* zones never hear each other. At the first movement one of them takes it,
+* if a listener wants it; otherwise the browser scrolls. Zones nest, and
+* must be inside a GestureProvider.
+*/
+function GestureZone({ ref, style, children, trapped = false, ...props }) {
+	const provided = useContext(ProviderContext);
+	if (provided === void 0) throw new Error("GestureZone must be used inside a GestureProvider");
+	const { tracker, motion, bindZone } = provided;
+	const [element, setElement] = useState(null);
+	useEffect(() => {
+		if (element === null) return;
+		const removeZone = tracker.addZone(element);
+		const unbind = bindZone(element);
+		return () => {
+			unbind();
+			removeZone();
+		};
+	}, [
+		tracker,
+		bindZone,
+		element
+	]);
+	const attach = useCallback((next) => {
+		setElement(next);
+		assignRef(ref, next);
+	}, [ref]);
+	return /* @__PURE__ */ jsx(ZoneContext, {
+		value: {
+			tracker,
+			motion,
+			element
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			ref: attach,
+			"data-slot": "gesture-zone",
+			"data-trapped": trapped ? "" : void 0,
+			style: {
+				...ZONE_STYLE,
+				...style
+			},
+			...props,
+			children
+		})
+	});
+}
+const useZone = (user) => {
+	const zone = useContext(ZoneContext);
+	if (zone === void 0) throw new Error(`${user} must be used inside a GestureZone`);
+	return zone;
+};
+const useLatest = (value) => {
+	const ref = useRef(value);
+	useLayoutEffect(() => {
+		ref.current = value;
+	});
+	return ref;
+};
+const NONE = /* @__PURE__ */ new Map();
+/**
+* Reads every Gesture its nearest Gesture Zone hears: each that starts in
+* it, or in a zone inside it that is not trapped, until another zone takes
+* it, unless it only watches. It reports each finger
+* that lands between the first landing and the last lifting, with where,
+* when and on what it landed and motion values that follow it. It never
+* classifies anything; what a Gesture means is up to the caller.
+*/
+function useGesture(options = {}) {
+	const { tracker, motion, element } = useZone("useGesture");
+	const latest = useLatest(options);
+	const pointers = useMotionValue(NONE);
+	const [active, setActive] = useState(false);
+	useEffect(() => {
+		if (element === null) return;
+		return tracker.addGesture(element, {
+			enabled: () => latest.current.enabled !== false,
+			start: (core) => {
+				const next = motion(core);
+				pointers.set(next);
+				setActive(true);
+				latest.current.onStart?.(next);
+			},
+			pointer: (pointer, core) => {
+				const next = motion(core);
+				const own = next.get(pointer.id);
+				pointers.set(next);
+				if (own !== void 0) latest.current.onPointer?.(own, next);
+			},
+			move: (_pointer, core) => {
+				motion(core);
+			},
+			captures: (point) => latest.current.captures?.(point) === true,
+			directions: () => latest.current.directions,
+			guardsEdge: () => latest.current.guardsEdge,
+			acts: () => latest.current.captures !== void 0 || latest.current.directions !== void 0,
+			direction: (direction) => latest.current.onDirection?.(direction),
+			end: (last, end) => {
+				latest.current.onEnd?.(motion(last), end);
+				pointers.set(NONE);
+				setActive(false);
+			}
+		});
+	}, [
+		tracker,
+		motion,
+		element,
+		latest,
+		pointers
+	]);
+	return {
+		pointers,
+		active
+	};
+}
+//#endregion
+export { GestureProvider, GestureZone, useGesture };
+
+//# sourceMappingURL=zone.js.map

package/dist/input/gesture/zones/zone/zone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone.js","names":[],"sources":["../../../../../src/input/gesture/zones/zone/zone.tsx"],"sourcesContent":["import { type MotionValue, useMotionValue } from 'motion/react';\nimport {\n  type ComponentProps,\n  type CSSProperties,\n  createContext,\n  type ReactNode,\n  type Ref,\n  useCallback,\n  useContext,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useState,\n} from 'react';\nimport {\n  createGestureProvider,\n  type Direction,\n  type Directions,\n  type GestureEnd,\n  type GestureProvider as CoreProvider,\n} from '@kestack/use-gesture';\nimport {\n  createTouchInput,\n  DOM_ZONES,\n  type Target,\n} from '../touch-input/index.ts';\nimport {\n  createMotionPointers,\n  type Pointer,\n  type Pointers,\n} from './motion-pointers.ts';\n\nexport type { Direction, Directions, GestureEnd } from '@kestack/use-gesture';\nexport type { Pointer, Pointers } from './motion-pointers.ts';\n\ntype Tracker = CoreProvider<Element, Target>;\n\ntype Provided = {\n  readonly tracker: Tracker;\n  /** The core's Pointers as this provider's motion values. */\n  readonly motion: ReturnType<typeof createMotionPointers>;\n  readonly bindZone: (element: Element) => () => void;\n};\n\nconst ProviderContext = createContext<Provided | undefined>(undefined);\n\ntype Zone = {\n  readonly tracker: Tracker;\n  readonly motion: Provided['motion'];\n  readonly element: Element | null;\n};\n\nconst ZoneContext = createContext<Zone | undefined>(undefined);\n\nconst assignRef = <T,>(ref: Ref<T> | undefined, value: T | null) => {\n  if (typeof ref === 'function') ref(value);\n  else if (ref !== null && ref !== undefined) ref.current = value;\n};\n\n/**\n * Tracks every Gesture in the Gesture Zones inside it: the one place its\n * fingers are followed. Put one at the app's root; separate sections may\n * each have their own, and each then runs its own Gesture. One inside\n * another does nothing: its zones join the outer one, so nested screens\n * share one Gesture.\n */\nexport function GestureProvider(props: { readonly children?: ReactNode }) {\n  const outer = useContext(ProviderContext);\n  return outer === undefined ? (\n    <Provider>{props.children}</Provider>\n  ) : (\n    props.children\n  );\n}\n\nfunction Provider(props: { readonly children?: ReactNode }) {\n  const [provided] = useState(() => {\n    const tracker = createGestureProvider(DOM_ZONES);\n    const input =\n      typeof window === 'undefined'\n        ? undefined\n        : createTouchInput(window, tracker.sink);\n    return {\n      tracker,\n      motion: createMotionPointers(),\n      input,\n      bindZone: (element: Element) => input?.bindZone(element) ?? (() => {}),\n    };\n  });\n\n  useEffect(() => {\n    provided.input?.start();\n    return () => provided.input?.stop();\n  }, [provided]);\n\n  return <ProviderContext value={provided}>{props.children}</ProviderContext>;\n}\n\nexport type GestureZoneProps = ComponentProps<'div'> & {\n  /**\n   * Whether Gestures that start in it stay in it, rather than also reaching\n   * the zones around it. It never keeps a touch from the browser. False by\n   * default. Read as a Gesture starts.\n   */\n  readonly trapped?: boolean;\n};\n\n// Touch defaults for the zone's own element, as inline style so they need no\n// stylesheet; `style` on the zone overrides any of them.\nconst ZONE_STYLE: CSSProperties = {\n  userSelect: 'none',\n  WebkitUserSelect: 'none',\n  WebkitTouchCallout: 'none',\n};\n\n/**\n * An area where the app can own touch, read with `useGesture` by any\n * component inside it, shown or hidden. A Gesture starting in it is heard\n * here and by each zone around it up to the first trapped one; sibling\n * zones never hear each other. At the first movement one of them takes it,\n * if a listener wants it; otherwise the browser scrolls. Zones nest, and\n * must be inside a GestureProvider.\n */\nexport function GestureZone({\n  ref,\n  style,\n  children,\n  trapped = false,\n  ...props\n}: GestureZoneProps) {\n  const provided = useContext(ProviderContext);\n  if (provided === undefined) {\n    throw new Error('GestureZone must be used inside a GestureProvider');\n  }\n  const { tracker, motion, bindZone } = provided;\n  const [element, setElement] = useState<HTMLDivElement | null>(null);\n\n  useEffect(() => {\n    if (element === null) return;\n    const removeZone = tracker.addZone(element);\n    const unbind = bindZone(element);\n    return () => {\n      unbind();\n      removeZone();\n    };\n  }, [tracker, bindZone, element]);\n\n  const attach = useCallback(\n    (next: HTMLDivElement | null) => {\n      setElement(next);\n      assignRef(ref, next);\n    },\n    [ref],\n  );\n\n  return (\n    <ZoneContext value={{ tracker, motion, element }}>\n      <div\n        ref={attach}\n        data-slot=\"gesture-zone\"\n        data-trapped={trapped ? '' : undefined}\n        style={{ ...ZONE_STYLE, ...style }}\n        {...props}\n      >\n        {children}\n      </div>\n    </ZoneContext>\n  );\n}\n\n// The nearest Gesture Zone; hooks throw a clear error outside one.\nconst useZone = (user: string): Zone => {\n  const zone = useContext(ZoneContext);\n  if (zone === undefined) {\n    throw new Error(`${user} must be used inside a GestureZone`);\n  }\n  return zone;\n};\n\n// The latest options, read by the zone mid-Gesture without re-registering.\nconst useLatest = <T,>(value: T) => {\n  const ref = useRef(value);\n  useLayoutEffect(() => {\n    ref.current = value;\n  });\n  return ref;\n};\n\nconst NONE: Pointers = new Map();\n\nexport type GestureOptions = {\n  /** Whether it takes the next Gesture: true by default. Read as its first finger lands. */\n  readonly enabled?: boolean;\n  /** The first finger landed. */\n  readonly onStart?: (pointers: Pointers) => void;\n  /** A finger landed or lifted; `pointer` is that finger. */\n  readonly onPointer?: (pointer: Pointer, pointers: Pointers) => void;\n  /**\n   * The last finger lifted: every finger of the Gesture, lifted ones\n   * included. Also when the browser or another zone took it, `interrupted`.\n   */\n  readonly onEnd?: (pointers: Pointers, end: GestureEnd) => void;\n  /**\n   * The Directions it takes touches in: `['left', 'right']`, or `'all'`. An\n   * element under the finger that can still scroll that way keeps it\n   * instead. Read at the touch's first movement. Without `directions` or\n   * `captures` it only watches, and never keeps a touch from the browser,\n   * apart from the edge it `guardsEdge`.\n   */\n  readonly directions?: Directions;\n  /** The Gesture first moved in `direction`: read once, for every listener. */\n  readonly onDirection?: (direction: Direction) => void;\n  /**\n   * Whether it captures a touch whose first finger landed at `point`, in\n   * viewport px, whichever way it moves, even over an element that could\n   * scroll it. Read at the touch's first movement; taps are never affected.\n   */\n  readonly captures?: (point: {\n    readonly x: number;\n    readonly y: number;\n  }) => boolean;\n  /**\n   * A side edge it keeps from the browser's edge swipe (back and forward on\n   * iOS) while it is enabled, even when it would not take a touch there. It\n   * neither captures nor wants anything, so it never changes who takes a\n   * Gesture. Read as a touch lands.\n   */\n  readonly guardsEdge?: 'left' | 'right';\n};\n\nexport type GestureState = {\n  /**\n   * Every finger of the Gesture under way, by id, lifted ones included;\n   * empty between Gestures. It changes as a finger lands or lifts; each\n   * finger's own motion values follow it as it moves.\n   */\n  readonly pointers: MotionValue<Pointers>;\n  /** True from the first finger landing until the last one lifts. */\n  readonly active: boolean;\n};\n\n/**\n * Reads every Gesture its nearest Gesture Zone hears: each that starts in\n * it, or in a zone inside it that is not trapped, until another zone takes\n * it, unless it only watches. It reports each finger\n * that lands between the first landing and the last lifting, with where,\n * when and on what it landed and motion values that follow it. It never\n * classifies anything; what a Gesture means is up to the caller.\n */\nexport function useGesture(options: GestureOptions = {}): GestureState {\n  const { tracker, motion, element } = useZone('useGesture');\n  const latest = useLatest(options);\n  const pointers = useMotionValue(NONE);\n  const [active, setActive] = useState(false);\n\n  useEffect(() => {\n    if (element === null) return;\n    return tracker.addGesture(element, {\n      enabled: () => latest.current.enabled !== false,\n      start: (core) => {\n        const next = motion(core);\n        pointers.set(next);\n        setActive(true);\n        latest.current.onStart?.(next);\n      },\n      pointer: (pointer, core) => {\n        const next = motion(core);\n        const own = next.get(pointer.id);\n        pointers.set(next);\n        if (own !== undefined) latest.current.onPointer?.(own, next);\n      },\n      move: (_pointer, core) => {\n        motion(core);\n      },\n      captures: (point) => latest.current.captures?.(point) === true,\n      directions: () => latest.current.directions,\n      guardsEdge: () => latest.current.guardsEdge,\n      acts: () =>\n        latest.current.captures !== undefined ||\n        latest.current.directions !== undefined,\n      direction: (direction) => latest.current.onDirection?.(direction),\n      end: (last, end) => {\n        latest.current.onEnd?.(motion(last), end);\n        pointers.set(NONE);\n        setActive(false);\n      },\n    });\n  }, [tracker, motion, element, latest, pointers]);\n\n  return { pointers, active };\n}\n"],"mappings":"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"}

package/dist/input/index.d.ts

@@ -0,0 +1,8 @@
+import { DEVICE_SCRIPT, Device, useDevice } from "./device/device.js";
+import { Pointer, Pointers } from "./gesture/zones/zone/motion-pointers.js";
+import { Directions, GestureEnd, GestureOptions, GestureProvider, GestureState, GestureZone, GestureZoneProps, useGesture } from "./gesture/zones/zone/zone.js";
+import { CommitRule, Direction, Edge, Fingers, Swipe, SwipeCancel, SwipeOptions, SwipeRelease, SwipeState, useSwipe } from "./gesture/recognizers/swipe/use-swipe.js";
+import { PullState, usePullToRefresh } from "./gesture/patterns/pull-to-refresh/use-pull-to-refresh.js";
+import { useSidebar } from "./gesture/patterns/sidebar/use-sidebar.js";
+import "./gesture/index.js";
+export { type CommitRule, DEVICE_SCRIPT, type Device, type Direction, type Directions, type Edge, type Fingers, type GestureEnd, type GestureOptions, GestureProvider, type GestureState, GestureZone, type GestureZoneProps, type Pointer, type Pointers, type PullState, type Swipe, type SwipeCancel, type SwipeOptions, type SwipeRelease, type SwipeState, useDevice, useGesture, usePullToRefresh, useSidebar, useSwipe };

package/dist/input/index.js

@@ -0,0 +1,6 @@
+import { DEVICE_SCRIPT, useDevice } from "./device/device.js";
+import { GestureProvider, GestureZone, useGesture } from "./gesture/zones/zone/zone.js";
+import { useSwipe } from "./gesture/recognizers/swipe/use-swipe.js";
+import { usePullToRefresh } from "./gesture/patterns/pull-to-refresh/use-pull-to-refresh.js";
+import { useSidebar } from "./gesture/patterns/sidebar/use-sidebar.js";
+export { DEVICE_SCRIPT, GestureProvider, GestureZone, useDevice, useGesture, usePullToRefresh, useSidebar, useSwipe };

package/dist/pwa/browser/dom-events.d.ts

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+//#region src/pwa/browser/dom-events.d.ts
+/** Adds `listener` for the life of the current scope. */
+export declare const listen: (target: EventTarget, type: string, listener: (event: Event) => void) => Effect.Effect<void, never, Scope.Scope>;
+/** False during SSR and in workers. */
+export declare const isBrowser: () => boolean;
+//#endregion
+//# sourceMappingURL=dom-events.d.ts.map

package/dist/pwa/browser/dom-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-events.d.ts","names":[],"sources":["../../../src/pwa/browser/dom-events.ts"],"mappings":";;;;qBAIa,SAAM,QACT,aAAW,cACP,WACD,OAAO,mBACjB,OAAO,oBAAoB,MAAM;;qBAOvB"}

package/dist/pwa/browser/dom-events.js

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+//#region src/pwa/browser/dom-events.ts
+/** Adds `listener` for the life of the current scope. */
+const listen = (target, type, listener) => Effect.acquireRelease(Effect.sync(() => target.addEventListener(type, listener)), () => Effect.sync(() => target.removeEventListener(type, listener)));
+/** False during SSR and in workers. */
+const isBrowser = () => typeof window !== "undefined" && typeof document !== "undefined";
+//#endregion
+export { isBrowser, listen };
+
+//# sourceMappingURL=dom-events.js.map

package/dist/pwa/browser/dom-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-events.js","names":[],"sources":["../../../src/pwa/browser/dom-events.ts"],"sourcesContent":["import * as Effect from 'effect/Effect';\nimport type * as Scope from 'effect/Scope';\n\n/** Adds `listener` for the life of the current scope. */\nexport const listen = (\n  target: EventTarget,\n  type: string,\n  listener: (event: Event) => void,\n): Effect.Effect<void, never, Scope.Scope> =>\n  Effect.acquireRelease(\n    Effect.sync(() => target.addEventListener(type, listener)),\n    () => Effect.sync(() => target.removeEventListener(type, listener)),\n  );\n\n/** False during SSR and in workers. */\nexport const isBrowser = (): boolean =>\n  typeof window !== 'undefined' && typeof document !== 'undefined';\n"],"mappings":";;;AAIA,MAAa,UACX,QACA,MACA,aAEA,OAAO,eACL,OAAO,WAAW,OAAO,iBAAiB,MAAM,QAAQ,CAAC,SACnD,OAAO,WAAW,OAAO,oBAAoB,MAAM,QAAQ,CAAC,CACpE;;AAGF,MAAa,kBACX,OAAO,WAAW,eAAe,OAAO,aAAa"}

package/dist/pwa/browser/subscription-ref.d.ts

@@ -0,0 +1,6 @@
+import * as SubscriptionRef from "effect/SubscriptionRef";
+//#region src/pwa/browser/subscription-ref.d.ts
+/** The ref's current value, re-rendering on change; `fallback` during SSR, hydration and before the ref exists. */
+export declare const useSubscriptionRef: <A>(ref: SubscriptionRef.SubscriptionRef<A> | undefined, fallback: A) => A;
+//#endregion
+//# sourceMappingURL=subscription-ref.d.ts.map

package/dist/pwa/browser/subscription-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-ref.d.ts","names":[],"sources":["../../../src/pwa/browser/subscription-ref.ts"],"mappings":";;;qBAOa,qBAAsB,GAAC,KAC7B,gBAAgB,gBAAgB,gBAAc,UACzC,MACT"}

package/dist/pwa/browser/subscription-ref.js

@@ -0,0 +1,19 @@
+import { useCallback, useSyncExternalStore } from "react";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+//#region src/pwa/browser/subscription-ref.ts
+/** The ref's current value, re-rendering on change; `fallback` during SSR, hydration and before the ref exists. */
+const useSubscriptionRef = (ref, fallback) => {
+	const subscribe = useCallback((onChange) => {
+		if (ref === void 0) return () => {};
+		const fiber = Effect.runFork(Stream.runForEach(SubscriptionRef.changes(ref), () => Effect.sync(onChange)));
+		return () => void Effect.runFork(Fiber.interrupt(fiber));
+	}, [ref]);
+	return useSyncExternalStore(subscribe, () => ref === void 0 ? fallback : SubscriptionRef.getUnsafe(ref), () => fallback);
+};
+//#endregion
+export { useSubscriptionRef };
+
+//# sourceMappingURL=subscription-ref.js.map

package/dist/pwa/browser/subscription-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-ref.js","names":[],"sources":["../../../src/pwa/browser/subscription-ref.ts"],"sourcesContent":["import * as Effect from 'effect/Effect';\nimport * as Fiber from 'effect/Fiber';\nimport * as Stream from 'effect/Stream';\nimport * as SubscriptionRef from 'effect/SubscriptionRef';\nimport { useCallback, useSyncExternalStore } from 'react';\n\n/** The ref's current value, re-rendering on change; `fallback` during SSR, hydration and before the ref exists. */\nexport const useSubscriptionRef = <A>(\n  ref: SubscriptionRef.SubscriptionRef<A> | undefined,\n  fallback: A,\n): A => {\n  const subscribe = useCallback(\n    (onChange: () => void) => {\n      if (ref === undefined) return () => {};\n      const fiber = Effect.runFork(\n        Stream.runForEach(SubscriptionRef.changes(ref), () =>\n          Effect.sync(onChange),\n        ),\n      );\n      return () => void Effect.runFork(Fiber.interrupt(fiber));\n    },\n    [ref],\n  );\n  return useSyncExternalStore(\n    subscribe,\n    () => (ref === undefined ? fallback : SubscriptionRef.getUnsafe(ref)),\n    () => fallback,\n  );\n};\n"],"mappings":";;;;;;;AAOA,MAAa,sBACX,KACA,aACM;CACN,MAAM,YAAY,aACf,aAAyB;EACxB,IAAI,QAAQ,KAAA,GAAW,aAAa,CAAC;EACrC,MAAM,QAAQ,OAAO,QACnB,OAAO,WAAW,gBAAgB,QAAQ,GAAG,SAC3C,OAAO,KAAK,QAAQ,CACtB,CACF;EACA,aAAa,KAAK,OAAO,QAAQ,MAAM,UAAU,KAAK,CAAC;CACzD,GACA,CAAC,GAAG,CACN;CACA,OAAO,qBACL,iBACO,QAAQ,KAAA,IAAY,WAAW,gBAAgB,UAAU,GAAG,SAC7D,QACR;AACF"}

package/dist/pwa/client/client.d.ts

@@ -0,0 +1,32 @@
+import { ClientBuildInfo } from "../shared/config/config.js";
+import "../shared/config/index.js";
+import { PwaStatus, StatusService } from "./status/status.js";
+import "./status/index.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region src/pwa/client/client.d.ts
+declare const Pwa_base: Context.ServiceClass<Pwa, "@kestack/web-platform/pwa/Pwa", StatusService & {
+  /** Deletes every Runtime Cache (use on sign-out); the Precache stays. */
+  readonly clearRuntimeCache: Effect.Effect<void>;
+}>;
+/**
+ * The PWA as the page sees it: one `status` stream, and the two things the
+ * page can do about updates. Never reloads unasked; `applyUpdate` activates
+ * the waiting build and every open page reloads into it.
+ */
+export declare class Pwa extends Pwa_base {
+  /**
+   * Registers the worker and watches it. Browser only: build it after
+   * hydration, never during SSR (there it is `Unsupported`).
+   */
+  static layer(info: ClientBuildInfo): Layer.Layer<Pwa>;
+}
+/**
+ * Deletes every Runtime Cache straight from CacheStorage, which the page
+ * shares with the worker, so it needs no registration or `Pwa` service.
+ */
+export declare const clearRuntimeCache: Effect.Effect<void>;
+//#endregion
+export { PwaStatus };
+//# sourceMappingURL=client.d.ts.map

package/dist/pwa/client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","names":[],"sources":["../../../src/pwa/client/client.ts"],"mappings":";;;;;;;;;;WAmBgC,mBAAA,OAAO;;;;;;;qBAJ1B,YAAY;;;;;SAWhB,MAAM,MAAM,kBAAkB,MAAM,MAAM;;;;;;qBAgBtC,mBAAmB,OAAO"}

package/dist/pwa/client/client.js

@@ -0,0 +1,36 @@
+import { register } from "./registration.js";
+import { clearRuntimeCaches } from "./runtime-cache.js";
+import { PwaStatus, makeStatus } from "./status/status.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region src/pwa/client/client.ts
+/**
+* The PWA as the page sees it: one `status` stream, and the two things the
+* page can do about updates. Never reloads unasked; `applyUpdate` activates
+* the waiting build and every open page reloads into it.
+*/
+var Pwa = class extends Context.Service()("@kestack/web-platform/pwa/Pwa") {
+	/**
+	* Registers the worker and watches it. Browser only: build it after
+	* hydration, never during SSR (there it is `Unsupported`).
+	*/
+	static layer(info) {
+		return Layer.effect(this, Effect.gen(function* () {
+			const registration = yield* register(info);
+			return {
+				...yield* makeStatus(info.update, registration),
+				clearRuntimeCache: clearRuntimeCaches
+			};
+		}));
+	}
+};
+/**
+* Deletes every Runtime Cache straight from CacheStorage, which the page
+* shares with the worker, so it needs no registration or `Pwa` service.
+*/
+const clearRuntimeCache = clearRuntimeCaches;
+//#endregion
+export { Pwa, PwaStatus, clearRuntimeCache };
+
+//# sourceMappingURL=client.js.map

package/dist/pwa/client/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../../../src/pwa/client/client.ts"],"sourcesContent":["import * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport type { ClientBuildInfo } from '../shared/config/index.js';\nimport { register } from './registration.js';\nimport { clearRuntimeCaches } from './runtime-cache.js';\nimport { makeStatus, type StatusService } from './status/index.js';\n\nexport { PwaStatus } from './status/index.js';\n\n/**\n * The PWA as the page sees it: one `status` stream, and the two things the\n * page can do about updates. Never reloads unasked; `applyUpdate` activates\n * the waiting build and every open page reloads into it.\n */\nexport class Pwa extends Context.Service<\n  Pwa,\n  StatusService & {\n    /** Deletes every Runtime Cache (use on sign-out); the Precache stays. */\n    readonly clearRuntimeCache: Effect.Effect<void>;\n  }\n>()('@kestack/web-platform/pwa/Pwa') {\n  /**\n   * Registers the worker and watches it. Browser only: build it after\n   * hydration, never during SSR (there it is `Unsupported`).\n   */\n  static layer(info: ClientBuildInfo): Layer.Layer<Pwa> {\n    return Layer.effect(\n      this,\n      Effect.gen(function* () {\n        const registration = yield* register(info);\n        const status = yield* makeStatus(info.update, registration);\n        return { ...status, clearRuntimeCache: clearRuntimeCaches };\n      }),\n    );\n  }\n}\n\n/**\n * Deletes every Runtime Cache straight from CacheStorage, which the page\n * shares with the worker, so it needs no registration or `Pwa` service.\n */\nexport const clearRuntimeCache: Effect.Effect<void> = clearRuntimeCaches;\n"],"mappings":";;;;;;;;;;;;AAeA,IAAa,MAAb,cAAyB,QAAQ,QAM/B,CAAC,CAAC,+BAA+B,CAAC,CAAC;;;;;CAKnC,OAAO,MAAM,MAAyC;EACpD,OAAO,MAAM,OACX,MACA,OAAO,IAAI,aAAa;GACtB,MAAM,eAAe,OAAO,SAAS,IAAI;GAEzC,OAAO;IAAE,GAAG,OADU,WAAW,KAAK,QAAQ,YAAY;IACtC,mBAAmB;GAAmB;EAC5D,CAAC,CACH;CACF;AACF;;;;;AAMA,MAAa,oBAAyC"}

package/dist/pwa/client/commands/commands.d.ts

@@ -0,0 +1,9 @@
+import { CommandReply, CommandType } from "../../shared/commands/commands.js";
+import "../../shared/commands/index.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+//#region src/pwa/client/commands/commands.d.ts
+/** Sends one command to `worker`; none on timeout or an unreadable reply. */
+export declare const sendCommand: (worker: ServiceWorker, type: CommandType) => Effect.Effect<Option.Option<CommandReply>>;
+//#endregion
+//# sourceMappingURL=commands.d.ts.map

package/dist/pwa/client/commands/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","names":[],"sources":["../../../../src/pwa/client/commands/commands.ts"],"mappings":";;;;;;qBAaa,cAAW,QACd,eAAa,MACf,gBACL,OAAO,OAAO,OAAO,OAAO"}

package/dist/pwa/client/commands/commands.js

@@ -0,0 +1,21 @@
+import { makeCommand, matchCommandReply } from "../../shared/commands/commands.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+//#region src/pwa/client/commands/commands.ts
+/** A worker that does not know `type` never replies, so every request times out. */
+const REPLY_TIMEOUT = "3 seconds";
+/** Sends one command to `worker`; none on timeout or an unreadable reply. */
+const sendCommand = (worker, type) => Effect.callback((resume) => {
+	const channel = new MessageChannel();
+	channel.port1.onmessage = (event) => resume(Effect.succeed(matchCommandReply(event.data)));
+	try {
+		worker.postMessage(makeCommand(type), [channel.port2]);
+	} catch {
+		resume(Effect.succeed(Option.none()));
+	}
+	return Effect.sync(() => channel.port1.close());
+}).pipe(Effect.timeoutOption(REPLY_TIMEOUT), Effect.map(Option.flatten));
+//#endregion
+export { sendCommand };
+
+//# sourceMappingURL=commands.js.map

package/dist/pwa/client/commands/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","names":[],"sources":["../../../../src/pwa/client/commands/commands.ts"],"sourcesContent":["import * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport {\n  type CommandReply,\n  type CommandType,\n  makeCommand,\n  matchCommandReply,\n} from '../../shared/commands/index.js';\n\n/** A worker that does not know `type` never replies, so every request times out. */\nconst REPLY_TIMEOUT = '3 seconds';\n\n/** Sends one command to `worker`; none on timeout or an unreadable reply. */\nexport const sendCommand = (\n  worker: ServiceWorker,\n  type: CommandType,\n): Effect.Effect<Option.Option<CommandReply>> =>\n  Effect.callback<Option.Option<CommandReply>>((resume) => {\n    const channel = new MessageChannel();\n    channel.port1.onmessage = (event: MessageEvent) =>\n      resume(Effect.succeed(matchCommandReply(event.data)));\n    try {\n      worker.postMessage(makeCommand(type), [channel.port2]);\n    } catch {\n      resume(Effect.succeed(Option.none()));\n    }\n    return Effect.sync(() => channel.port1.close());\n  }).pipe(Effect.timeoutOption(REPLY_TIMEOUT), Effect.map(Option.flatten));\n"],"mappings":";;;;;AAUA,MAAM,gBAAgB;;AAGtB,MAAa,eACX,QACA,SAEA,OAAO,UAAuC,WAAW;CACvD,MAAM,UAAU,IAAI,eAAe;CACnC,QAAQ,MAAM,aAAa,UACzB,OAAO,OAAO,QAAQ,kBAAkB,MAAM,IAAI,CAAC,CAAC;CACtD,IAAI;EACF,OAAO,YAAY,YAAY,IAAI,GAAG,CAAC,QAAQ,KAAK,CAAC;CACvD,QAAQ;EACN,OAAO,OAAO,QAAQ,OAAO,KAAK,CAAC,CAAC;CACtC;CACA,OAAO,OAAO,WAAW,QAAQ,MAAM,MAAM,CAAC;AAChD,CAAC,CAAC,CAAC,KAAK,OAAO,cAAc,aAAa,GAAG,OAAO,IAAI,OAAO,OAAO,CAAC"}

package/dist/pwa/client/commands/index.d.ts

@@ -0,0 +1,2 @@
+import { sendCommand } from "./commands.js";
+export { sendCommand };

package/dist/pwa/client/commands/index.js

@@ -0,0 +1,2 @@
+import { sendCommand } from "./commands.js";
+export { sendCommand };

package/dist/pwa/client/index.d.ts

@@ -0,0 +1,3 @@
+import { PwaStatus } from "./status/status.js";
+import { Pwa, clearRuntimeCache } from "./client.js";
+export { Pwa, PwaStatus, clearRuntimeCache };

package/dist/pwa/client/index.js

@@ -0,0 +1,3 @@
+import { PwaStatus } from "./status/status.js";
+import { Pwa, clearRuntimeCache } from "./client.js";
+export { Pwa, PwaStatus, clearRuntimeCache };