@astryxdesign/core 0.7.7 → 0.7.8-canary.0588a13

package/dist/keyboard/keyboardModel.d.ts

@@ -0,0 +1,93 @@
+/** Which browser's keyboard reports the guide reads. */
+export type KeyboardProfile = 'chromium';
+/** An eased slide: the curve a transition plays (Gboard going up or down). */
+export interface KeyboardCurve {
+    /** Length, ms. */
+    readonly durationMs: number;
+    /** Cubic-bézier control points. */
+    readonly points: readonly [number, number, number, number];
+}
+/** How the keyboard's cover changes. */
+export type KeyboardTransitionKind = 'show' | 'hide' | 'change';
+/** One change of the keyboard's cover, as the guide reports it. */
+export interface KeyboardTransition {
+    readonly kind: KeyboardTransitionKind;
+    /** Inset presented at `start`, CSS px. */
+    readonly from: number;
+    /** Inset the keyboard comes to rest at, CSS px. */
+    readonly to: number;
+    /**
+     * When the keyboard starts to move, ms on the document timeline
+     * (`performance.now()`). For a slide Chrome reported, the guide dates it
+     * back to Gboard's start. For a hide after a blur, it is shortly ahead.
+     */
+    readonly start: number;
+    /** The inset's velocity at `start`, px/s (0 unless it interrupts one). */
+    readonly velocity: number;
+    /** False when the inset jumps at `start` (another keyboard while one is up). */
+    readonly animated: boolean;
+    /** True until the visual viewport confirms a transition the guide inferred. */
+    readonly predicted: boolean;
+    /**
+     * The eased slide the keyboard moves on (Gboard in Chrome on Android), or
+     * null when the inset jumps. A surface riding the keyboard plays it from
+     * `start`, as rideKeyboard does. It is the keyboard's own motion, with no
+     * motion role.
+     */
+    readonly curve: KeyboardCurve | null;
+}
+/** The guide's clock-free core: inputs carry their own times. */
+export interface KeyboardModel {
+    /** The inset the keyboard rests at (or is heading to), CSS px. */
+    readonly inset: number;
+    /** The latest transition. */
+    readonly transition: KeyboardTransition;
+    /** The inset presented at `time`, CSS px. */
+    presentation(time: number): number;
+    /** The presented inset's velocity at `time`, px/s. */
+    velocity(time: number): number;
+    /**
+     * The visual viewport reports an inset (null when unknown) at `time` (the
+     * event's timestamp). Returns the transition the report starts, if any.
+     */
+    report(inset: number | null, time: number): KeyboardTransition | null;
+    /**
+     * A control that brings up a keyboard lost focus to nothing that brings
+     * up one.
+     */
+    blurred(time: number): KeyboardTransition | null;
+    /** A control that brings up a keyboard gained focus. */
+    focused(time: number): KeyboardTransition | null;
+    /**
+     * Checks a predicted transition against the viewport once it should have
+     * ended; moves to what the viewport says when they disagree.
+     */
+    verify(inset: number | null, time: number): KeyboardTransition | null;
+}
+/**
+ * Creates the guide's core. Tests drive it with explicit times, and the
+ * window's guide feeds it events.
+ *
+ * Chrome reports each keyboard slide through the visual viewport just after
+ * it starts (README.md, "What the page sees"). Content rides Gboard's own
+ * slides, fitted on Chromium 158 with Gboard (motion/android/keyboard.ts).
+ *
+ * - Show: from the report, dated back `androidKeyboard.showReportLagMs`, on
+ *   `showCurve` over `showMs`, joining the slide where it is. The report's
+ *   first painted frame trails Gboard's first moved frame by 14 to 35 ms. An
+ *   `<input>` that brings an accessory bar first gives a smaller report
+ *   before the keyboard's. It rides to the last keyboard's height instead, as
+ *   a prediction, and the keyboard's report confirms it.
+ * - Hide: on `hideCurve` over `hideMs`. It starts
+ *   `androidKeyboard.hideAfterBlurMs` after a blur that brings no keyboard,
+ *   as a prediction, because Gboard starts down at the blur. When nothing
+ *   predicted it, as with Back, it starts from Chrome's report, dated back
+ *   `hideReportLagMs`, the lag measured on blurs.
+ * - A keyboard that changes while up, such as another keyboard, lays out at
+ *   once.
+ *
+ * A prediction the viewport has not confirmed by its end gives way to what
+ * the viewport says (`verify`).
+ */
+export declare function createKeyboardModel(initialInset?: number): KeyboardModel;
+//# sourceMappingURL=keyboardModel.d.ts.map

