@qsxy/element-plus-react 1.0.0-next.1

package/dist/Checkbox/Checkbox.js

@@ -0,0 +1,168 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Checkbox/Checkbox.tsx
+var Checkbox_exports = {};
+__export(Checkbox_exports, {
+  default: () => Checkbox_default
+});
+module.exports = __toCommonJS(Checkbox_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_CheckboxGroup = require("../CheckboxGroup");
+var import_Tooltip = __toESM(require("../Tooltip/Tooltip"));
+var import_hooks = require("../hooks");
+var Checkbox = (0, import_react.memo)(
+  (0, import_react.forwardRef)((props, ref) => {
+    const {
+      name: nameContext,
+      disabled: disabledContext,
+      readOnly: readOnlyContext,
+      value: groupValue,
+      size: groupSize,
+      onChange: onGroupChange
+    } = (0, import_react.useContext)(import_CheckboxGroup.CheckboxGroupContext);
+    const {
+      checked: controlledChecked,
+      className,
+      children,
+      defaultChecked,
+      title,
+      indeterminate,
+      readOnly = readOnlyContext,
+      name = nameContext,
+      value,
+      onClick,
+      onCheckboxClick,
+      onChange,
+      prevent,
+      onMouseEnter,
+      onMouseLeave,
+      ...rest
+    } = props;
+    const disabled = (0, import_hooks.useDisabled)(disabledContext || props.disabled);
+    const size = (0, import_hooks.useSize)(groupSize ?? props.size);
+    const isChecked = (0, import_react.useCallback)(() => {
+      if (typeof groupValue !== "undefined") {
+        return groupValue instanceof Array ? groupValue.some((i) => i === value) : groupValue;
+      }
+      return controlledChecked;
+    }, [controlledChecked, groupValue, value]);
+    const [checked, setChecked] = (0, import_hooks.useControlled)(isChecked(), defaultChecked);
+    const { b, m, e, is } = (0, import_hooks.useClassNames)("checkbox");
+    const [htmlInputProps, restProps] = (0, import_hooks.partitionHTMLProps)(rest);
+    const inputRef = (0, import_react.useRef)();
+    const containerRef = (0, import_react.useRef)();
+    const handleChange = (0, import_react.useCallback)(
+      (event) => {
+        const nextChecked = !checked;
+        if (disabled || readOnly) {
+          return;
+        }
+        setChecked(nextChecked);
+        onChange == null ? void 0 : onChange(nextChecked, value, event);
+        onGroupChange == null ? void 0 : onGroupChange(value, nextChecked, event);
+      },
+      [checked, disabled, readOnly, setChecked, onChange, value, onGroupChange]
+    );
+    (0, import_react.useImperativeHandle)(ref, () => ({
+      get input() {
+        return inputRef.current;
+      },
+      isChcked: () => checked,
+      setChecked
+    }));
+    const main = (0, import_react.useMemo)(
+      () => /* @__PURE__ */ import_react.default.createElement(
+        "label",
+        {
+          className: (0, import_classnames.default)(b(), is({ checked, disabled }), m({ [size]: size }), className),
+          ref: containerRef,
+          onClick,
+          onMouseEnter,
+          onMouseLeave,
+          ...restProps
+        },
+        /* @__PURE__ */ import_react.default.createElement(
+          "input",
+          {
+            key: name,
+            ...htmlInputProps,
+            name,
+            value,
+            type: "checkbox",
+            ref: inputRef,
+            className: (0, import_classnames.default)(e`hidden`, is({ indeterminate })),
+            checked,
+            "data-checked": checked,
+            readOnly,
+            disabled,
+            onClick: (event) => {
+              event.stopPropagation();
+              prevent && event.preventDefault();
+              onCheckboxClick == null ? void 0 : onCheckboxClick(event);
+            },
+            onChange: handleChange
+          }
+        ),
+        /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(e`inner`, is({ checked, disabled })) }),
+        /* @__PURE__ */ import_react.default.createElement("span", { className: e`label` }, children)
+      ),
+      [
+        b,
+        checked,
+        children,
+        className,
+        disabled,
+        e,
+        handleChange,
+        htmlInputProps,
+        indeterminate,
+        is,
+        m,
+        name,
+        onCheckboxClick,
+        onClick,
+        onMouseEnter,
+        onMouseLeave,
+        prevent,
+        readOnly,
+        restProps,
+        size,
+        value
+      ]
+    );
+    return title ? /* @__PURE__ */ import_react.default.createElement(import_Tooltip.default, { content: title }, main) : main;
+  })
+);
+Checkbox.defaultProps = {
+  prevent: false,
+  defaultChecked: false
+};
+Checkbox.displayName = "ElCheckbox";
+var Checkbox_default = Checkbox;

