@astryxdesign/core 0.7.6 → 0.7.7-canary.0eb44a2

package/dist/Switch/switchTouch.d.ts

@@ -0,0 +1,81 @@
+export interface SwitchTouchGeometry {
+    readonly trackWidth: number;
+    readonly trackHeight: number;
+    /** The thumb at rest, px. */
+    readonly thumbWidth: number;
+    readonly thumbHeight: number;
+    /** Gap between the thumb and the track's top, bottom and nearer end, px. */
+    readonly inset: number;
+    /** Offset of the thumb at the on end, px. */
+    readonly travel: number;
+    /**
+     * Scale of the lifted thumb, one value on both axes. It is UIKit's lift,
+     * capped so the thumb grows into at most half the gap on each side.
+     */
+    readonly liftScaleX: number;
+    readonly liftScaleY: number;
+    /**
+     * The drag's rubber-band dimension, px: UIKit's, scaled to the track. It
+     * never exceeds the gap the lift leaves (`inset` less the lifted growth).
+     * The band approaches its dimension and never reaches it, so a banded thumb
+     * stays inside the track.
+     */
+    readonly rubberBandDimension: number;
+    /** How far the finger goes toward the other end before a flip, px. */
+    readonly flipDistance: number;
+}
+/**
+ * The thumb geometry in a track of this size: the thumb's measured box when
+ * given, UIKit's proportions otherwise.
+ */
+export declare function switchTouchGeometry(trackWidth: number, trackHeight: number, thumb?: {
+    readonly width: number;
+    readonly height: number;
+}): SwitchTouchGeometry;
+/**
+ * Where the drag puts the thumb's target. It is the offset at the landing,
+ * moved by the finger's translation and rubber-banded past either end.
+ *
+ * `start` is the thumb's offset on screen when the finger landed, mid-flight
+ * or banded. It is unbanded first, so a finger that grabs a moving thumb
+ * continues without a jump.
+ */
+export declare function dragTarget(start: number, translation: number, geometry: SwitchTouchGeometry): number;
+/** A drag's flip state: the side it shows and how it got there. */
+export interface SwitchFlip {
+    /** The value when the finger landed. */
+    readonly startedOn: boolean;
+    readonly isVisuallyOn: boolean;
+    /** The finger passed `flipDistance` on the last event: the next one flips. */
+    readonly isArmed: boolean;
+    /** The drag has flipped at least once. */
+    readonly didFlip: boolean;
+}
+export declare function startFlip(isOn: boolean): SwitchFlip;
+/**
+ * One touch event of the drag. `translation` is the finger's travel since it
+ * landed along the writing direction (positive toward the on end).
+ */
+export declare function stepFlip(flip: SwitchFlip, translation: number, geometry: SwitchTouchGeometry): SwitchFlip;
+/**
+ * Passive: how long a lift waits for the browser's own click before the
+ * switch clicks its input itself, ms. The browser sends that click with the
+ * lift's `touchend`. The surface's `touch-action` leaves no double-tap delay.
+ * So this only runs out for a lift the browser does not count as a click.
+ */
+export declare const BROWSER_CLICK_WAIT_MS = 300;
+/**
+ * What a release commits: the side a drag flipped to; when nothing flipped,
+ * the other side of the value, wherever the finger lifts. A press slid off
+ * and lifted outside toggles too, as UISwitch's does. A toggle is
+ * reversible, so a stray release costs one more tap.
+ */
+export declare function commitOnRelease(flip: SwitchFlip | null, isOn: boolean): boolean;
+/**
+ * When the lifted thumb may settle, on the document timeline (ms). It is the
+ * release, but never sooner than the minimum lift time after the lift.
+ * A caller may pass the minimum it plays; the table's measured one by
+ * default.
+ */
+export declare function settleTime(releaseTime: number, liftTime: number, minimumLiftMs?: number): number;
+//# sourceMappingURL=switchTouch.d.ts.map