package/dist/keyboard/keyboardModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboardModel.d.ts","sourceRoot":"","sources":["../../src/keyboard/keyboardModel.ts"],"names":[],"mappings":"AAkBA,wDAAwD;AACxD,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC;AAEzC,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,kBAAkB;IAClB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,mCAAmC;IACnC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5D;AAED,wCAAwC;AACxC,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEhE,mEAAmE;AACnE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;CACtC;AAED,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,6CAA6C;IAC7C,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAAC;IACtE;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAAC;IACjD,wDAAwD;IACxD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAAC;IACjD;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAAC;CACvE;AAUD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,SAAI,GAAG,aAAa,CAkLnE"}

package/dist/keyboard/keyboardModel.js

@@ -0,0 +1,220 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file keyboardModel.ts
+ * @input `keyboard` from the Android table: Gboard's slides and Chrome's
+ *   report timings
+ * @output createKeyboardModel, the keyboard layout guide's clock-free core,
+ *   and the KeyboardTransition and KeyboardModel types
+ * @position The state of the keyboard layout guide (keyboardLayoutGuide.ts).
+ *   It infers the keyboard's transition from the visual viewport's reports
+ *   and focus changes, each input with its own time. It is internal to core.
+ *
+ * SYNC: When modified, update /packages/core/src/keyboard/README.md
+ */
+
+import { keyboard as androidKeyboard } from "../motion/android/keyboard.js";
+import { cubicBezier } from "../motion/bezier.js";
+
+/** Which browser's keyboard reports the guide reads. */
+
+/** An eased slide: the curve a transition plays (Gboard going up or down). */
+
+/** How the keyboard's cover changes. */
+
+/** One change of the keyboard's cover, as the guide reports it. */
+
+/** The guide's clock-free core: inputs carry their own times. */
+
+const EPSILON = 0.5;
+
+/** The inset and its velocity, seconds after a transition's start. */
+
+/**
+ * Creates the guide's core. Tests drive it with explicit times, and the
+ * window's guide feeds it events.
+ *
+ * Chrome reports each keyboard slide through the visual viewport just after
+ * it starts (README.md, "What the page sees"). Content rides Gboard's own
+ * slides, fitted on Chromium 158 with Gboard (motion/android/keyboard.ts).
+ *
+ * - Show: from the report, dated back `androidKeyboard.showReportLagMs`, on
+ *   `showCurve` over `showMs`, joining the slide where it is. The report's
+ *   first painted frame trails Gboard's first moved frame by 14 to 35 ms. An
+ *   `<input>` that brings an accessory bar first gives a smaller report
+ *   before the keyboard's. It rides to the last keyboard's height instead, as
+ *   a prediction, and the keyboard's report confirms it.
+ * - Hide: on `hideCurve` over `hideMs`. It starts
+ *   `androidKeyboard.hideAfterBlurMs` after a blur that brings no keyboard,
+ *   as a prediction, because Gboard starts down at the blur. When nothing
+ *   predicted it, as with Back, it starts from Chrome's report, dated back
+ *   `hideReportLagMs`, the lag measured on blurs.
+ * - A keyboard that changes while up, such as another keyboard, lays out at
+ *   once.
+ *
+ * A prediction the viewport has not confirmed by its end gives way to what
+ * the viewport says (`verify`).
+ */
+export function createKeyboardModel(initialInset = 0) {
+  let transition = {
+    kind: 'change',
+    from: initialInset,
+    to: initialInset,
+    start: -Infinity,
+    velocity: 0,
+    animated: false,
+    predicted: false,
+    curve: null
+  };
+  // The inset over seconds since the transition's start.
+  let curve = null;
+  // An eased slide's value and velocity.
+  const easedCurve = (from, to, slide) => {
+    const span = slide.durationMs / 1000;
+    const ease = cubicBezier(slide.points);
+    const value = t => from + (to - from) * ease(Math.min(1, Math.max(0, t / span)));
+    return {
+      value,
+      velocity: t => {
+        if (t >= span) {
+          return 0;
+        }
+        const a = Math.max(0, t - 0.001);
+        const b = Math.min(span, t + 0.001);
+        return (value(b) - value(a)) / (b - a);
+      }
+    };
+  };
+  // Gboard's slides, as Chrome draws them: the table's show and hide curves.
+  const showSlide = {
+    durationMs: androidKeyboard.showMs,
+    points: androidKeyboard.showCurve
+  };
+  const hideSlide = {
+    durationMs: androidKeyboard.hideMs,
+    points: androidKeyboard.hideCurve
+  };
+  // How long the current transition moves for.
+  const lengthOf = () => transition.curve != null ? transition.curve.durationMs : 0;
+  // The inset of the last keyboard that was up, for a hide that turns back.
+  let shownInset = initialInset;
+  const presentation = time => {
+    // A jump has happened at its start; a curve starts from `from`.
+    if (time < transition.start) {
+      return transition.from;
+    }
+    if (curve == null || time >= transition.start + lengthOf()) {
+      return transition.to;
+    }
+    return curve.value((time - transition.start) / 1000);
+  };
+  const velocity = time => {
+    if (time <= transition.start) {
+      return transition.velocity;
+    }
+    if (curve == null || time >= transition.start + lengthOf()) {
+      return 0;
+    }
+    return curve.velocity((time - transition.start) / 1000);
+  };
+  const begin = (kind, to, start, {
+    animated = true,
+    predicted = false
+  } = {}) => {
+    // Never date a transition before the one it interrupts.
+    const at = Math.max(start, transition.start);
+    const from = presentation(at);
+    const v = animated ? velocity(at) : 0;
+    const slide = animated ? to > from ? showSlide : hideSlide : null;
+    transition = {
+      kind,
+      from,
+      to,
+      start: at,
+      velocity: v,
+      animated,
+      predicted,
+      curve: slide
+    };
+    curve = slide != null && Math.abs(to - from) + Math.abs(v) > 0 ? easedCurve(from, to, slide) : null;
+    if (to > EPSILON) {
+      shownInset = to;
+    }
+    return transition;
+  };
+  const confirm = () => {
+    if (transition.predicted) {
+      transition = {
+        ...transition,
+        predicted: false
+      };
+    }
+    return null;
+  };
+  return {
+    get inset() {
+      return transition.to;
+    },
+    get transition() {
+      return transition;
+    },
+    presentation,
+    velocity,
+    report(inset, time) {
+      if (inset == null) {
+        return null;
+      }
+      const target = transition.to;
+      if (Math.abs(inset - target) < EPSILON) {
+        return confirm();
+      }
+      if (inset <= EPSILON) {
+        // A hide nothing predicted (Back): Chrome reports it just after
+        // Gboard starts down, so it rides from that moment.
+        return begin('hide', 0, time - androidKeyboard.hideReportLagMs);
+      }
+      if (target <= EPSILON) {
+        // Chrome reports the show just after Gboard starts up: ride from
+        // that moment, joining the slide where it is. A smaller first
+        // report is the accessory bar, the keyboard's own following: ride
+        // to the last keyboard's height and let its report confirm it.
+        const predicted = shownInset > inset + EPSILON;
+        return begin('show', predicted ? shownInset : inset, time - androidKeyboard.showReportLagMs, {
+          predicted
+        });
+      }
+      // The keyboard changed while up (another keyboard, or the keyboard's
+      // report after the accessory bar's): Chrome lays the page out at once.
+      return begin('change', inset, time, {
+        animated: false
+      });
+    },
+    blurred(time) {
+      if (transition.to <= EPSILON) {
+        return null;
+      }
+      return begin('hide', 0, time + androidKeyboard.hideAfterBlurMs, {
+        predicted: true
+      });
+    },
+    focused(time) {
+      if (transition.kind !== 'hide' || !transition.predicted) {
+        return null;
+      }
+      // Focus came back before the predicted hide finished: the keyboard
+      // turns back to the inset it had.
+      return begin('show', shownInset, Math.max(time, transition.start), {
+        predicted: true
+      });
+    },
+    verify(inset, time) {
+      if (!transition.predicted || inset == null || time < transition.start + lengthOf()) {
+        return null;
+      }
+      if (Math.abs(inset - transition.to) < EPSILON) {
+        return confirm();
+      }
+      return begin(inset > transition.to ? 'show' : 'hide', inset, time);
+    }
+  };
+}

