@broxus/react-uikit 0.1.0

package/dist/cjs/components/Control/Input/Password/index.js

@@ -0,0 +1,89 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Password = void 0;
+const React = __importStar(require("react"));
+const js_utils_1 = require("@broxus/js-utils");
+const Icon_1 = require("../../../Icon");
+const Input_1 = require("../Input");
+require("./index.scss");
+exports.Password = React.forwardRef((props, ref) => {
+    const { onBlur: onBlurCallback, onChange: onChangeCallback, ...restProps } = props;
+    const inputRef = React.useRef(null);
+    const removePasswordTimeout = React.useRef(null);
+    const [visible, toggleVisible] = React.useState(false);
+    const removePasswordValueAttribute = () => {
+        removePasswordTimeout.current = setTimeout(() => {
+            if (inputRef?.current?.getInputRef()?.current?.getAttribute('type') === 'password'
+                && inputRef?.current?.getInputRef()?.current?.hasAttribute('value')) {
+                inputRef?.current?.getInputRef()?.current?.removeAttribute('value');
+            }
+        });
+    };
+    const onChange = event => {
+        removePasswordValueAttribute();
+        onChangeCallback?.(event);
+    };
+    const onBlur = event => {
+        removePasswordValueAttribute();
+        onBlurCallback?.(event);
+    };
+    const onFocus = event => {
+        removePasswordValueAttribute();
+        restProps.onFocus?.(event);
+    };
+    const onClickIcon = React.useCallback(() => {
+        toggleVisible(!visible);
+        restProps.onVisibilityChange?.(!visible);
+    }, [visible]);
+    React.useImperativeHandle(ref, () => ({
+        blur() {
+            inputRef.current?.blur();
+        },
+        focus() {
+            inputRef.current?.focus();
+        },
+        getInputRef() {
+            return inputRef.current
+                ? inputRef.current.getInputRef()
+                : null;
+        },
+    }));
+    React.useEffect(() => {
+        removePasswordValueAttribute();
+        return () => {
+            if (removePasswordTimeout.current) {
+                clearTimeout(removePasswordTimeout.current);
+            }
+        };
+    }, []);
+    const suffix = React.useMemo(() => (React.createElement(React.Fragment, null,
+        React.createElement(Icon_1.Icon, { key: "toggle_visibility_icon", icon: visible
+                ? (restProps.iconVisibility ?? 'visibility')
+                : (restProps.iconVisibilityOff ?? 'visibility_off'), className: "uk-control-password-icon", onClick: onClickIcon, onMouseDown: js_utils_1.preventEvent, onMouseUp: js_utils_1.preventEvent }),
+        restProps.suffix)), [restProps.iconVisibility, restProps.iconVisibilityOff, visible]);
+    return (React.createElement(Input_1.Input, { ...restProps, suffix: suffix, type: visible ? 'text' : 'password', ref: inputRef, onChange: onChange, onBlur: onBlur, onFocus: onFocus }));
+});
+exports.Password.displayName = 'Input.Password';

package/dist/cjs/components/Control/Input/Password/index.scss

@@ -0,0 +1,32 @@
+// Name:            Number Input Control
+// Description:     Component to create Number Input element
+//
+// Component:       `uk-control-password`
+//
+// ========================================================================
+
+
+/* ========================================================================
+   Component: Password
+ ========================================================================== */
+
+/*
+ * Icon
+ */
+
+.uk-control-password-icon {
+    color: var(--control-icon-color);
+    cursor: pointer;
+    font-size: 1.3rem;
+    transition: all var(--transition-duration);
+}
+
+// Hover state
+.uk-control-password-icon:hover {
+    color: var(--control-icon-hover-color);
+}
+
+// Disabled state
+.uk-control-password.uk-disabled .uk-control-password-icon {
+    display: none;
+}

