@phillips/seldon 1.276.0 → 1.278.0

package/dist/components/SlideToActivate/hooks/useSlideDragHandlers.js

@@ -0,0 +1,90 @@
+import { useRef as a, useCallback as d, useEffect as b } from "react";
+import { SlideToActivateDirections as x } from "../types.js";
+import { clampProgress as M, isGestureBusy as X } from "../slideToActivateUtils.js";
+const w = 0.95, O = 8, U = 1, G = (o, l) => {
+  try {
+    return o.setPointerCapture(l), typeof o.hasPointerCapture == "function" ? o.hasPointerCapture(l) : !1;
+  } catch {
+    return !1;
+  }
+}, k = ({
+  direction: o,
+  isDisabled: l,
+  stateRef: e,
+  measureTravel: f,
+  dispatch: E,
+  emitProgress: I,
+  runActivation: S,
+  snapToIdle: C
+}) => {
+  const L = a(0), y = a(0), m = a(!1), u = a(null), D = a(null), h = a(null), i = d(() => {
+    h.current?.(), h.current = null;
+  }, []);
+  b(() => () => i(), [i]);
+  const g = d(
+    (r, n) => {
+      if (n !== u.current || e.current.status !== "dragging")
+        return;
+      let s = e.current.maxTravel;
+      if (s <= 0 && (f(), s = e.current.maxTravel, s <= 0))
+        return;
+      const p = r - L.current, c = o === x.rtl ? -p : p;
+      if (!m.current) {
+        if (Math.abs(c) < O)
+          return;
+        m.current = !0;
+      }
+      const t = M(y.current + c * U / s);
+      I(t);
+    },
+    [o, I, f, e]
+  ), P = d(() => {
+    i();
+    const r = D.current, n = u.current;
+    try {
+      r && n !== null && r.hasPointerCapture(n) && r.releasePointerCapture(n);
+    } catch {
+    }
+    if (u.current = null, D.current = null, e.current.status === "dragging") {
+      if (e.current.progress >= w || e.current.progress >= 1) {
+        S();
+        return;
+      }
+      C();
+    }
+  }, [i, S, C, e]), v = d(
+    (r) => {
+      r.pointerId === u.current && (r.cancelable && r.preventDefault(), g(r.clientX, r.pointerId));
+    },
+    [g]
+  );
+  return {
+    handlePointerDown: d(
+      (r) => {
+        if (l || X(e.current.status) || e.current.progress >= 1)
+          return;
+        r.preventDefault(), f();
+        const n = r.currentTarget;
+        n.focus(), D.current = n, u.current = r.pointerId;
+        const s = G(n, r.pointerId);
+        if (L.current = r.clientX, y.current = e.current.progress, m.current = !1, E({ type: "dragStarted" }), i(), !s) {
+          const p = (t) => {
+            t.cancelable && t.preventDefault(), g(t.clientX, t.pointerId);
+          }, c = (t) => {
+            t.pointerId === u.current && P();
+          };
+          document.addEventListener("pointermove", p, { passive: !1 }), document.addEventListener("pointerup", c), document.addEventListener("pointercancel", c), h.current = () => {
+            document.removeEventListener("pointermove", p), document.removeEventListener("pointerup", c), document.removeEventListener("pointercancel", c);
+          };
+        }
+      },
+      [g, i, E, P, l, f, e]
+    ),
+    handlePointerMove: v,
+    handlePointerUp: P,
+    handlePointerCancel: P
+  };
+};
+export {
+  k as useSlideDragHandlers
+};

package/dist/components/SlideToActivate/hooks/useSlideKeyboardActivate.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("react"),y=require("../slideToActivateUtils.cjs"),f=({isDisabled:u,stateRef:c,runActivation:l})=>{const n=t.useRef(null),r=t.useCallback(()=>{n.current=null},[]);t.useEffect(()=>{u&&r()},[r,u]);const a=t.useCallback(e=>{if(!(u||y.isGestureBusy(c.current.status)||c.current.progress>=1)){if(e.key==="Escape"){e.preventDefault(),r();return}if(!(e.key!=="Enter"&&e.key!==" ")){if(e.repeat||n.current){e.preventDefault();return}e.preventDefault(),n.current=e.key}}},[r,u,c]),o=t.useCallback(e=>{e.key===n.current&&(e.preventDefault(),n.current=null,!(u||c.current.status==="pending")&&l())},[u,l,c]),s=t.useCallback(()=>{r()},[r]);return{handleKeyDown:a,handleKeyUp:o,handleBlur:s,cancelKeyboardGesture:r}};exports.useSlideKeyboardActivate=f;

