mimir-ui-kit 1.38.36 → 1.38.39

package/dist/components/CheckboxMimir/CheckboxMimir.d.ts

@@ -0,0 +1,301 @@
+import { CheckboxProps } from '@headlessui/react';
+import { ReactNode } from 'react';
+
+export type TCheckboxMimirProps = CheckboxProps & {
+    children?: ReactNode;
+    isInteractive?: boolean;
+};
+export declare const CheckboxMimir: 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?: 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;
+} & {
+    children?: ReactNode;
+    isInteractive?: boolean;
+} & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/CheckboxMimir/CheckboxMimir.js

@@ -0,0 +1,63 @@
+import { jsxs as L, jsx as p } from "react/jsx-runtime";
+import { W as O, p as V, o as d, $ as W, b as X, D as q, H as z, c as D } from "../../keyboard-B0lm_zyn.js";
+import h, { useId as J, useState as Q, useMemo as Y, useCallback as Z, forwardRef as ee } from "react";
+import { w as re } from "../../use-active-press-86hajhdd.js";
+import { u as ae, a as oe, b as te, T as ce, I as ne, G as se, j as ie, p as le, K as de } from "../../label-y3ANLTNC.js";
+import { r as be } from "../../bugs-diTMAGNw.js";
+import { H as ue } from "../../field-FJ34aSs4.js";
+import { c as me } from "../../index-DIxK0V-G.js";
+import { Icon as fe } from "../../icons/Icon.js";
+import '../../assets/CheckboxMimir.css';let pe = "span";
+function he(u, m) {
+  let n = J(), f = ae(), s = oe(), { id: i = f || `headlessui-checkbox-${n}`, disabled: e = s || !1, autoFocus: a = !1, checked: P, defaultChecked: j, onChange: y, name: v, value: F, form: I, indeterminate: l = !1, ...H } = u, o = te(j), [t, c] = ce(P, y, o ?? !1), N = ne(), R = se(), E = V(), [k, x] = Q(!1), $ = d(() => {
+    x(!0), c == null || c(!t), E.nextFrame(() => {
+      x(!1);
+    });
+  }), K = d((r) => {
+    if (be(r.currentTarget)) return r.preventDefault();
+    r.preventDefault(), $();
+  }), T = d((r) => {
+    r.key === D.Space ? (r.preventDefault(), $()) : r.key === D.Enter && le(r.currentTarget);
+  }), M = d((r) => r.preventDefault()), { isFocusVisible: _, focusProps: w } = W({ autoFocus: a }), { isHovered: g, hoverProps: G } = X({ isDisabled: e }), { pressed: C, pressProps: S } = re({ disabled: e }), U = q({ ref: m, id: i, role: "checkbox", "aria-checked": l ? "mixed" : t ? "true" : "false", "aria-labelledby": N, "aria-describedby": R, "aria-disabled": e ? !0 : void 0, indeterminate: l ? "true" : void 0, tabIndex: e ? void 0 : 0, onKeyUp: e ? void 0 : T, onKeyPress: e ? void 0 : M, onClick: e ? void 0 : K }, w, G, S), A = Y(() => ({ checked: t, disabled: e, hover: g, focus: _, active: C, indeterminate: l, changing: k, autofocus: a }), [t, l, e, g, _, C, k, a]), B = Z(() => {
+    if (o !== void 0) return c == null ? void 0 : c(o);
+  }, [c, o]);
+  return h.createElement(h.Fragment, null, v != null && h.createElement(ie, { disabled: e, data: { [v]: F || "on" }, overrides: { type: "checkbox", checked: t }, form: I, onReset: B }), z({ ourProps: U, theirProps: H, slot: A, defaultTag: pe, name: "Checkbox" }));
+}
+let ve = O(he);
+const ke = "_container_13bjb_2", xe = "_checkbox_13bjb_8", $e = "_label_13bjb_27", _e = "_enabled_13bjb_31", b = {
+  container: ke,
+  checkbox: xe,
+  label: $e,
+  enabled: _e
+}, Ne = ee(
+  (u, m) => {
+    const {
+      checked: n,
+      onChange: f,
+      children: s,
+      id: i,
+      isInteractive: e = !0,
+      ...a
+    } = u;
+    return /* @__PURE__ */ L(ue, { className: b.container, children: [
+      /* @__PURE__ */ p(
+        ve,
+        {
+          id: i,
+          ref: m,
+          checked: n,
+          onChange: e ? f : void 0,
+          className: me(b.checkbox, {
+            [b.enabled]: n
+          }),
+          ...a,
+          children: /* @__PURE__ */ p(fe, { iconName: "Done16px" })
+        }
+      ),
+      s && /* @__PURE__ */ p(de, { htmlFor: i, className: b.label, children: s })
+    ] });
+  }
+);
+export {
+  Ne as CheckboxMimir
+};

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