package/dist/keyboard/rideKeyboard.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @file rideKeyboard.ts
+ * @input An animator, target values and a keyboard transition, with its
+ *   start and the curve the guide publishes with it, and ride options
+ * @output rideKeyboard, which moves an element with the keyboard on the
+ *   keyboard's own motion
+ * @position Keyboard module, internal to core. A guide subscriber calls it
+ *   for each transition, as BottomSheet's hook does.
+ *
+ * SYNC: When modified, update /packages/core/src/keyboard/README.md
+ */
+import type { Animator, MotionHandle, MotionValues } from '../motion/animator.js';
+import type { KeyboardTransition } from './keyboardModel.js';
+/** How a ride treats Reduce Motion. */
+export interface RideOptions {
+    /**
+     * Under Reduce Motion, lands the element at once and fades it in. Without
+     * it, the animator's own Reduce Motion plan applies.
+     */
+    readonly entrance?: boolean;
+}
+/**
+ * Moves `animator`'s element to `to` with the keyboard: on its curve from
+ * `transition.start`, or at once when the keyboard jumps.
+ *
+ * Android's keyboard moves on Gboard's slides up and down
+ * (motion/android/keyboard.ts). The transition publishes the slide
+ * (`curve`), and the ride plays it. Every ride starts at the transition's
+ * start, so content that joins a slide late lands where the keyboard is. A
+ * transition that is not animated lands at once, such as a keyboard changing
+ * while up. So does a slide that has ended by the call. These values are the
+ * keyboard's own motion, with no motion role. The system moves the keyboard
+ * on them whatever the page does, so any other curve would leave the element
+ * out of step.
+ *
+ * @example
+ * ```
+ * guide.subscribe(t => rideKeyboard(dock.animator, {y: -lift(t.to)}, t));
+ * ```
+ */
+export declare function rideKeyboard(animator: Animator, to: MotionValues, transition: KeyboardTransition, { entrance }?: RideOptions): MotionHandle | null;
+//# sourceMappingURL=rideKeyboard.d.ts.map

