@rainbow-oh/yee-c 0.1.0 → 0.3.0

package/dist/cjs/Radio/style/index.less

@@ -9,14 +9,16 @@
     gap: var(--yee-radio-group-gap);
 
     &-small {
-      @{pls} {
-        padding: var(--yee-radio-small-padding, 2px 4px);
+      @{pls}-button-wrapper {
+        font-size: var(--yee-radio-font-small-size);
+        padding: var(--yee-radio-small-padding);
       }
     }
 
     &-large {
-      @{pls} {
-        padding: var(--yee-radio-large-padding, 6px 12px);
+      @{pls}-button-wrapper {
+        font-size: var(--yee-radio-font-large-size);
+        padding: var(--yee-radio-large-padding);
       }
     }
 
@@ -61,12 +63,25 @@
           bottom: 0;
           border-color: transparent;
           border-style: solid;
-          border-width: var(--yee-radio-cornermark-border-width);
+          border-width: calc(var(--yee-radio-cornermark-border-width) / 3 * 2);
           border-right-color: var(--yee-radio-inner-checked-border-color);
           border-bottom-color: var(--yee-radio-inner-checked-border-color);
           content: '';
         }
 
+        &::before {
+          position: absolute;
+          z-index: 1;
+          right: 3px;
+          top: 18px;
+          width: 3px;
+          height: 7px;
+          border: 2px solid #fff;
+          border-width: 0 2px 2px 0;
+          transform: rotate(45deg);
+          content: '';
+        }
+
         z-index: 1;
       }
 
@@ -74,6 +89,12 @@
         margin-left: -1px;
       }
     }
+
+    &-with-gap {
+      @{pls}-button-wrapper {
+        border-radius: var(--yee-radio-button-wrapper-border-radius);
+      }
+    }
   }
 
   &-wrapper {

package/dist/cjs/Segmented/demo/basic.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: () => React.JSX.Element;
+export default _default;

package/dist/cjs/Segmented/demo/basic.js

@@ -0,0 +1,51 @@
+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/Segmented/demo/basic.tsx
+var basic_exports = {};
+__export(basic_exports, {
+  default: () => basic_default
+});
+module.exports = __toCommonJS(basic_exports);
+var import_yee_c = require("../..");
+var import_react = __toESM(require("react"));
+var basic_default = () => {
+  const [value, setValue] = (0, import_react.useState)("daily");
+  return /* @__PURE__ */ import_react.default.createElement(import_yee_c.Space, { direction: "vertical" }, /* @__PURE__ */ import_react.default.createElement(
+    import_yee_c.Segmented,
+    {
+      options: [
+        { label: "Daily", value: "daily" },
+        { label: "Weekly", value: "weekly" },
+        { label: "Monthly", value: "monthly" }
+      ],
+      value,
+      onChange: setValue
+    }
+  ), /* @__PURE__ */ import_react.default.createElement(import_yee_c.Segmented, { options: ["List", "Table", "Chart"], defaultValue: "List" }), /* @__PURE__ */ import_react.default.createElement("div", null, "Selected: ", value));
+};

package/dist/cjs/Segmented/demo/block.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: () => React.JSX.Element;
+export default _default;

package/dist/cjs/Segmented/demo/block.js

@@ -0,0 +1,49 @@
+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/Segmented/demo/block.tsx
+var block_exports = {};
+__export(block_exports, {
+  default: () => block_default
+});
+module.exports = __toCommonJS(block_exports);
+var import_yee_c = require("../..");
+var import_lucide_react = require("lucide-react");
+var import_react = __toESM(require("react"));
+var block_default = () => /* @__PURE__ */ import_react.default.createElement("div", { style: { width: 480 } }, /* @__PURE__ */ import_react.default.createElement(
+  import_yee_c.Segmented,
+  {
+    block: true,
+    defaultValue: "list",
+    options: [
+      { label: "List", value: "list", icon: /* @__PURE__ */ import_react.default.createElement(import_lucide_react.List, { size: 16 }) },
+      { label: "Grid", value: "grid", icon: /* @__PURE__ */ import_react.default.createElement(import_lucide_react.LayoutGrid, { size: 16 }) },
+      { label: "Detail", value: "detail" }
+    ]
+  }
+));

package/dist/cjs/Segmented/demo/disabled.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: () => React.JSX.Element;
+export default _default;

package/dist/cjs/Segmented/demo/disabled.js

@@ -0,0 +1,47 @@
+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/Segmented/demo/disabled.tsx
+var disabled_exports = {};
+__export(disabled_exports, {
+  default: () => disabled_default
+});
+module.exports = __toCommonJS(disabled_exports);
+var import_yee_c = require("../..");
+var import_react = __toESM(require("react"));
+var disabled_default = () => /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, /* @__PURE__ */ import_react.default.createElement(
+  import_yee_c.Segmented,
+  {
+    options: [
+      { label: "A", value: "a" },
+      { label: "B", value: "b", disabled: true },
+      { label: "C", value: "c" }
+    ],
+    defaultValue: "a"
+  }
+), /* @__PURE__ */ import_react.default.createElement("br", null), /* @__PURE__ */ import_react.default.createElement("br", null), /* @__PURE__ */ import_react.default.createElement(import_yee_c.Segmented, { disabled: true, options: ["A", "B", "C"], defaultValue: "A" }));