package/dist/Switch/switchTouch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switchTouch.d.ts","sourceRoot":"","sources":["../../src/Switch/switchTouch.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,6BAA6B;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,sEAAsE;IACtE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAC,GACxD,mBAAmB,CAoCrB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,mBAAmB,GAC5B,MAAM,CAOR;AAED,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,wCAAwC;IACxC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAEnD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,UAAU,EAChB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,mBAAmB,GAC5B,UAAU,CAkBZ;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,GAAG,IAAI,EACvB,IAAI,EAAE,OAAO,GACZ,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,aAAa,GAAE,MAAoC,GAClD,MAAM,CAER"}

package/dist/Switch/switchTouch.js

@@ -0,0 +1,133 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file switchTouch.ts
+ * @input The UIKit switch constants (motion/uikit/switch.ts) and a track size
+ * @output The pure model of Switch's touch presentation: thumb geometry, the
+ *   drag's target, the flip rule, the commit on release and its click wait,
+ *   and when the lifted thumb may settle
+ * @position Pure half of Switch's touch presentation; driven by
+ *   useSwitchTouch.ts, tested by switchTouch.test.ts without a browser
+ *
+ * Positions are thumb offsets from the off end, 0 … `travel`, in the writing
+ * direction; the caller mirrors them for right-to-left.
+ * SYNC: When modified, update useSwitchTouch.ts and switchTouch.test.ts.
+ */
+
+import { rubberBandClamp, rubberBandUnclamp } from "../motion/rubberBand.js";
+import { switchControl } from "../motion/uikit/switch.js";
+const [UIKIT_TRACK_WIDTH, UIKIT_TRACK_HEIGHT] = switchControl.trackSize;
+const [UIKIT_THUMB_WIDTH, UIKIT_THUMB_HEIGHT] = switchControl.thumbSize;
+const [LIFTED_WIDTH, LIFTED_HEIGHT] = switchControl.liftedThumbSize;
+
+/**
+ * The thumb geometry in a track of this size: the thumb's measured box when
+ * given, UIKit's proportions otherwise.
+ */
+export function switchTouchGeometry(trackWidth, trackHeight, thumb) {
+  const thumbHeight = thumb?.height ?? trackHeight * UIKIT_THUMB_HEIGHT / UIKIT_TRACK_HEIGHT;
+  const thumbWidth = thumb?.width ?? trackWidth * UIKIT_THUMB_WIDTH / UIKIT_TRACK_WIDTH;
+  const inset = Math.max(0, (trackHeight - thumbHeight) / 2);
+  // UIKit lifts to 58 × 38.3 from 37 × 24; here the lift fills at most half
+  // the gap on each side, on both axes alike.
+  const liftScale = Math.max(1, Math.min(LIFTED_WIDTH / UIKIT_THUMB_WIDTH, LIFTED_HEIGHT / UIKIT_THUMB_HEIGHT, thumbWidth > 0 ? 1 + inset / thumbWidth : 1, thumbHeight > 0 ? 1 + inset / thumbHeight : 1));
+  const liftGrowth = thumbWidth * (liftScale - 1) / 2;
+  return {
+    trackWidth,
+    trackHeight,
+    thumbWidth,
+    thumbHeight,
+    inset,
+    travel: Math.max(0, trackWidth - thumbWidth - 2 * inset),
+    liftScaleX: liftScale,
+    liftScaleY: liftScale,
+    rubberBandDimension: Math.max(0, Math.min(switchControl.rubberBand.dimension * trackHeight / UIKIT_TRACK_HEIGHT, inset - liftGrowth)),
+    flipDistance: Math.max(0, trackWidth - thumbWidth)
+  };
+}
+
+/**
+ * Where the drag puts the thumb's target. It is the offset at the landing,
+ * moved by the finger's translation and rubber-banded past either end.
+ *
+ * `start` is the thumb's offset on screen when the finger landed, mid-flight
+ * or banded. It is unbanded first, so a finger that grabs a moving thumb
+ * continues without a jump.
+ */
+export function dragTarget(start, translation, geometry) {
+  const {
+    travel,
+    rubberBandDimension
+  } = geometry;
+  const coefficient = switchControl.rubberBand.coefficient;
+  const raw = rubberBandUnclamp(start, 0, travel, rubberBandDimension, coefficient) + translation;
+  return rubberBandClamp(raw, 0, travel, rubberBandDimension, coefficient);
+}
+
+/** A drag's flip state: the side it shows and how it got there. */
+
+export function startFlip(isOn) {
+  return {
+    startedOn: isOn,
+    isVisuallyOn: isOn,
+    isArmed: false,
+    didFlip: false
+  };
+}
+
+/**
+ * One touch event of the drag. `translation` is the finger's travel since it
+ * landed along the writing direction (positive toward the on end).
+ */
+export function stepFlip(flip, translation, geometry) {
+  // Travel toward the other end: right from off, left from on.
+  const toward = flip.startedOn ? -translation : translation;
+  if (flip.isVisuallyOn !== flip.startedOn) {
+    return toward < 0 ? {
+      ...flip,
+      isVisuallyOn: flip.startedOn,
+      isArmed: false
+    } : flip;
+  }
+  const isPast = toward >= geometry.flipDistance;
+  if (flip.isArmed && isPast) {
+    return {
+      ...flip,
+      isVisuallyOn: !flip.startedOn,
+      isArmed: false,
+      didFlip: true
+    };
+  }
+  return isPast === flip.isArmed ? flip : {
+    ...flip,
+    isArmed: isPast
+  };
+}
+
+/**
+ * Passive: how long a lift waits for the browser's own click before the
+ * switch clicks its input itself, ms. The browser sends that click with the
+ * lift's `touchend`. The surface's `touch-action` leaves no double-tap delay.
+ * So this only runs out for a lift the browser does not count as a click.
+ */
+export const BROWSER_CLICK_WAIT_MS = 300;
+
+/**
+ * What a release commits: the side a drag flipped to; when nothing flipped,
+ * the other side of the value, wherever the finger lifts. A press slid off
+ * and lifted outside toggles too, as UISwitch's does. A toggle is
+ * reversible, so a stray release costs one more tap.
+ */
+export function commitOnRelease(flip, isOn) {
+  return flip?.didFlip === true ? flip.isVisuallyOn : !isOn;
+}
+
+/**
+ * When the lifted thumb may settle, on the document timeline (ms). It is the
+ * release, but never sooner than the minimum lift time after the lift.
+ * A caller may pass the minimum it plays; the table's measured one by
+ * default.
+ */
+export function settleTime(releaseTime, liftTime, minimumLiftMs = switchControl.minimumLiftMs) {
+  return Math.max(releaseTime, liftTime + minimumLiftMs);
+}

