@via-profit/ui-kit 0.1.0-rc.2 → 0.1.0-rc.20

package/Autocomplete/index.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { MenuRef, MenuProps, Value } from '../Menu';
+export type AutocompleteProps<T, Multiple extends boolean | undefined = undefined> = AutocompleteMenuProps<T, Multiple>;
+export type AutocompleteContainerRef = HTMLDivElement;
+type AutocompleteMenuProps<T, Multiple extends boolean | undefined = undefined> = Pick<MenuProps<T, Multiple>, 'items' | 'value' | 'estimatedItemSize' | 'endThreshold' | 'overscanCount' | 'getOptionSelected' | 'onEndReached' | 'onSelectItem' | 'renderItem' | 'multiple' | 'zIndex' | 'onRequestClose' | 'isOpen'> & {
+    readonly containerRef?: React.Ref<AutocompleteContainerRef>;
+    readonly itemToString: ItemToString<T, Multiple>;
+    readonly renderInput: (params: RenderInputProps<T, Multiple>) => React.ReactNode;
+    readonly onRequestOpen: (event?: FocusEvent | KeyboardEvent | MouseEvent | React.FocusEvent | React.KeyboardEvent | React.MouseEvent) => void;
+    readonly onInputChange?: React.ChangeEventHandler<HTMLInputElement>;
+    readonly filterItems?: (items: readonly T[], data: {
+        readonly query: string;
+        readonly inputValue: string;
+    }) => readonly T[];
+};
+export type ItemToString<T, Multiple> = Multiple extends undefined | false ? (item: T) => string : undefined;
+export type RenderInputProps<T, Multiple extends boolean | undefined = undefined> = {
+    readonly selected: Value<T, Multiple> | null;
+    readonly value: string;
+    readonly inputRef: React.Ref<HTMLInputElement>;
+    readonly onClick: React.MouseEventHandler<HTMLInputElement>;
+    readonly onFocus: React.FocusEventHandler<HTMLInputElement>;
+    readonly onBlur: React.FocusEventHandler<HTMLInputElement>;
+    readonly onKeyDown: React.KeyboardEventHandler<HTMLInputElement>;
+    readonly onChange: React.ChangeEventHandler<HTMLInputElement>;
+};
+export type AutocompleteRef<T> = Pick<MenuRef<T>, 'scrollToItem' | 'scrollTo' | 'scrollToFirstSelected' | 'selectItem' | 'highlightIndex' | 'hightlightPrevItem' | 'hightlightNextItem' | 'hightlightFirstItem' | 'hightlightLastItem' | 'selectHightlightedItem' | 'updatePopper'> & {
+    readonly clear: () => void;
+    readonly focus: () => void;
+    readonly blur: () => void;
+    readonly clearInput: () => void;
+};
+declare const _default: <T, Multiple extends boolean | undefined = undefined>(props: Pick<MenuProps<T, Multiple>, "zIndex" | "isOpen" | "estimatedItemSize" | "overscanCount" | "items" | "value" | "endThreshold" | "multiple" | "getOptionSelected" | "onEndReached" | "onSelectItem" | "renderItem" | "onRequestClose"> & {
+    readonly containerRef?: React.Ref<HTMLDivElement> | undefined;
+    readonly itemToString: ItemToString<T, Multiple>;
+    readonly renderInput: (params: RenderInputProps<T, Multiple>) => React.ReactNode;
+    readonly onRequestOpen: (event?: MouseEvent | KeyboardEvent | FocusEvent | React.FocusEvent<Element, Element> | React.KeyboardEvent<Element> | React.MouseEvent<Element, MouseEvent> | undefined) => void;
+    readonly onInputChange?: React.ChangeEventHandler<HTMLInputElement> | undefined;
+    readonly filterItems?: ((items: readonly T[], data: {
+        readonly query: string;
+        readonly inputValue: string;
+    }) => readonly T[]) | undefined;
+} & {
+    ref?: React.Ref<AutocompleteRef<T>> | undefined;
+}) => JSX.Element;
+export default _default;