package/dist/components/SlideToActivate/hooks/useSlideKeyboardActivate.d.ts

@@ -0,0 +1,14 @@
+import { MutableRefObject, KeyboardEvent as ReactKeyboardEvent } from 'react';
+import { SlideToActivateState } from '../slideToActivateReducer';
+interface UseSlideKeyboardActivateOptions {
+    isDisabled: boolean;
+    stateRef: MutableRefObject<SlideToActivateState>;
+    runActivation: () => Promise<void>;
+}
+export declare const useSlideKeyboardActivate: ({ isDisabled, stateRef, runActivation }: UseSlideKeyboardActivateOptions) => {
+    handleKeyDown: (event: ReactKeyboardEvent<HTMLButtonElement>) => void;
+    handleKeyUp: (event: ReactKeyboardEvent<HTMLButtonElement>) => void;
+    handleBlur: () => void;
+    cancelKeyboardGesture: () => void;
+};
+export {};

package/dist/components/SlideToActivate/hooks/useSlideKeyboardActivate.js

@@ -0,0 +1,44 @@
+import { useRef as y, useCallback as c, useEffect as a } from "react";
+import { isGestureBusy as s } from "../slideToActivateUtils.js";
+const m = ({ isDisabled: u, stateRef: n, runActivation: o }) => {
+  const t = y(null), e = c(() => {
+    t.current = null;
+  }, []);
+  a(() => {
+    u && e();
+  }, [e, u]);
+  const f = c(
+    (r) => {
+      if (!(u || s(n.current.status) || n.current.progress >= 1)) {
+        if (r.key === "Escape") {
+          r.preventDefault(), e();
+          return;
+        }
+        if (!(r.key !== "Enter" && r.key !== " ")) {
+          if (r.repeat || t.current) {
+            r.preventDefault();
+            return;
+          }
+          r.preventDefault(), t.current = r.key;
+        }
+      }
+    },
+    [e, u, n]
+  ), l = c(
+    (r) => {
+      r.key === t.current && (r.preventDefault(), t.current = null, !(u || n.current.status === "pending") && o());
+    },
+    [u, o, n]
+  ), p = c(() => {
+    e();
+  }, [e]);
+  return {
+    handleKeyDown: f,
+    handleKeyUp: l,
+    handleBlur: p,
+    cancelKeyboardGesture: e
+  };
+};
+export {
+  m as useSlideKeyboardActivate
+};

