@kommo-crm/crm-react-ui-kit 1.1.1-beta.3 → 1.1.1-beta.4

package/dist/components/CheckboxGroup/components/Checkbox/Checkbox.js

@@ -1,17 +1,34 @@
-import React, { forwardRef } from 'react';
-import { Checkbox as CheckboxCore } from 'src/components/Checkbox/Checkbox';
-import { useCheckboxGroupContext } from '../../CheckboxGroup.context';
-import { useCheckboxItemRootContext } from '../ItemRoot/ItemRoot.context';
-const DISPLAY_NAME = 'CheckboxGroup.Checkbox';
-export const Checkbox = forwardRef((props, ref) => {
-    const { theme, className, ...rest } = props;
-    const { values, isDisabled: isGlobalDisabled } = useCheckboxGroupContext(DISPLAY_NAME);
-    const { isDisabled: isItemRootIsDisabled, name, value, onChange, } = useCheckboxItemRootContext(DISPLAY_NAME);
-    const isDisabled = isGlobalDisabled || isItemRootIsDisabled;
-    const isChecked = Boolean(values.get(name || '')?.isChecked);
-    const handleChange = (e) => {
-        onChange({ type: 'checkbox', name: e.target.name });
-    };
-    return (React.createElement(CheckboxCore, { ref: ref, className: className, name: name, value: value, theme: theme, onChange: handleChange, isChecked: isChecked, isDisabled: isDisabled, ...rest }));
+import { jsx as k } from "react/jsx-runtime";
+import { forwardRef as p } from "react";
+import { Checkbox as f } from "../../../Checkbox/Checkbox.js";
+import { useCheckboxGroupContext as u } from "../../CheckboxGroup.context.js";
+import { useCheckboxItemRootContext as g } from "../ItemRoot/ItemRoot.context.js";
+const e = "CheckboxGroup.Checkbox", D = p((t, a) => {
+  var s;
+  const { theme: n, className: c, ...r } = t, { values: i, isDisabled: m } = u(e), {
+    isDisabled: h,
+    name: o,
+    value: C,
+    onChange: b
+  } = g(e), l = m || h, x = !!((s = i.get(o || "")) != null && s.isChecked);
+  return /* @__PURE__ */ k(
+    f,
+    {
+      ref: a,
+      className: c,
+      name: o,
+      value: C,
+      theme: n,
+      onChange: (d) => {
+        b({ type: "checkbox", name: d.target.name });
+      },
+      isChecked: x,
+      isDisabled: l,
+      ...r
+    }
+  );
 });
-Checkbox.displayName = DISPLAY_NAME;
+D.displayName = e;
+export {
+  D as Checkbox
+};

package/dist/components/CheckboxGroup/components/Checkbox/Checkbox.props.d.ts

@@ -1,3 +1,3 @@
-import { type CheckboxProps as CheckboxCoreProps } from 'src/components/Checkbox/Checkbox.props';
+import { CheckboxProps as CheckboxCoreProps } from '../../../Checkbox/Checkbox.props';
 export type CheckboxProps = Omit<CheckboxCoreProps, 'onChange' | 'value' | 'isDisabled' | 'isChecked' | 'isDefaultChecked'>;
 //# sourceMappingURL=Checkbox.props.d.ts.map

package/dist/components/CheckboxGroup/components/Checkbox/Checkbox.props.js

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

package/dist/components/CheckboxGroup/components/Checkbox/index.js

@@ -1 +1,4 @@
-export { Checkbox } from './Checkbox';
+import { Checkbox as r } from "./Checkbox.js";
+export {
+  r as Checkbox
+};

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/CheckboxSelectAll.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type CheckboxProps } from '../Checkbox/Checkbox.props';
+import { default as React } from 'react';
+import { CheckboxProps } from '../Checkbox/Checkbox.props';
 export declare const CheckboxSelectAll: React.ForwardRefExoticComponent<Omit<CheckboxProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
 //# sourceMappingURL=CheckboxSelectAll.d.ts.map

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/CheckboxSelectAll.js

@@ -1,26 +1,37 @@
-import React, { forwardRef } from 'react';
-import { Checkbox } from 'src/components/Checkbox/Checkbox';
-import { useCheckboxGroupContext } from '../../CheckboxGroup.context';
-import { useCheckboxItemRootSelectAllContext } from './ItemRootSelectAll.context';
-const DISPLAY_NAME = 'CheckboxGroup.CheckboxSelectAll';
-const SELECT_ALL = 'selectAll';
-export const CheckboxSelectAll = forwardRef((props, ref) => {
-    const { theme, className, ...rest } = props;
-    const { values, isDisabled: isGlobalDisabled } = useCheckboxGroupContext(DISPLAY_NAME);
-    const { onChange, isDisabled } = useCheckboxItemRootSelectAllContext(DISPLAY_NAME);
-    const handleChange = () => {
-        onChange({ type: SELECT_ALL, name: SELECT_ALL });
-    };
-    const getPropsBasedOnInternalState = () => {
-        const allChecked = Array.from(values.values()).every((checkbox) => checkbox.isChecked);
-        const checkedStyle = allChecked
-            ? 'mark'
-            : 'indeterminate';
+import { jsx as d } from "react/jsx-runtime";
+import { forwardRef as k } from "react";
+import { Checkbox as p } from "../../../Checkbox/Checkbox.js";
+import { useCheckboxGroupContext as b } from "../../CheckboxGroup.context.js";
+import { useCheckboxItemRootSelectAllContext as u } from "./ItemRootSelectAll.context.js";
+const t = "CheckboxGroup.CheckboxSelectAll", o = "selectAll", x = k((a, l) => {
+  const { theme: r, className: n, ...c } = a, { values: s, isDisabled: m } = b(t), { onChange: h, isDisabled: i } = u(t);
+  return /* @__PURE__ */ d(
+    p,
+    {
+      ref: l,
+      className: n,
+      onChange: () => {
+        h({ type: o, name: o });
+      },
+      theme: r,
+      value: o,
+      isDisabled: m || i,
+      ...(() => {
+        const C = Array.from(s.values()).every(
+          (e) => e.isChecked
+        ) ? "mark" : "indeterminate";
         return {
-            isChecked: Array.from(values.values()).some((checkbox) => checkbox.isChecked),
-            checkedStyle,
+          isChecked: Array.from(s.values()).some(
+            (e) => e.isChecked
+          ),
+          checkedStyle: C
         };
-    };
-    return (React.createElement(Checkbox, { ref: ref, className: className, onChange: handleChange, theme: theme, value: SELECT_ALL, isDisabled: isGlobalDisabled || isDisabled, ...getPropsBasedOnInternalState(), ...rest }));
+      })(),
+      ...c
+    }
+  );
 });
-CheckboxSelectAll.displayName = DISPLAY_NAME;
+x.displayName = t;
+export {
+  x as CheckboxSelectAll
+};

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/ItemRootSelectAll.context.d.ts

@@ -1,5 +1,5 @@
-import { type CheckboxItemSelectAllContextValue } from './ItemRootSelectAll.props';
+import { CheckboxItemSelectAllContextValue } from './ItemRootSelectAll.props';
 declare const DISPLAY_NAME = "CheckboxGroup.ItemRootSelectAll";
-declare const CheckboxItemRootSelectAllProvider: import("../../../../lib/react/createComponentContext").ContextProps<CheckboxItemSelectAllContextValue>, useCheckboxItemRootSelectAllContext: (consumerName: string) => NonNullable<CheckboxItemSelectAllContextValue>;
+declare const CheckboxItemRootSelectAllProvider: import('../../../../lib/react/createComponentContext').ContextProps<CheckboxItemSelectAllContextValue>, useCheckboxItemRootSelectAllContext: (consumerName: string) => NonNullable<CheckboxItemSelectAllContextValue>;
 export { CheckboxItemRootSelectAllProvider, useCheckboxItemRootSelectAllContext, DISPLAY_NAME, };
 //# sourceMappingURL=ItemRootSelectAll.context.d.ts.map

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/ItemRootSelectAll.context.js

@@ -1,4 +1,7 @@
-import { createComponentContext } from 'src/lib/react';
-const DISPLAY_NAME = 'CheckboxGroup.ItemRootSelectAll';
-const [CheckboxItemRootSelectAllProvider, useCheckboxItemRootSelectAllContext] = createComponentContext(DISPLAY_NAME);
-export { CheckboxItemRootSelectAllProvider, useCheckboxItemRootSelectAllContext, DISPLAY_NAME, };
+import { createComponentContext as e } from "../../../../lib/react/createComponentContext/createComponentContext.js";
+const o = "CheckboxGroup.ItemRootSelectAll", [c, l] = e(o);
+export {
+  c as CheckboxItemRootSelectAllProvider,
+  o as DISPLAY_NAME,
+  l as useCheckboxItemRootSelectAllContext
+};

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/ItemRootSelectAll.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type ItemRootSelectAllProps } from './ItemRootSelectAll.props';
+import { default as React } from 'react';
+import { ItemRootSelectAllProps } from './ItemRootSelectAll.props';
 export declare const ItemRootSelectAll: React.FC<ItemRootSelectAllProps>;
 //# sourceMappingURL=ItemRootSelectAll.d.ts.map

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/ItemRootSelectAll.js

@@ -1,22 +1,41 @@
-import React from 'react';
-import cx from 'classnames';
-import { useThemeClassName } from 'src/hooks/useThemeClassName';
-import { useCheckboxGroupContext } from '../../CheckboxGroup.context';
-import { CheckboxItemRootSelectAllProvider, DISPLAY_NAME, } from './ItemRootSelectAll.context';
-import s from '../ItemRoot/ItemRoot.module.css';
-export const ItemRootSelectAll = ({ children, theme, className, isDisabled, }) => {
-    const themeClassName = useThemeClassName(theme);
-    const { isDisabled: isGlobalDisabled, register } = useCheckboxGroupContext(DISPLAY_NAME);
-    return (React.createElement(CheckboxItemRootSelectAllProvider, { isDisabled: isDisabled, ...register('selectAll') },
-        React.createElement("div", { className: cx(s.item_root, themeClassName, className, {
-                /**
-                 * If `isDisabled` was passed directly to the component
-                 * Blocking a specific Checkbox.
-                 *
-                 * If passed to the CheckboxGroup component
-                 * We block all Checkboxes.
-                 */
-                [s.disabled]: isGlobalDisabled || isDisabled,
-            }) }, children)));
+import { jsx as o } from "react/jsx-runtime";
+import { c as p } from "../../../../index-L8X2o7IH.mjs";
+import { useThemeClassName as d } from "../../../../hooks/useThemeClassName/useThemeClassName.js";
+import { useCheckboxGroupContext as f } from "../../CheckboxGroup.context.js";
+import { DISPLAY_NAME as r, CheckboxItemRootSelectAllProvider as n } from "./ItemRootSelectAll.context.js";
+import { s as t } from "../../../../ItemRoot.module-DaaOqYPx.mjs";
+const x = ({
+  children: m,
+  theme: s,
+  className: l,
+  isDisabled: e
+}) => {
+  const i = d(s), { isDisabled: a, register: c } = f(r);
+  return /* @__PURE__ */ o(
+    n,
+    {
+      isDisabled: e,
+      ...c("selectAll"),
+      children: /* @__PURE__ */ o(
+        "div",
+        {
+          className: p(t.item_root, i, l, {
+            /**
+             * If `isDisabled` was passed directly to the component
+             * Blocking a specific Checkbox.
+             *
+             * If passed to the CheckboxGroup component
+             * We block all Checkboxes.
+             */
+            [t.disabled]: a || e
+          }),
+          children: m
+        }
+      )
+    }
+  );
+};
+x.displayName = r;
+export {
+  x as ItemRootSelectAll
 };
-ItemRootSelectAll.displayName = DISPLAY_NAME;

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/ItemRootSelectAll.props.d.ts

@@ -1,5 +1,5 @@
-import { type InternalCheckboxGroupChangeEvent } from '../../CheckboxGroup.props';
-import { type ItemRootProps } from '../ItemRoot';
+import { InternalCheckboxGroupChangeEvent } from '../../CheckboxGroup.props';
+import { ItemRootProps } from '../ItemRoot';
 export type ItemRootSelectAllProps = Omit<ItemRootProps, 'name' | 'isDefaultChecked' | 'value'>;
 export type CheckboxItemSelectAllContextValue = Omit<ItemRootSelectAllProps, 'theme' | 'children' | 'className'> & {
     /**

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/ItemRootSelectAll.props.js

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

package/dist/components/CheckboxGroup/components/CheckboxSelectAll/index.js

@@ -1,2 +1,6 @@
-export { CheckboxSelectAll } from './CheckboxSelectAll';
-export { ItemRootSelectAll } from './ItemRootSelectAll';
+import { CheckboxSelectAll as l } from "./CheckboxSelectAll.js";
+import { ItemRootSelectAll as r } from "./ItemRootSelectAll.js";
+export {
+  l as CheckboxSelectAll,
+  r as ItemRootSelectAll
+};

package/dist/components/CheckboxGroup/components/ItemRoot/ItemRoot.context.d.ts

@@ -1,5 +1,5 @@
-import { type CheckboxItemContextProps } from './ItemRoot.props';
+import { CheckboxItemContextProps } from './ItemRoot.props';
 declare const DISPLAY_NAME = "CheckboxGroup.ItemRoot";
-declare const CheckboxItemRootProvider: import("../../../../lib/react/createComponentContext").ContextProps<CheckboxItemContextProps>, useCheckboxItemRootContext: (consumerName: string) => NonNullable<CheckboxItemContextProps>;
+declare const CheckboxItemRootProvider: import('../../../../lib/react/createComponentContext').ContextProps<CheckboxItemContextProps>, useCheckboxItemRootContext: (consumerName: string) => NonNullable<CheckboxItemContextProps>;
 export { CheckboxItemRootProvider, useCheckboxItemRootContext, DISPLAY_NAME };
 //# sourceMappingURL=ItemRoot.context.d.ts.map

package/dist/components/CheckboxGroup/components/ItemRoot/ItemRoot.context.js

@@ -1,4 +1,7 @@
-import { createComponentContext } from 'src/lib/react';
-const DISPLAY_NAME = 'CheckboxGroup.ItemRoot';
-const [CheckboxItemRootProvider, useCheckboxItemRootContext] = createComponentContext(DISPLAY_NAME);
-export { CheckboxItemRootProvider, useCheckboxItemRootContext, DISPLAY_NAME };
+import { createComponentContext as o } from "../../../../lib/react/createComponentContext/createComponentContext.js";
+const t = "CheckboxGroup.ItemRoot", [r, c] = o(t);
+export {
+  r as CheckboxItemRootProvider,
+  t as DISPLAY_NAME,
+  c as useCheckboxItemRootContext
+};

package/dist/components/CheckboxGroup/components/ItemRoot/ItemRoot.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type ItemRootProps } from './ItemRoot.props';
+import { default as React } from 'react';
+import { ItemRootProps } from './ItemRoot.props';
 export declare const ItemRoot: React.FC<ItemRootProps>;
 //# sourceMappingURL=ItemRoot.d.ts.map

package/dist/components/CheckboxGroup/components/ItemRoot/ItemRoot.js

@@ -1,22 +1,36 @@
-import React from 'react';
-import cx from 'classnames';
-import { useThemeClassName } from 'src/hooks/useThemeClassName';
-import { useCheckboxGroupContext } from '../../CheckboxGroup.context';
-import { CheckboxItemRootProvider, DISPLAY_NAME } from './ItemRoot.context';
-import s from './ItemRoot.module.css';
-export const ItemRoot = ({ children, theme, className, name, value, ...checkboxProps }) => {
-    const themeClassName = useThemeClassName(theme);
-    const { isDisabled, register } = useCheckboxGroupContext(DISPLAY_NAME);
-    return (React.createElement(CheckboxItemRootProvider, { value: value, ...register(name, checkboxProps) },
-        React.createElement("div", { className: cx(s.item_root, themeClassName, className, {
-                /**
-                 * If `isDisabled` was passed directly to the component
-                 * Blocking a specific Checkbox.
-                 *
-                 * If passed to the CheckboxGroup component
-                 * We block all Checkboxes.
-                 */
-                [s.disabled]: isDisabled || checkboxProps.isDisabled,
-            }) }, children)));
+import { jsx as e } from "react/jsx-runtime";
+import { c as f } from "../../../../index-L8X2o7IH.mjs";
+import { useThemeClassName as n } from "../../../../hooks/useThemeClassName/useThemeClassName.js";
+import { useCheckboxGroupContext as x } from "../../CheckboxGroup.context.js";
+import { DISPLAY_NAME as r, CheckboxItemRootProvider as C } from "./ItemRoot.context.js";
+import { s as m } from "../../../../ItemRoot.module-DaaOqYPx.mjs";
+const N = ({
+  children: t,
+  theme: s,
+  className: i,
+  name: a,
+  value: d,
+  ...o
+}) => {
+  const l = n(s), { isDisabled: p, register: c } = x(r);
+  return /* @__PURE__ */ e(C, { value: d, ...c(a, o), children: /* @__PURE__ */ e(
+    "div",
+    {
+      className: f(m.item_root, l, i, {
+        /**
+         * If `isDisabled` was passed directly to the component
+         * Blocking a specific Checkbox.
+         *
+         * If passed to the CheckboxGroup component
+         * We block all Checkboxes.
+         */
+        [m.disabled]: p || o.isDisabled
+      }),
+      children: t
+    }
+  ) });
+};
+N.displayName = r;
+export {
+  N as ItemRoot
 };