package/Autocomplete/index.js

@@ -0,0 +1,187 @@
+"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 Menu_1 = __importDefault(require("../Menu"));
+const popper_options_1 = __importDefault(require("./popper-options"));
+const Autocomplete = react_1.default.forwardRef((props, ref) => {
+    const { items, value, estimatedItemSize, endThreshold, overscanCount, zIndex, isOpen, multiple, itemToString, containerRef, filterItems, renderInput, getOptionSelected, onEndReached, onSelectItem, renderItem, onRequestClose, onRequestOpen, onInputChange, } = props;
+    const [inputValue, setInputValue] = react_1.default.useState('');
+    const menuRef = react_1.default.useRef(null);
+    const isFocusedRef = react_1.default.useRef(false);
+    const [currentOpen, setCurrentOpen] = react_1.default.useState(isOpen);
+    const [currentValue, setCurrentValue] = react_1.default.useState(value);
+    const [anchorElement, setAnchorElement] = react_1.default.useState(null);
+    const [filteredItems, setFilteredItems] = react_1.default.useState(items);
+    /**
+     * API
+     */
+    react_1.default.useImperativeHandle(ref, () => ({
+        highlightIndex: (index) => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.highlightIndex(index); },
+        hightlightPrevItem: () => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.hightlightPrevItem(); },
+        hightlightNextItem: () => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.hightlightNextItem(); },
+        hightlightFirstItem: () => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.hightlightFirstItem(); },
+        hightlightLastItem: () => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.hightlightLastItem(); },
+        selectHightlightedItem: () => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.selectHightlightedItem(); },
+        updatePopper: () => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.updatePopper(); },
+        scrollToFirstSelected: () => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.scrollToFirstSelected(); },
+        selectItem: (index) => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.selectItem(index); },
+        scrollTo: (scrollOffset) => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.scrollTo(scrollOffset); },
+        scrollToItem: (index, align) => { var _a; return (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(index, align); },
+        clear: () => {
+            setCurrentValue(null);
+            setInputValue('');
+            anchorElement === null || anchorElement === void 0 ? void 0 : anchorElement.focus();
+            setFilteredItems(items);
+        },
+        focus: () => anchorElement === null || anchorElement === void 0 ? void 0 : anchorElement.focus(),
+        blur: () => anchorElement === null || anchorElement === void 0 ? void 0 : anchorElement.blur(),
+        clearInput: () => setInputValue(''),
+    }), [anchorElement, items]);
+    const inputKeydownEvent = react_1.default.useCallback((event) => {
+        var _a, _b, _c, _d, _e;
+        if (!isFocusedRef.current) {
+            return;
+        }
+        switch (event.code) {
+            case 'Enter':
+            case 'NumpadEnter':
+                event.preventDefault();
+                (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.selectHightlightedItem();
+                break;
+            case 'ArrowUp':
+                {
+                    event.preventDefault();
+                    (_b = menuRef.current) === null || _b === void 0 ? void 0 : _b.hightlightPrevItem();
+                }
+                break;
+            case 'ArrowDown':
+                {
+                    event.preventDefault();
+                    (_c = menuRef.current) === null || _c === void 0 ? void 0 : _c.hightlightNextItem();
+                    if (!currentOpen) {
+                        onRequestOpen(event);
+                    }
+                }
+                break;
+            case 'Home':
+                {
+                    event.preventDefault();
+                    (_d = menuRef.current) === null || _d === void 0 ? void 0 : _d.hightlightFirstItem();
+                }
+                break;
+            case 'End':
+                {
+                    event.preventDefault();
+                    (_e = menuRef.current) === null || _e === void 0 ? void 0 : _e.hightlightLastItem();
+                }
+                break;
+            case 'PageUp':
+            case 'PageDown':
+                event.preventDefault();
+                break;
+            case 'Escape':
+            case 'Tab':
+                onRequestClose(event);
+                break;
+            default:
+                if (!currentOpen) {
+                    onRequestOpen(event);
+                }
+                // do nothing
+                break;
+        }
+    }, [currentOpen, onRequestClose, onRequestOpen]);
+    const onSelectItemF = react_1.default.useCallback(selected => {
+        setCurrentValue(selected);
+        if (typeof onSelectItem === 'function') {
+            if (!Array.isArray(selected) && typeof itemToString === 'function') {
+                setInputValue(itemToString(selected));
+            }
+            onSelectItem(selected);
+        }
+    }, [itemToString, onSelectItem]);
+    react_1.default.useEffect(() => {
+        if (value === null) {
+            setCurrentValue(null);
+            return;
+        }
+        if (multiple) {
+            if (Array.isArray(value)) {
+                setCurrentValue(value);
+            }
+            if (!Array.isArray(value)) {
+                setCurrentValue([value]);
+            }
+        }
+        if (!multiple) {
+            if (Array.isArray(value)) {
+                setCurrentValue(value[0]);
+            }
+            if (!Array.isArray(value)) {
+                setCurrentValue(value);
+            }
+        }
+    }, [value, multiple]);
+    react_1.default.useEffect(() => {
+        setCurrentOpen(isOpen);
+    }, [isOpen]);
+    const renderInputOnChange = react_1.default.useCallback(event => {
+        setInputValue(event.currentTarget.value);
+        if (typeof onInputChange === 'function') {
+            onInputChange(event);
+        }
+        const query = event.currentTarget.value.toLowerCase().trim();
+        // Apply filter
+        const newItems = typeof filterItems !== 'function' || query.length === 0
+            ? items
+            : filterItems(items, { query, inputValue });
+        setFilteredItems(newItems);
+    }, [inputValue, items, onInputChange, filterItems]);
+    react_1.default.useEffect(() => {
+        var _a;
+        if (filteredItems.length === 1) {
+            (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.highlightIndex(0);
+        }
+    }, [filteredItems]);
+    const inputElement = react_1.default.useMemo(() => {
+        const elem = renderInput({
+            inputRef: setAnchorElement,
+            value: inputValue,
+            selected: currentValue,
+            onBlur: () => {
+                isFocusedRef.current = false;
+            },
+            onFocus: event => {
+                isFocusedRef.current = true;
+                onRequestOpen(event);
+            },
+            onKeyDown: inputKeydownEvent,
+            onChange: renderInputOnChange,
+            onClick: event => {
+                if (isFocusedRef.current) {
+                    onRequestOpen(event);
+                }
+            },
+        });
+        return elem;
+    }, [
+        inputKeydownEvent,
+        inputValue,
+        onRequestOpen,
+        renderInput,
+        renderInputOnChange,
+        currentValue,
+    ]);
+    return (react_1.default.createElement("div", { ref: containerRef },
+        inputElement,
+        react_1.default.createElement(Menu_1.default, { ref: menuRef, items: filteredItems, value: currentValue, isOpen: currentOpen && filteredItems.length > 0, autofocus: false, anchorElement: anchorElement, estimatedItemSize: estimatedItemSize, endThreshold: endThreshold, overscanCount: overscanCount, getOptionSelected: getOptionSelected, onEndReached: onEndReached, onSelectItem: onSelectItemF, renderItem: renderItem, multiple: multiple, zIndex: zIndex, closeOutsideClick: true, popperOptions: popper_options_1.default, onRequestClose: evt => {
+                if ((evt === null || evt === void 0 ? void 0 : evt.target) !== anchorElement) {
+                    onRequestClose(evt);
+                }
+            } })));
+});
+Autocomplete.displayName = 'Autocomplete';
+exports.default = Autocomplete;

