impact-nova 2.0.8 → 2.1.0-alpha.1

package/dist/components/forms/select/select.variants.js

@@ -0,0 +1,76 @@
+import { cva as e } from "class-variance-authority";
+const s = e(
+  "relative w-full cursor-pointer rounded-[8px] border border-solid px-3 py-1 text-start shadow-sm sm:text-sm transition-all flex items-center overflow-hidden",
+  {
+    variants: {
+      size: {
+        default: "h-[32px]",
+        sm: "h-6",
+        md: "h-[28px]",
+        lg: "h-10"
+      },
+      error: {
+        true: "border-destructive focus-visible:ring-destructive",
+        false: "border-stroke-field hover:border-stroke focus-visible:border-brand focus-visible:ring-1 focus-visible:ring-focus-ring"
+      },
+      disabled: {
+        true: "bg-canvas-disabled cursor-not-allowed opacity-75",
+        false: ""
+      },
+      readOnly: {
+        true: "cursor-default bg-canvas-disabled",
+        false: ""
+      },
+      open: {
+        true: "ring-1 ring-focus-ring border-brand",
+        false: ""
+      }
+    },
+    compoundVariants: [
+      {
+        disabled: !1,
+        readOnly: !1,
+        class: "bg-canvas-elevated"
+      }
+    ],
+    defaultVariants: {
+      size: "default",
+      error: !1,
+      disabled: !1,
+      readOnly: !1,
+      open: !1
+    }
+  }
+), a = e(
+  "cursor-default select-none py-[6px] px-3 flex items-center justify-between transition-colors rounded-md text-foreground",
+  {
+    variants: {
+      disabled: {
+        true: "opacity-50 cursor-not-allowed bg-disabled-surface",
+        false: "hover:bg-muted cursor-pointer"
+      },
+      readOnly: {
+        true: "cursor-default hover:bg-transparent",
+        false: ""
+      },
+      selected: {
+        true: "bg-accent text-foreground",
+        false: ""
+      },
+      highlighted: {
+        true: "ring-2 ring-inset ring-primary bg-accent",
+        false: ""
+      }
+    },
+    defaultVariants: {
+      disabled: !1,
+      readOnly: !1,
+      selected: !1,
+      highlighted: !1
+    }
+  }
+);
+export {
+  a as selectOptionVariants,
+  s as selectTriggerVariants
+};

package/dist/components/forms/select/utils/getSelectableOptionIndices.d.ts

@@ -0,0 +1,21 @@
+import { FlatOption } from '../hooks/useFlattenOptions';
+export interface SelectableIndicesParams {
+    isLoading: boolean;
+    isProcessing: boolean;
+    fetchError: unknown;
+    isMulti: boolean | undefined;
+    isSelectAllEnabled: boolean;
+    isReadOnly: boolean;
+    flatOptions: FlatOption[];
+    enableSubMenus: boolean;
+}
+export declare function hasSelectAllRow(params: {
+    isLoading: boolean;
+    isProcessing: boolean;
+    fetchError: unknown;
+    isMulti: boolean | undefined;
+    isSelectAllEnabled: boolean;
+    isReadOnly: boolean;
+    flatOptionsLength: number;
+}): boolean;
+export declare function getSelectableOptionIndices(params: SelectableIndicesParams): number[];

package/dist/components/forms/select/utils/getSelectableOptionIndices.js

@@ -0,0 +1,22 @@
+import { SELECT_ALL_INDEX as o } from "../select.constants.js";
+function c(i) {
+  return !i.isLoading && !i.isProcessing && !i.fetchError && !!i.isMulti && i.isSelectAllEnabled && !i.isReadOnly && i.flatOptionsLength > 0;
+}
+function d(i) {
+  const { flatOptions: l, enableSubMenus: t } = i, e = [];
+  return c({
+    isLoading: i.isLoading,
+    isProcessing: i.isProcessing,
+    fetchError: i.fetchError,
+    isMulti: i.isMulti,
+    isSelectAllEnabled: i.isSelectAllEnabled,
+    isReadOnly: i.isReadOnly,
+    flatOptionsLength: l.length
+  }) && e.push(o), l.forEach((n, s) => {
+    !n.isGroup && !(t && n.isSubmenuParent) && !n.isDisabled && e.push(s);
+  }), e;
+}
+export {
+  d as getSelectableOptionIndices,
+  c as hasSelectAllRow
+};