package/dist/Checkbox/CheckboxButton.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { CheckboxProps } from './typings';
+declare const Comp: FC<CheckboxProps>;
+export default Comp;

package/dist/Checkbox/CheckboxButton.js

@@ -0,0 +1,166 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Checkbox/CheckboxButton.tsx
+var CheckboxButton_exports = {};
+__export(CheckboxButton_exports, {
+  default: () => CheckboxButton_default
+});
+module.exports = __toCommonJS(CheckboxButton_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_CheckboxGroup = require("../CheckboxGroup");
+var import_Tooltip = __toESM(require("../Tooltip/Tooltip"));
+var import_hooks = require("../hooks");
+var CheckboxButton = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    name: nameContext,
+    disabled: disabledContext,
+    readOnly: readOnlyContext,
+    value: groupValue,
+    size: groupSize,
+    onChange: onGroupChange
+  } = (0, import_react.useContext)(import_CheckboxGroup.CheckboxGroupContext);
+  const {
+    checked: controlledChecked,
+    className,
+    children,
+    defaultChecked,
+    title,
+    indeterminate,
+    readOnly = readOnlyContext,
+    name = nameContext,
+    value,
+    onClick,
+    onCheckboxClick,
+    onChange,
+    prevent,
+    onMouseEnter,
+    onMouseLeave,
+    ...rest
+  } = props;
+  const disabled = (0, import_hooks.useDisabled)(disabledContext || props.disabled);
+  const size = (0, import_hooks.useSize)(groupSize ?? props.size);
+  const isChecked = (0, import_react.useCallback)(() => {
+    if (typeof groupValue !== "undefined") {
+      return groupValue instanceof Array ? groupValue.some((i) => i === value) : groupValue;
+    }
+    return controlledChecked;
+  }, [controlledChecked, groupValue, value]);
+  const [checked, setChecked] = (0, import_hooks.useControlled)(isChecked(), defaultChecked);
+  const { b, m, e, is } = (0, import_hooks.useClassNames)("checkbox-button");
+  const [htmlInputProps, restProps] = (0, import_hooks.partitionHTMLProps)(rest);
+  const inputRef = (0, import_react.useRef)();
+  const handleChange = (0, import_react.useCallback)(
+    (event) => {
+      const nextChecked = !checked;
+      if (disabled || readOnly) {
+        return;
+      }
+      setChecked(nextChecked);
+      onChange == null ? void 0 : onChange(nextChecked, value, event);
+      onGroupChange == null ? void 0 : onGroupChange(value, nextChecked, event);
+    },
+    [checked, disabled, readOnly, setChecked, onChange, value, onGroupChange]
+  );
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    get input() {
+      return inputRef.current;
+    },
+    isChcked: () => checked,
+    setChecked
+  }));
+  const main = (0, import_react.useMemo)(
+    () => /* @__PURE__ */ import_react.default.createElement(
+      "label",
+      {
+        className: (0, import_classnames.default)(b(), is({ checked, disabled }), m({ [size]: size }), className),
+        ref,
+        onClick,
+        onMouseEnter,
+        onMouseLeave,
+        ...restProps
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        "input",
+        {
+          key: name,
+          ...htmlInputProps,
+          name,
+          value,
+          type: "checkbox",
+          ref: inputRef,
+          className: (0, import_classnames.default)(e`original`, is({ indeterminate })),
+          checked,
+          "data-checked": checked,
+          readOnly,
+          disabled,
+          onClick: (event) => {
+            event.stopPropagation();
+            prevent && event.preventDefault();
+            onCheckboxClick == null ? void 0 : onCheckboxClick(event);
+          },
+          onChange: handleChange
+        }
+      ),
+      /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(e`inner`, is({ checked, disabled })) }, children)
+    ),
+    [
+      b,
+      checked,
+      children,
+      className,
+      disabled,
+      e,
+      handleChange,
+      htmlInputProps,
+      indeterminate,
+      is,
+      m,
+      name,
+      onCheckboxClick,
+      onClick,
+      onMouseEnter,
+      onMouseLeave,
+      prevent,
+      readOnly,
+      ref,
+      restProps,
+      size,
+      value
+    ]
+  );
+  return title ? /* @__PURE__ */ import_react.default.createElement(import_Tooltip.default, { content: title }, main) : main;
+});
+var Comp = (0, import_react.memo)(CheckboxButton);
+Comp.defaultProps = {
+  prevent: false,
+  defaultChecked: false
+};
+Comp.displayName = "ElCheckboxButton";
+var CheckboxButton_default = Comp;

