mimir-ui-kit 1.8.0 → 1.9.0

package/dist/components/Switch/Switch.d.ts

@@ -1,4 +1,294 @@
-import { FC } from 'react';
-import { TSwitchProps } from './types';
+import { CheckboxProps } from '@headlessui/react';
 
-export declare const Switch: FC<TSwitchProps>;
+export type TSwitchProps = CheckboxProps;
+export declare const Switch: import('react').ForwardRefExoticComponent<{
+    suppressHydrationWarning?: boolean | undefined;
+    color?: string | undefined;
+    id?: string | undefined;
+    lang?: string | undefined;
+    style?: import('react').CSSProperties | undefined;
+    "aria-activedescendant"?: string | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+    "aria-braillelabel"?: string | undefined;
+    "aria-brailleroledescription"?: string | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-colcount"?: number | undefined;
+    "aria-colindex"?: number | undefined;
+    "aria-colindextext"?: string | undefined;
+    "aria-colspan"?: number | undefined;
+    "aria-controls"?: string | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+    "aria-description"?: string | undefined;
+    "aria-details"?: string | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+    "aria-errormessage"?: string | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+    "aria-keyshortcuts"?: string | undefined;
+    "aria-label"?: string | undefined;
+    "aria-level"?: number | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    "aria-owns"?: string | undefined;
+    "aria-placeholder"?: string | undefined;
+    "aria-posinset"?: number | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined;
+    "aria-rowcount"?: number | undefined;
+    "aria-rowindex"?: number | undefined;
+    "aria-rowindextext"?: string | undefined;
+    "aria-rowspan"?: number | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    "aria-valuemax"?: number | undefined;
+    "aria-valuemin"?: number | undefined;
+    "aria-valuenow"?: number | undefined;
+    "aria-valuetext"?: string | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: import('react').ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCopyCapture?: import('react').ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCut?: import('react').ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCutCapture?: import('react').ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onPaste?: import('react').ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onPasteCapture?: import('react').ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCompositionEnd?: import('react').CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionStart?: import('react').CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionUpdate?: import('react').CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLSpanElement> | undefined;
+    onFocus?: import('react').FocusEventHandler<HTMLSpanElement> | undefined;
+    onFocusCapture?: import('react').FocusEventHandler<HTMLSpanElement> | undefined;
+    onBlur?: import('react').FocusEventHandler<HTMLSpanElement> | undefined;
+    onBlurCapture?: import('react').FocusEventHandler<HTMLSpanElement> | undefined;
+    onChangeCapture?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onBeforeInput?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onBeforeInputCapture?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onInput?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onInputCapture?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onReset?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onResetCapture?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onSubmit?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onSubmitCapture?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onInvalid?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onInvalidCapture?: import('react').FormEventHandler<HTMLSpanElement> | undefined;
+    onLoad?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onError?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onErrorCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onKeyDown?: import('react').KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyPress?: import('react').KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyUp?: import('react').KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onAbort?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onAbortCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlay?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlayCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlayThrough?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onDurationChange?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onDurationChangeCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onEmptied?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onEmptiedCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onEncrypted?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onEncryptedCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onEnded?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onEndedCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedData?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedDataCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedMetadata?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadStart?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadStartCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onPause?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onPauseCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlay?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlayCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlaying?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlayingCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onProgress?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onProgressCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onRateChange?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onRateChangeCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onResize?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onResizeCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeeked?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeekedCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeeking?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeekingCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onStalled?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onStalledCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onSuspend?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onSuspendCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onTimeUpdate?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onVolumeChange?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onWaiting?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onWaitingCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onAuxClick?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onAuxClickCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onClick?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onClickCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onContextMenu?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onContextMenuCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onDoubleClick?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onDoubleClickCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onDrag?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEnd?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEndCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEnter?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEnterCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragExit?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragExitCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragLeave?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragLeaveCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragOver?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragOverCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragStart?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDragStartCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDrop?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onDropCapture?: import('react').DragEventHandler<HTMLSpanElement> | undefined;
+    onMouseDown?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseDownCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseEnter?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseLeave?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseMove?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseMoveCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOut?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOutCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOver?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOverCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseUp?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseUpCapture?: import('react').MouseEventHandler<HTMLSpanElement> | undefined;
+    onSelect?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onSelectCapture?: import('react').ReactEventHandler<HTMLSpanElement> | undefined;
+    onTouchCancel?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchCancelCapture?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchEnd?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchEndCapture?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchMove?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchMoveCapture?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchStart?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchStartCapture?: import('react').TouchEventHandler<HTMLSpanElement> | undefined;
+    onPointerDown?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerDownCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerMove?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerMoveCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerUp?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerUpCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerCancel?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerCancelCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerEnter?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerLeave?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOver?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOverCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOut?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOutCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onGotPointerCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onLostPointerCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLSpanElement> | undefined;
+    onScroll?: import('react').UIEventHandler<HTMLSpanElement> | undefined;
+    onScrollCapture?: import('react').UIEventHandler<HTMLSpanElement> | undefined;
+    onWheel?: import('react').WheelEventHandler<HTMLSpanElement> | undefined;
+    onWheelCapture?: import('react').WheelEventHandler<HTMLSpanElement> | undefined;
+    onAnimationStart?: import('react').AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationEnd?: import('react').AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationIteration?: import('react').AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLSpanElement> | undefined;
+    onTransitionEnd?: import('react').TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLSpanElement> | undefined;
+    key?: import('react').Key | null | undefined;
+    slot?: string | undefined;
+    title?: string | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    hidden?: boolean | undefined;
+    nonce?: string | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    prefix?: string | undefined;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCapitalize?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "on" | "off" | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+    is?: string | undefined;
+} & {
+    as?: "span" | undefined;
+    children?: import('react').ReactNode | ((bag: {
+        checked: boolean;
+        changing: boolean;
+        focus: boolean;
+        active: boolean;
+        hover: boolean;
+        autofocus: boolean;
+        disabled: boolean;
+        indeterminate: boolean;
+    }) => import('react').ReactElement);
+    refName?: string;
+} & {
+    className?: string | ((bag: {
+        checked: boolean;
+        changing: boolean;
+        focus: boolean;
+        active: boolean;
+        hover: boolean;
+        autofocus: boolean;
+        disabled: boolean;
+        indeterminate: boolean;
+    }) => string) | undefined;
+} & {
+    value?: string | undefined;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    autoFocus?: boolean;
+    form?: string;
+    name?: string;
+    onChange?: (checked: boolean) => void;
+} & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/Switch/Switch.js

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { c as classNames } from "../../index-CweZ_OcN.js";
-import React__default, { useId, useState, useMemo, useCallback } from "react";
+import React__default, { useId, useState, useMemo, useCallback, forwardRef, useEffect } from "react";
 import { Icon } from "../../icons/Icon.js";
 import { W, d as u, b as a, l, T, I, G, p, o, $ as $f7dceffc5ad7768b$export$4e328f61c538687f, c as $6179b936705e76d3$export$ae780daf29e6d456, D, j, H, r, e as o$1, f as p$1 } from "../../label-BXAcSLy0.js";
 import { w } from "../../use-active-press-9MCrfRZk.js";