package/dist/components/forms/select/utils/hasClearableSelectValue.d.ts

@@ -0,0 +1,2 @@
+import { MultiValue, Option, SingleValue } from '../select.types';
+export declare function hasClearableSelectValue<OptionType extends Option>(isMulti: boolean | undefined, internalValue: SingleValue<OptionType> | MultiValue<OptionType> | null | undefined): boolean;

package/dist/components/forms/select/utils/hasClearableSelectValue.js

@@ -0,0 +1,11 @@
+import { isInvertedSelection as l, isOptionArray as o } from "./select.js";
+function i(r, t) {
+  if (r) {
+    const e = t || [];
+    return l(e) && e.isAllSelected || o(e) && e.length > 0;
+  }
+  return !!t;
+}
+export {
+  i as hasClearableSelectValue
+};

package/dist/components/forms/select/utils/select.d.ts

@@ -0,0 +1,12 @@
+import { Option, Group, MultiValue, SingleValue, InvertedSelection } from '../select.types';
+export declare const cx: (...classes: (string | undefined | null | false)[]) => string;
+export declare const isInvertedSelection: <OptionType extends Option>(value: MultiValue<OptionType>) => value is InvertedSelection;
+export declare const isOptionArray: <OptionType extends Option>(value: MultiValue<OptionType>) => value is readonly OptionType[];
+export declare const getLeafOptions: (option: Option | Group, enableSubMenus?: boolean, enableGroups?: boolean) => Option[];
+export declare const isSelected: <OptionType extends Option>(option: Option, internalValue: MultiValue<OptionType> | OptionType | null, isMulti: boolean) => boolean;
+export declare const getIndeterminateState: <OptionType extends Option>(option: Option, isMulti: boolean, internalValue: MultiValue<OptionType> | OptionType | null) => boolean;
+export declare const getSequence: <OptionType extends Option>(option: Option | {
+    naturalIndex?: number;
+    value: string;
+}, showSequence: boolean, isMulti: boolean, selectionOrder: string[] | undefined, internalValue: MultiValue<OptionType> | SingleValue<OptionType> | undefined) => number | undefined;
+export declare const getSelectedCount: <OptionType extends Option>(option: Option, isMulti: boolean, internalValue: MultiValue<OptionType> | OptionType | null) => number;

package/dist/components/forms/select/utils/selectFlatOptions.d.ts

@@ -0,0 +1,5 @@
+import { FlatOption } from '../hooks/useFlattenOptions';
+export declare function isSelectableFlatOption(option: FlatOption): boolean;
+export declare function hasSelectableFlatOptions(flatOptions: FlatOption[]): boolean;
+export declare function forEachSelectableFlatOption(flatOptions: FlatOption[], callback: (option: FlatOption) => void): void;
+export declare function collectSelectableFlatOptionValues(flatOptions: FlatOption[]): Set<string>;

package/dist/components/forms/select/utils/selectFlatOptions.js

@@ -0,0 +1,25 @@
+function l(e) {
+  return !e.isGroup && !e.isSubmenuParent && !e.isDisabled;
+}
+function a(e) {
+  for (const t of e)
+    if (l(t))
+      return !0;
+  return !1;
+}
+function o(e, t) {
+  for (const n of e)
+    l(n) && t(n);
+}
+function i(e) {
+  const t = /* @__PURE__ */ new Set();
+  return o(e, (n) => {
+    t.add(n.value);
+  }), t;
+}
+export {
+  i as collectSelectableFlatOptionValues,
+  o as forEachSelectableFlatOption,
+  a as hasSelectableFlatOptions,
+  l as isSelectableFlatOption
+};

package/dist/components/forms/select/utils/selectKeyboardNavigation.d.ts

@@ -0,0 +1,21 @@
+import { KeyboardEvent } from 'react';
+export type ScrollToHighlight = (index: number) => void;
+export interface MenuKeyboardNavigationContext {
+    selectableIndices: number[];
+    highlightedIndex: number;
+    flatOptionsLength: number;
+    setHighlightedIndex: (index: number) => void;
+    scrollToHighlight: ScrollToHighlight;
+    onSelectAll: () => void;
+    onSelectHighlightedOption: () => void;
+    onCloseMenu: () => void;
+    onFocusTrigger: () => void;
+}
+export interface MenuKeyboardNavigationOptions {
+    allowSpaceToSelect?: boolean;
+    allowHomeEnd?: boolean;
+}
+export declare function stepHighlightedIndex(direction: "next" | "prev", selectableIndices: number[], highlightedIndex: number): number;
+export declare function activateHighlightedOption(ctx: MenuKeyboardNavigationContext): void;
+export declare function handleMenuKeyboardEvent(e: KeyboardEvent, ctx: MenuKeyboardNavigationContext, options?: MenuKeyboardNavigationOptions): boolean;
+export declare const OPEN_MENU_KEYS: Set<string>;