package/dist/components/SlideToActivate/hooks/useSlideToActivate.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react"),b=require("../slideToActivateReducer.cjs"),S=require("../slideToActivateUtils.cjs"),F=require("../types.cjs"),O=require("./useSlideDragHandlers.cjs"),j=require("./useSlideKeyboardActivate.cjs"),B=({direction:d,isDisabled:s,reduceMotion:p,pendingAnnouncement:h,successAnnouncement:A,errorAnnouncement:m,resetOnError:k,onActivation:C,onError:y,onProgress:v,onStatusChange:P})=>{const[a,K]=e.useReducer(b.slideToActivateReducer,b.initialSlideToActivateState),n=e.useRef(a),t=e.useCallback(r=>{n.current=b.slideToActivateReducer(n.current,r),K(r)},[]),R=e.useRef(null),g=e.useRef(null),c=e.useRef(null),l=e.useRef(!0),i=e.useCallback(()=>{const r=R.current,f=g.current;!r||!f||t({type:"measured",maxTravel:S.measureMaxTravel({track:r,thumb:f,direction:d})})},[d,t]);e.useLayoutEffect(()=>{i()},[i]),e.useEffect(()=>{const r=R.current;if(!r||typeof ResizeObserver>"u")return;const f=new ResizeObserver(()=>i());return f.observe(r),()=>f.disconnect()},[i]);const o=e.useCallback(r=>{t({type:"progressChanged",progress:r}),v?.(r)},[t,v]),u=e.useCallback(()=>{c.current&&(clearTimeout(c.current),c.current=null)},[]);e.useEffect(()=>(l.current=!0,()=>{l.current=!1,u()}),[u]);const T=e.useCallback(()=>{u(),o(0),t({type:"snapStarted",immediate:p}),!p&&(c.current=setTimeout(()=>{l.current&&(t({type:"snapCompleted"}),c.current=null)},S.SNAP_MS))},[u,t,o,p]),q=e.useCallback(async()=>{if(n.current.status!=="pending"){o(1),t({type:"activationStarted",announcement:h});try{if(await C?.(),!l.current)return;u(),t({type:"activationSucceeded",announcement:A})}catch(r){if(!l.current)return;y?y(r):console.error(r),k?(t({type:"activationFailed",announcement:m}),T()):t({type:"activationFailedHeld",announcement:m})}}},[u,t,o,m,C,y,h,k,T,A]),M=e.useRef(s);e.useEffect(()=>{M.current&&!s&&(u(),t({type:"reset"}),v?.(0)),M.current=s},[u,t,s,v]);const w=e.useRef(!1);e.useEffect(()=>{if(!w.current){w.current=!0;return}P?.(a.status)},[a.status,P]);const{handleKeyDown:N,handleKeyUp:_,handleBlur:x,cancelKeyboardGesture:D}=j.useSlideKeyboardActivate({isDisabled:s,stateRef:n,runActivation:q}),{handlePointerDown:E,handlePointerMove:H,handlePointerUp:U,handlePointerCancel:z}=O.useSlideDragHandlers({direction:d,isDisabled:s,stateRef:n,measureTravel:()=>{D(),i()},dispatch:t,emitProgress:o,runActivation:q,snapToIdle:T});return{progress:a.progress,status:a.status,announcement:a.announcement,trackRef:R,thumbRef:g,thumbTranslatePx:a.progress*a.maxTravel*(d===F.SlideToActivateDirections.rtl?-1:1),handlePointerDown:E,handlePointerMove:H,handlePointerUp:U,handlePointerCancel:z,handleKeyDown:N,handleKeyUp:_,handleBlur:x,snapDurationMs:p?0:S.SNAP_MS}};exports.SNAP_MS=S.SNAP_MS;exports.useSlideToActivate=B;

package/dist/components/SlideToActivate/hooks/useSlideToActivate.d.ts

@@ -0,0 +1,33 @@
+import { SlideToActivateStatus } from '../slideToActivateUtils';
+import { SlideToActivateDirections } from '../types';
+export type { SlideToActivateStatus } from '../slideToActivateUtils';
+export { SNAP_MS } from '../slideToActivateUtils';
+export interface UseSlideToActivateOptions {
+    direction: SlideToActivateDirections | `${SlideToActivateDirections}`;
+    isDisabled: boolean;
+    reduceMotion: boolean;
+    pendingAnnouncement: string;
+    successAnnouncement: string;
+    errorAnnouncement: string;
+    resetOnError: boolean;
+    onActivation?: () => void | Promise<void>;
+    onError?: (error: unknown) => void;
+    onProgress?: (progress: number) => void;
+    onStatusChange?: (status: SlideToActivateStatus) => void;
+}
+export declare const useSlideToActivate: ({ direction, isDisabled, reduceMotion, pendingAnnouncement, successAnnouncement, errorAnnouncement, resetOnError, onActivation, onError, onProgress, onStatusChange, }: UseSlideToActivateOptions) => {
+    progress: number;
+    status: SlideToActivateStatus;
+    announcement: string;
+    trackRef: import('react').RefObject<HTMLDivElement>;
+    thumbRef: import('react').RefObject<HTMLButtonElement>;
+    thumbTranslatePx: number;
+    handlePointerDown: (event: import('react').PointerEvent<HTMLButtonElement>) => void;
+    handlePointerMove: (event: import('react').PointerEvent<HTMLButtonElement>) => void;
+    handlePointerUp: () => void;
+    handlePointerCancel: () => void;
+    handleKeyDown: (event: import('react').KeyboardEvent<HTMLButtonElement>) => void;
+    handleKeyUp: (event: import('react').KeyboardEvent<HTMLButtonElement>) => void;
+    handleBlur: () => void;
+    snapDurationMs: number;
+};