package/dist/cjs/components/Control/Input/index.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { InputNumber } from './Number';
+import { Password } from './Password';
+import type { InputProps, InputRef } from './types';
+export * from './types';
+export * from './useInput';
+export interface CompoundedInput extends React.ForwardRefExoticComponent<InputProps & React.RefAttributes<InputRef>> {
+    Number: typeof InputNumber;
+    Password: typeof Password;
+}
+export declare const Input: CompoundedInput;

package/dist/cjs/components/Control/Input/index.js

@@ -0,0 +1,25 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Input = void 0;
+const Input_1 = require("./Input");
+const Number_1 = require("./Number");
+const Password_1 = require("./Password");
+__exportStar(require("./types"), exports);
+__exportStar(require("./useInput"), exports);
+exports.Input = Input_1.Input;
+exports.Input.Number = Number_1.InputNumber;
+exports.Input.Password = Password_1.Password;

package/dist/cjs/components/Control/Input/types.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import type { InputNumberProps as RcInputNumberProps } from 'rc-input-number';
+import type { ControlProps, ValueType } from '../types';
+export interface InputFocusOptions extends FocusOptions {
+    cursor?: 'start' | 'end' | 'all';
+}
+export interface InputRef {
+    blur(): void;
+    focus(): void;
+    getInputRef(): React.RefObject<HTMLInputElement> | null;
+}
+export declare type OmittedNativeInput = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'size' | 'prefix' | 'type' | 'max' | 'min'>;
+export interface InputProps<T extends ValueType = ValueType> extends OmittedNativeInput, ControlProps<T> {
+    useInternalValueState?: boolean;
+    onClear?(event: React.MouseEvent<HTMLElement>): void;
+}
+export interface PasswordProps extends InputProps {
+    iconVisibility?: string;
+    iconVisibilityOff?: string;
+    onVisibilityChange?(visible: boolean): void;
+}
+export interface InputNumberProps<T extends ValueType = ValueType> extends Omit<RcInputNumberProps<T>, 'prefix' | 'size'>, ControlProps<T> {
+    useInternalValueState?: boolean;
+    onClear?(event: React.MouseEvent<HTMLElement>): void;
+}

package/dist/cjs/components/Control/Input/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/components/Control/Input/useInput.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { ValueType } from '../types';
+import type { InputNumberProps, InputProps } from './types';
+interface HookConsumedProps {
+    inputRef: React.RefObject<HTMLInputElement>;
+    wrapperClasses: string;
+}
+declare type Props<T, U extends ValueType = ValueType> = T extends InputNumberProps<U> ? T : T extends InputProps<U> ? T : any;
+export declare function fixControlledValue<T>(value: T): T | string;
+export declare function useInput<T, U extends ValueType = ValueType>({ className, direction, size, state, useInternalValueState, onPressEnter, ...props }: Props<T, U>): T & HookConsumedProps;
+export {};

package/dist/cjs/components/Control/Input/useInput.js