@@ -26,27 +26,32 @@ const cls = {
   "switch": "_switch_1g34c_2",
   enabled
 };
-const Switch = ({
-  checked,
-  onChange
-}) => {
-  const [enabled2, setEnabled] = useState(checked);
-  const handleChange = (value) => {
-    setEnabled(value);
-    onChange == null ? void 0 : onChange(value);
-  };
-  return /* @__PURE__ */ jsx(
-    Re,
-    {
-      checked: enabled2,
-      onChange: handleChange,
-      className: classNames(cls.switch, {
-        [cls.enabled]: enabled2
-      }),
-      children: /* @__PURE__ */ jsx(Icon, { iconName: "Done16px" })
-    }
-  );
-};
+const Switch = forwardRef(
+  (props, ref) => {
+    const { checked, onChange, ...restProps } = props;
+    const [enabled2, setEnabled] = useState(checked);
+    const handleChange = (value) => {
+      setEnabled(value);
+      onChange == null ? void 0 : onChange(value);
+    };
+    useEffect(() => {
+      setEnabled(!!checked);
+    }, [checked]);
+    return /* @__PURE__ */ jsx(
+      Re,
+      {
+        ref,
+        checked: enabled2,
+        onChange: handleChange,
+        className: classNames(cls.switch, {
+          [cls.enabled]: enabled2
+        }),
+        ...restProps,
+        children: /* @__PURE__ */ jsx(Icon, { iconName: "Done16px" })
+      }
+    );
+  }
+);
 export {
   Switch
 };

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

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

