@astryxdesign/core 0.7.7 → 0.7.8-canary.07ee4b5

package/dist/DateInput/PickerWheel.js

@@ -0,0 +1,625 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file PickerWheel.tsx
+ * @input Wheel's props (wheelOptions.ts): options, value and change callback
+ * @output PickerWheel: one picker column that moves like UIPickerView
+ * @position Internal component; the Wheel under a finger (Wheel.tsx picks it)
+ *
+ * It moves on the gesture system and the shared animator, not on a native
+ * scroller. One strip holds the rows and is the only element that moves.
+ *
+ * SYNC: When modified, update PickerWheel.test.tsx, Wheel.tsx,
+ * DateInputTouch.test.tsx, DateInput.doc.mjs and TimeInput.doc.mjs.
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import * as stylex from '@stylexjs/stylex';
+import { scrollTypeOf } from "../gestures/GestureHost.js";
+import { PanGestureRecognizer } from "../gestures/PanGestureRecognizer.js";
+import { TapGestureRecognizer } from "../gestures/TapGestureRecognizer.js";
+import { useGestureRecognizer } from "../gestures/useGestureRecognizer.js";
+import { useIsomorphicLayoutEffect } from "../hooks/useIsomorphicLayoutEffect.js";
+import { rubberBandInverse } from "../motion/rubberBand.js";
+import { resolveMotion } from "../motion/resolveMotion.js";
+import { picker, registerPickerTable } from "../motion/uikit/picker.js";
+import { registerScrollTable, scroll } from "../motion/uikit/scroll.js";
+import { registerTimingTable, timing } from "../motion/uikit/timing.js";
+import "../theme/tokens.stylex.js";
+import { colorVars, fontWeightVars, radiusVars, spacingVars, typeScaleVars } from "../theme/tokens.stylex.js";
+import { focusOutlineStyles } from "../utils/focusOutline.stylex.js";
+import { lockSelection } from "../gestures/selectionLock.js";
+import "./tokens.stylex.js";
+import { dateInputTouchGeometry, dateInputTouchSizes } from "./tokens.stylex.js";
+import { useOwnScrollGesture } from "./useOwnScrollGesture.js";
+import { useWheelListbox } from "./useWheelListbox.js";
+import { createWheelStrip } from "./wheelStrip.js";
+import { dragOffset, nearestIndex, offsetBounds, planRelease, spinCurve } from "./wheelPhysics.js";
+import { endIndex, nearestEnabledIndex, steppedIndex, WHEEL_ROW_HEIGHT } from "./wheelOptions.js";
+
+/** Row pitch, px: the touch column keeps the scrolling column's pitch. */
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const ROW_HEIGHT = WHEEL_ROW_HEIGHT;
+/** UIKit's picker measures scaled to that pitch (UIKit's row is 32 pt). */
+const UIKIT_SCALE = ROW_HEIGHT / picker.geometry.rowHeight;
+/** UIKit's rubber band dimension for the picker's table, at that pitch. */
+const RUBBER_BAND_DIMENSION = picker.geometry.rubberBandDimension * UIKIT_SCALE;
+const _temp = {
+  k87sOh: "x5mnzd7",
+  "$$css": true
+};
+const styles = {
+  column: {
+    kVAEAm: "x1n2onr6",
+    kUk6DE: "x1cqoux5",
+    k7Eaqz: "xeuugli",
+    kZKoxP: "xm8gem",
+    kVQacm: "xb3r6kr",
+    kI3sdo: "x1a2a7pz",
+    kQizK7: "x1i10hfl",
+    $$css: true
+  },
+  row: {
+    kVAEAm: "x10l6tqk",
+    kkqhue: "x17y0mx6",
+    kZKoxP: "x6hpsvf",
+    k1xSpc: "x78zum5",
+    kGNEyG: "x6s0dn4",
+    kjj79g: "xl56j7k",
+    kg3NbH: "xf314gf",
+    kB7OPa: "x9f619",
+    kGuDYH: "x18juvz8",
+    k63SB2: "x1sodnla",
+    kMwMTN: "x1tgivj0",
+    khDVqt: "xuxw1ft",
+    kVQacm: "xb3r6kr",
+    kg5iWk: "xlyipyv",
+    kfSwDN: "x87ps6o",
+    $$css: true
+  },
+  rowActive: {
+    kMwMTN: "xjse4m1",
+    k63SB2: "x2mo6ok",
+    $$css: true
+  },
+  rowDisabled: {
+    kMwMTN: "xnbbluu",
+    $$css: true
+  },
+  rowAt: top => [_temp, {
+    "--x-insetBlockStart": (val => typeof val === "number" ? val + "px" : val != null ? val : undefined)(top)
+  }]
+};
+
+/**
+ * The motion tables the wheel resolves internal roles from: the timing curve,
+ * the scroll bounce and the picker's tap spin. Nothing registers on import
+ * (motion/roles.ts) and each register is idempotent, so the wheel calls this
+ * right before it resolves a role.
+ */
+function registerWheelTables() {
+  registerTimingTable();
+  registerScrollTable();
+  registerPickerTable();
+}
+
+/**
+ * A turn onto `to` on the picker's tap spin: its duration and its curve, as
+ * resolved under `column` when the turn starts.
+ */
+function turnCurve(column, from, to) {
+  registerWheelTables();
+  return spinCurve(from, to, resolveMotion(column, picker.tapSpin, 'durationMs') / 1000, resolveMotion(column, timing.curves.move));
+}
+/**
+ * One UIPickerView column: the Wheel under a finger. It does not scroll
+ * natively. WebKit gives every scroll-snapping scroller the fast deceleration
+ * rate, and a scroller's momentum cannot be caught or measured. A busy main
+ * thread does not stop or jump a motion here. Under Reduce Motion a throw's
+ * momentum still plays, as iOS scrolling does. Every other motion
+ * cross-fades onto its row.
+ *
+ * @example
+ * ```
+ * <PickerWheel label="Month" options={monthOptions} value={month} onChange={setMonth} />
+ * ```
+ */
+export function PickerWheel({
+  label,
+  options,
+  value,
+  onChange,
+  isActive = true
+}) {
+  const columnRef = useRef(null);
+  const rowsRef = useRef(null);
+  const rowCount = options.length;
+  const layout = useMemo(() => ({
+    rowHeight: ROW_HEIGHT,
+    rowCount
+  }), [rowCount]);
+  const [motion] = useState(() => createWheelStrip(layout));
+  const selectedIndex = Math.max(0, options.findIndex(option => option.value === value));
+  const dragRef = useRef(null);
+  /** A finger landed on a moving wheel and stopped it. */
+  const caughtRef = useRef(false);
+
+  // The latest props, for the motion's and the gesture listeners' callbacks,
+  // which are attached once and outlive a render.
+  const latestRef = useRef({
+    options,
+    value,
+    onChange,
+    layout
+  });
+  useIsomorphicLayoutEffect(() => {
+    latestRef.current = {
+      options,
+      value,
+      onChange,
+      layout
+    };
+  });
+
+  // The row under the band is marked as the scrolling column marks it. At rest
+  // that is the committed row, styled in render. While a finger drags the
+  // wheel, the row reaching the band is painted directly, so marking it never
+  // re-renders. A motion unmarks every row as it starts and marks the row it
+  // stops or ends on. The compositor then plays it with no layout or paint per
+  // frame, and no mark rides away from the band.
+  const paintedRef = useRef(new Set());
+  const paintRow = useCallback(position => {
+    const container = rowsRef.current;
+    if (container == null || container.children.length === 0) {
+      return;
+    }
+    const rows = container.children;
+    const {
+      options: currentOptions,
+      value: currentValue
+    } = latestRef.current;
+    const active = position == null ? null : rows[position] ?? null;
+    const painted = paintedRef.current;
+    for (const row of painted) {
+      row.style.removeProperty('color');
+      row.style.removeProperty('font-weight');
+    }
+    painted.clear();
+    const selected = currentOptions.findIndex(option => option.value === currentValue);
+    if (rows[selected] != null && rows[selected] !== active) {
+      // The committed row's own mark gives way while another row is under
+      // the band.
+      const row = rows[selected];
+      row.style.color = currentOptions[selected]?.isDisabled ? colorVars['--color-text-disabled'] : colorVars['--color-text-primary'];
+      row.style.fontWeight = fontWeightVars['--font-weight-normal'];
+      painted.add(row);
+    }
+    if (active == null || position == null) {
+      return;
+    }
+    active.style.color = currentOptions[position]?.isDisabled ? colorVars['--color-text-disabled'] : colorVars['--color-text-accent'];
+    active.style.fontWeight = fontWeightVars['--font-weight-semibold'];
+    painted.add(active);
+  }, []);
+
+  // Every motion the wheel starts. Under Reduce Motion a transition lands
+  // without travel: the animator cross-fades the strip onto its row. The
+  // momentum that continues a throw is not a transition, so it plays as is.
+  const move = useCallback((curve, options = {}) => {
+    paintRow(null);
+    // The mark comes back from the row the motion reports nearest when it
+    // ends, even the row it began on.
+    motion.forgetNearest();
+    motion.play(curve, options);
+  }, [motion, paintRow]);
+
+  // The wheel came to rest at `offset`: commit, or turn on to the row the
+  // rest rule names first.
+  const arrive = useCallback(offset => {
+    const current = latestRef.current;
+    const row = nearestIndex(offset, current.layout);
+    const committed = current.options.findIndex(option => option.value === current.value);
+    // A rest on the committed row is not a stop to correct. A committed value
+    // outside the bounds stays until a person moves the wheel off it, as in
+    // the scrolling column.
+    let step = 0;
+    if (row !== committed) {
+      step = nearestEnabledIndex(current.options, row, Math.max(0, committed)) - row;
+    }
+    if (step !== 0) {
+      const target = row + step;
+      move(turnCurve(columnRef.current, offset, target * ROW_HEIGHT), {
+        onEnd: (outcome, end) => {
+          if (outcome === 'arrived') {
+            arrive(end);
+          }
+        }
+      });
+      return;
+    }
+    const option = current.options[row];
+    if (option != null && !option.isDisabled && option.value !== current.value) {
+      current.onChange(option.value);
+    }
+  }, [move]);
+  const onEnd = useCallback((outcome, offset) => {
+    if (outcome === 'arrived') {
+      arrive(offset);
+    }
+  }, [arrive]);
+
+  // The animator holds the strip while it is attached, and lets it go as it
+  // detaches or is replaced.
+  const attachStrip = useCallback(strip => {
+    rowsRef.current = strip;
+    motion.attach(strip);
+    return () => {
+      rowsRef.current = null;
+      motion.attach(null);
+    };
+  }, [motion]);
+
+  // The motion's layout follows the rows.
+  useIsomorphicLayoutEffect(() => {
+    motion.setLayout(layout);
+  }, [motion, layout]);
+
+  // The band's mark follows the row the motion reports nearest the band.
+  useIsomorphicLayoutEffect(() => {
+    motion.onNearestChange(paintRow);
+    return () => motion.onNearestChange(null);
+  }, [motion, paintRow]);
+  // At rest on the committed row, render's own mark takes over again.
+  useIsomorphicLayoutEffect(() => {
+    if (motion.isMoving() || dragRef.current != null || nearestIndex(motion.offset(), layout) !== selectedIndex) {
+      return;
+    }
+    for (const row of paintedRef.current) {
+      row.style.removeProperty('color');
+      row.style.removeProperty('font-weight');
+    }
+    paintedRef.current.clear();
+  });
+
+  // The motion's animations and timers end with the wheel.
+  useEffect(() => () => motion.dispose(), [motion]);
+
+  // Park the committed row under the band when the wheel is shown, at once. A
+  // value that changes from outside while the wheel is shown turns the wheel
+  // onto its row instead. UIDatePicker turns onto its maximum the same way, and
+  // never jumps there. For example, a bound clamps the time after another wheel
+  // turned, or the calendar moved to another month. A second change during that
+  // turn turns on from where the wheel is drawn. Never while a finger or a
+  // motion of its own owns the wheel.
+  const parkedRef = useRef(false);
+  const parkTurnRef = useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    if (!isActive) {
+      parkedRef.current = false;
+      return;
+    }
+    if (dragRef.current != null || motion.isMoving() && parkTurnRef.current == null) {
+      return;
+    }
+    const target = selectedIndex * ROW_HEIGHT;
+    const shown = motion.isMoving() ? motion.stop() : motion.offset();
+    const isAway = Math.abs(shown - target) > 0.01;
+    if (isAway && parkedRef.current) {
+      // The turn's own end paints the band's row.
+      const turn = {};
+      parkTurnRef.current = turn;
+      move(turnCurve(columnRef.current, shown, target), {
+        onEnd: () => {
+          if (parkTurnRef.current === turn) {
+            parkTurnRef.current = null;
+          }
+        }
+      });
+      return;
+    }
+    if (isAway) {
+      motion.setOffset(target);
+    }
+    parkedRef.current = true;
+  }, [isActive, selectedIndex, motion, move]);
+
+  // A hidden wheel keeps no motion running and holds no drag. Hiding it
+  // mid-drag ends the pan without calling its listener, because the toggle's
+  // owner owns that end. So the drag is dropped here, uncommitted. Shown again,
+  // the wheel parks the committed row.
+  useEffect(() => {
+    if (!isActive) {
+      dragRef.current = null;
+      motion.stop();
+    }
+  }, [isActive, motion]);
+
+  // A finger lands: a moving wheel stops where it is on screen.
+  const onTouchDown = useCallback(time => {
+    caughtRef.current = motion.isMoving();
+    if (caughtRef.current) {
+      motion.stop(time);
+    }
+  }, [motion]);
+
+  // The latest touch-down handler, for the gesture listener attached once.
+  const onTouchDownRef = useRef(onTouchDown);
+  useIsomorphicLayoutEffect(() => {
+    onTouchDownRef.current = onTouchDown;
+  });
+  const release = useCallback(velocity => {
+    registerWheelTables();
+    const plan = planRelease(motion.offset(), velocity, latestRef.current.layout, resolveMotion(columnRef.current, scroll.bounce));
+    move(plan.curve, {
+      ticks: true,
+      onEnd,
+      touchRelease: true,
+      momentum: plan.kind === 'coast' || plan.kind === 'edge'
+    });
+  }, [motion, move, onEnd]);
+  const pan = useGestureRecognizer(columnRef, () => new PanGestureRecognizer({
+    name: 'wheel-pan',
+    direction: 'vertical',
+    // A trackpad's two-finger scroll drives the pan as a finger does. The
+    // rows follow, coast on at the lift with the fingers' last speed, and
+    // rest by the rest rule. A mouse wheel's notches never reach the pan.
+    allowedScrollTypes: ['continuous'],
+    // A held finger on the wheel never starts text selection or the
+    // callout.
+    selectionLock: lockSelection,
+    shouldReceiveTouch: (_pan, touch) => {
+      onTouchDownRef.current(touch.time);
+      return true;
+    }
+  }), recognizer => {
+    const {
+      layout: currentLayout
+    } = latestRef.current;
+    switch (recognizer.state) {
+      case 'began':
+        {
+          const shown = motion.isMoving() ? motion.stop() : motion.offset();
+          dragRef.current = {
+            start: fingerOffset(shown, currentLayout)
+          };
+          motion.resetDrag();
+          motion.setOffset(dragOffset(dragRef.current.start - recognizer.translation().y, currentLayout), {
+            ticks: true
+          });
+          break;
+        }
+      case 'changed':
+        {
+          const drag = dragRef.current;
+          if (drag == null) {
+            break;
+          }
+          motion.setOffset(dragOffset(drag.start - recognizer.translation().y, currentLayout), {
+            ticks: true
+          });
+          break;
+        }
+      case 'ended':
+        {
+          const drag = dragRef.current;
+          dragRef.current = null;
+          // A scroll view's release velocity (the pan's last two, blended as
+          // UIPickerView's); the rows move against the finger.
+          release(drag == null ? 0 : -recognizer.scrollVelocity().y);
+          break;
+        }
+      case 'cancelled':
+        {
+          dragRef.current = null;
+          release(0);
+          break;
+        }
+      case 'possible':
+      case 'failed':
+        break;
+    }
+  }, {
+    isEnabled: isActive
+  });
+
+  // A touch that stopped a moving wheel and lifted without dragging: the
+  // wheel eases onto the nearest row, as a release without velocity does.
+  useEffect(() => pan.addTransitionListener((_pan, _from, to) => {
+    // The flag stays up until the next touch lands. The tap recognizer may
+    // hear of this lift after the pan does, and must not read it as a tap
+    // on a row.
+    if (to === 'failed' && caughtRef.current && !motion.isMoving()) {
+      release(0);
+    }
+  }), [pan, motion, release]);
+  useGestureRecognizer(columnRef, () => new TapGestureRecognizer({
+    name: 'wheel-tap'
+  }), recognizer => {
+    if (recognizer.state !== 'ended' || caughtRef.current) {
+      return;
+    }
+    const column = columnRef.current;
+    if (column == null) {
+      return;
+    }
+    const box = column.getBoundingClientRect();
+    const {
+      y
+    } = recognizer.location();
+    const offset = motion.offset();
+    const currentLayout = latestRef.current.layout;
+    const target = rowAtPoint(y - (box.top + box.height / 2), offset, currentLayout);
+    if (target == null || target === nearestIndex(offset, currentLayout)) {
+      return;
+    }
+    move(turnCurve(columnRef.current, offset, target * ROW_HEIGHT), {
+      onEnd
+    });
+  }, {
+    isEnabled: isActive
+  });
+
+  // Keep the finger, and the pointer it lands with: inside a BottomSheet the
+  // sheet would otherwise read a downward drag here as swipe-to-dismiss. This
+  // wheel pans through the gesture system, which never cancels the pointer
+  // the sheet armed on (see useOwnScrollGesture).
+  useOwnScrollGesture(columnRef, 'all', {
+    isEnabled: isActive,
+    isPointerKept: true
+  });
+
+  // A key commits the row at `position` at once and turns the wheel there
+  // from `offset`.
+  const turnToPosition = useCallback((position, offset) => {
+    const current = latestRef.current;
+    const option = current.options[position];
+    if (option.value !== current.value) {
+      current.onChange(option.value);
+    }
+    move(turnCurve(columnRef.current, offset, position * ROW_HEIGHT));
+  }, [move]);
+  const moveBy = useCallback(delta => {
+    const current = latestRef.current;
+    if (current.options.length === 0 || delta === 0) {
+      return;
+    }
+    // Keys step from the row the wheel is heading to, not the one it is
+    // passing: two quick presses move two rows. A key with nowhere to go
+    // leaves a turn in flight to finish on its row.
+    const row = steppedIndex(current.options, nearestIndex(motion.target(), current.layout), delta);
+    if (row == null) {
+      return;
+    }
+    const offset = motion.isMoving() ? motion.stop() : motion.offset();
+    turnToPosition(row, offset);
+  }, [motion, turnToPosition]);
+
+  // A mouse wheel's notch turns the wheel one row, as an arrow key does, with
+  // no coast. The gesture host leaves a notch to what is under the pointer,
+  // which is this wheel. A wheel the pan took arrives here already prevented.
+  // A ctrl-wheel stays the page's zoom, and a sideways scroll stays the
+  // page's.
+  useEffect(() => {
+    const column = columnRef.current;
+    if (column == null || !isActive) {
+      return undefined;
+    }
+    const onWheel = event => {
+      if (event.defaultPrevented || event.ctrlKey || event.shiftKey || event.deltaY === 0 || Math.abs(event.deltaX) > Math.abs(event.deltaY) || scrollTypeOf(event) !== 'discrete') {
+        return;
+      }
+      event.preventDefault();
+      moveBy(Math.sign(event.deltaY));
+    };
+    column.addEventListener('wheel', onWheel, {
+      passive: false
+    });
+    return () => column.removeEventListener('wheel', onWheel);
+  }, [isActive, moveBy]);
+
+  // Home and End: the first and the last enabled row.
+  const moveToEnd = useCallback(end => {
+    const row = endIndex(latestRef.current.options, end);
+    if (row == null) {
+      return;
+    }
+    const offset = motion.isMoving() ? motion.stop() : motion.offset();
+    turnToPosition(row, offset);
+  }, [motion, turnToPosition]);
+
+  // A click on a row commits it at once and turns the wheel there, as the arrow
+  // keys do. The click comes from assistive technology, a keyboard, a test, or
+  // a mouse the tap recognizer did not take. A finger's tap is the tap
+  // recognizer's, and the click it would produce is swallowed by the gesture
+  // system.
+  const activateRow = useCallback(row => {
+    const current = latestRef.current;
+    const option = current.options[row];
+    if (option == null || option.isDisabled) {
+      return;
+    }
+    const offset = motion.isMoving() ? motion.stop() : motion.offset();
+    if (option.value !== current.value) {
+      current.onChange(option.value);
+    }
+    move(turnCurve(columnRef.current, offset, row * ROW_HEIGHT));
+  }, [motion, move]);
+  const {
+    listboxProps,
+    optionProps
+  } = useWheelListbox({
+    label,
+    options,
+    value,
+    // The committed row: a value set from outside shows in the same render.
+    activeIndex: selectedIndex,
+    stepBy: moveBy,
+    toEnd: moveToEnd,
+    activate: activateRow
+  });
+  return /*#__PURE__*/_jsx("div", {
+    ref: columnRef,
+    ...listboxProps,
+    "data-wheel": "",
+    ...stylex.props(styles.column, focusOutlineStyles.focusVisible),
+    children: /*#__PURE__*/_jsxs("div", {
+      "data-wheel-fade": "",
+      ...{
+        className: "x10l6tqk x10a8y8t x47corl xheapza"
+      },
+      children: [/*#__PURE__*/_jsx("div", {
+        "aria-hidden": "true",
+        ...{
+          className: "x10l6tqk x17y0mx6 x7rbydg x6hpsvf xh6dtrn x17x4s8c x47corl"
+        }
+      }), /*#__PURE__*/_jsx("div", {
+        ref: attachStrip,
+        "data-wheel-strip": "",
+        ...{
+          className: "x10l6tqk x17y0mx6 x7rbydg x47corl"
+        },
+        children: options.map((option, index) => /*#__PURE__*/_jsx("div", {
+          ...optionProps(option, index),
+          "data-wheel-row": "",
+          "data-label": option.label,
+          ...stylex.props(styles.row, styles.rowAt(`${index * ROW_HEIGHT}px`), index === selectedIndex && styles.rowActive, option.isDisabled && styles.rowDisabled),
+          children: option.label
+        }, option.value))
+      })]
+    })
+  });
+}
+PickerWheel.displayName = 'PickerWheel';
+
+/**
+ * The row under a point `dy` px below the band's centre, or null past either
+ * end of the list.
+ */
+function rowAtPoint(dy, offset, layout) {
+  const position = Math.round((offset + dy) / layout.rowHeight);
+  if (position < 0 || position >= layout.rowCount) {
+    return null;
+  }
+  return position;
+}
+
+/**
+ * The finger's offset for a shown one. Past an end, it is the travel that the
+ * rubber band shows as `shown`. So a drag that starts in a bounce continues
+ * without a jump.
+ */
+function fingerOffset(shown, layout) {
+  const {
+    min,
+    max
+  } = offsetBounds(layout);
+  const dimension = RUBBER_BAND_DIMENSION;
+  if (shown < min) {
+    return min + rubberBandInverse(shown - min, dimension);
+  }
+  if (shown > max) {
+    return max + rubberBandInverse(shown - max, dimension);
+  }
+  return shown;
+}