@@ -0,0 +1,119 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInput = exports.fixControlledValue = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+function fixControlledValue(value) {
+    if (value == null) {
+        return '';
+    }
+    return value;
+}
+exports.fixControlledValue = fixControlledValue;
+function useInput({ className, direction, size, state, useInternalValueState = true, onPressEnter, ...props }) {
+    // Refs
+    const inputRef = React.useRef(null);
+    // States
+    const [focused, setFocused] = React.useState(false);
+    const [internalValue, setInternalValue] = React.useState(useInternalValueState ? (props.value || props.defaultValue) : undefined);
+    // Methods
+    const onChange = (event) => {
+        if (useInternalValueState) {
+            if (typeof event === 'string' || typeof event === 'number') {
+                setInternalValue(event);
+            }
+            else {
+                setInternalValue(event.target.value);
+            }
+        }
+        props.onChange?.(event);
+    };
+    const onClear = event => {
+        if (inputRef.current) {
+            inputRef.current.value = '';
+        }
+        onChange(event);
+    };
+    const onBlur = event => {
+        setFocused(false);
+        props.onBlur?.(event);
+    };
+    const onFocus = event => {
+        setFocused(true);
+        props.onFocus?.(event);
+    };
+    const onKeyDown = event => {
+        if (onPressEnter && event.keyCode === 13) {
+            onPressEnter(event);
+        }
+        props.onKeyDown?.(event);
+    };
+    // Effects
+    React.useEffect(() => {
+        if (useInternalValueState) {
+            setInternalValue(props.value);
+        }
+    }, [props.value]);
+    // Pre-render logic
+    const inputProps = React.useMemo(() => ({
+        ...props,
+        value: fixControlledValue(internalValue || props.value),
+        // eslint-disable-next-line sort-keys
+        onBlur,
+        onChange,
+        onClear,
+        onFocus,
+        onKeyDown,
+    }), [props, internalValue]);
+    const wrapperClasses = React.useMemo(() => (0, classnames_1.default)('uk-control', {
+        [`uk-control-${props.type}`]: props.type,
+        [`uk-control-${size}`]: size,
+        [`uk-control-${state}`]: state,
+        'uk-control-rtl': direction === 'rtl',
+        'uk-disabled': props.disabled,
+        'uk-focused': focused,
+        'uk-readonly': props.readOnly,
+    }, className), [
+        className,
+        direction,
+        focused,
+        size,
+        state,
+        props.disabled,
+        props.readOnly,
+        props.type,
+    ]);
+    // Return consumed props
+    return {
+        ...inputProps,
+        inputRef,
+        wrapperClasses,
+    };
+}
+exports.useInput = useInput;

package/dist/cjs/components/Control/Radio/Context.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { RadioGroupConsumerProps } from './types';
+export declare const Context: React.Context<RadioGroupConsumerProps | null>;
+export declare function useRadioGroup(): RadioGroupConsumerProps | null;

package/dist/cjs/components/Control/Radio/Context.js

@@ -0,0 +1,32 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRadioGroup = exports.Context = void 0;
+const React = __importStar(require("react"));
+exports.Context = React.createContext(null);
+function useRadioGroup() {
+    return React.useContext(exports.Context);
+}
+exports.useRadioGroup = useRadioGroup;

package/dist/cjs/components/Control/Radio/Group.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { RadioGroupProps } from './types';
+export declare const Group: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;

package/dist/cjs/components/Control/Radio/Group.js

@@ -0,0 +1,74 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Group = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+const useMergedState_1 = __importDefault(require("rc-util/lib/hooks/useMergedState"));
+const Radio_1 = require("./Radio");
+const Context_1 = require("./Context");
+exports.Group = React.forwardRef((props, ref) => {
+    const { block, children, className, defaultValue, direction, disabled, id, options, size, stack, style, onMouseEnter, onMouseLeave, ...restProps } = props;
+    const [value, setValue] = (0, useMergedState_1.default)(defaultValue, {
+        value: restProps.value,
+    });
+    const onRadioChange = (event) => {
+        const lastValue = value;
+        const val = event.target.value;
+        if (!('value' in restProps)) {
+            setValue(val);
+        }
+        if (val !== lastValue) {
+            restProps.onChange?.(event);
+        }
+    };
+    const context = React.useMemo(() => ({
+        disabled,
+        name: restProps.name,
+        value,
+        // eslint-disable-next-line sort-keys
+        onChange: onRadioChange,
+    }), [disabled, value, restProps]);
+    const renderGroup = () => {
+        let childrenToRender = children;
+        if (options && options.length > 0) {
+            childrenToRender = options.map((option) => {
+                if (typeof option === 'string') {
+                    return (React.createElement(Radio_1.Radio, { key: option, block: block, checked: value === option, direction: direction, disabled: disabled, size: size, value: option, className: "uk-radio-group-item" }, option));
+                }
+                return (React.createElement(Radio_1.Radio, { key: `radio-group-value-options-${option.value}`, block: block, checked: value === option.value, direction: direction, disabled: option.disabled || disabled, size: size, value: option.value, style: option.style, className: "uk-radio-group-item" }, option.label));
+            });
+        }
+        return (React.createElement("div", { ref: ref, className: (0, classnames_1.default)('uk-radio-group', {
+                'uk-radio-group-rtl': direction === 'rtl',
+                'uk-radio-group-stack': stack,
+            }, className), id: id, style: style, onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave }, childrenToRender));
+    };
+    return (React.createElement(Context_1.Context.Provider, { value: context }, renderGroup()));
+});
+exports.Group.displayName = 'Radio.Group';