-ItemRoot.displayName = DISPLAY_NAME;

package/dist/components/CheckboxGroup/components/ItemRoot/ItemRoot.props.d.ts

@@ -1,5 +1,5 @@
-import { type InternalCheckboxGroupChangeEvent } from '../../CheckboxGroup.props';
-import { type ItemRootThemeType } from './ItemRoot.themes';
+import { InternalCheckboxGroupChangeEvent } from '../../CheckboxGroup.props';
+import { ItemRootThemeType } from './ItemRoot.themes';
 export type ItemRootProps = {
     /**
      * The unique name used to identify the `checkbox` element.

package/dist/components/CheckboxGroup/components/ItemRoot/ItemRoot.props.js

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

package/dist/components/CheckboxGroup/components/ItemRoot/ItemRoot.themes.js

@@ -1,3 +1,6 @@
-export const CheckboxGroupItemRootTheme = {
-    '--crm-ui-kit-checkbox-group-item-root-disabled-opacity': 'var(--crm-ui-kit-disabled-opacity)',
+const o = {
+  "--crm-ui-kit-checkbox-group-item-root-disabled-opacity": "var(--crm-ui-kit-disabled-opacity)"
+};
+export {
+  o as CheckboxGroupItemRootTheme
 };

package/dist/components/CheckboxGroup/components/ItemRoot/index.js

@@ -1,2 +1,6 @@
-export { ItemRoot } from './ItemRoot';
-export { CheckboxGroupItemRootTheme, } from './ItemRoot.themes';
+import { ItemRoot as t } from "./ItemRoot.js";
+import { CheckboxGroupItemRootTheme as r } from "./ItemRoot.themes.js";
+export {
+  r as CheckboxGroupItemRootTheme,
+  t as ItemRoot
+};

package/dist/components/CheckboxGroup/hooks/index.js

@@ -1 +1,4 @@
-export { useCheckboxGroupState } from './useCheckboxGroupState';
+import { useCheckboxGroupState as r } from "./useCheckboxGroupState.js";
+export {
+  r as useCheckboxGroupState
+};

package/dist/components/CheckboxGroup/hooks/useCheckboxGroupState.d.ts

@@ -1,4 +1,4 @@
-import { type RegisterHandlerType, type CheckboxStateType, type UseCheckboxGroupStateArgs } from '../CheckboxGroup.props';
+import { RegisterHandlerType, CheckboxStateType, UseCheckboxGroupStateArgs } from '../CheckboxGroup.props';
 export declare const useCheckboxGroupState: ({ isDisabled, onChange, }: UseCheckboxGroupStateArgs) => {
     state: Map<string, CheckboxStateType>;
     register: RegisterHandlerType;

package/dist/components/CheckboxGroup/hooks/useCheckboxGroupState.js

@@ -1,60 +1,50 @@
-import { useLayoutEffect, useRef, useState } from 'react';
-export const useCheckboxGroupState = ({ isDisabled, onChange, }) => {
-    const [state, setState] = useState(new Map());
-    const registeredComponents = useRef({});
-    const queueComponents = useRef([]);
-    const handleChange = (changeEvent) => {
-        setState((prev) => {
-            const copyState = new Map(prev);
-            if (changeEvent.type === 'selectAll' && !isDisabled) {
-                const isSomeChecked = Array.from(copyState.values()).some((checkbox) => checkbox.isChecked && !checkbox.isDisabled);
-                copyState.forEach((checkbox) => {
-                    if (!checkbox.isDisabled) {
-                        checkbox.isChecked = !isSomeChecked;
-                    }
-                });
-            }
-            if (changeEvent.type === 'checkbox' && !isDisabled) {
-                const currentCheckbox = copyState.get(changeEvent.name);
-                if (currentCheckbox && !currentCheckbox.isDisabled) {
-                    copyState.set(currentCheckbox.name, {
-                        ...currentCheckbox,
-                        isChecked: !currentCheckbox.isChecked,
-                    });
-                }
-            }
-            onChange([...copyState.values()], changeEvent);
-            return copyState;
+import { useState as C, useRef as a, useLayoutEffect as h } from "react";
+const m = ({
+  isDisabled: n,
+  onChange: l
+}) => {
+  const [f, u] = C(/* @__PURE__ */ new Map()), i = a({}), c = a([]), d = (e) => {
+    u((r) => {
+      const s = new Map(r);
+      if (e.type === "selectAll" && !n) {
+        const t = Array.from(s.values()).some(
+          (o) => o.isChecked && !o.isDisabled
+        );
+        s.forEach((o) => {
+          o.isDisabled || (o.isChecked = !t);
         });
-    };
-    useLayoutEffect(() => {
-        if (queueComponents.current.length) {
-            const queue = queueComponents.current;
-            queueComponents.current = [];
-            setState((prev) => {
-                const copyState = new Map(prev);
-                queue.forEach((checkbox) => copyState.set(checkbox.name, checkbox));
-                return copyState;
-            });
-        }
+      }
+      if (e.type === "checkbox" && !n) {
+        const t = s.get(e.name);
+        t && !t.isDisabled && s.set(t.name, {
+          ...t,
+          isChecked: !t.isChecked
+        });
+      }
+      return l([...s.values()], e), s;
     });
-    const register = (name, options = {}) => {
-        if (name !== 'selectAll' && !registeredComponents.current[name]) {
-            registeredComponents.current[name] = true;
-            queueComponents.current.push({
-                name,
-                isChecked: Boolean(options.isDefaultChecked),
-                isDisabled: Boolean(options.isDisabled),
-            });
-        }
-        return {
-            name,
-            onChange: handleChange,
-            ...options,
-        };
-    };
-    return {
-        state,
-        register,
-    };
+  };
+  return h(() => {
+    if (c.current.length) {
+      const e = c.current;
+      c.current = [], u((r) => {
+        const s = new Map(r);
+        return e.forEach((t) => s.set(t.name, t)), s;
+      });
+    }
+  }), {
+    state: f,
+    register: (e, r = {}) => (e !== "selectAll" && !i.current[e] && (i.current[e] = !0, c.current.push({
+      name: e,
+      isChecked: !!r.isDefaultChecked,
+      isDisabled: !!r.isDisabled
+    })), {
+      name: e,
+      onChange: d,
+      ...r
+    })
+  };
+};
+export {
+  m as useCheckboxGroupState
 };