package/Autocomplete/popper-options.d.ts

@@ -0,0 +1,4 @@
+import type { usePopper } from 'react-popper';
+export type PopperOptions = Parameters<typeof usePopper>[2];
+export declare const popperOptions: PopperOptions;
+export default popperOptions;

package/Autocomplete/popper-options.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.popperOptions = void 0;
+exports.popperOptions = {
+    placement: 'bottom-start',
+    modifiers: [
+        {
+            name: 'offset',
+            options: {
+                offset: [0, 8],
+            },
+        },
+        {
+            name: 'flip',
+            enabled: true,
+            options: {
+                altBoundary: true,
+                padding: 8,
+            },
+        },
+        {
+            name: 'preventOverflow',
+            enabled: true,
+            options: {
+                altAxis: true,
+                altBoundary: true,
+                tether: true,
+                padding: 8,
+            },
+        },
+    ],
+};
+exports.default = exports.popperOptions;

package/Button/ButtonBase.d.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+import { ButtonIconWrapperProps } from './ButtonIconWrapper';
+import { ButtonTextWrapperProps } from './ButtonTextWrapper';
+import { ButtonContainerProps } from './ButtonContainer';
+type ButtonNativeProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+export interface ButtonBaseProps extends Omit<ButtonNativeProps, 'color'> {
+    /**
+     * Icon or another JSX element placed before button label\
+     * Example:
+     * ```tsx
+     * <Button startIcon={<MyIconElement />}>
+     *   Label
+     * </Button>
+     * ```
+     */
+    readonly startIcon?: JSX.Element;
+    /**
+     * Icon or another JSX element placed after button label
+     * Example:
+     * ```tsx
+     * <Button endIcon={<MyIconElement />}>
+     *   Label
+     * </Button>
+     * ```
+     */
+    readonly endIcon?: JSX.Element;
+    /**
+     * If true, then expect SVG icon as children. The button will be rendered as icon button
+     * Example:
+     * ```tsx
+     * <Button iconOnly>
+     *   <MyIconSVG />
+     * </Button>
+     * ```
+     `
+     */
+    readonly iconOnly?: ButtonContainerProps['iconOnly'];
+    /**
+     * You can pass the primary, default, secondary name of the colors or your specified color value
+     */
+    readonly color?: ButtonContainerProps['color'];
+    /**
+     * Overridable components map
+     */
+    readonly overrides?: ButtonBaseOverrides;
+}
+export interface ButtonBaseOverrides {
+    /**
+     * Element container
+     */
+    readonly Container?: React.ForwardRefExoticComponent<ButtonContainerProps & React.RefAttributes<HTMLButtonElement>>;
+    /**
+     * icon wrapper
+     */
+    readonly IconWrapper?: React.ForwardRefExoticComponent<ButtonIconWrapperProps & React.RefAttributes<HTMLSpanElement>>;
+    /**
+     * text wrapper
+     */
+    readonly TextWrapper?: React.ForwardRefExoticComponent<ButtonTextWrapperProps & React.RefAttributes<HTMLSpanElement>>;
+}
+declare const _default: React.ForwardRefExoticComponent<ButtonBaseProps & React.RefAttributes<HTMLButtonElement>>;
+export default _default;