package/dist/components/SlideToActivate/hooks/useSlideToActivate.js

@@ -0,0 +1,122 @@
+import { useReducer as O, useRef as a, useCallback as c, useLayoutEffect as _, useEffect as y } from "react";
+import { slideToActivateReducer as A, initialSlideToActivateState as j } from "../slideToActivateReducer.js";
+import { measureMaxTravel as q, SNAP_MS as D } from "../slideToActivateUtils.js";
+import { SlideToActivateDirections as E } from "../types.js";
+import { useSlideDragHandlers as J } from "./useSlideDragHandlers.js";
+import { useSlideKeyboardActivate as Q } from "./useSlideKeyboardActivate.js";
+const ee = ({
+  direction: m,
+  isDisabled: u,
+  reduceMotion: d,
+  pendingAnnouncement: b,
+  successAnnouncement: w,
+  errorAnnouncement: T,
+  resetOnError: k,
+  onActivation: x,
+  onError: h,
+  onProgress: v,
+  onStatusChange: K
+}) => {
+  const [r, F] = O(A, j), s = a(r), e = c((t) => {
+    s.current = A(s.current, t), F(t);
+  }, []), R = a(null), g = a(null), o = a(null), i = a(!0), l = c(() => {
+    const t = R.current, p = g.current;
+    !t || !p || e({ type: "measured", maxTravel: q({ track: t, thumb: p, direction: m }) });
+  }, [m, e]);
+  _(() => {
+    l();
+  }, [l]), y(() => {
+    const t = R.current;
+    if (!t || typeof ResizeObserver > "u")
+      return;
+    const p = new ResizeObserver(() => l());
+    return p.observe(t), () => p.disconnect();
+  }, [l]);
+  const f = c(
+    (t) => {
+      e({ type: "progressChanged", progress: t }), v?.(t);
+    },
+    [e, v]
+  ), n = c(() => {
+    o.current && (clearTimeout(o.current), o.current = null);
+  }, []);
+  y(() => (i.current = !0, () => {
+    i.current = !1, n();
+  }), [n]);
+  const S = c(() => {
+    n(), f(0), e({ type: "snapStarted", immediate: d }), !d && (o.current = setTimeout(() => {
+      i.current && (e({ type: "snapCompleted" }), o.current = null);
+    }, D));
+  }, [n, e, f, d]), C = c(async () => {
+    if (s.current.status !== "pending") {
+      f(1), e({ type: "activationStarted", announcement: b });
+      try {
+        if (await x?.(), !i.current)
+          return;
+        n(), e({ type: "activationSucceeded", announcement: w });
+      } catch (t) {
+        if (!i.current)
+          return;
+        h ? h(t) : console.error(t), k ? (e({ type: "activationFailed", announcement: T }), S()) : e({ type: "activationFailedHeld", announcement: T });
+      }
+    }
+  }, [
+    n,
+    e,
+    f,
+    T,
+    x,
+    h,
+    b,
+    k,
+    S,
+    w
+  ]), P = a(u);
+  y(() => {
+    P.current && !u && (n(), e({ type: "reset" }), v?.(0)), P.current = u;
+  }, [n, e, u, v]);
+  const z = a(!1);
+  y(() => {
+    if (!z.current) {
+      z.current = !0;
+      return;
+    }
+    K?.(r.status);
+  }, [r.status, K]);
+  const { handleKeyDown: H, handleKeyUp: M, handleBlur: U, cancelKeyboardGesture: B } = Q({
+    isDisabled: u,
+    stateRef: s,
+    runActivation: C
+  }), { handlePointerDown: G, handlePointerMove: I, handlePointerUp: L, handlePointerCancel: N } = J({
+    direction: m,
+    isDisabled: u,
+    stateRef: s,
+    measureTravel: () => {
+      B(), l();
+    },
+    dispatch: e,
+    emitProgress: f,
+    runActivation: C,
+    snapToIdle: S
+  });
+  return {
+    progress: r.progress,
+    status: r.status,
+    announcement: r.announcement,
+    trackRef: R,
+    thumbRef: g,
+    thumbTranslatePx: r.progress * r.maxTravel * (m === E.rtl ? -1 : 1),
+    handlePointerDown: G,
+    handlePointerMove: I,
+    handlePointerUp: L,
+    handlePointerCancel: N,
+    handleKeyDown: H,
+    handleKeyUp: M,
+    handleBlur: U,
+    snapDurationMs: d ? 0 : D
+  };
+};
+export {
+  D as SNAP_MS,
+  ee as useSlideToActivate
+};