package/dist/cjs/components/Control/Radio/Radio.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { RadioProps } from './types';
+export declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;

package/dist/cjs/components/Control/Radio/Radio.js

@@ -0,0 +1,85 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Radio = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+const rc_checkbox_1 = __importDefault(require("rc-checkbox"));
+const ref_1 = require("rc-util/lib/ref");
+const Context_1 = require("./Context");
+exports.Radio = React.forwardRef((props, ref) => {
+    const { block, size, className, children, direction, skipGroup, style, type = 'radio', onMouseEnter, onMouseLeave, ...restProps } = props;
+    const radioGroup = (0, Context_1.useRadioGroup)();
+    const innerRef = React.useRef();
+    const mergedRef = (0, ref_1.composeRef)(ref, innerRef);
+    const [internalChecked, setInternalChecked] = React.useState(restProps.checked
+        ?? restProps.defaultChecked
+        ?? ('value' in restProps && restProps.value === radioGroup?.value));
+    const onChange = (event) => {
+        setInternalChecked(true);
+        restProps.onChange?.(event);
+        radioGroup?.onChange?.(event);
+    };
+    React.useEffect(() => {
+        setInternalChecked(restProps.checked
+            ?? restProps.defaultChecked
+            ?? ('value' in restProps && restProps.value === radioGroup?.value));
+    }, [restProps.checked, restProps.defaultChecked, radioGroup?.value]);
+    const radioProps = React.useMemo(() => ({
+        ...restProps,
+        checked: internalChecked,
+        type,
+        // eslint-disable-next-line sort-keys
+        onChange,
+    }), [restProps, internalChecked]);
+    if (radioGroup && !skipGroup) {
+        radioProps.checked = restProps.value === radioGroup.value;
+        radioProps.disabled = restProps.disabled || radioGroup.disabled;
+        radioProps.name = radioGroup.name;
+        radioProps.onChange = onChange;
+    }
+    const prefixCls = 'uk-radio';
+    const wrapperClasses = React.useMemo(() => (0, classnames_1.default)({
+        'uk-control': block,
+        'uk-control-radio': block,
+        [`uk-control-${size}`]: block && size,
+        [`${prefixCls}-wrapper`]: true,
+        [`${prefixCls}-rtl`]: direction === 'rtl',
+        // eslint-disable-next-line sort-keys
+        'uk-checked': internalChecked,
+        'uk-disabled': radioProps.disabled,
+    }, className), [radioProps, block, size, direction]);
+    return (React.createElement("label", { className: wrapperClasses, style: style, onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave },
+        React.createElement(rc_checkbox_1.default
+        // @ts-ignore
+        , { 
+            // @ts-ignore
+            ref: mergedRef, ...radioProps, prefixCls: prefixCls }),
+        children !== undefined && (React.createElement("span", { className: `${prefixCls}-label` }, children))));
+});
+exports.Radio.displayName = 'Radio';

package/dist/cjs/components/Control/Radio/index.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { Group } from './Group';
+import type { RadioProps } from './types';
+import './index.scss';
+export * from './types';
+export interface CompoundedRadio extends React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>> {
+    Group: typeof Group;
+}
+export declare const Radio: CompoundedRadio;

package/dist/cjs/components/Control/Radio/index.js

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Radio = void 0;
+const Group_1 = require("./Group");
+const Radio_1 = require("./Radio");
+require("./index.scss");
+__exportStar(require("./types"), exports);
+exports.Radio = Radio_1.Radio;
+exports.Radio.Group = Group_1.Group;