package/dist/Checkbox/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Checkbox } from './Checkbox';
+export { default as CheckboxButton } from './CheckboxButton';
+export type { CheckboxProps, ValueType } from './typings';

package/dist/Checkbox/index.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Checkbox/index.ts
+var Checkbox_exports = {};
+__export(Checkbox_exports, {
+  Checkbox: () => import_Checkbox.default,
+  CheckboxButton: () => import_CheckboxButton.default
+});
+module.exports = __toCommonJS(Checkbox_exports);
+var import_Checkbox = __toESM(require("./Checkbox"));
+var import_CheckboxButton = __toESM(require("./CheckboxButton"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Checkbox,
+  CheckboxButton
+});

package/dist/Checkbox/typings.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { BaseProps, FormControlBaseProps, NativeProps } from '../types/common';
+export type ValueType = string | number;
+export type CheckboxRef = {
+    input: HTMLInputElement;
+    isChcked: () => boolean;
+    setChecked: (value: boolean) => void;
+};
+export interface CheckboxProps<V = ValueType> extends Omit<React.AllHTMLAttributes<HTMLElement>, 'value' | 'defaultValue' | 'loading' | 'size' | 'icon' | 'style' | 'onChange' | 'children'>, Omit<FormControlBaseProps<V>, 'onChange'>, BaseProps, NativeProps {
+    title?: string;
+    inline?: boolean;
+    readOnly?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    name?: string;
+    prevent?: boolean;
+    onChange?: (checked: boolean, value: ValueType, event: React.ChangeEvent<HTMLInputElement>) => void;
+    onClick?: (event: React.MouseEvent<HTMLLabelElement, MouseEvent>) => void;
+    onCheckboxClick?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
+}

package/dist/Checkbox/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Checkbox/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/CheckboxGroup/CheckboxGroup.d.ts

@@ -0,0 +1,12 @@
+import { FC } from 'react';
+import type { ValueType } from '../Checkbox/index';
+import { BaseProps, FormControlBaseProps, NativeProps, TypeAttributes } from '../types/common';
+export interface CheckboxGroupProps<V = ValueType[] | boolean> extends FormControlBaseProps<V>, BaseProps, NativeProps {
+    name?: string;
+    size?: TypeAttributes.Size;
+    getBooleanOnSingle?: boolean;
+    min?: number;
+    max?: number;
+}
+declare const CheckboxGroup: FC<CheckboxGroupProps>;
+export default CheckboxGroup;

package/dist/CheckboxGroup/CheckboxGroup.js