package/dist/components/CheckboxGroup/index.js

@@ -1,4 +1,12 @@
-export { CheckboxGroup } from './CheckboxGroup';
-export { CheckboxGroupTheme, } from './CheckboxGroup.themes';
-export { ItemRoot, CheckboxGroupItemRootTheme, } from './components/ItemRoot';
-export { Checkbox } from './components/Checkbox';
+import { CheckboxGroup as r } from "./CheckboxGroup.js";
+import { CheckboxGroupTheme as t } from "./CheckboxGroup.themes.js";
+import { ItemRoot as p } from "./components/ItemRoot/ItemRoot.js";
+import { CheckboxGroupItemRootTheme as f } from "./components/ItemRoot/ItemRoot.themes.js";
+import { Checkbox as c } from "./components/Checkbox/Checkbox.js";
+export {
+  c as Checkbox,
+  r as CheckboxGroup,
+  f as CheckboxGroupItemRootTheme,
+  t as CheckboxGroupTheme,
+  p as ItemRoot
+};

package/dist/components/ConfigProvider/ConfigProvider.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type ConfigProviderProps } from './ConfigProvider.props';
+import { default as React } from 'react';
+import { ConfigProviderProps } from './ConfigProvider.props';
 export declare const ConfigProvider: ({ appearance, children, }: ConfigProviderProps) => React.ReactNode;
 //# sourceMappingURL=ConfigProvider.d.ts.map