package/dist/components/forms/select/utils/selectKeyboardNavigation.js

@@ -0,0 +1,78 @@
+import { SELECT_ALL_INDEX as g } from "../select.constants.js";
+function h(t, e, i) {
+  if (e.length === 0)
+    return i;
+  const r = e.indexOf(i);
+  if (t === "next") {
+    const o = r < e.length - 1 ? r + 1 : 0;
+    return e[o];
+  }
+  const l = r > 0 ? r - 1 : e.length - 1;
+  return e[l];
+}
+function s(t) {
+  if (t.highlightedIndex === g) {
+    t.onSelectAll();
+    return;
+  }
+  t.highlightedIndex >= 0 && t.highlightedIndex < t.flatOptionsLength && t.onSelectHighlightedOption();
+}
+function f(t, e, i = {}) {
+  const { selectableIndices: r } = e;
+  if (r.length === 0)
+    return !1;
+  const { allowSpaceToSelect: l = !1, allowHomeEnd: o = !1 } = i;
+  switch (t.key) {
+    case "ArrowDown": {
+      t.preventDefault();
+      const n = h(
+        "next",
+        r,
+        e.highlightedIndex
+      );
+      return e.setHighlightedIndex(n), n >= 0 && e.scrollToHighlight(n), !0;
+    }
+    case "ArrowUp": {
+      t.preventDefault();
+      const n = h(
+        "prev",
+        r,
+        e.highlightedIndex
+      );
+      return e.setHighlightedIndex(n), n >= 0 && e.scrollToHighlight(n), !0;
+    }
+    case "Enter":
+    case " ":
+      return t.key === " " && !l ? !1 : (t.preventDefault(), s(e), !0);
+    case "Escape":
+      return t.preventDefault(), e.onCloseMenu(), e.onFocusTrigger(), !0;
+    case "Home": {
+      if (!o)
+        return !1;
+      t.preventDefault();
+      const n = r[0];
+      return e.setHighlightedIndex(n), n >= 0 && e.scrollToHighlight(n), !0;
+    }
+    case "End": {
+      if (!o)
+        return !1;
+      t.preventDefault();
+      const n = r[r.length - 1];
+      return e.setHighlightedIndex(n), n >= 0 && e.scrollToHighlight(n), !0;
+    }
+    default:
+      return !1;
+  }
+}
+const a = /* @__PURE__ */ new Set([
+  "Enter",
+  " ",
+  "ArrowDown",
+  "ArrowUp"
+]);
+export {
+  a as OPEN_MENU_KEYS,
+  s as activateHighlightedOption,
+  f as handleMenuKeyboardEvent,
+  h as stepHighlightedIndex
+};

package/dist/components/forms/select/workers/flatten.worker.d.ts

@@ -0,0 +1,9 @@
+import { Option, Group } from '../select.types';
+export interface FlatOption extends Option {
+    depth: number;
+    isGroup?: boolean;
+    isSubmenuParent?: boolean;
+    parent?: FlatOption;
+    original: Option | Group;
+    naturalIndex?: number;
+}

package/dist/components/forms/slider/index.d.ts

@@ -0,0 +1,2 @@
+export { Slider } from './slider';
+export type { SliderProps } from './slider.types';

package/dist/components/forms/slider/index.js

@@ -0,0 +1,4 @@
+import { Slider as o } from "./slider.js";
+export {
+  o as Slider
+};

package/dist/components/forms/slider/slider.js