@@ -0,0 +1,117 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/CheckboxGroup/CheckboxGroup.tsx
+var CheckboxGroup_exports = {};
+__export(CheckboxGroup_exports, {
+  default: () => CheckboxGroup_default
+});
+module.exports = __toCommonJS(CheckboxGroup_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
+var import_remove = __toESM(require("lodash/remove"));
+var import_react = __toESM(require("react"));
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_CheckboxGroupContext = require("./CheckboxGroupContext");
+var CheckboxGroup = (0, import_react.memo)(
+  (0, import_react.forwardRef)((props, ref) => {
+    const { className, name, value: valueProp, defaultValue, classPrefix = "checkbox-group", readOnly, onChange, getBooleanOnSingle, min, max, ...rest } = props;
+    const { m } = (0, import_hooks.useClassNames)(classPrefix);
+    const [value, setValue, isControlled] = (0, import_hooks.useControlled)(valueProp, defaultValue);
+    const disabled = (0, import_hooks.useDisabled)(props.disabled);
+    const size = (0, import_hooks.useSize)(props.size);
+    const getTabPaneInstance = (0, import_hooks.useChildrenInstance)(["ElCheckbox", "ElCheckboxButton"]);
+    const children = (0, import_react.useMemo)(() => {
+      const componentChildren = getTabPaneInstance(props == null ? void 0 : props.children);
+      return componentChildren;
+    }, [getTabPaneInstance, props == null ? void 0 : props.children]);
+    const isSingle = (0, import_react.useMemo)(() => {
+      return children.length === 1;
+    }, [children]);
+    const handleChange = (0, import_react.useCallback)(
+      (itemValue, itemChecked, event) => {
+        let nextValue = (0, import_cloneDeep.default)(value) ?? [];
+        if (isSingle) {
+          if (itemChecked) {
+            nextValue = getBooleanOnSingle ? itemChecked : [(0, import_cloneDeep.default)(itemValue)];
+          } else {
+            nextValue = getBooleanOnSingle ? itemChecked : [];
+          }
+        } else {
+          if (nextValue instanceof Array) {
+            if (itemChecked) {
+              nextValue.push(itemValue);
+            } else {
+              (0, import_remove.default)(nextValue, (i) => (0, import_Util.shallowEqual)(i, itemValue));
+            }
+          }
+        }
+        setValue(nextValue);
+        onChange == null ? void 0 : onChange(nextValue, event);
+      },
+      [getBooleanOnSingle, isSingle, onChange, setValue, value]
+    );
+    const contextValue = (0, import_react.useMemo)(
+      () => ({
+        name,
+        value,
+        readOnly,
+        disabled,
+        size,
+        controlled: isControlled,
+        onChange: handleChange
+      }),
+      [disabled, handleChange, isControlled, name, readOnly, size, value]
+    );
+    const childs = (0, import_react.useMemo)(() => {
+      if (min > 0 && value instanceof Array && value.length <= min) {
+        return children.map((item, index) => {
+          const isChcked = value.some((i) => i === item.props.value);
+          if (isChcked && value.length < max) {
+            return import_react.default.cloneElement(item, { key: index, ...item.props, disabled: isChcked });
+          } else if (value.length == max) {
+            return import_react.default.cloneElement(item, { key: index, ...item.props, disabled: !isChcked });
+          } else {
+            return import_react.default.cloneElement(item, { key: index, ...item.props });
+          }
+        });
+      }
+      if (max > 0 && value instanceof Array && value.length == max) {
+        return children.map((item, index) => {
+          const isChcked = value.some((i) => i === item.props.value);
+          return import_react.default.cloneElement(item, { key: index, ...item.props, disabled: !isChcked });
+        });
+      }
+      return children;
+    }, [children, max, min, value]);
+    return /* @__PURE__ */ import_react.default.createElement(import_CheckboxGroupContext.CheckboxGroupContext.Provider, { value: contextValue }, /* @__PURE__ */ import_react.default.createElement("div", { ref, className: (0, import_classnames.default)(className, m({ [size]: size })) }, childs));
+  })
+);
+CheckboxGroup.displayName = "ElCheckboxGroup";
+var CheckboxGroup_default = CheckboxGroup;

package/dist/CheckboxGroup/CheckboxGroupContext.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { ValueType } from '../Checkbox/index';
+import { TypeAttributes } from '../types/common';
+export interface CheckboxGroupContextValue {
+    inline?: boolean;
+    name?: string;
+    value?: ValueType[] | boolean;
+    controlled?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    plaintext?: boolean;
+    size?: TypeAttributes.Size;
+    onChange?: (value: any, checked: boolean, event: any) => void;
+}
+export declare const CheckboxGroupContext: import("react").Context<CheckboxGroupContextValue>;

package/dist/CheckboxGroup/CheckboxGroupContext.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/CheckboxGroup/CheckboxGroupContext.ts
+var CheckboxGroupContext_exports = {};
+__export(CheckboxGroupContext_exports, {
+  CheckboxGroupContext: () => CheckboxGroupContext
+});
+module.exports = __toCommonJS(CheckboxGroupContext_exports);
+var import_react = require("react");
+var CheckboxGroupContext = (0, import_react.createContext)({});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckboxGroupContext
+});

package/dist/CheckboxGroup/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CheckboxGroup } from './CheckboxGroup';
+export type { CheckboxGroupProps } from './CheckboxGroup';
+export { CheckboxGroupContext } from './CheckboxGroupContext';
+export type { CheckboxGroupContextValue } from './CheckboxGroupContext';

package/dist/CheckboxGroup/index.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/CheckboxGroup/index.ts
+var CheckboxGroup_exports = {};
+__export(CheckboxGroup_exports, {
+  CheckboxGroup: () => import_CheckboxGroup.default,
+  CheckboxGroupContext: () => import_CheckboxGroupContext.CheckboxGroupContext
+});
+module.exports = __toCommonJS(CheckboxGroup_exports);
+var import_CheckboxGroup = __toESM(require("./CheckboxGroup"));
+var import_CheckboxGroupContext = require("./CheckboxGroupContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckboxGroup,
+  CheckboxGroupContext
+});

package/dist/Col/Col.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { ColProps } from './typings';
+declare const Col: FC<ColProps>;
+export default Col;