package/dist/components/ConfigProvider/ConfigProvider.js

@@ -1,8 +1,14 @@
-import { useLayoutEffect } from 'react';
-import { APPEARANCE_ATTRIBUTE_NAME } from 'src/lib/appearance';
-export const ConfigProvider = ({ appearance, children, }) => {
-    useLayoutEffect(() => {
-        document.documentElement.setAttribute(APPEARANCE_ATTRIBUTE_NAME, appearance);
-    }, [appearance]);
-    return children;
+import { useLayoutEffect as e } from "react";
+import { APPEARANCE_ATTRIBUTE_NAME as r } from "../../lib/appearance/index.js";
+const A = ({
+  appearance: t,
+  children: o
+}) => (e(() => {
+  document.documentElement.setAttribute(
+    r,
+    t
+  );
+}, [t]), o);
+export {
+  A as ConfigProvider
 };

package/dist/components/ConfigProvider/ConfigProvider.props.d.ts

@@ -1,4 +1,4 @@
-import { Appearance } from 'src/lib/appearance';
+import { Appearance } from '../../lib/appearance';
 export interface ConfigProviderProps {
     /**
      * Nested element

package/dist/components/ConfigProvider/ConfigProvider.props.js

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

package/dist/components/ConfigProvider/index.js

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

package/dist/components/ContentBlock/ContentBlock.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type ContentBlockProps } from './ContentBlock.props';
+import { default as React } from 'react';
+import { ContentBlockProps } from './ContentBlock.props';
 export declare const ContentBlock: React.ForwardRefExoticComponent<Omit<ContentBlockProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 //# sourceMappingURL=ContentBlock.d.ts.map

package/dist/components/ContentBlock/ContentBlock.js

@@ -1,10 +1,14 @@
-import React, { forwardRef } from 'react';
-import cx from 'classnames';
-import { useThemeClassName } from 'src/hooks/useThemeClassName';
-import s from './ContentBlock.module.css';
-export const ContentBlock = forwardRef((props, ref) => {
-    const { className = '', theme, children, ...rest } = props;
-    const themeClassName = useThemeClassName(theme);
-    return (React.createElement("div", { ref: ref, className: cx(s.block, themeClassName, className), ...rest }, children));
+import { jsx as a } from "react/jsx-runtime";
+import { forwardRef as l } from "react";
+import { c as n } from "../../index-L8X2o7IH.mjs";
+import { useThemeClassName as f } from "../../hooks/useThemeClassName/useThemeClassName.js";
+import '../../assets/ContentBlock.css';const i = "_block_1efq7_1", k = {
+  block: i
+}, p = l((o, e) => {
+  const { className: s = "", theme: t, children: c, ...m } = o, r = f(t);
+  return /* @__PURE__ */ a("div", { ref: e, className: n(k.block, r, s), ...m, children: c });
 });
-ContentBlock.displayName = 'ContentBlock';
+p.displayName = "ContentBlock";
+export {
+  p as ContentBlock
+};

package/dist/components/ContentBlock/ContentBlock.props.js

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