@@ -0,0 +1,57 @@
+import { jsxs as d, jsx as o } from "react/jsx-runtime";
+import * as c from "react";
+import * as e from "@radix-ui/react-slider";
+import { cn as b } from "../../../lib/utils.js";
+import { useImpactNovaI18n as u } from "../../../i18n/use-impact-nova-i18n.js";
+const m = c.forwardRef(({ className: r, "aria-label": i, ...a }, n) => {
+  const { t: s } = u(), l = i ?? s("aria.slider");
+  return /* @__PURE__ */ d(
+    e.Root,
+    {
+      ref: n,
+      "aria-label": l,
+      className: b(
+        "relative flex w-full touch-none select-none items-center",
+        r
+      ),
+      ...a,
+      "data-component": "slider",
+      children: [
+        /* @__PURE__ */ o(
+          e.Track,
+          {
+            className: "relative h-1.5 w-full grow overflow-hidden rounded-full bg-brand/20",
+            "data-component": "slider-track",
+            children: /* @__PURE__ */ o(
+              e.Range,
+              {
+                className: "absolute h-full bg-brand",
+                "data-component": "slider-range"
+              }
+            )
+          }
+        ),
+        Array.isArray(a.value || a.defaultValue) ? (a.value || a.defaultValue || []).map((f, t) => /* @__PURE__ */ o(
+          e.Thumb,
+          {
+            "aria-label": l,
+            className: "block h-4 w-4 rounded-full border border-brand/50 bg-canvas shadow transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-focus-ring disabled:pointer-events-none disabled:opacity-50",
+            "data-component": "slider-thumb"
+          },
+          t
+        )) : /* @__PURE__ */ o(
+          e.Thumb,
+          {
+            "aria-label": l,
+            className: "block h-4 w-4 rounded-full border border-brand/50 bg-canvas shadow transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-focus-ring disabled:pointer-events-none disabled:opacity-50",
+            "data-component": "slider-thumb"
+          }
+        )
+      ]
+    }
+  );
+});
+m.displayName = e.Root.displayName;
+export {
+  m as Slider
+};

package/dist/components/forms/smart-input/index.d.ts

@@ -0,0 +1,2 @@
+export { SmartInput } from './smart-input';
+export type { SmartInputProps, ComparisonOperator } from './smart-input.types';

package/dist/components/forms/smart-input/index.js

@@ -0,0 +1,4 @@
+import { SmartInput as m } from "./smart-input.js";
+export {
+  m as SmartInput
+};

package/dist/components/forms/smart-input/smart-input.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { SmartInputProps } from './smart-input.types';
+export type { SmartInputProps, ComparisonOperator } from './smart-input.types';
+declare const SmartInput: React.ForwardRefExoticComponent<SmartInputProps & React.RefAttributes<HTMLInputElement>>;
+export { SmartInput };

package/dist/components/forms/smart-input/smart-input.js

