@via-profit/ui-kit 0.3.0 → 0.4.0

package/Radio/RadioBox.js

@@ -0,0 +1,100 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const react_2 = require("@emotion/react");
+const useRadioColor_1 = __importDefault(require("./useRadioColor"));
+const Root = styled_1.default.span `
+  position: relative;
+  display: inline-flex;
+  flex-shrink: 0;
+  width: 1.15em;
+  height: 1.15em;
+`;
+/**
+ * The checked look comes from the `:checked` state of the input, not from the props:
+ * the browser unchecks the other radio buttons of the same `name` itself
+ * (data attributes, not class names: emotion labels are absent in the published package)
+ */
+const StyledInput = styled_1.default.input `
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  padding: 0;
+  opacity: 0;
+  cursor: inherit;
+  z-index: 1;
+
+  &:checked + [data-radio-circle] {
+    border-color: ${({ theme, $color, $error }) => $error ? theme.color.error.toString() : $color.toString()};
+  }
+
+  &:checked + [data-radio-circle] [data-radio-dot] {
+    transform: scale(1);
+  }
+
+  &:focus-visible + [data-radio-circle] {
+    outline: 0.14em solid ${({ theme }) => theme.color.accentPrimary.toString()};
+    outline-offset: 0.14em;
+  }
+`;
+const Circle = styled_1.default.span `
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  border-radius: 50%;
+  border-width: 0.1em;
+  border-style: solid;
+  background-color: ${({ theme }) => theme.color.surface.toString()};
+  transition: border-color 150ms ease-out;
+  border-color: ${({ theme, $error }) => $error ? theme.color.error.toString() : theme.color.textPrimary.alpha(0.4).toString()};
+
+  ${({ $disabled, $error, $color }) => !$disabled &&
+    !$error &&
+    (0, react_2.css) `
+      label:hover & {
+        border-color: ${$color.toString()};
+      }
+    `}
+`;
+const Dot = styled_1.default.span `
+  width: 50%;
+  height: 50%;
+  border-radius: 50%;
+  background-color: ${({ $color }) => $color.toString()};
+  transform: scale(0);
+  transition: transform 150ms ease-out;
+`;
+/**
+ * The circle with the native input over it.
+ * The ref and the input attributes go to the input: it is the element that holds the value and the focus.
+ * `className` and `style` go to the root element, so `styled(RadioBox)` styles the circle
+ */
+const RadioBox = (props, ref) => {
+    const { error, color, disabled, className, style } = props, nativeProps = __rest(props, ["error", "color", "disabled", "className", "style"]);
+    const $color = (0, useRadioColor_1.default)(color);
+    return (react_1.default.createElement(Root, { className: className, style: style },
+        react_1.default.createElement(StyledInput, Object.assign({}, nativeProps, { type: "radio", disabled: disabled, "$color": $color, "$error": Boolean(error), ref: ref })),
+        react_1.default.createElement(Circle, { "data-radio-circle": "", "$color": $color, "$error": Boolean(error), "$disabled": Boolean(disabled) },
+            react_1.default.createElement(Dot, { "data-radio-dot": "", "$color": $color }))));
+};
+exports.default = react_1.default.forwardRef(RadioBox);

package/Radio/RadioContainer.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+export type RadioLabelPosition = 'start' | 'end' | 'top' | 'bottom';
+export type RadioContainerProps = React.LabelHTMLAttributes<HTMLLabelElement> & {
+    /**
+     * Position of the label relative to the radio button
+     * Default: `end`
+     */
+    readonly labelPosition?: RadioLabelPosition;
+    /**
+     * If `true` the radio button state can not be changed
+     * Default: false;
+     */
+    readonly disabled?: boolean;
+};
+declare const _default: React.ForwardRefExoticComponent<React.LabelHTMLAttributes<HTMLLabelElement> & {
+    /**
+     * Position of the label relative to the radio button
+     * Default: `end`
+     */
+    readonly labelPosition?: RadioLabelPosition | undefined;
+    /**
+     * If `true` the radio button state can not be changed
+     * Default: false;
+     */
+    readonly disabled?: boolean | undefined;
+} & React.RefAttributes<HTMLLabelElement>>;
+export default _default;