package/Button/ButtonBase.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 ButtonIconWrapper_1 = __importDefault(require("./ButtonIconWrapper"));
+const ButtonTextWrapper_1 = __importDefault(require("./ButtonTextWrapper"));
+const ButtonContainer_1 = __importDefault(require("./ButtonContainer"));
+const ButtonBase = (props, ref) => {
+    const { children, startIcon, endIcon, color, overrides, iconOnly } = props, nativeProps = __rest(props, ["children", "startIcon", "endIcon", "color", "overrides", "iconOnly"]);
+    const overridesMap = react_1.default.useMemo(() => (Object.assign({ TextWrapper: ButtonTextWrapper_1.default,
+        IconWrapper: ButtonIconWrapper_1.default,
+        Container: ButtonContainer_1.default }, overrides)), [overrides]);
+    if (iconOnly &&
+        ((typeof startIcon !== 'undefined' && startIcon !== null) ||
+            (typeof endIcon !== 'undefined' && endIcon !== null))) {
+        console.warn('The «iconOnly» property should not be used simultaneously with «startIcon» and/or «endIcon»');
+    }
+    return (react_1.default.createElement(overridesMap.Container, Object.assign({}, nativeProps, { color: color, iconOnly: iconOnly, ref: ref }),
+        typeof startIcon !== 'undefined' && startIcon !== null && (react_1.default.createElement(overridesMap.IconWrapper, { position: "start" }, startIcon)),
+        react_1.default.createElement(overridesMap.TextWrapper, { iconOnly: iconOnly }, children),
+        typeof endIcon !== 'undefined' && endIcon !== null && (react_1.default.createElement(overridesMap.IconWrapper, { position: "end" }, endIcon))));
+};
+exports.default = react_1.default.forwardRef(ButtonBase);