package/dist/components/SlideToActivate/index.d.ts

@@ -0,0 +1,4 @@
+export { default as SlideToActivate } from './SlideToActivate';
+export type { SlideToActivateConfig, SlideToActivateProps } from './types';
+export type { SlideToActivateStatus } from './slideToActivateUtils';
+export { SlideToActivateDirections, SlideToActivateSizes, SlideToActivateBorderRadii } from './types';

package/dist/components/SlideToActivate/slideToActivateReducer.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a={status:"idle",progress:0,maxTravel:0,announcement:""};function u(e,n){switch(n.type){case"measured":return n.maxTravel===e.maxTravel?e:{...e,maxTravel:n.maxTravel};case"dragStarted":return e.status==="dragging"?e:{...e,status:"dragging"};case"progressChanged":return n.progress===e.progress?e:{...e,progress:n.progress};case"activationStarted":return{...e,status:"pending",announcement:n.announcement};case"activationSucceeded":return{...e,status:"idle",announcement:n.announcement};case"activationFailed":return{...e,announcement:n.announcement};case"activationFailedHeld":return{...e,status:"idle",announcement:n.announcement};case"snapStarted":{const r=n.immediate?"idle":"snapping";return r===e.status?e:{...e,status:r}}case"snapCompleted":return e.status==="idle"?e:{...e,status:"idle"};case"reset":return e.status==="idle"&&e.progress===0?e:{...e,status:"idle",progress:0};default:return e}}exports.initialSlideToActivateState=a;exports.slideToActivateReducer=u;

package/dist/components/SlideToActivate/slideToActivateReducer.d.ts

@@ -0,0 +1,37 @@
+import { SlideToActivateStatus } from './slideToActivateUtils';
+export interface SlideToActivateState {
+    status: SlideToActivateStatus;
+    progress: number;
+    maxTravel: number;
+    announcement: string;
+}
+export declare const initialSlideToActivateState: SlideToActivateState;
+export type SlideToActivateAction = {
+    type: 'measured';
+    maxTravel: number;
+} | {
+    type: 'dragStarted';
+} | {
+    type: 'progressChanged';
+    progress: number;
+} | {
+    type: 'activationStarted';
+    announcement: string;
+} | {
+    type: 'activationSucceeded';
+    announcement: string;
+} | {
+    type: 'activationFailed';
+    announcement: string;
+} | {
+    type: 'activationFailedHeld';
+    announcement: string;
+} | {
+    type: 'snapStarted';
+    immediate: boolean;
+} | {
+    type: 'snapCompleted';
+} | {
+    type: 'reset';
+};
+export declare function slideToActivateReducer(state: SlideToActivateState, action: SlideToActivateAction): SlideToActivateState;

package/dist/components/SlideToActivate/slideToActivateReducer.js

@@ -0,0 +1,38 @@
+const u = {
+  status: "idle",
+  progress: 0,
+  maxTravel: 0,
+  announcement: ""
+};
+function a(e, n) {
+  switch (n.type) {
+    case "measured":
+      return n.maxTravel === e.maxTravel ? e : { ...e, maxTravel: n.maxTravel };
+    case "dragStarted":
+      return e.status === "dragging" ? e : { ...e, status: "dragging" };
+    case "progressChanged":
+      return n.progress === e.progress ? e : { ...e, progress: n.progress };
+    case "activationStarted":
+      return { ...e, status: "pending", announcement: n.announcement };
+    case "activationSucceeded":
+      return { ...e, status: "idle", announcement: n.announcement };
+    case "activationFailed":
+      return { ...e, announcement: n.announcement };
+    case "activationFailedHeld":
+      return { ...e, status: "idle", announcement: n.announcement };
+    case "snapStarted": {
+      const r = n.immediate ? "idle" : "snapping";
+      return r === e.status ? e : { ...e, status: r };
+    }
+    case "snapCompleted":
+      return e.status === "idle" ? e : { ...e, status: "idle" };
+    case "reset":
+      return e.status === "idle" && e.progress === 0 ? e : { ...e, status: "idle", progress: 0 };
+    default:
+      return e;
+  }
+}
+export {
+  u as initialSlideToActivateState,
+  a as slideToActivateReducer
+};