package/dist/keyboard/rideKeyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rideKeyboard.d.ts","sourceRoot":"","sources":["../../src/keyboard/rideKeyboard.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,QAAQ,EAER,YAAY,EAEZ,YAAY,EACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAExD,uCAAuC;AACvC,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,YAAY,EAChB,UAAU,EAAE,kBAAkB,EAC9B,EAAC,QAAgB,EAAC,GAAE,WAAgB,GACnC,YAAY,GAAG,IAAI,CA0CrB"}

package/dist/keyboard/rideKeyboard.js

@@ -0,0 +1,77 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file rideKeyboard.ts
+ * @input An animator, target values and a keyboard transition, with its
+ *   start and the curve the guide publishes with it, and ride options
+ * @output rideKeyboard, which moves an element with the keyboard on the
+ *   keyboard's own motion
+ * @position Keyboard module, internal to core. A guide subscriber calls it
+ *   for each transition, as BottomSheet's hook does.
+ *
+ * SYNC: When modified, update /packages/core/src/keyboard/README.md
+ */
+
+import { cubicBezier } from "../motion/bezier.js";
+
+/** How a ride treats Reduce Motion. */
+
+/**
+ * Moves `animator`'s element to `to` with the keyboard: on its curve from
+ * `transition.start`, or at once when the keyboard jumps.
+ *
+ * Android's keyboard moves on Gboard's slides up and down
+ * (motion/android/keyboard.ts). The transition publishes the slide
+ * (`curve`), and the ride plays it. Every ride starts at the transition's
+ * start, so content that joins a slide late lands where the keyboard is. A
+ * transition that is not animated lands at once, such as a keyboard changing
+ * while up. So does a slide that has ended by the call. These values are the
+ * keyboard's own motion, with no motion role. The system moves the keyboard
+ * on them whatever the page does, so any other curve would leave the element
+ * out of step.
+ *
+ * @example
+ * ```
+ * guide.subscribe(t => rideKeyboard(dock.animator, {y: -lift(t.to)}, t));
+ * ```
+ */
+export function rideKeyboard(animator, to, transition, {
+  entrance = false
+} = {}) {
+  // A frame after a busy task still draws an animation at that task's
+  // start. The ride sets a slide that has already ended, so no frame shows the
+  // element short of its target.
+  if (!transition.animated || transition.curve == null || performance.now() >= transition.start + transition.curve.durationMs) {
+    animator.set(to);
+    return null;
+  }
+  // Under Reduce Motion nothing travels. The animator's default cross-fades
+  // the element to its new place on a touch screen, and elsewhere moves it at
+  // once. An entrance lands it at once and fades it in.
+  const options = entrance ? {
+    at: transition.start,
+    crossfadeAs: 'entrance'
+  } : {
+    at: transition.start
+  };
+  const span = transition.curve.durationMs / 1000;
+  const ease = cubicBezier(transition.curve.points);
+  const curves = {};
+  for (const [property, target] of Object.entries(to)) {
+    const from = animator.get(property, transition.start);
+    const at = t => from + (target - from) * ease(Math.min(1, Math.max(0, t / span)));
+    curves[property] = {
+      duration: span,
+      at,
+      velocity: t => {
+        if (t >= span) {
+          return 0;
+        }
+        const a = Math.max(0, t - 0.001);
+        const b = Math.min(span, t + 0.001);
+        return (at(b) - at(a)) / (b - a);
+      }
+    };
+  }
+  return animator.play(curves, options);
+}