package/Radio/RadioContainer.js

@@ -0,0 +1,38 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const directions = {
+    start: 'row-reverse',
+    end: 'row',
+    top: 'column-reverse',
+    bottom: 'column',
+};
+const StyledContainer = styled_1.default.label `
+  cursor: ${({ $disabled }) => ($disabled ? 'default' : 'pointer')};
+  font-size: 1em;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5em;
+  opacity: ${({ $disabled }) => ($disabled ? 0.6 : 1)};
+  flex-direction: ${({ $labelPosition }) => directions[$labelPosition || 'end']};
+`;
+const RadioContainer = (props, ref) => {
+    const { children, labelPosition, disabled } = props, nativeProps = __rest(props, ["children", "labelPosition", "disabled"]);
+    return (react_1.default.createElement(StyledContainer, Object.assign({}, nativeProps, { "$labelPosition": labelPosition, "$disabled": disabled, ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(RadioContainer);

package/Radio/RadioTextWrapper.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export type RadioTextWrapperProps = React.HTMLAttributes<HTMLSpanElement>;
+declare const _default: React.ForwardRefExoticComponent<RadioTextWrapperProps & React.RefAttributes<HTMLSpanElement>>;
+export default _default;

package/Radio/RadioTextWrapper.js

@@ -0,0 +1,29 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const TextWrapper = styled_1.default.span `
+  font-size: 0.86em;
+  display: flex;
+  align-items: center;
+  user-select: none;
+`;
+const RadioTextWrapper = (props, ref) => {
+    const { children } = props, nativeProps = __rest(props, ["children"]);
+    return (react_1.default.createElement(TextWrapper, Object.assign({}, nativeProps, { ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(RadioTextWrapper);

package/Radio/index.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import { RadioContainerProps, RadioLabelPosition } from './RadioContainer';
+import { RadioBoxProps } from './RadioBox';
+import { RadioTextWrapperProps } from './RadioTextWrapper';
+export type { RadioLabelPosition };
+export type RadioProps = Omit<RadioBoxProps, 'color' | 'error'> & {
+    /**
+     * The value of the radio button. Inside `<RadioGroup>` it is required:
+     * the group compares it with its own value
+     */
+    readonly value?: string;
+    /**
+     * You can pass the primary, default, secondary name of the colors or your specified color value\
+     * **Default:** `default`, inside `<RadioGroup>` — the color of the group
+     */
+    readonly color?: 'default' | 'primary' | 'secondary' | string;
+    /**
+     * Position of the label relative to the radio button\
+     * **Default:** `end`
+     */
+    readonly labelPosition?: RadioLabelPosition;
+    /**
+     * Paints the circle with the error color. Inside `<RadioGroup>` it comes from the group
+     */
+    readonly error?: boolean;
+    readonly overrides?: RadioOverrides;
+};
+export interface RadioOverrides {
+    /**
+     * The label element with the radio button and the text
+     */
+    readonly Container?: React.ComponentType<RadioContainerProps & React.RefAttributes<HTMLLabelElement>>;
+    /**
+     * The circle with the native input
+     */
+    readonly Box?: React.ComponentType<RadioBoxProps & React.RefAttributes<HTMLInputElement>>;
+    /**
+     * The text wrapper
+     */
+    readonly TextWrapper?: React.ComponentType<RadioTextWrapperProps & React.RefAttributes<HTMLSpanElement>>;
+}
+declare const _default: React.ForwardRefExoticComponent<Omit<RadioBoxProps, "color" | "error"> & {
+    /**
+     * The value of the radio button. Inside `<RadioGroup>` it is required:
+     * the group compares it with its own value
+     */
+    readonly value?: string | undefined;
+    /**
+     * You can pass the primary, default, secondary name of the colors or your specified color value\
+     * **Default:** `default`, inside `<RadioGroup>` — the color of the group
+     */
+    readonly color?: string | undefined;
+    /**
+     * Position of the label relative to the radio button\
+     * **Default:** `end`
+     */
+    readonly labelPosition?: RadioLabelPosition | undefined;
+    /**
+     * Paints the circle with the error color. Inside `<RadioGroup>` it comes from the group
+     */
+    readonly error?: boolean | undefined;
+    readonly overrides?: RadioOverrides | undefined;
+} & React.RefAttributes<HTMLInputElement>>;
+export default _default;

package/Radio/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const RadioContainer_1 = __importDefault(require("./RadioContainer"));
+const RadioBox_1 = __importDefault(require("./RadioBox"));
+const RadioTextWrapper_1 = __importDefault(require("./RadioTextWrapper"));
+const RadioGroupContext_1 = __importDefault(require("../RadioGroup/RadioGroupContext"));
+const Radio = (props, ref) => {
+    var _a;
+    const group = react_1.default.useContext(RadioGroupContext_1.default);
+    const { children, value, checked, defaultChecked, onChange, disabled, color, labelPosition, error, name, required, overrides, className, style } = props, nativeProps = __rest(props, ["children", "value", "checked", "defaultChecked", "onChange", "disabled", "color", "labelPosition", "error", "name", "required", "overrides", "className", "style"]);
+    const overridesMap = react_1.default.useMemo(() => ({
+        Container: (overrides === null || overrides === void 0 ? void 0 : overrides.Container) || RadioContainer_1.default,
+        Box: (overrides === null || overrides === void 0 ? void 0 : overrides.Box) || RadioBox_1.default,
+        TextWrapper: (overrides === null || overrides === void 0 ? void 0 : overrides.TextWrapper) || RadioTextWrapper_1.default,
+    }), [overrides]);
+    // Inside a group the group decides; the own props of the radio button win where it makes sense
+    const isDisabled = disabled !== null && disabled !== void 0 ? disabled : group === null || group === void 0 ? void 0 : group.disabled;
+    const groupChecked = group && typeof value !== 'undefined' && typeof group.value !== 'undefined'
+        ? group.value === value
+        : undefined;
+    const groupDefaultChecked = group && typeof value !== 'undefined' && typeof group.value === 'undefined'
+        ? group.defaultValue === value
+        : undefined;
+    const handleChange = event => {
+        onChange === null || onChange === void 0 ? void 0 : onChange(event);
+        if (group && typeof value !== 'undefined') {
+            group.onChange(value, event);
+        }
+    };
+    return (react_1.default.createElement(overridesMap.Container, { className: className, style: style, labelPosition: labelPosition, disabled: isDisabled },
+        react_1.default.createElement(overridesMap.Box, Object.assign({}, nativeProps, { value: value, name: (_a = group === null || group === void 0 ? void 0 : group.name) !== null && _a !== void 0 ? _a : name, checked: checked !== null && checked !== void 0 ? checked : groupChecked, defaultChecked: defaultChecked !== null && defaultChecked !== void 0 ? defaultChecked : groupDefaultChecked, onChange: handleChange, disabled: isDisabled, required: required !== null && required !== void 0 ? required : group === null || group === void 0 ? void 0 : group.required, color: color !== null && color !== void 0 ? color : group === null || group === void 0 ? void 0 : group.color, error: error !== null && error !== void 0 ? error : group === null || group === void 0 ? void 0 : group.error, ref: ref })),
+        typeof children !== 'undefined' && (react_1.default.createElement(overridesMap.TextWrapper, null, children))));
+};
+exports.default = react_1.default.forwardRef(Radio);

package/Radio/useRadioColor.d.ts

@@ -0,0 +1,6 @@
+import Color from '../Color';
+/**
+ * Resolves the `color` property of the Radio to the Color instance
+ */
+declare const useRadioColor: (color: 'default' | 'primary' | 'secondary' | string | undefined) => Color;
+export default useRadioColor;

package/Radio/useRadioColor.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_2 = require("@emotion/react");
+const Color_1 = __importDefault(require("../Color"));
+/**
+ * Resolves the `color` property of the Radio to the Color instance
+ */
+const useRadioColor = (color) => {
+    const theme = (0, react_2.useTheme)();
+    return react_1.default.useMemo(() => {
+        switch (true) {
+            case color === 'secondary':
+                return theme.color.accentSecondary;
+            case typeof color === 'undefined':
+            case color === 'default':
+            case color === 'primary':
+                return theme.color.accentPrimary;
+            default:
+                try {
+                    return Color_1.default.fromString(String(color));
+                }
+                catch (err) {
+                    console.error(`invalid color value «${color}»`);
+                    return theme.color.accentPrimary;
+                }
+        }
+    }, [color, theme.color]);
+};
+exports.default = useRadioColor;

package/RadioGroup/RadioGroupAsterisk.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export interface RadioGroupAsteriskProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * If true, the asterisk will be set the error color
+     */
+    readonly error?: boolean;
+    /**
+     * Not used
+     */
+    readonly focused?: boolean;
+}
+declare const _default: React.ForwardRefExoticComponent<RadioGroupAsteriskProps & React.RefAttributes<HTMLSpanElement>>;
+export default _default;

package/RadioGroup/RadioGroupAsterisk.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = __importStar(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const Asterisk = styled_1.default.span `
+  font-size: 0.8em;
+  margin-left: 0.2em;
+  position: relative;
+  top: -0.4em;
+  color: ${({ theme }) => theme.color.error.toString()};
+`;
+const RadioGroupAsterisk = (props, ref) => {
+    const { children, error, focused } = props, nativeProps = __rest(props, ["children", "error", "focused"]);
+    return (React.createElement(Asterisk, Object.assign({}, nativeProps, { "$error": error, "$focused": focused, ref: ref }), children));
+};
+exports.default = React.forwardRef(RadioGroupAsterisk);

package/RadioGroup/RadioGroupContainer.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export type RadioGroupContainerProps = React.FieldsetHTMLAttributes<HTMLFieldSetElement>;
+declare const _default: React.ForwardRefExoticComponent<RadioGroupContainerProps & React.RefAttributes<HTMLFieldSetElement>>;
+export default _default;

package/RadioGroup/RadioGroupContainer.js

@@ -0,0 +1,36 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+/**
+ * `<fieldset>`: the legend names the group, `disabled` disables all the radio buttons inside
+ */
+const StyledContainer = styled_1.default.fieldset `
+  display: inline-flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.5em;
+  min-width: 0;
+  margin: 0;
+  padding: 0;
+  border: 0;
+`;
+const RadioGroupContainer = (props, ref) => {
+    const { children } = props, nativeProps = __rest(props, ["children"]);
+    return (react_1.default.createElement(StyledContainer, Object.assign({}, nativeProps, { ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(RadioGroupContainer);

package/RadioGroup/RadioGroupContext.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export type RadioGroupContextValue = {
+    readonly name: string;
+    /**
+     * The selected value. `undefined` — the group is uncontrolled and the radio buttons are not
+     * controlled either, `null` — nothing is selected
+     */
+    readonly value: string | null | undefined;
+    readonly defaultValue?: string | null;
+    readonly onChange: (value: string, event: React.ChangeEvent<HTMLInputElement>) => void;
+    readonly disabled?: boolean;
+    readonly required?: boolean;
+    readonly error?: boolean;
+    readonly color?: string;
+};
+/**
+ * Radio buttons inside the RadioGroup read the name, the value and the change handler from this context
+ */
+declare const RadioGroupContext: React.Context<RadioGroupContextValue | null>;
+export default RadioGroupContext;

package/RadioGroup/RadioGroupContext.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+/**
+ * Radio buttons inside the RadioGroup read the name, the value and the change handler from this context
+ */
+const RadioGroupContext = react_1.default.createContext(null);
+exports.default = RadioGroupContext;

package/RadioGroup/RadioGroupErrorText.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface RadioGroupErrorTextProps extends React.HTMLAttributes<HTMLSpanElement> {
+    readonly error?: boolean;
+}
+declare const _default: React.ForwardRefExoticComponent<RadioGroupErrorTextProps & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/RadioGroup/RadioGroupErrorText.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = __importStar(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const NoSSR_1 = __importDefault(require("../NoSSR"));
+const ErrorTextContainer = styled_1.default.div `
+  margin-left: 0;
+  max-height: 0;
+  max-height: ${({ $maxHeight }) => typeof $maxHeight === 'number' ? `${$maxHeight}px` : $maxHeight};
+  transition: max-height 240ms cubic-bezier(0.22, 0.61, 0.36, 1);
+  overflow: hidden;
+`;
+const ErrorTextInner = styled_1.default.div `
+  color: ${({ theme }) => theme.color.error.toString()};
+  font-size: 0.8em;
+  transform: translateY(${({ $error }) => ($error ? 0 : '0.2em')});
+  opacity: ${({ $error }) => ($error ? 1 : 0)};
+  transition: all 240ms 240ms ease-out;
+`;
+const RadioGroupErrorText = (props, ref) => {
+    const { children, error } = props, nativeProps = __rest(props, ["children", "error"]);
+    const innerRef = React.useRef(null);
+    const [maxHeight, setMaxHeight] = React.useState('initial');
+    React.useEffect(() => {
+        const updateMaxHeight = () => {
+            if (innerRef.current && innerRef.current.getBoundingClientRect().height > 0) {
+                setMaxHeight(innerRef.current.getBoundingClientRect().height);
+            }
+        };
+        updateMaxHeight();
+        window.addEventListener('resize', updateMaxHeight);
+        return () => {
+            window.removeEventListener('resize', updateMaxHeight);
+        };
+    }, [children]);
+    return (React.createElement(ErrorTextContainer, Object.assign({}, nativeProps, { "$maxHeight": error ? maxHeight : 0, ref: ref }),
+        React.createElement(ErrorTextInner, { ref: innerRef, "$error": Boolean(error) }, children ? React.createElement(NoSSR_1.default, null, children) : React.createElement(React.Fragment, null, "\u00A0"))));
+};
+exports.default = React.forwardRef(RadioGroupErrorText);

package/RadioGroup/RadioGroupItems.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type RadioGroupOrientation = 'vertical' | 'horizontal';
+export type RadioGroupItemsProps = React.HTMLAttributes<HTMLDivElement> & {
+    readonly orientation?: RadioGroupOrientation;
+};
+declare const _default: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    readonly orientation?: RadioGroupOrientation | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/RadioGroup/RadioGroupItems.js

@@ -0,0 +1,30 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const StyledItems = styled_1.default.div `
+  display: flex;
+  flex-direction: ${({ $orientation }) => ($orientation === 'horizontal' ? 'row' : 'column')};
+  flex-wrap: wrap;
+  align-items: flex-start;
+  gap: ${({ $orientation }) => ($orientation === 'horizontal' ? '0.5em 1.5em' : '0.75em')};
+`;
+const RadioGroupItems = (props, ref) => {
+    const { children, orientation = 'vertical' } = props, nativeProps = __rest(props, ["children", "orientation"]);
+    return (react_1.default.createElement(StyledItems, Object.assign({}, nativeProps, { "$orientation": orientation, ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(RadioGroupItems);

package/RadioGroup/RadioGroupLegend.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export type RadioGroupLegendProps = React.HTMLAttributes<HTMLLegendElement>;
+declare const _default: React.ForwardRefExoticComponent<RadioGroupLegendProps & React.RefAttributes<HTMLLegendElement>>;
+export default _default;