package/dist/components/SlideToActivate/slideToActivateUtils.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=200,o="Press Space or Enter to activate. Press Escape to cancel.",i=t=>Math.min(1,Math.max(0,t)),u=t=>t==="pending"||t==="snapping",l=({track:t,thumb:e,direction:s})=>{const r=t.getBoundingClientRect(),a=e.getBoundingClientRect(),c=s==="rtl"?Math.max(0,r.right-a.right):Math.max(0,a.left-r.left);return Math.max(0,r.width-a.width-c*2)},g=({event:t,thumb:e,isInteractive:s,isThumbHidden:r})=>{!s||r||!e||e.contains(t.target)||(t.preventDefault(),e.focus())};exports.DEFAULT_KEYBOARD_HINT=o;exports.SNAP_MS=n;exports.clampProgress=i;exports.focusThumbFromTrack=g;exports.isGestureBusy=u;exports.measureMaxTravel=l;

package/dist/components/SlideToActivate/slideToActivateUtils.d.ts

@@ -0,0 +1,19 @@
+import { PointerEvent as ReactPointerEvent } from 'react';
+export type SlideToActivateStatus = 'idle' | 'dragging' | 'pending' | 'snapping';
+export declare const SNAP_MS = 200;
+export declare const DEFAULT_KEYBOARD_HINT = "Press Space or Enter to activate. Press Escape to cancel.";
+export declare const clampProgress: (value: number) => number;
+/** True while a new gesture should not start. */
+export declare const isGestureBusy: (status: SlideToActivateStatus) => status is "pending" | "snapping";
+export declare const measureMaxTravel: ({ track, thumb, direction, }: {
+    track: HTMLElement;
+    thumb: HTMLElement;
+    direction: "ltr" | "rtl";
+}) => number;
+/** Clicking the track (outside the thumb) focuses the thumb instead of leaving focus stuck on nothing. */
+export declare const focusThumbFromTrack: ({ event, thumb, isInteractive, isThumbHidden, }: {
+    event: ReactPointerEvent<HTMLDivElement>;
+    thumb: HTMLButtonElement | null;
+    isInteractive: boolean;
+    isThumbHidden: boolean;
+}) => void;

package/dist/components/SlideToActivate/slideToActivateUtils.js

@@ -0,0 +1,23 @@
+const r = 200, o = "Press Space or Enter to activate. Press Escape to cancel.", i = (t) => Math.min(1, Math.max(0, t)), g = (t) => t === "pending" || t === "snapping", h = ({
+  track: t,
+  thumb: e,
+  direction: c
+}) => {
+  const n = t.getBoundingClientRect(), a = e.getBoundingClientRect(), s = c === "rtl" ? Math.max(0, n.right - a.right) : Math.max(0, a.left - n.left);
+  return Math.max(0, n.width - a.width - s * 2);
+}, l = ({
+  event: t,
+  thumb: e,
+  isInteractive: c,
+  isThumbHidden: n
+}) => {
+  !c || n || !e || e.contains(t.target) || (t.preventDefault(), e.focus());
+};
+export {
+  o as DEFAULT_KEYBOARD_HINT,
+  r as SNAP_MS,
+  i as clampProgress,
+  l as focusThumbFromTrack,
+  g as isGestureBusy,
+  h as measureMaxTravel
+};

package/dist/components/SlideToActivate/slideToActivateUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/SlideToActivate/types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../Button/types.cjs");var e=(t=>(t.ltr="ltr",t.rtl="rtl",t))(e||{});const s=l.ButtonSizes;var r=(t=>(t.sharp="sharp",t.rounded="rounded",t.pill="pill",t))(r||{});exports.SlideToActivateBorderRadii=r;exports.SlideToActivateDirections=e;exports.SlideToActivateSizes=s;