package/dist/keyboard/useMobileKeyboard.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @file useMobileKeyboard.ts
+ * @input A target element and its scroll area, the keyboard module's reports
+ *   and focus claim, and the layout guide
+ * @output useMobileKeyboard, which keeps a focused field in the target above
+ *   the on-screen keyboard and returns the inset and a dismiss
+ * @position Keyboard module, internal to core. BottomSheet passes its panel.
+ *
+ * SYNC: When modified, update /packages/core/src/keyboard/README.md
+ */
+import { type RefObject } from 'react';
+/** How a target keeps a focused field above the on-screen keyboard. */
+export interface MobileKeyboardOptions {
+    /**
+     * How the target moves the field: `'ride'` reveals it with the scroller
+     * and rides the scroller's content on the keyboard's slide.
+     */
+    move: 'ride';
+    /**
+     * Reserves the keyboard's inset at the end of the target's scroll area,
+     * the first element inside it that `useScrollableArea` marks with
+     * `data-scroll-axis`.
+     */
+    inset?: boolean;
+    /** The gap kept between the focused field and the keyboard, CSS px. */
+    offset: number;
+    /** Whether the target follows the keyboard at all. */
+    isEnabled: boolean;
+    /** Whether the target is at its full height, where it reveals fields. */
+    isExpanded: boolean;
+    /** Whether the target is open. Focus that leaves for nothing parks on it. */
+    isOpen: boolean;
+    /** Whether the page's own scroll is locked under the target. */
+    isPageScrollLocked: boolean;
+}
+/** What useMobileKeyboard returns. */
+export interface MobileKeyboard {
+    /** The inset the target lays out at its scroller's content end, CSS px. */
+    readonly inset: number;
+    /**
+     * Dismisses the keyboard, keeping the inset while the keyboard goes. The
+     * focused field blurs, or `focusTarget` takes focus.
+     */
+    readonly dismiss: (focusTarget?: HTMLElement) => void;
+}
+/** Forgets every window's recorded reveal, for tests. */
+export declare function __resetRevealsAtReportForTest(): void;
+/**
+ * Keeps a focused field in `targetRef`'s element above the on-screen
+ * keyboard (see README.md). A sheet passes its panel, and the hook reserves
+ * the inset in the panel's scroll area. Returns the inset the keyboard takes
+ * at the end of that area's content, CSS px, or 0 without a keyboard, and a
+ * dismiss.
+ *
+ * @example
+ * ```
+ * const keyboard = useMobileKeyboard(panelRef, {move: 'ride', inset: true, offset: 48, isEnabled, isExpanded, isOpen, isPageScrollLocked});
+ * ```
+ */
+export declare function useMobileKeyboard(targetRef: RefObject<HTMLElement | null>, { inset: reservesInset, offset, isEnabled, isExpanded, isOpen, isPageScrollLocked, }: MobileKeyboardOptions): MobileKeyboard;
+//# sourceMappingURL=useMobileKeyboard.d.ts.map

package/dist/keyboard/useMobileKeyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMobileKeyboard.d.ts","sourceRoot":"","sources":["../../src/keyboard/useMobileKeyboard.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AAEH,OAAO,EAA2C,KAAK,SAAS,EAAC,MAAM,OAAO,CAAC;AA+B/E,uEAAuE;AACvE,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,SAAS,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,UAAU,EAAE,OAAO,CAAC;IACpB,6EAA6E;IAC7E,MAAM,EAAE,OAAO,CAAC;IAChB,gEAAgE;IAChE,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,WAAW,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;CACvD;AAmBD,yDAAyD;AACzD,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAkBD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACxC,EACE,KAAK,EAAE,aAAqB,EAC5B,MAAM,EACN,SAAS,EACT,UAAU,EACV,MAAM,EACN,kBAAkB,GACnB,EAAE,qBAAqB,GACvB,cAAc,CAmtBhB"}