@@ -0,0 +1,188 @@
+import { jsx as P } from "react/jsx-runtime";
+import { forwardRef as E, useState as x } from "react";
+import { Input as L } from "../input/input.js";
+const ee = E(function({
+  value: S,
+  type: C = "text",
+  onChange: v,
+  onBlur: b,
+  onFocus: z,
+  allowNegative: D = !0,
+  min: s,
+  max: u,
+  minOperator: F,
+  maxOperator: K,
+  min_operator: O = ">=",
+  max_operator: W = "<=",
+  maxIntegerDigits: V,
+  decimalPlaces: c,
+  enforceDecimal: j = !1,
+  allowDecimal: y = !0,
+  maxLength: i,
+  trimLeadingSpaces: B = !0,
+  customValidator: N,
+  onValidationError: p,
+  disabled: h = !1,
+  ...k
+}, R) {
+  const $ = S !== void 0, [T, w] = x(""), l = $ ? String(S ?? "") : T, a = C === "number", g = F ?? O, m = K ?? W, U = (t) => {
+    if (s === void 0) return !0;
+    switch (g) {
+      case ">":
+        return t > s;
+      case ">=":
+        return t >= s;
+      case "<":
+        return t < s;
+      case "<=":
+        return t <= s;
+      default:
+        return !0;
+    }
+  }, q = (t) => {
+    if (u === void 0) return !0;
+    switch (m) {
+      case ">":
+        return t > u;
+      case ">=":
+        return t >= u;
+      case "<":
+        return t < u;
+      case "<=":
+        return t <= u;
+      default:
+        return !0;
+    }
+  }, A = (t) => {
+    let e = t;
+    if (s !== void 0) {
+      const r = g === ">" ? s + 0.01 : s;
+      e = Math.max(e, r);
+    }
+    if (u !== void 0) {
+      const r = m === "<" ? u - 0.01 : u;
+      e = Math.min(e, r);
+    }
+    return e;
+  }, G = (t) => {
+    const e = D ? /[^0-9.-]/g : /[^0-9.]/g;
+    return t.replace(e, "");
+  }, H = (t) => {
+    const e = t.split(".");
+    return e.length > 2 ? e[0] + "." + e.slice(1).join("") : t;
+  }, J = (t, e) => {
+    if (!D) return t;
+    if ((t.match(/-/g) || []).length > 1) {
+      let n = t.replace(/-/g, "");
+      return e.startsWith("-") && (n = "-" + n), n;
+    } else if (t.includes("-") && !t.startsWith("-"))
+      return t.replace("-", "");
+    return t;
+  }, Q = (t) => {
+    if (c === void 0 || !t.includes(".")) return t;
+    const [e, r] = t.split(".");
+    return r && r.length > c ? `${e}.${r.slice(0, c)}` : t;
+  }, X = (t) => {
+    if (V === void 0) return t;
+    const [e, r] = t.split("."), n = e.replace("-", "");
+    if (n.length > V) {
+      const f = n.slice(0, V), d = e.startsWith("-") ? "-" : "";
+      return r !== void 0 ? `${d}${f}.${r}` : `${d}${f}`;
+    }
+    return t;
+  }, I = (t) => {
+    if (!a) return t;
+    let e = String(t ?? "");
+    return B && (e = e.replace(/^\s+/, "")), e = G(e), e = H(e), e = J(e, t), e = Q(e), e = X(e), y || (e = e.replace(".", "")), e;
+  }, Y = (t) => {
+    if (!a || !t || t === "-") return t;
+    let e = t;
+    const r = parseFloat(e);
+    if (isNaN(r)) return "";
+    const n = A(r);
+    if (j && c !== void 0)
+      e = n.toFixed(c);
+    else if (c !== void 0 && e.includes(".")) {
+      const [f, d = ""] = e.split("."), M = d.padEnd(c, "0");
+      e = `${f}.${M}`;
+    } else
+      e = String(n);
+    return e;
+  }, Z = (t) => {
+    if (!t) return !0;
+    if (N && !N(t))
+      return p?.("Custom validation failed"), !1;
+    if (a) {
+      const e = parseFloat(t);
+      if (isNaN(e))
+        return p?.("Invalid number"), !1;
+      if (!U(e))
+        return p?.(`Value must be ${g} ${s}`), !1;
+      if (!q(e))
+        return p?.(`Value must be ${m} ${u}`), !1;
+    }
+    return i && t.length > i ? (p?.(`Maximum length is ${i}`), !1) : !0;
+  };
+  return /* @__PURE__ */ P(
+    "div",
+    {
+      "data-component": "smart-input",
+      className: "w-full",
+      "data-numeric": a || void 0,
+      "data-decimal-places": c,
+      "data-min": s,
+      "data-max": u,
+      children: /* @__PURE__ */ P(
+        L,
+        {
+          ...k,
+          type: C,
+          value: l,
+          onChange: (t) => {
+            if (h) return;
+            let r = t.target.value;
+            a ? r = I(r) : B && (r = r.replace(/^\s+/, "")), i && r.length > i && (r = r.slice(0, i)), $ || w(r), v?.(r, t);
+          },
+          onBlur: (t) => {
+            let e = l;
+            a && e && (e = Y(e), Z(e) && ($ || w(e), e !== l && v?.(e))), b?.(t);
+          },
+          onFocus: z,
+          onKeyDown: (t) => {
+            if (h || !a) return;
+            const e = t.key;
+            if (e === "e" || e === "E") {
+              t.preventDefault();
+              return;
+            }
+            if (e === "-" && !D) {
+              t.preventDefault();
+              return;
+            }
+            if (e === "-" && l.includes("-")) {
+              t.preventDefault();
+              return;
+            }
+            if (e === "." && (!y || l.includes("."))) {
+              t.preventDefault();
+              return;
+            }
+          },
+          onPaste: (t) => {
+            if (h) return;
+            t.preventDefault();
+            const e = t.clipboardData.getData("text"), r = a ? I(e) : e, n = t.target, f = n.selectionStart || 0, d = n.selectionEnd || 0, M = l.slice(0, f), _ = l.slice(d);
+            let o = M + r + _;
+            a && (o = I(o)), i && o.length > i && (o = o.slice(0, i)), $ || w(o), v?.(o);
+          },
+          disabled: h,
+          ref: R
+        }
+      )
+    }
+  );
+});
+ee.displayName = "SmartInput";
+export {
+  ee as SmartInput
+};