package/dist/DateInput/TouchDateField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TouchDateField.d.ts","sourceRoot":"","sources":["../../src/DateInput/TouchDateField.tsx"],"names":[],"mappings":"AAiEA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAwehD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,aAAqB,EACrB,WAAW,EACX,UAAkB,EAClB,UAAkB,EAClB,UAAkB,EAClB,eAAe,EACf,KAAK,EACL,QAAQ,EACR,YAAY,EACZ,SAAiB,EACjB,GAAG,EACH,GAAG,EACH,eAAe,EACf,WAAW,EAAE,oBAAoB,EACjC,IAAI,EAAE,QAAQ,EACd,MAAM,EACN,aAA0B,EAC1B,YAAY,EACZ,QAAgB,EAIhB,cAAc,EAAE,eAAe,EAC/B,YAAY,EAAE,gBAAoB,EAClC,MAAoB,EACpB,KAAK,EACL,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,GAAG,EACH,GAAG,SAAS,EACb,EAAE,cAAc,+BAgxBhB;yBApzBe,cAAc"}
+{"version":3,"file":"TouchDateField.d.ts","sourceRoot":"","sources":["../../src/DateInput/TouchDateField.tsx"],"names":[],"mappings":"AAiEA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAuehD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,aAAqB,EACrB,WAAW,EACX,UAAkB,EAClB,UAAkB,EAClB,UAAkB,EAClB,eAAe,EACf,KAAK,EACL,QAAQ,EACR,YAAY,EACZ,SAAiB,EACjB,GAAG,EACH,GAAG,EACH,eAAe,EACf,WAAW,EAAE,oBAAoB,EACjC,IAAI,EAAE,QAAQ,EACd,MAAM,EACN,aAA0B,EAC1B,YAAY,EACZ,QAAgB,EAIhB,cAAc,EAAE,eAAe,EAC/B,YAAY,EAAE,gBAAoB,EAClC,MAAoB,EACpB,KAAK,EACL,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,GAAG,EACH,GAAG,SAAS,EACb,EAAE,cAAc,+BAuvBhB;yBA3xBe,cAAc"}