package/dist/components/SlideToActivate/types.d.ts

@@ -0,0 +1,105 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { ButtonSizes } from '../Button/types';
+import { TextVariants } from '../Text';
+import { SlideToActivateStatus } from './slideToActivateUtils';
+export declare enum SlideToActivateDirections {
+    ltr = "ltr",
+    rtl = "rtl"
+}
+/** Matches Button's size scale (default 44 / small 32) — reused rather than redeclared. */
+export declare const SlideToActivateSizes: typeof ButtonSizes;
+export type SlideToActivateSizes = ButtonSizes;
+/**
+ * Shared corner radius for track, thumb face, and focus ring.
+ * `sharp` is 0 to match Saleroom Bid Status; `rounded` / `pill` for branded variants.
+ */
+export declare enum SlideToActivateBorderRadii {
+    sharp = "sharp",
+    rounded = "rounded",
+    pill = "pill"
+}
+/** Visual and behavioural tuning props, grouped to reduce top-level prop count. */
+export interface SlideToActivateConfig {
+    /** Text variant for the track label. Default `labelMedium`. */
+    textVariant?: TextVariants;
+    /** Control height; matches Button default (44) / small (32). */
+    size?: SlideToActivateSizes | `${SlideToActivateSizes}`;
+    /** Corner radius shared by track, thumb face, and focus ring. Default `sharp` (0 — Figma Bid Status). */
+    borderRadius?: SlideToActivateBorderRadii | `${SlideToActivateBorderRadii}`;
+    /** Swipe direction. Default `ltr`. */
+    direction?: SlideToActivateDirections | `${SlideToActivateDirections}`;
+    /**
+     * Icon rendered inside the thumb (decorative). Defaults to a double ChevronRight
+     * matching the Saleroom Figma Bid Status control. Pass `null` to hide.
+     */
+    thumbIcon?: ReactNode;
+    /** When set, thumb becomes a pill of this width (px); otherwise square like Button. */
+    thumbWidth?: number;
+    /** Pending UI while awaiting `onActivation`. Defaults to Seldon `Loader`. */
+    pendingIndicator?: ReactNode;
+    trackClassName?: string;
+    thumbClassName?: string;
+}
+export interface SlideToActivateProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onProgress'> {
+    /** Visible label; also used as the accessible name. Consumer owns idle/pending copy. */
+    labelText: string;
+    /**
+     * Called when activation threshold/edge is reached on release (or via keyboard).
+     *
+     * After this resolves, the component enters `idle` with `progress=1` — the thumb stays
+     * latched at the end and re-activation is blocked by the `progress >= 1` guard. Pass
+     * `isComplete` to present the settled visual state (implies non-interactive).
+     */
+    onActivation?: () => void | Promise<void>;
+    /** Called on `onActivation` rejection when provided; otherwise the error is `console.error`ed. */
+    onError?: (error: unknown) => void;
+    /** Fired while dragging with progress in `[0, 1]`. */
+    onProgress?: (progress: number) => void;
+    /**
+     * Screen-reader announcement while `onActivation` is pending, via a persistent `aria-live`
+     * region (separate from the visible label). Default: `labelText`.
+     */
+    pendingAnnouncement?: string;
+    /** Screen-reader announcement once `onActivation` resolves. Default `'Activated.'`. */
+    successAnnouncement?: string;
+    /**
+     * Screen-reader announcement when `onActivation` rejects. Default
+     * `'Action failed. Please try again.'`.
+     */
+    errorAnnouncement?: string;
+    /**
+     * Visually hidden keyboard instructions exposed via `aria-describedby` on the thumb.
+     * Default: `'Press Space or Enter to activate. Press Escape to cancel.'`.
+     * Pass an empty string to omit the description.
+     */
+    keyboardHint?: string;
+    /**
+     * Called on every status transition after mount. Useful for syncing external state to
+     * the component's gesture lifecycle (e.g. dimming sibling elements while `dragging`).
+     */
+    onStatusChange?: (status: SlideToActivateStatus) => void;
+    /**
+     * When `false`, the component does not snap back to idle after `onActivation` rejects —
+     * the thumb stays latched and status returns to `idle`. Consumer is responsible for the
+     * reset (typically `isComplete`). Default `true`.
+     */
+    resetOnError?: boolean;
+    /**
+     * Blocks pointer and keyboard activation with the "blocked" visual
+     * (grey track/label). Ignored for interaction when `isComplete` is also set —
+     * complete appearance wins.
+     */
+    isDisabled?: boolean;
+    /**
+     * Settled success state: dark track, white label, hidden thumb, and non-interactive.
+     * Implies disabled — no need to also pass `isDisabled`.
+     */
+    isComplete?: boolean;
+    /**
+     * When `false` and `isDisabled` is `true`, the thumb is hidden.
+     * Ignored when `isComplete` is `true` (thumb is always hidden then). Default `true`.
+     */
+    showThumbWhenDisabled?: boolean;
+    /** Visual and behavioural tuning. All properties are optional with sensible defaults. */
+    config?: SlideToActivateConfig;
+}