@@ -0,0 +1,2 @@
+export { CheckboxMimir } from './CheckboxMimir';
+export type { TCheckboxMimirProps } from './CheckboxMimir';

package/dist/components/CheckboxMimir/index.js

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

package/dist/components/Chip/Chip.d.ts

@@ -0,0 +1,30 @@
+import { PropsWithChildren } from 'react';
+import { EChipSize, EChipVariant } from './constants';
+
+export type TProps = {
+    /**
+     * Дополнительный класс для компонента.
+     */
+    className?: string;
+    /**
+     * Вариант чипа. Возможные значения определены в перечислении `EChipVariant`.
+     */
+    variant?: `${EChipVariant}` | EChipVariant;
+    /**
+     * Размер чипа. Возможные значения определены в перечислении `EChipSize`.
+     */
+    size?: `${EChipSize}` | EChipSize;
+    /**
+     * Отключено ли чип.
+     */
+    disabled?: boolean;
+    /**
+     * Имеет ли чип действие (например, кнопку закрытия).
+     */
+    withAction?: boolean;
+    /**
+     * Обработчик для кнопки закрытия
+     */
+    onClose?: VoidFunction;
+};
+export declare const Chip: ({ size, variant, className, disabled, withAction, children, onClose }: PropsWithChildren<TProps>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Chip/Chip.js

@@ -0,0 +1,44 @@
+import { jsxs as r, jsx as m } from "react/jsx-runtime";
+import { c as p } from "../../index-DIxK0V-G.js";
+import { EChipSize as h, EChipVariant as b } from "./constants.js";
+import { Button as l } from "../Button/Button.js";
+import '../../assets/Chip.css';const v = "_chip_19bvm_2", d = "_disabled_19bvm_40", x = "_xs_19bvm_51", g = "_s_19bvm_59", u = "_m_19bvm_67", w = "_sapphire_19bvm_75", C = "_citrine_19bvm_84", f = "_asphalt_19bvm_93", y = "_gray_19bvm_102", N = "_white_19bvm_111", j = "_green_19bvm_120", s = {
+  chip: v,
+  "with-action": "_with-action_19bvm_18",
+  disabled: d,
+  xs: x,
+  s: g,
+  m: u,
+  sapphire: w,
+  citrine: C,
+  asphalt: f,
+  gray: y,
+  white: N,
+  green: j
+}, z = ({
+  size: i = h.M,
+  variant: _ = b.Sapphire,
+  className: c,
+  disabled: e,
+  withAction: t,
+  children: o,
+  onClose: a
+}) => {
+  const n = p(
+    s.chip,
+    c,
+    {
+      [s["with-action"]]: t,
+      [s.disabled]: e
+    },
+    s[_],
+    s[i]
+  );
+  return /* @__PURE__ */ r("div", { className: n, children: [
+    o,
+    t && /* @__PURE__ */ m(l, { isIconButton: !0, iconName: "Close16px", onClick: a, clear: !0 })
+  ] });
+};
+export {
+  z as Chip
+};

package/dist/components/Chip/constants.d.ts

@@ -0,0 +1,13 @@
+export declare enum EChipSize {
+    XS = "xs",
+    S = "s",
+    M = "m"
+}
+export declare enum EChipVariant {
+    Sapphire = "sapphire",
+    Citrine = "citrine",
+    Asphalt = "asphalt",
+    Gray = "gray",
+    White = "white",
+    Green = "green"
+}

package/dist/components/Chip/constants.js

@@ -0,0 +1,5 @@
+var r = /* @__PURE__ */ ((e) => (e.XS = "xs", e.S = "s", e.M = "m", e))(r || {}), s = /* @__PURE__ */ ((e) => (e.Sapphire = "sapphire", e.Citrine = "citrine", e.Asphalt = "asphalt", e.Gray = "gray", e.White = "white", e.Green = "green", e))(s || {});
+export {
+  r as EChipSize,
+  s as EChipVariant
+};

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

@@ -0,0 +1,2 @@
+export { Chip } from './Chip';
+export { EChipSize, EChipVariant } from './constants';

package/dist/components/Chip/index.js

@@ -0,0 +1,7 @@
+import { Chip as r } from "./Chip.js";
+import { EChipSize as e, EChipVariant as h } from "./constants.js";
+export {
+  r as Chip,
+  e as EChipSize,
+  h as EChipVariant
+};

package/dist/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,110 @@
+import { TInputProps } from '../Input';
+
+export type TProps = {
+    /**
+     * Функция обратного вызова при изменении значения даты
+     */
+    onChangeValue?: (e: TDatePickerValue) => void;
+    /**
+     * Функция обратного вызова при возникновении ошибки валидации
+     */
+    onError?: (e: TDatePickerOnError) => void;
+    /**
+     * Функция обратного вызова при потере фокуса компонентом
+     */
+    onBlur?: (e: string) => void;
+    /**
+     *  Функция ограничения выбора даты (до какой даты выбор не доступен)
+     */
+    before?: Date | string;
+    /**
+     * Значение даты из стейта (data)
+     */
+    value?: Date | string;
+    /**
+     * Значение типа модального окна календаря
+     */
+    type?: 'days' | 'months' | 'years';
+    /**
+     * Флаг отключения компонента
+     */
+    disabled?: boolean;
+    /**
+     * Флаг наличия ошибки или текст ошибки
+     */
+    error?: boolean | string;
+    /**
+     * Флаг немедленной валидации при вводе
+     */
+    validateImmediately?: boolean;
+    /**
+     * Флаг разрешения ручного ввода даты
+     */
+    editable?: boolean;
+    /**
+     * Флаг открытия модального окна календаря при вводе
+     */
+    openOnInput?: boolean;
+    /**
+     * Флаг отправки промежуточных значений в родительский компонент
+     */
+    sendIntermediateValues?: boolean;
+} & TInputProps;
+export type TDatePickerValue = {
+    value?: string;
+    name?: string;
+};
+export type TDatePickerOnError = {
+    name?: string;
+    active: boolean;
+};
+export declare const DatePicker: import('react').MemoExoticComponent<import('react').ForwardRefExoticComponent<{
+    /**
+     * Функция обратного вызова при изменении значения даты
+     */
+    onChangeValue?: (e: TDatePickerValue) => void;
+    /**
+     * Функция обратного вызова при возникновении ошибки валидации
+     */
+    onError?: (e: TDatePickerOnError) => void;
+    /**
+     * Функция обратного вызова при потере фокуса компонентом
+     */
+    onBlur?: (e: string) => void;
+    /**
+     *  Функция ограничения выбора даты (до какой даты выбор не доступен)
+     */
+    before?: Date | string;
+    /**
+     * Значение даты из стейта (data)
+     */
+    value?: Date | string;
+    /**
+     * Значение типа модального окна календаря
+     */
+    type?: "days" | "months" | "years";
+    /**
+     * Флаг отключения компонента
+     */
+    disabled?: boolean;
+    /**
+     * Флаг наличия ошибки или текст ошибки
+     */
+    error?: boolean | string;
+    /**
+     * Флаг немедленной валидации при вводе
+     */
+    validateImmediately?: boolean;
+    /**
+     * Флаг разрешения ручного ввода даты
+     */
+    editable?: boolean;
+    /**
+     * Флаг открытия модального окна календаря при вводе
+     */
+    openOnInput?: boolean;
+    /**
+     * Флаг отправки промежуточных значений в родительский компонент
+     */
+    sendIntermediateValues?: boolean;
+} & import('../Input/types').TInputProps & import('../Input').TAdditionalProps & import('react').RefAttributes<HTMLInputElement>>>;