package/dist/Switch/useSwitchTouch.d.ts

@@ -0,0 +1,285 @@
+/**
+ * @file useSwitchTouch.ts
+ * @input Switch's parts (gesture surface, input, thumb and track), its value,
+ *   whether it is interactive, the track's other state (switchFill.ts) and
+ *   the thumb geometry (switchTouch.ts)
+ * @output Exports useSwitchTouch: Switch's gestures for a mouse, a pen and a
+ *   finger, and its touch presentation under a coarse primary pointer
+ * @position DOM half of Switch's touch presentation, on the gesture system
+ *   (../gestures) and the compositor animator (../motion/animator)
+ *
+ * SYNC: When modified, update switchTouch.ts, Switch.tsx
+ * and __tests__/Switch.interaction.browser.spec.ts.
+ */
+import { type RefObject } from 'react';
+import { type SwitchTouchGeometry } from './switchTouch.js';
+import { type TrackState } from './switchFill.js';
+export interface SwitchTouchParts {
+    /** Receives the touches: the input and the track. */
+    readonly surface: RefObject<HTMLElement | null>;
+    readonly input: RefObject<HTMLInputElement | null>;
+    /** Moves: the themed thumb itself. */
+    readonly thumb: RefObject<HTMLElement | null>;
+    /**
+     * The track: its `::after` is the fade layer over its own fill, showing
+     * the fill it is leaving or heading to (switchFill.ts).
+     */
+    readonly track: RefObject<HTMLElement | null>;
+}
+export interface SwitchTouchOptions {
+    readonly isOn: boolean;
+    /** False while disabled or busy: no touch is tracked. */
+    readonly isInteractive: boolean;
+    /**
+     * Disabled: the touch presentation is off and attaches nothing. A
+     * busy switch stays attached, so a change that starts a busy state still
+     * plays its release motion.
+     */
+    readonly isDisabled: boolean;
+    /** The track's box, px (width × height): the thumb geometry's scale. */
+    readonly trackSize: readonly [number, number];
+    /**
+     * The props the track renders with in its other state (its theme target
+     * and fill), for the fade layer's colour.
+     */
+    readonly otherTrackProps: object;
+}
+/**
+ * The switch's presentation: the touch presentation under a coarse primary
+ * pointer, or its own under a fine one.
+ */
+type SwitchPresentation = 'touch' | 'pointer';
+interface Elements {
+    surface: HTMLElement;
+    input: HTMLInputElement;
+    thumb: HTMLElement;
+    track: HTMLElement;
+}
+/**
+ * The touch presentation of one switch: animators, recognizers and the
+ * gesture state. No React state: a gesture never renders. UISwitch on iOS
+ * 26.2 is the reference; every number is in motion/uikit/switch.ts.
+ *
+ * - The thumb's resting place is CSS (its inline-start inset). So the steady
+ *   state needs no script and mirrors under RTL by itself. The animator only
+ *   moves the thumb by a delta from that place (`translate`). When the value
+ *   moves the CSS place, the delta is rebased in the same layout effect.
+ *   Nothing moves on screen, and the velocity is kept.
+ * - Touches go to a press tracker, which never blocks a scroll. No
+ *   recognizer claims the touch. `touch-action: pan-y` (Switch.tsx) keeps
+ *   horizontal moves for the switch: a drag follows and flips it, and the
+ *   release commits. A vertical drag is the page's scroll, and the switch
+ *   yields.
+ * - A tap, a hold or a short drag activates through the browser's own click.
+ *   The browser sends no click for a finger's hold, so the switch clicks its
+ *   input once the click window passes. A mouse or a pen gets a click when
+ *   it is released on the input. A drag that flipped the switch gets no
+ *   click, so the switch clicks its input, and the shared click guard
+ *   swallows the browser's late click. A finger's press slid off and lifted
+ *   outside toggles too, as UISwitch's does. Forms, `onChange` and the
+ *   keyboard stay the native checkbox's.
+ * - The drag never renders: each move retargets the thumb's tracking spring
+ *   and steps the flip rule on the finger's travel.
+ * - The thumb lifts while a finger presses, into half of the gap around it,
+ *   and its shadow fades in. At the release it settles back, no sooner than
+ *   the minimum lift time. The lift and the settle are one curve, built at
+ *   the release, so the settle starts on time on the compositor.
+ * - The track keeps its own fill in both states. A fade layer over it,
+ *   painted with the track's other fill, fades the colour on the compositor.
+ *   When the value changes, the layer swaps to the other fill and to the
+ *   complement of its opacity. So nothing changes on screen. A change the
+ *   fade already heads to swaps nothing: the track holds its previous fill
+ *   inline until the fade lands. WebKit plays a curve built in a held frame
+ *   only once the long task ends, so a swap there stepped the colour back.
+ *   The layer is composited from the start (`will-change`, Switch.tsx), or
+ *   iOS Safari runs its fade on the main thread.
+ * - Under reduced motion nothing travels or springs: a change plays the
+ *   animator's Reduce Motion cross-fade. A dragging finger still moves the
+ *   thumb: that is direct manipulation.
+ * - Under a fine primary pointer the switch keeps its own look. The same
+ *   tracking, flip rule and release decide the value, with no animator, and
+ *   the thumb moves when the value does. Only its press listens at rest. Its
+ *   click listener comes with a press.
+ */
+export declare class SwitchTouchController {
+    private elements;
+    private geometry;
+    private isOn;
+    private isInteractive;
+    /** The side the visuals show or head to. */
+    private isVisuallyOn;
+    /** +1 left-to-right, −1 right-to-left. */
+    private direction;
+    private thumb;
+    /** The fade layer: its opacity is how far the visuals are from the value. */
+    private fade;
+    /** The lifted shadow: the thumb's `::after`, faded in with the lift. */
+    private shadow;
+    /** When the thumb lifted (document timeline, ms); null while at rest. */
+    private liftTime;
+    /** When the running settle leaves the lift (settleTime), ms. */
+    private settleAt;
+    private otherTrack;
+    /**
+     * A change landed mid-fade, and the fade already heads to it. The track's
+     * own fill stays the previous value's (inline) until the fade lands. So the
+     * change's frame builds no curve and repaints nothing. `baseHold` counts
+     * holds, so a settled one ignores its late landing.
+     */
+    private baseHeld;
+    private baseHold;
+    private detachers;
+    /** When the press began (document timeline, ms); null with no press. */
+    private pressTime;
+    /** The thumb's offset when the current finger landed. */
+    private downOffset;
+    private drag;
+    /** The finger's last travel along x, for a lift that reports none. */
+    private lastTravel;
+    /**
+     * The press and the pan both report every touch event; the first report
+     * takes the step and this skips the second (cleared after the event).
+     */
+    private isStepping;
+    /** The current touch already ended in a release. */
+    private released;
+    /**
+     * Reduced motion: a release changed the value. The thumb's travel waits for
+     * the value to commit, so its one cross-fade lands in the new frame.
+     */
+    private pendingTravel;
+    /** Passive: a finger is down on the switch. */
+    private isTracking;
+    /** Which presentation the switch has: the touch one, or its own. */
+    private presentation;
+    /** The press-time listeners under a fine pointer, while armed. */
+    private pressListeners;
+    private pressListenersTimer;
+    /** Passive: a lift is waiting for the browser's own click. */
+    private browserClickTimer;
+    private reconcileTimer;
+    constructor(isOn: boolean, geometry: SwitchTouchGeometry);
+    get isAttached(): boolean;
+    attach(elements: Elements, presentation: SwitchPresentation): void;
+    /**
+     * Passive: UIControl's tracking, which never blocks a scroll. The press
+     * begins with the touch, or with the first horizontal move a pan would
+     * begin on. Inside a scroller the touch waits for the content delay. Every
+     * move steps the flip rule, and the release commits. A touch the browser
+     * takes for its scroll yields with no toggle.
+     */
+    private attachPassive;
+    /** Under a fine pointer: adds the switch's own listeners for a press. */
+    private listenForPress;
+    private startPressListeners;
+    /** The press's click window is over: its listeners go. */
+    private endPressListeners;
+    private stopPressListeners;
+    /** Undo everything: listeners, timers, animations and inline styles. */
+    detach(): void;
+    setInteractive(isInteractive: boolean): void;
+    /** The track's other state, re-rendered with each value. */
+    setOtherTrack(otherTrack: TrackState): void;
+    setGeometry(geometry: SwitchTouchGeometry): void;
+    /**
+     * The thumb geometry from the rendered boxes. The track's box lets a theme
+     * resize the track. The thumb's box is the circle of the current value. It
+     * rests by insets from the track's padding box, so padding does not move it.
+     */
+    private measureGeometry;
+    /**
+     * The rendered value changed. The CSS has already moved the thumb's
+     * resting place. So the thumb's delta is rebased first, and nothing moves on
+     * screen. Then the visuals head for the new value.
+     */
+    setValue(isOn: boolean): void;
+    private touchDown;
+    /** Passive: a mouse, a pen or a finger on the switch, UIControl's events. */
+    private onControlEvent;
+    /**
+     * One touch event of a held or dragged switch. It retargets the thumb at the
+     * finger (one style write) and steps the flip rule.
+     */
+    private move;
+    /**
+     * The finger lifted after a tap, a hold or a drag. `byBrowserClick`: the
+     * browser's own click activates the input, and the switch clicks it only
+     * if that click never comes.
+     */
+    private release;
+    /**
+     * The switch's own click on its input. The shared click guard then swallows
+     * the browser's late click for the same lift, so the switch toggles once.
+     */
+    private clickInput;
+    /** If the owner kept the old value, the visuals go back to it. */
+    private scheduleReconcile;
+    /** The touch ended without a release (cancelled, or the switch turned off). */
+    private abandon;
+    private rest;
+    /** The animator's x for a thumb offset, relative to its CSS place. */
+    private toX;
+    /** The thumb's offset on screen at `time`, from the curve. */
+    private offsetAt;
+    private showWell;
+    /**
+     * The fade layer heads for the visuals, on UIKit's well springs (on:
+     * 0.68 s, off: 0.40 s). It is clear when they show the value. It is opaque,
+     * the other fill, when they show the other side.
+     */
+    private animateFade;
+    /**
+     * The track now shows the new value's fill. The fade layer swaps to the
+     * other fill and to the complement of its opacity, so nothing changes on
+     * screen. It keeps heading where the visuals head, on the running clock.
+     */
+    private swapFade;
+    /**
+     * Holds the track's own fill at the previous value's (the other state's,
+     * now) until the fade lands. False when there is nothing to read it from.
+     */
+    private holdBase;
+    /**
+     * Ends a held fill: the track shows its value's fill again and the fade
+     * layer swaps under it. Once the fade has landed, the layer is opaque and
+     * nothing changes on screen. Called early, by a new touch, value or other
+     * state, the swap keeps the picture where it is.
+     */
+    private landBase;
+    /** The fade layer's colour: the track's fill in its other state. */
+    private paintFade;
+    /** Track color and thumb head for one side. */
+    private showSide;
+    /** The press began: the switch holds the touch and the thumb lifts. */
+    private pressBegan;
+    /** The press ended (a release, a cancel or the switch turning off). */
+    private pressEnded;
+    /**
+     * The thumb grows about its center into half the gap around it, and its
+     * lifted shadow fades in. Under reduced motion nothing lifts: the lift is
+     * feedback with no fade of its own.
+     */
+    private lift;
+    /**
+     * The thumb settles back after the press, no sooner than the minimum lift
+     * time after it lifted. One curve per property, built now, starts the
+     * settle on the compositor's clock.
+     */
+    private settle;
+    /**
+     * The thumb's box changed size with the value: the on circle is larger.
+     * Its scale carries the size it showed, so nothing jumps. Then it heads for
+     * the new box through the settle, or to the lift a held press keeps.
+     */
+    private rescaleThumb;
+    private clearTimers;
+}
+/**
+ * Switch's gestures, attached for every pointer, with the touch
+ * presentation under a coarse primary pointer. Its parts
+ * must be rendered (and styled for it) whether or not it is active; it only
+ * animates and listens.
+ */
+export declare function useSwitchTouch(parts: SwitchTouchParts, { isOn, isInteractive, isDisabled, trackSize, otherTrackProps, }: SwitchTouchOptions): void;
+export {};
+//# sourceMappingURL=useSwitchTouch.d.ts.map

package/dist/Switch/useSwitchTouch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSwitchTouch.d.ts","sourceRoot":"","sources":["../../src/Switch/useSwitchTouch.ts"],"names":[],"mappings":"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"}