package/dist/components/SlideToActivate/types.js

@@ -0,0 +1,9 @@
+import { ButtonSizes as l } from "../Button/types.js";
+var p = /* @__PURE__ */ ((r) => (r.ltr = "ltr", r.rtl = "rtl", r))(p || {});
+const u = l;
+var t = /* @__PURE__ */ ((r) => (r.sharp = "sharp", r.rounded = "rounded", r.pill = "pill", r))(t || {});
+export {
+  t as SlideToActivateBorderRadii,
+  p as SlideToActivateDirections,
+  u as SlideToActivateSizes
+};

package/dist/components/Toast/ToastContextProvider.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("react/jsx-runtime"),c=require("../../node_modules/@radix-ui/react-toast/dist/index.cjs"),s=require("react"),v=require("./Toast.cjs"),T=require("../../utils/index.cjs"),j=require("../../node_modules/uuid/dist/esm-browser/v4.cjs"),d=s.createContext(void 0),p=({children:u})=>{const[i,n]=s.useState([]),l=s.useCallback(e=>{const t=j.default();n(r=>[...r,{...e,id:t}])},[]),a=s.useCallback(e=>{n(t=>t.filter(r=>r.id!==e))},[]),x={toasts:i,addToast:l,removeToast:a};return o.jsx(d.Provider,{value:x,children:o.jsxs(c.Provider,{children:[u,o.jsx(c.Viewport,{className:`${T.px}-toast-viewport`}),i.map(e=>o.jsx(v.default,{...e,onOpenChange:t=>!t&&a(e.id),title:e.title??""},e.id))]})})};exports.ToastContext=d;exports.ToastProvider=p;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("react/jsx-runtime"),c=require("../../node_modules/@radix-ui/react-toast/dist/index.cjs"),s=require("react"),v=require("./Toast.cjs"),T=require("../../utils/index.cjs"),j=require("../../node_modules/uuid/dist/v4.cjs"),d=s.createContext(void 0),p=({children:u})=>{const[i,n]=s.useState([]),l=s.useCallback(e=>{const t=j.default();n(r=>[...r,{...e,id:t}])},[]),a=s.useCallback(e=>{n(t=>t.filter(r=>r.id!==e))},[]),x={toasts:i,addToast:l,removeToast:a};return o.jsx(d.Provider,{value:x,children:o.jsxs(c.Provider,{children:[u,o.jsx(c.Viewport,{className:`${T.px}-toast-viewport`}),i.map(e=>o.jsx(v.default,{...e,onOpenChange:t=>!t&&a(e.id),title:e.title??""},e.id))]})})};exports.ToastContext=d;exports.ToastProvider=p;

package/dist/components/Toast/ToastContextProvider.js

@@ -3,7 +3,7 @@ import { Provider as l, Viewport as v } from "../../node_modules/@radix-ui/react
 import { useState as f, useCallback as m, createContext as x } from "react";
 import T from "./Toast.js";
 import { px as u } from "../../utils/index.js";
-import C from "../../node_modules/uuid/dist/esm-browser/v4.js";
+import C from "../../node_modules/uuid/dist/v4.js";
 const h = x(void 0), N = ({ children: n }) => {
   const [s, i] = f([]), c = m((o) => {
     const t = C();