package/dist/cjs/Segmented/demo/size.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: () => React.JSX.Element;
+export default _default;

package/dist/cjs/Segmented/demo/size.js

@@ -0,0 +1,37 @@
+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/Segmented/demo/size.tsx
+var size_exports = {};
+__export(size_exports, {
+  default: () => size_default
+});
+module.exports = __toCommonJS(size_exports);
+var import_yee_c = require("../..");
+var import_react = __toESM(require("react"));
+var size_default = () => /* @__PURE__ */ import_react.default.createElement(import_yee_c.Space, { direction: "vertical" }, /* @__PURE__ */ import_react.default.createElement(import_yee_c.Segmented, { size: "small", options: ["Small", "B", "C"] }), /* @__PURE__ */ import_react.default.createElement(import_yee_c.Segmented, { options: ["Default", "B", "C"] }), /* @__PURE__ */ import_react.default.createElement(import_yee_c.Segmented, { size: "large", options: ["Large", "B", "C"] }));

package/dist/cjs/Segmented/index.d.ts

@@ -0,0 +1,3 @@
+import InternalSegmented from './segmented';
+export type { SegmentedOption, SegmentedLabeledOption, SegmentedRawOption, SegmentedSemanticDOM, SegmentedValue, SegmentedProps, } from './interface';
+export default InternalSegmented;

package/dist/cjs/Segmented/index.js

@@ -0,0 +1,36 @@
+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/Segmented/index.ts
+var Segmented_exports = {};
+__export(Segmented_exports, {
+  default: () => Segmented_default
+});
+module.exports = __toCommonJS(Segmented_exports);
+var import_segmented = __toESM(require("./segmented"));
+var Segmented_default = import_segmented.default;

package/dist/cjs/Segmented/interface.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="react" />
+import type { DataAttributeProps } from '../utils/types';
+export type SegmentedValue = string | number;
+export type SegmentedSemanticDOM = 'item' | 'thumb';
+export interface SegmentedLabeledOption {
+    /**
+     * Custom item class name
+     */
+    className?: string;
+    /**
+     * Item label
+     */
+    label?: React.ReactNode;
+    /**
+     * Item value
+     */
+    value: SegmentedValue;
+    /**
+     * Whether the item is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Item icon
+     */
+    icon?: React.ReactNode;
+}
+export type SegmentedRawOption = SegmentedValue;
+export type SegmentedOption = SegmentedLabeledOption | SegmentedRawOption;
+export interface SegmentedProps extends DataAttributeProps {
+    /**
+     * Custom prefix class name
+     */
+    prefixCls?: string;
+    /**
+     * Custom root class name
+     */
+    className?: string;
+    /**
+     * Custom root style
+     */
+    style?: React.CSSProperties;
+    /**
+     * Semantic structure class names
+     */
+    classNames?: Partial<Record<SegmentedSemanticDOM, string>>;
+    /**
+     * Semantic structure styles
+     */
+    styles?: Partial<Record<SegmentedSemanticDOM, React.CSSProperties>>;
+    /**
+     * Options, supports config objects or primitive shorthand (string/number)
+     */
+    options?: SegmentedOption[];
+    /**
+     * Controlled selected value
+     */
+    value?: SegmentedValue;
+    /**
+     * Default selected value
+     */
+    defaultValue?: SegmentedValue;
+    /**
+     * Callback when selected value changes
+     */
+    onChange?: (value: SegmentedValue) => void;
+    /**
+     * Whether to disable all options
+     */
+    disabled?: boolean;
+    /**
+     * Size
+     */
+    size?: 'small' | 'default' | 'large';
+    /**
+     * Whether to fill the container width, options share the space equally
+     */
+    block?: boolean;
+    /**
+     * Group name for the underlying radio inputs
+     */
+    name?: string;
+}