package/dist/components/Timer/Timer.d.ts

@@ -0,0 +1,24 @@
+type TProps = {
+    /**
+     *  число, которое представляет собой временную метку, указывающую время, когда истекает таймер.
+     * const timer = new Date().getTime() + 60000; => таймер на 1 минуту
+     */
+    expiryTimestamp: number;
+    /**
+     * необязательное свойство типа boolean, которое указывает, должен ли таймер начинаться автоматически при создании компонента.
+     */
+    autoStart?: boolean;
+    /**
+     * необязательная функция, которая вызывается, когда таймер истекает.
+     */
+    onTimerEnd?: () => void;
+    /**
+     * Дополнительный класс.
+     */
+    className?: string;
+};
+/**
+ *  Компонент Timer отображает таймер с отсчетом времени в минутах и секундах.
+ */
+export declare const Timer: ({ expiryTimestamp, autoStart, onTimerEnd, className }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Timer/Timer.js

@@ -0,0 +1,29 @@
+import { jsxs } from "react/jsx-runtime";
+import { c as classNames } from "../../index-CweZ_OcN.js";
+import { useTimer } from "../../hooks/useTimer/index.js";
+import '../../assets/Timer.css';const timer = "_timer_llwad_3";
+const cls = {
+  timer
+};
+const Timer = ({
+  expiryTimestamp,
+  autoStart = false,
+  onTimerEnd,
+  className
+}) => {
+  const { minutes, seconds } = useTimer({
+    expiryTimestamp,
+    onExpire: onTimerEnd,
+    autoStart
+  });
+  const formattedMinutes = String(minutes).padStart(2, "0");
+  const formattedSeconds = String(seconds).padStart(2, "0");
+  return /* @__PURE__ */ jsxs("div", { className: classNames(cls.timer, className), children: [
+    formattedMinutes,
+    ":",
+    formattedSeconds
+  ] });
+};
+export {
+  Timer
+};

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

@@ -0,0 +1 @@
+export { Timer } from './Timer';

package/dist/components/Timer/index.js

@@ -0,0 +1,4 @@
+import { Timer } from "./Timer.js";
+export {
+  Timer
+};

package/dist/components/index.d.ts

@@ -6,9 +6,9 @@ export type { TInputPasswordProps } from './InputPassword';
 export { InputPhoneNumber, getMaskedInputPhoneValue, getUnmaskedInputValue } from './InputPhoneNumber';
 export { OtpInput } from './OtpInput';
 export { RadioGroup } from './RadioGroup';
-export type { TRadioOption } from './RadioGroup';
+export type { TRadioOption, TRadioGroupProps } from './RadioGroup';
 export { DatePicker } from './DatePicker';
-export type { TDatePickerProps } from './DatePicker';
+export type { TDatePickerProps, TDatePickerValue } from './DatePicker';
 export { MergedButton } from './MergedButton';
 export { EMergedButtonVariantRound } from './MergedButton';
 export type { TButtonPropsWithoutStyles } from './MergedButton';
@@ -20,6 +20,7 @@ export { EDrawerPosition } from './Drawer';
 export { Steps, EStepsPrimaryColor, EStepsSecondaryColor, EStepsSize, type TCommonStepsProps } from './Steps';
 export { Vote, EVoteSize, type TCommonVoteProps } from './Vote';
 export { SelectSearch, ESelectSearchSize } from './SelectSearch';
-export type { TSelectSearchItem, TSelectSearchProps, TSelectSearchSize } from './SelectSearch';
+export type { TSelectSearchItem, TSelectSearchProps } from './SelectSearch';
 export { Switch } from './Switch';
 export type { TSwitchProps } from './Switch';
+export { Timer } from './Timer';

package/dist/components/index.js

@@ -22,6 +22,7 @@ import { EVoteSize } from "./Vote/constants.js";
 import { SelectSearch } from "./SelectSearch/SelectSearch.js";
 import { ESelectSearchSize } from "./SelectSearch/constants.js";
 import { Switch } from "./Switch/Switch.js";
+import { Timer } from "./Timer/Timer.js";
 export {
   Button,
   DatePicker,
@@ -51,6 +52,7 @@ export {
   Slider,
   Steps,
   Switch,
+  Timer,
   Vote,
   getMaskedInputPhoneValue,
   getUnmaskedInputValue

package/dist/hooks/index.d.ts

@@ -1,2 +1,4 @@
 export { useMediaQuery, EMediaQuery } from './useMediaQuery';
 export { useLockBodyScroll } from './useLockBodyScroll';
+export { useInterval } from './useInterval';
+export { useTimer } from './useTimer';

package/dist/hooks/index.js

@@ -1,8 +1,12 @@
 import { useMediaQuery } from "./useMediaQuery/useMediaQuery.js";
 import { EMediaQuery } from "./useMediaQuery/constants.js";
 import { useLockBodyScroll } from "./useLockBodyScroll/useLockBodyScroll.js";
+import { useInterval } from "./useInterval/useInterval.js";
+import { useTimer } from "./useTimer/index.js";
 export {
   EMediaQuery,
+  useInterval,
   useLockBodyScroll,
-  useMediaQuery
+  useMediaQuery,
+  useTimer
 };

package/dist/hooks/useInterval/index.d.ts

@@ -0,0 +1 @@
+export { useInterval } from './useInterval';

package/dist/hooks/useInterval/index.js

@@ -0,0 +1,4 @@
+import { useInterval } from "./useInterval.js";
+export {
+  useInterval
+};

package/dist/hooks/useInterval/useInterval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(callback: VoidFunction, delay: number | null): void;

package/dist/hooks/useInterval/useInterval.js

@@ -0,0 +1,17 @@
+import { useRef, useEffect } from "react";
+function useInterval(callback, delay) {
+  const callbackRef = useRef();
+  callbackRef.current = callback;
+  useEffect(() => {
+    if (!delay) {
+      return;
+    }
+    const interval = setInterval(() => {
+      callbackRef.current && callbackRef.current();
+    }, delay);
+    return () => clearInterval(interval);
+  }, [delay]);
+}
+export {
+  useInterval
+};

package/dist/hooks/useTimer/index.d.ts

@@ -0,0 +1,18 @@
+export type TUserTimer = ReturnType<typeof useTimer>;
+export type TUseTimerProps = {
+    expiryTimestamp?: number;
+    onExpire?: VoidFunction;
+    autoStart?: boolean;
+};
+export declare function useTimer({ expiryTimestamp: expiry, onExpire, autoStart }: TUseTimerProps): {
+    start: () => void;
+    pause: () => void;
+    resume: () => void;
+    restart: (newExpiryTimestamp: number, newAutoStart?: boolean) => void;
+    isRunning: boolean;
+    totalSeconds: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+};

package/dist/hooks/useTimer/index.js

@@ -0,0 +1,83 @@
+import { useState, useCallback } from "react";
+import { Time, Validate } from "./utils.js";
+import { useInterval } from "../useInterval/useInterval.js";
+const DEFAULT_DELAY = 1e3;
+function getDelayFromExpiryTimestamp(expiryTimestamp) {
+  if (!Validate.expiryTimestamp(expiryTimestamp)) {
+    return null;
+  }
+  const seconds = Time.getSecondsFromExpiry(expiryTimestamp);
+  const extraMilliSeconds = Math.floor((seconds - Math.floor(seconds)) * 1e3);
+  return extraMilliSeconds > 0 ? extraMilliSeconds : DEFAULT_DELAY;
+}
+function useTimer({
+  expiryTimestamp: expiry,
+  onExpire,
+  autoStart = false
+}) {
+  const [expiryTimestamp, setExpiryTimestamp] = useState(expiry);
+  const [seconds, setSeconds] = useState(
+    Time.getSecondsFromExpiry(expiry ?? 0)
+  );
+  const [isRunning, setIsRunning] = useState(autoStart);
+  const [didStart, setDidStart] = useState(autoStart);
+  const [delay, setDelay] = useState(getDelayFromExpiryTimestamp(expiry ?? 0));
+  const handleExpire = useCallback(() => {
+    Validate.onExpire(onExpire) && (onExpire == null ? void 0 : onExpire());
+    setIsRunning(false);
+    setDelay(null);
+  }, [onExpire]);
+  const pause = useCallback(() => {
+    setIsRunning(false);
+  }, []);
+  const restart = useCallback(
+    (newExpiryTimestamp, newAutoStart = true) => {
+      setDelay(getDelayFromExpiryTimestamp(newExpiryTimestamp));
+      setDidStart(newAutoStart);
+      setIsRunning(newAutoStart);
+      setExpiryTimestamp(newExpiryTimestamp);
+      setSeconds(Time.getSecondsFromExpiry(newExpiryTimestamp));
+    },
+    []
+  );
+  const resume = useCallback(() => {
+    const time = /* @__PURE__ */ new Date();
+    time.setMilliseconds(time.getMilliseconds() + seconds * 1e3);
+    restart(time.getTime(), true);
+  }, [seconds, restart]);
+  const start = useCallback(() => {
+    if (didStart) {
+      setSeconds(Time.getSecondsFromExpiry(expiryTimestamp ?? 0, false));
+      setIsRunning(true);
+    } else {
+      resume();
+    }
+  }, [expiryTimestamp, didStart, resume]);
+  useInterval(
+    () => {
+      if (delay !== DEFAULT_DELAY) {
+        setDelay(DEFAULT_DELAY);
+      }
+      const secondsValue = Time.getSecondsFromExpiry(
+        expiryTimestamp ?? 0,
+        false
+      );
+      setSeconds(secondsValue);
+      if (secondsValue <= 0) {
+        handleExpire();
+      }
+    },
+    isRunning ? delay : null
+  );
+  return {
+    ...Time.getTimeFromSeconds(seconds),
+    start,
+    pause,
+    resume,
+    restart,
+    isRunning
+  };
+}
+export {
+  useTimer
+};

package/dist/hooks/useTimer/useTimer.d.ts

@@ -0,0 +1,18 @@
+export type TUserTimer = ReturnType<typeof useTimer>;
+export type TUseTimerProps = {
+    expiryTimestamp?: number;
+    onExpire?: VoidFunction;
+    autoStart?: boolean;
+};
+export declare function useTimer({ expiryTimestamp: expiry, onExpire, autoStart }: TUseTimerProps): {
+    start: () => void;
+    pause: () => void;
+    resume: () => void;
+    restart: (newExpiryTimestamp: number, newAutoStart?: boolean) => void;
+    isRunning: boolean;
+    totalSeconds: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+};