package/dist/components/forms/smart-input/smart-input.types.d.ts

@@ -0,0 +1,28 @@
+import { HTMLInputTypeAttribute } from 'react';
+import { InputProps } from '../input/input.types';
+import type * as React from "react";
+export type ComparisonOperator = ">" | "<" | ">=" | "<=";
+export interface SmartInputProps extends Omit<InputProps, "onChange" | "value" | "onFocus" | "onBlur"> {
+    value?: string | number;
+    onChange?: (value: string, syntheticEvent?: React.ChangeEvent<HTMLInputElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    type?: HTMLInputTypeAttribute;
+    allowNegative?: boolean;
+    min?: number;
+    max?: number;
+    minOperator?: ComparisonOperator;
+    maxOperator?: ComparisonOperator;
+    /** @deprecated Use `minOperator` */
+    min_operator?: ComparisonOperator;
+    /** @deprecated Use `maxOperator` */
+    max_operator?: ComparisonOperator;
+    maxIntegerDigits?: number;
+    decimalPlaces?: number;
+    enforceDecimal?: boolean;
+    allowDecimal?: boolean;
+    maxLength?: number;
+    trimLeadingSpaces?: boolean;
+    customValidator?: (value: string) => boolean;
+    onValidationError?: (error: string) => void;
+}

package/dist/components/forms/switch/index.d.ts

@@ -0,0 +1,2 @@
+export { Switch } from './switch';
+export type { SwitchProps } from './switch.types';

package/dist/components/forms/switch/index.js

@@ -0,0 +1,4 @@
+import { Switch as t } from "./switch.js";
+export {
+  t as Switch
+};

package/dist/components/forms/switch/switch.d.ts

@@ -0,0 +1,8 @@
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+declare const SwitchRoot: import('react').ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & import('react').RefAttributes<HTMLButtonElement>, "ref"> & import('class-variance-authority').VariantProps<(props?: ({
+    size?: "sm" | "md" | "lg" | "default" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & import('../../../lib/primitives/field.types').FieldControlProps & {
+    isDisabled?: boolean;
+    isError?: boolean;
+} & import('react').RefAttributes<HTMLButtonElement>>;
+export { SwitchRoot as Switch };

package/dist/components/forms/switch/switch.js

@@ -0,0 +1,59 @@
+import { jsx as r, Fragment as C } from "react/jsx-runtime";
+import * as n from "@radix-ui/react-switch";
+import { createComponent as F } from "../../../lib/primitives/create-component.js";
+import { isFieldError as R } from "../../../lib/primitives/field.types.js";
+import { useFieldChrome as E } from "../../../lib/primitives/use-field-chrome.js";
+import { cn as N } from "../../../lib/utils.js";
+import { switchThumbVariants as V, switchRootVariants as g } from "./switch.variants.js";
+const k = F(
+  "Switch",
+  ({
+    className: e,
+    size: t = "default",
+    label: i,
+    helperText: a,
+    helperTextPosition: d,
+    labelOrientation: h,
+    error: l,
+    isError: p,
+    disabled: f,
+    isDisabled: w,
+    required: u,
+    id: v,
+    ...b
+  }, S) => {
+    const m = f ?? w, o = R(l ?? p), s = E({
+      label: i,
+      helperText: a,
+      helperTextPosition: d,
+      labelOrientation: h,
+      error: o,
+      required: u,
+      disabled: m,
+      id: v
+    }), c = /* @__PURE__ */ r(
+      n.Root,
+      {
+        className: N(g({ size: t }), e),
+        ...b,
+        ref: S,
+        id: s.controlId,
+        disabled: m,
+        "data-component": "switch",
+        "data-invalid": o || void 0,
+        "aria-invalid": o || void 0,
+        children: /* @__PURE__ */ r(
+          n.Thumb,
+          {
+            className: V({ size: t }),
+            "data-component": "switch-thumb"
+          }
+        )
+      }
+    );
+    return i || a || o ? /* @__PURE__ */ r(C, { children: s.wrapControl(c) }) : c;
+  }
+);
+export {
+  k as Switch
+};