package/dist/cjs/Segmented/interface.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/Segmented/interface.ts
+var interface_exports = {};
+module.exports = __toCommonJS(interface_exports);

package/dist/cjs/Segmented/segmented.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { SegmentedProps } from './interface';
+import './style/index.less';
+declare const Segmented: React.ForwardRefExoticComponent<SegmentedProps & React.RefAttributes<HTMLDivElement>>;
+export default Segmented;

package/dist/cjs/Segmented/segmented.js

@@ -0,0 +1,177 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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/Segmented/segmented.tsx
+var segmented_exports = {};
+__export(segmented_exports, {
+  default: () => segmented_default
+});
+module.exports = __toCommonJS(segmented_exports);
+var import_clsx = __toESM(require("clsx"));
+var import_react = __toESM(require("react"));
+var import_react2 = require("motion/react");
+var import_Config_Provider = require("../Config-Provider");
+var import_useMergedState = __toESM(require("../hooks/useMergedState"));
+var import_mergeContextToProps = __toESM(require("../utils/mergeContextToProps"));
+var import_style = require("./style/index.less");
+var normalizeOption = (option) => {
+  if (typeof option === "string" || typeof option === "number") {
+    return { label: String(option), value: option };
+  }
+  return option;
+};
+var Segmented = import_react.default.forwardRef(
+  (baseprops, ref) => {
+    var _b;
+    const { segmented } = (0, import_react.useContext)(import_Config_Provider.GlobalContext);
+    const props = (0, import_mergeContextToProps.default)(baseprops, segmented);
+    const uid = (0, import_react.useId)();
+    const _a = props, {
+      prefixCls = "yee-segmented",
+      className,
+      style,
+      classNames,
+      styles,
+      options = [],
+      value,
+      defaultValue,
+      disabled,
+      size,
+      block,
+      name = uid,
+      onChange
+    } = _a, rest = __objRest(_a, [
+      "prefixCls",
+      "className",
+      "style",
+      "classNames",
+      "styles",
+      "options",
+      "value",
+      "defaultValue",
+      "disabled",
+      "size",
+      "block",
+      "name",
+      "onChange"
+    ]);
+    const items = (0, import_react.useMemo)(
+      () => options.map(normalizeOption),
+      [options]
+    );
+    const firstValue = (_b = items[0]) == null ? void 0 : _b.value;
+    const [mergedValue, setMergedValue] = (0, import_useMergedState.default)(firstValue, {
+      value,
+      defaultValue
+    });
+    const cls = (0, import_clsx.default)(
+      prefixCls,
+      {
+        [`${prefixCls}-${size}`]: size,
+        [`${prefixCls}-block`]: block,
+        [`${prefixCls}-disabled`]: disabled
+      },
+      className
+    );
+    const handleChange = (itemValue) => {
+      setMergedValue(itemValue);
+      onChange == null ? void 0 : onChange(itemValue);
+    };
+    return /* @__PURE__ */ import_react.default.createElement("div", __spreadProps(__spreadValues({}, rest), { ref, className: cls, style, role: "radiogroup" }), items.map((item) => {
+      const selected = item.value === mergedValue;
+      const itemDisabled = disabled || item.disabled;
+      return /* @__PURE__ */ import_react.default.createElement(
+        "label",
+        {
+          key: item.value,
+          className: (0, import_clsx.default)(`${prefixCls}-item`, item.className, {
+            [`${prefixCls}-item-selected`]: selected,
+            [`${prefixCls}-item-disabled`]: itemDisabled
+          })
+        },
+        selected ? /* @__PURE__ */ import_react.default.createElement(
+          import_react2.motion.span,
+          {
+            layoutId: `${prefixCls}-thumb-${uid}`,
+            className: (0, import_clsx.default)(`${prefixCls}-thumb`, classNames == null ? void 0 : classNames.thumb),
+            style: styles == null ? void 0 : styles.thumb,
+            transition: {
+              type: "spring",
+              visualDuration: 0.3,
+              bounce: 0.2
+            }
+          }
+        ) : null,
+        /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-item-inner` }, item.icon ? /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-item-icon` }, item.icon) : null, item.label !== void 0 && item.label !== null ? /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-item-label` }, item.label) : null),
+        /* @__PURE__ */ import_react.default.createElement(
+          "input",
+          {
+            type: "radio",
+            className: `${prefixCls}-input`,
+            name,
+            value: item.value,
+            checked: selected,
+            disabled: itemDisabled,
+            onChange: () => handleChange(item.value)
+          }
+        )
+      );
+    }));
+  }
+);
+Segmented.displayName = "Segmented";
+var segmented_default = Segmented;