@prokodo/ui 0.0.26 → 0.0.28

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/useList/useList.js

@@ -1,150 +1,211 @@
-import * as i from "react";
-import { ListActionTypes as l } from "./listActions.types.js";
-import { listReducer as $ } from "./listReducer.js";
-import { useControllableReducer as H } from "../utils/useControllableReducer.js";
-import { areArraysEqual as B } from "../utils/areArraysEqual.js";
-import { useTextNavigation as ee } from "../utils/useTextNavigation.js";
-import te from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
-import oe from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
-const q = {}, se = () => {
-}, ne = (a, b) => a === b, ie = () => !1, re = (a) => typeof a == "string" ? a : String(a), ce = () => ({
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+import { ListActionTypes } from "./listActions.types.js";
+import { listReducer } from "./listReducer.js";
+import { useControllableReducer } from "../utils/useControllableReducer.js";
+import { areArraysEqual } from "../utils/areArraysEqual.js";
+import { useTextNavigation } from "../utils/useTextNavigation.js";
+import useForkRef from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
+import extractEventHandlers from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
+const EMPTY_OBJECT = {};
+const NOOP = /* @__PURE__ */ __name(() => {
+}, "NOOP");
+const defaultItemComparer = /* @__PURE__ */ __name((optionA, optionB) => optionA === optionB, "defaultItemComparer");
+const defaultIsItemDisabled = /* @__PURE__ */ __name(() => false, "defaultIsItemDisabled");
+const defaultItemStringifier = /* @__PURE__ */ __name((item) => typeof item === "string" ? item : String(item), "defaultItemStringifier");
+const defaultGetInitialState = /* @__PURE__ */ __name(() => ({
   highlightedValue: null,
   selectedValues: []
-});
-function pe(a) {
+}), "defaultGetInitialState");
+function useList(params) {
   const {
-    controlledProps: b = q,
-    disabledItemsFocusable: k = !1,
-    disableListWrap: C = !1,
-    focusManagement: n = "activeDescendant",
-    getInitialState: K = ce,
-    getItemDomElement: f,
-    getItemId: E,
-    isItemDisabled: V = ie,
-    rootRef: F,
-    onStateChange: m = se,
-    items: u,
-    itemComparer: r = ne,
-    getItemAsString: S = re,
-    onChange: g,
-    onHighlightChange: p,
-    onItemsChange: h,
-    orientation: y = "vertical",
-    pageSize: A = 5,
-    reducerActionContext: O = q,
-    selectionMode: T = "single",
-    stateReducer: U,
-    componentName: _ = "useList"
-  } = a;
+    controlledProps = EMPTY_OBJECT,
+    disabledItemsFocusable = false,
+    disableListWrap = false,
+    focusManagement = "activeDescendant",
+    getInitialState = defaultGetInitialState,
+    getItemDomElement,
+    getItemId,
+    isItemDisabled = defaultIsItemDisabled,
+    rootRef: externalListRef,
+    onStateChange = NOOP,
+    items,
+    itemComparer = defaultItemComparer,
+    getItemAsString = defaultItemStringifier,
+    onChange,
+    onHighlightChange,
+    onItemsChange,
+    orientation = "vertical",
+    pageSize = 5,
+    reducerActionContext = EMPTY_OBJECT,
+    selectionMode = "single",
+    stateReducer: externalReducer,
+    componentName = "useList"
+  } = params;
   if (process.env.NODE_ENV !== "production") {
-    if (n === "DOM" && f == null)
+    if (focusManagement === "DOM" && getItemDomElement == null) {
       throw new Error("useList: The `getItemDomElement` prop is required when using the `DOM` focus management.");
-    if (n === "activeDescendant" && E == null)
+    }
+    if (focusManagement === "activeDescendant" && getItemId == null) {
       throw new Error("useList: The `getItemId` prop is required when using the `activeDescendant` focus management.");
+    }
   }
-  const L = i.useRef(null), N = te(F, L), D = i.useCallback((t, e, o) => {
-    var s;
-    p == null || p(t, e, o), n === "DOM" && e != null && (o === l.itemClick || o === l.keyDown || o === l.textNavigation) && ((s = f == null ? void 0 : f(e)) == null || s.focus());
-  }, [f, p, n]), I = i.useMemo(() => ({
-    highlightedValue: r,
-    selectedValues: (t, e) => B(t, e, r)
-  }), [r]), z = i.useCallback((t, e, o, s, w) => {
-    switch (m == null || m(t, e, o, s, w), e) {
+  const listRef = React.useRef(null);
+  const handleRef = useForkRef(externalListRef, listRef);
+  const handleHighlightChange = React.useCallback((event, value, reason) => {
+    var _a;
+    onHighlightChange == null ? void 0 : onHighlightChange(event, value, reason);
+    if (focusManagement === "DOM" && value != null && (reason === ListActionTypes.itemClick || reason === ListActionTypes.keyDown || reason === ListActionTypes.textNavigation)) {
+      (_a = getItemDomElement == null ? void 0 : getItemDomElement(value)) == null ? void 0 : _a.focus();
+    }
+  }, [getItemDomElement, onHighlightChange, focusManagement]);
+  const stateComparers = React.useMemo(() => ({
+    highlightedValue: itemComparer,
+    selectedValues: /* @__PURE__ */ __name((valuesArray1, valuesArray2) => areArraysEqual(valuesArray1, valuesArray2, itemComparer), "selectedValues")
+  }), [itemComparer]);
+  const handleStateChange = React.useCallback((event, field, value, reason, state2) => {
+    onStateChange == null ? void 0 : onStateChange(event, field, value, reason, state2);
+    switch (field) {
       case "highlightedValue":
-        D(t, o, s);
+        handleHighlightChange(event, value, reason);
         break;
       case "selectedValues":
-        g == null || g(t, o, s);
+        onChange == null ? void 0 : onChange(event, value, reason);
         break;
     }
-  }, [D, g, m]), P = i.useMemo(() => ({
-    disabledItemsFocusable: k,
-    disableListWrap: C,
-    focusManagement: n,
-    isItemDisabled: V,
-    itemComparer: r,
-    items: u,
-    getItemAsString: S,
-    onHighlightChange: D,
-    orientation: y,
-    pageSize: A,
-    selectionMode: T,
-    stateComparers: I
-  }), [k, C, n, V, r, u, S, D, y, A, T, I]), G = K(), J = U ?? $, W = i.useMemo(() => ({
-    ...O,
-    ...P
-  }), [O, P]), [R, c] = H({
-    reducer: J,
-    actionContext: W,
-    initialState: G,
-    controlledProps: b,
-    stateComparers: I,
-    onStateChange: z,
-    componentName: _
-  }), {
-    highlightedValue: d,
-    selectedValues: v
-  } = R, Y = ee((t, e) => c({
-    type: l.textNavigation,
-    event: e,
-    searchString: t
-  })), M = i.useRef([]);
-  i.useEffect(() => {
-    B(M.current, u, r) || (c({
-      type: l.itemsChange,
+  }, [handleHighlightChange, onChange, onStateChange]);
+  const listActionContext = React.useMemo(() => {
+    return {
+      disabledItemsFocusable,
+      disableListWrap,
+      focusManagement,
+      isItemDisabled,
+      itemComparer,
+      items,
+      getItemAsString,
+      onHighlightChange: handleHighlightChange,
+      orientation,
+      pageSize,
+      selectionMode,
+      stateComparers
+    };
+  }, [disabledItemsFocusable, disableListWrap, focusManagement, isItemDisabled, itemComparer, items, getItemAsString, handleHighlightChange, orientation, pageSize, selectionMode, stateComparers]);
+  const initialState = getInitialState();
+  const reducer = externalReducer ?? listReducer;
+  const actionContext = React.useMemo(() => ({
+    ...reducerActionContext,
+    ...listActionContext
+  }), [reducerActionContext, listActionContext]);
+  const [state, dispatch] = useControllableReducer({
+    reducer,
+    actionContext,
+    initialState,
+    controlledProps,
+    stateComparers,
+    onStateChange: handleStateChange,
+    componentName
+  });
+  const {
+    highlightedValue,
+    selectedValues
+  } = state;
+  const handleTextNavigation = useTextNavigation((searchString, event) => dispatch({
+    type: ListActionTypes.textNavigation,
+    event,
+    searchString
+  }));
+  const previousItems = React.useRef([]);
+  React.useEffect(() => {
+    if (areArraysEqual(previousItems.current, items, itemComparer)) {
+      return;
+    }
+    dispatch({
+      type: ListActionTypes.itemsChange,
       event: null,
-      items: u,
-      previousItems: M.current
-    }), M.current = u, h == null || h(u));
-  }, [u, r, c, h]);
-  const j = (t) => (e) => {
-    var s;
-    if ((s = t.onKeyDown) == null || s.call(t, e), e.defaultMuiPrevented)
+      items,
+      previousItems: previousItems.current
+    });
+    previousItems.current = items;
+    onItemsChange == null ? void 0 : onItemsChange(items);
+  }, [items, itemComparer, dispatch, onItemsChange]);
+  const createHandleKeyDown = /* @__PURE__ */ __name((externalHandlers) => (event) => {
+    var _a;
+    (_a = externalHandlers.onKeyDown) == null ? void 0 : _a.call(externalHandlers, event);
+    if (event.defaultMuiPrevented) {
       return;
-    const o = ["Home", "End", "PageUp", "PageDown"];
-    y === "vertical" ? o.push("ArrowUp", "ArrowDown") : o.push("ArrowLeft", "ArrowRight"), n === "activeDescendant" && o.push(" ", "Enter"), o.includes(e.key) && e.preventDefault(), c({
-      type: l.keyDown,
-      key: e.key,
-      event: e
-    }), Y(e);
-  }, Q = (t) => (e) => {
-    var o, s;
-    (o = t.onBlur) == null || o.call(t, e), !e.defaultMuiPrevented && ((s = L.current) != null && s.contains(e.relatedTarget) || c({
-      type: l.blur,
-      event: e
-    }));
-  }, X = (t = {}) => {
-    const e = oe(t);
+    }
+    const keysToPreventDefault = ["Home", "End", "PageUp", "PageDown"];
+    if (orientation === "vertical") {
+      keysToPreventDefault.push("ArrowUp", "ArrowDown");
+    } else {
+      keysToPreventDefault.push("ArrowLeft", "ArrowRight");
+    }
+    if (focusManagement === "activeDescendant") {
+      keysToPreventDefault.push(" ", "Enter");
+    }
+    if (keysToPreventDefault.includes(event.key)) {
+      event.preventDefault();
+    }
+    dispatch({
+      type: ListActionTypes.keyDown,
+      key: event.key,
+      event
+    });
+    handleTextNavigation(event);
+  }, "createHandleKeyDown");
+  const createHandleBlur = /* @__PURE__ */ __name((externalHandlers) => (event) => {
+    var _a, _b;
+    (_a = externalHandlers.onBlur) == null ? void 0 : _a.call(externalHandlers, event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    if ((_b = listRef.current) == null ? void 0 : _b.contains(event.relatedTarget)) {
+      return;
+    }
+    dispatch({
+      type: ListActionTypes.blur,
+      event
+    });
+  }, "createHandleBlur");
+  const getRootProps = /* @__PURE__ */ __name((externalProps = {}) => {
+    const externalEventHandlers = extractEventHandlers(externalProps);
     return {
-      ...t,
-      "aria-activedescendant": n === "activeDescendant" && d != null ? E(d) : void 0,
-      tabIndex: n === "DOM" ? -1 : 0,
-      ref: N,
-      ...e,
-      onBlur: Q(e),
-      onKeyDown: j(e)
+      ...externalProps,
+      "aria-activedescendant": focusManagement === "activeDescendant" && highlightedValue != null ? getItemId(highlightedValue) : void 0,
+      tabIndex: focusManagement === "DOM" ? -1 : 0,
+      ref: handleRef,
+      ...externalEventHandlers,
+      onBlur: createHandleBlur(externalEventHandlers),
+      onKeyDown: createHandleKeyDown(externalEventHandlers)
     };
-  }, x = i.useCallback((t) => {
-    const e = (v ?? []).some((w) => w != null && r(t, w)), o = d != null && r(t, d);
+  }, "getRootProps");
+  const getItemState = React.useCallback((item) => {
+    const selected = (selectedValues ?? []).some((value) => value != null && itemComparer(item, value));
+    const highlighted = highlightedValue != null && itemComparer(item, highlightedValue);
+    const focusable = focusManagement === "DOM";
     return {
-      focusable: n === "DOM",
-      highlighted: o,
-      selected: e
+      focusable,
+      highlighted,
+      selected
     };
-  }, [r, v, d, n]), Z = i.useMemo(() => ({
-    dispatch: c,
-    getItemState: x
-  }), [c, x]);
-  return i.useDebugValue({
-    state: R
-  }), {
-    contextValue: Z,
-    dispatch: c,
-    getRootProps: X,
-    rootRef: N,
-    state: R
+  }, [itemComparer, selectedValues, highlightedValue, focusManagement]);
+  const contextValue = React.useMemo(() => ({
+    dispatch,
+    getItemState
+  }), [dispatch, getItemState]);
+  React.useDebugValue({
+    state
+  });
+  return {
+    contextValue,
+    dispatch,
+    getRootProps,
+    rootRef: handleRef,
+    state
   };
 }
+__name(useList, "useList");
 export {
-  pe as useList
+  useList
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/useList/useListItem.js

@@ -1,61 +1,81 @@
-import * as r from "react";
-import { ListActionTypes as c } from "./listActions.types.js";
-import { ListContext as g } from "./ListContext.js";
-import l from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
-function P(f) {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+import { ListActionTypes } from "./listActions.types.js";
+import { ListContext } from "./ListContext.js";
+import extractEventHandlers from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
+function useListItem(parameters) {
   const {
-    handlePointerOverEvents: m = !1,
-    item: i
-  } = f, s = r.useContext(g);
-  if (!s)
+    handlePointerOverEvents = false,
+    item
+  } = parameters;
+  const listContext = React.useContext(ListContext);
+  if (!listContext) {
     throw new Error("useListItem must be used within a ListProvider");
+  }
   const {
-    dispatch: n,
-    getItemState: p
-  } = s, {
-    highlighted: d,
-    selected: h,
-    focusable: v
-  } = p(i), a = r.useCallback((e) => (t) => {
-    var o;
-    if ((o = e.onClick) == null || o.call(e, t), !t.defaultPrevented) {
-      if (process.env.NODE_ENV !== "production" && i === void 0)
-        throw new Error(["MUI: The `item` provided to useListItem() is undefined.", "This should happen only during server-side rendering under React 17."].join(`
-`));
-      n({
-        type: c.itemClick,
-        item: i,
-        event: t
-      });
+    dispatch,
+    getItemState
+  } = listContext;
+  const {
+    highlighted,
+    selected,
+    focusable
+  } = getItemState(item);
+  const createHandleClick = React.useCallback((externalHandlers) => (event) => {
+    var _a;
+    (_a = externalHandlers.onClick) == null ? void 0 : _a.call(externalHandlers, event);
+    if (event.defaultPrevented) {
+      return;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      if (item === void 0) {
+        throw new Error(["MUI: The `item` provided to useListItem() is undefined.", "This should happen only during server-side rendering under React 17."].join("\n"));
+      }
+    }
+    dispatch({
+      type: ListActionTypes.itemClick,
+      item,
+      event
+    });
+  }, [dispatch, item]);
+  const createHandlePointerOver = React.useCallback((externalHandlers) => (event) => {
+    var _a;
+    (_a = externalHandlers.onMouseOver) == null ? void 0 : _a.call(externalHandlers, event);
+    if (event.defaultPrevented) {
+      return;
     }
-  }, [n, i]), E = r.useCallback((e) => (t) => {
-    var o;
-    if ((o = e.onMouseOver) == null || o.call(e, t), !t.defaultPrevented) {
-      if (process.env.NODE_ENV !== "production" && i === void 0)
-        throw new Error(["MUI: The `item` provided to useListItem() is undefined.", "This should happen only during server-side rendering under React 17."].join(`
-`));
-      n({
-        type: c.itemHover,
-        item: i,
-        event: t
-      });
+    if (process.env.NODE_ENV !== "production") {
+      if (item === void 0) {
+        throw new Error(["MUI: The `item` provided to useListItem() is undefined.", "This should happen only during server-side rendering under React 17."].join("\n"));
+      }
     }
-  }, [n, i]);
-  let u;
-  return v && (u = d ? 0 : -1), {
-    getRootProps: (e = {}) => {
-      const t = l(e);
-      return {
-        ...e,
-        onClick: a(t),
-        onPointerOver: m ? E(t) : void 0,
-        tabIndex: u
-      };
-    },
-    highlighted: d,
-    selected: h
+    dispatch({
+      type: ListActionTypes.itemHover,
+      item,
+      event
+    });
+  }, [dispatch, item]);
+  let tabIndex;
+  if (focusable) {
+    tabIndex = highlighted ? 0 : -1;
+  }
+  const getRootProps = /* @__PURE__ */ __name((externalProps = {}) => {
+    const externalEventHandlers = extractEventHandlers(externalProps);
+    return {
+      ...externalProps,
+      onClick: createHandleClick(externalEventHandlers),
+      onPointerOver: handlePointerOverEvents ? createHandlePointerOver(externalEventHandlers) : void 0,
+      tabIndex
+    };
+  }, "getRootProps");
+  return {
+    getRootProps,
+    highlighted,
+    selected
   };
 }
+__name(useListItem, "useListItem");
 export {
-  P as useListItem
+  useListItem
 };

package/dist/node_modules/.pnpm/@mui_base@5.0.0-beta.58_@types_react@19.1.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@mui/base/useOption/useOption.js

@@ -1,63 +1,82 @@
-import * as c from "react";
-import { combineHooksSlotProps as p } from "../utils/combineHooksSlotProps.js";
-import { useListItem as k } from "../useList/useListItem.js";
-import { useButton as x } from "../useButton/useButton.js";
-import E from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useId/useId.js";
-import { useCompoundItem as K } from "../useCompound/useCompoundItem.js";
-import M from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
-import O from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
-function S(d) {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as React from "react";
+import { combineHooksSlotProps } from "../utils/combineHooksSlotProps.js";
+import { useListItem } from "../useList/useListItem.js";
+import { useButton } from "../useButton/useButton.js";
+import useId from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useId/useId.js";
+import { useCompoundItem } from "../useCompound/useCompoundItem.js";
+import useForkRef from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.js";
+import extractEventHandlers from "../../../../../@mui_utils@6.0.0-rc.0_@types_react@19.1.0_react@19.1.0/node_modules/@mui/utils/esm/extractEventHandlers/extractEventHandlers.js";
+function useOption(params) {
   const {
-    value: t,
-    label: i,
-    disabled: r,
-    rootRef: a,
-    id: l
-  } = d, {
-    getRootProps: R,
-    highlighted: P,
-    selected: m
-  } = k({
-    item: t
-  }), {
-    getRootProps: g,
-    rootRef: b
-  } = x({
-    disabled: r,
-    focusableWhenDisabled: !0
-  }), s = E(l), u = c.useRef(null), w = c.useMemo(() => ({
-    disabled: r,
-    label: i,
-    value: t,
-    ref: u,
-    id: s
-  }), [r, i, t, s]), {
-    index: y
-  } = K(t, w), f = M(a, u, b), D = (o) => (e) => {
-    var n;
-    (n = o.onKeyDown) == null || n.call(o, e), !e.defaultMuiPrevented && [" ", "Enter"].includes(e.key) && (e.defaultMuiPrevented = !0);
-  }, I = (o = {}) => ({
-    onKeyDown: D(o)
+    value,
+    label,
+    disabled,
+    rootRef: optionRefParam,
+    id: idParam
+  } = params;
+  const {
+    getRootProps: getListItemProps,
+    highlighted,
+    selected
+  } = useListItem({
+    item: value
+  });
+  const {
+    getRootProps: getButtonProps,
+    rootRef: buttonRefHandler
+  } = useButton({
+    disabled,
+    focusableWhenDisabled: true
   });
+  const id = useId(idParam);
+  const optionRef = React.useRef(null);
+  const selectOption = React.useMemo(() => ({
+    disabled,
+    label,
+    value,
+    ref: optionRef,
+    id
+  }), [disabled, label, value, id]);
+  const {
+    index
+  } = useCompoundItem(value, selectOption);
+  const handleRef = useForkRef(optionRefParam, optionRef, buttonRefHandler);
+  const createHandleKeyDown = /* @__PURE__ */ __name((otherHandlers) => (event) => {
+    var _a;
+    (_a = otherHandlers.onKeyDown) == null ? void 0 : _a.call(otherHandlers, event);
+    if (event.defaultMuiPrevented) {
+      return;
+    }
+    if ([" ", "Enter"].includes(event.key)) {
+      event.defaultMuiPrevented = true;
+    }
+  }, "createHandleKeyDown");
+  const getOwnHandlers = /* @__PURE__ */ __name((otherHandlers = {}) => ({
+    onKeyDown: createHandleKeyDown(otherHandlers)
+  }), "getOwnHandlers");
   return {
-    getRootProps: (o = {}) => {
-      const e = O(o), n = p(R, p(g, I));
+    getRootProps: /* @__PURE__ */ __name((externalProps = {}) => {
+      const externalEventHandlers = extractEventHandlers(externalProps);
+      const getCombinedRootProps = combineHooksSlotProps(getListItemProps, combineHooksSlotProps(getButtonProps, getOwnHandlers));
       return {
-        ...o,
-        ...e,
-        ...n(e),
-        id: s,
-        ref: f,
+        ...externalProps,
+        ...externalEventHandlers,
+        ...getCombinedRootProps(externalEventHandlers),
+        id,
+        ref: handleRef,
         role: "option",
-        "aria-selected": m
+        "aria-selected": selected
       };
-    },
-    highlighted: P,
-    index: y,
-    selected: m,
-    rootRef: f
+    }, "getRootProps"),
+    highlighted,
+    index,
+    selected,
+    rootRef: handleRef
   };
 }
+__name(useOption, "useOption");
 export {
-  S as useOption
+  useOption
 };