package/Button/ButtonContainer.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+export type ButtonContainerProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    /**
+     * You can pass the primary, default, secondary name of the colors or your specified color value
+     */
+    readonly color?: 'default' | 'primary' | 'secondary' | string;
+    /**
+     * If true, then expect SVG icon as children. The button will be rendered as icon button
+     * Example:
+     * ```tsx
+     * <Button iconOnly>
+     *   <MyIconSVG />
+     * </Button>
+     * ```
+     `
+     */
+    readonly iconOnly?: boolean;
+};
+declare const _default: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    /**
+     * You can pass the primary, default, secondary name of the colors or your specified color value
+     */
+    readonly color?: string | undefined;
+    /**
+     * If true, then expect SVG icon as children. The button will be rendered as icon button
+     * Example:
+     * ```tsx
+     * <Button iconOnly>
+     *   <MyIconSVG />
+     * </Button>
+     * ```
+     `
+     */
+    readonly iconOnly?: boolean | undefined;
+} & React.RefAttributes<HTMLButtonElement>>;
+export default _default;

package/Button/ButtonContainer.js

@@ -0,0 +1,56 @@
+"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 StyledButton = styled_1.default.button `
+  border-radius: ${({ theme }) => theme.shape.radiusFactor * 2}em;
+  padding: 0.8em 1em;
+  font-size: 0.8rem;
+  cursor: ${({ disabled }) => (disabled ? 'default' : 'pointer')};
+  font-size: 1em;
+  border-width: 0;
+  outline-style: solid;
+  outline-color: transparent;
+  outline-width: 0.14em;
+  transition: all 180ms ease-out 0s;
+  background: none;
+  display: inline-flex;
+  align-items: center;
+  color: ${({ color, disabled, theme }) => {
+    switch (true) {
+        case disabled:
+            return theme.color.textSecondary.alpha(0.8).toString();
+        case !disabled && typeof color === 'undefined':
+        default:
+            return theme.color.textPrimary.toString();
+    }
+}};
+  ${({ iconOnly, theme }) => iconOnly &&
+    (0, react_2.css) `
+      padding: 1em;
+      justify-content: center;
+      width: 2.6em;
+      height: 2.6em;
+      border-radius: ${theme.shape.radiusFactor * 3}em;
+    `}
+`;
+const ButtonContainer = (props, ref) => {
+    const { children } = props, nativeProps = __rest(props, ["children"]);
+    return (react_1.default.createElement(StyledButton, Object.assign({}, nativeProps, { ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(ButtonContainer);

package/Button/ButtonIconWrapper.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export type ButtonIconWrapperProps = React.HTMLAttributes<HTMLSpanElement> & {
+    /**
+     * Icon position
+     */
+    readonly position: 'start' | 'end';
+};
+declare const _default: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & {
+    /**
+     * Icon position
+     */
+    readonly position: "end" | "start";
+} & React.RefAttributes<HTMLSpanElement>>;
+export default _default;

package/Button/ButtonIconWrapper.js

@@ -0,0 +1,34 @@
+"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 Wrapper = styled_1.default.span `
+  ${({ $position }) => $position === 'start' &&
+    (0, react_2.css) `
+      margin-right: 0.8em;
+    `};
+  ${({ $position }) => $position === 'end' &&
+    (0, react_2.css) `
+      margin-left: 0.8em;
+    `};
+`;
+const ButtonIconWrapper = (props, ref) => {
+    const { children, position } = props, nativeProps = __rest(props, ["children", "position"]);
+    return (react_1.default.createElement(Wrapper, Object.assign({ "$position": position }, nativeProps, { ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(ButtonIconWrapper);

package/Button/ButtonOutlined.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ButtonBaseProps } from './ButtonBase';
+export type ButtonOutlinedProps = ButtonBaseProps;
+declare const _default: React.ForwardRefExoticComponent<ButtonBaseProps & React.RefAttributes<HTMLButtonElement>>;
+export default _default;

package/Button/ButtonOutlined.js

@@ -0,0 +1,87 @@
+"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 Color_1 = __importDefault(require("../Color"));
+const ButtonBase_1 = __importDefault(require("./ButtonBase"));
+const StyledOutlinedButton = (0, styled_1.default)(ButtonBase_1.default) `
+  color: ${({ theme, disabled, $color }) => {
+    switch (true) {
+        case disabled:
+            return theme.color.textPrimary.alpha(0.4).toString();
+        default:
+            return $color.darken(30).toString();
+    }
+}};
+  border-color: ${({ theme, disabled, $color }) => {
+    switch (true) {
+        case disabled:
+            return theme.color.surface.darken(80).alpha(0.4).toString();
+        default:
+            return $color.toString();
+    }
+}};
+  background-color: transparent;
+  border-style: solid;
+  border-width: 0.14em;
+  ${({ disabled, $color, theme }) => !disabled &&
+    (0, react_2.css) `
+      &:hover {
+        background-color: ${$color.darken(20).alpha(0.1).toString()};
+      }
+      &:active {
+        background-color: ${$color.darken(50).alpha(0.3).toString()};
+      }
+      &:focus-visible {
+        outline-color: ${$color.rgbString() === theme.color.accentPrimary.rgbString()
+        ? theme.color.textPrimary.toString()
+        : theme.color.accentPrimary.toString()};
+      }
+    `};
+`;
+const ButtonOutlined = (props, ref) => {
+    const { children, disabled, color } = props, restProps = __rest(props, ["children", "disabled", "color"]);
+    const theme = (0, react_2.useTheme)();
+    const $color = react_1.default.useMemo(() => {
+        switch (true) {
+            case color === 'primary':
+                return theme.color.accentPrimary;
+            case color === 'secondary':
+                return theme.color.accentSecondary;
+            case typeof color === 'undefined':
+            case color === 'default':
+                return theme.color.textPrimary;
+            case typeof color === 'string': {
+                let c = theme.color.textPrimary;
+                try {
+                    if (color) {
+                        c = new Color_1.default(color);
+                    }
+                }
+                catch (err) {
+                    console.error(`invalid color value «${color}»`);
+                }
+                return c;
+            }
+            default:
+                return theme.color.textPrimary;
+        }
+    }, [color, theme.color]);
+    return (react_1.default.createElement(StyledOutlinedButton, Object.assign({ disabled: disabled, "$color": $color }, restProps, { ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(ButtonOutlined);

package/Button/ButtonPlain.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ButtonBaseProps } from './ButtonBase';
+export type ButtonPlainProps = ButtonBaseProps;
+declare const _default: React.ForwardRefExoticComponent<ButtonBaseProps & React.RefAttributes<HTMLButtonElement>>;
+export default _default;