@vincentgraul/react-components 1.0.18 → 1.0.19

package/README.md

@@ -15,6 +15,8 @@
 | useOutsideAlerter  | React hook to know if an click has been triggered outside an element                |
 | Modal              | React component used to display a modal                                             |
 | Loader             | React component used to display a loader                                            |
+| Select             | React component used to display a select                                            |
+| LanguageSelector   | React component used to display a language selector                                 |
 
 ## License
 

package/build/language-selector/LanguageSelector.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+interface Props {
+    languages: string[];
+    onChange?: (option: Option) => void;
+}
+interface Option {
+    value: string;
+    label: ReactNode;
+}
+export default function LanguageSelector(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=LanguageSelector.d.ts.map

package/build/language-selector/LanguageSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LanguageSelector.d.ts","sourceRoot":"","sources":["../../src/language-selector/LanguageSelector.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAE,SAAS,EAAuB,MAAM,OAAO,CAAC;AAI9D,UAAU,KAAK;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAED,UAAU,MAAM;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,KAAK,EAAE,KAAK,2CA+BpD"}

package/build/language-selector/LanguageSelector.js

@@ -0,0 +1,42 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import styled from "styled-components";
+import Select from "../select/Select";
+export default function LanguageSelector(props) {
+    const { languages, onChange } = props;
+    const [options, setOptions] = useState(null);
+    useEffect(() => {
+        const fetchIcon = (name) => __awaiter(this, void 0, void 0, function* () {
+            const { default: path } = yield import(`./flags/${name}.svg`);
+            return path;
+        });
+        const prepareOptions = () => __awaiter(this, void 0, void 0, function* () {
+            setOptions(yield Promise.all(languages.map((language) => __awaiter(this, void 0, void 0, function* () {
+                return {
+                    value: language,
+                    label: _jsx(Flag, { src: yield fetchIcon(language) }),
+                };
+            }))));
+        });
+        prepareOptions();
+    }, [languages]);
+    if (!options) {
+        return null;
+    }
+    return _jsx(Select, { options: options, onChange: onChange });
+}
+const Flag = styled.img `
+  display: block;
+  width: 30px;
+  margin: auto;
+  border-radius: 2px;
+`;

package/build/outside-alerter/useOutsideAlerter.d.ts

@@ -1,3 +1,8 @@
 import { RefObject } from "react";
-export default function useOutsideAlerter(ref: RefObject<HTMLElement>): boolean;
+interface OutsideAlerter {
+    hasClickedOutside: boolean;
+    onReset: () => void;
+}
+export default function useOutsideAlerter(ref: RefObject<HTMLElement>): OutsideAlerter;
+export {};
 //# sourceMappingURL=useOutsideAlerter.d.ts.map

package/build/outside-alerter/useOutsideAlerter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useOutsideAlerter.d.ts","sourceRoot":"","sources":["../../src/outside-alerter/useOutsideAlerter.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAY,MAAM,OAAO,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,GAAG,EAAE,SAAS,CAAC,WAAW,CAAC,GAAG,OAAO,CAqB9E"}
+{"version":3,"file":"useOutsideAlerter.d.ts","sourceRoot":"","sources":["../../src/outside-alerter/useOutsideAlerter.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAY,MAAM,OAAO,CAAC;AAEvD,UAAU,cAAc;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,GAAG,EAAE,SAAS,CAAC,WAAW,CAAC,GAAG,cAAc,CAyBrF"}

package/build/outside-alerter/useOutsideAlerter.js

@@ -1,6 +1,9 @@
 import { useEffect, useState } from "react";
 export default function useOutsideAlerter(ref) {
     const [hasClickedOutside, setClickedOutside] = useState(false);
+    const handleOnReset = () => {
+        setClickedOutside(false);
+    };
     const handleOnClickOutside = (event) => {
         if (event.target && ref.current) {
             if (!ref.current.contains(event.target)) {
@@ -16,5 +19,5 @@ export default function useOutsideAlerter(ref) {
             document.removeEventListener("mousedown", (event) => handleOnClickOutside(event));
         };
     }, [ref]);
-    return hasClickedOutside;
+    return { hasClickedOutside, onReset: handleOnReset };
 }

package/build/select/Select.d.ts

@@ -0,0 +1,287 @@
+import React, { ReactNode } from "react";
+interface Option {
+    id: number;
+    label: string | ReactNode;
+    value: string;
+}
+export type OptionWithoutId = Omit<Option, "id">;
+interface Props {
+    options: OptionWithoutId[];
+    onChange?: (option: Option) => void;
+}
+export default function Select(props: Props): import("react/jsx-runtime").JSX.Element;
+declare const Option: import("styled-components").IStyledComponent<"web", {
+    ref?: React.LegacyRef<HTMLLIElement>;
+    key?: React.Key;
+    value?: string | number | readonly string[];
+    defaultChecked?: boolean;
+    defaultValue?: string | number | readonly string[];
+    suppressContentEditableWarning?: boolean;
+    suppressHydrationWarning?: boolean;
+    accessKey?: string;
+    autoFocus?: boolean;
+    className?: string;
+    contentEditable?: "inherit" | (boolean | "true" | "false");
+    contextMenu?: string;
+    dir?: string;
+    draggable?: boolean | "true" | "false";
+    hidden?: boolean;
+    id?: string;
+    lang?: string;
+    nonce?: string;
+    placeholder?: string;
+    slot?: string;
+    spellCheck?: boolean | "true" | "false";
+    style?: React.CSSProperties;
+    tabIndex?: number;
+    title?: string;
+    translate?: "yes" | "no";
+    radioGroup?: string;
+    role?: React.AriaRole;
+    about?: string;
+    content?: string;
+    datatype?: string;
+    inlist?: any;
+    prefix?: string;
+    property?: string;
+    rel?: string;
+    resource?: string;
+    rev?: string;
+    typeof?: string;
+    vocab?: string;
+    autoCapitalize?: string;
+    autoCorrect?: string;
+    autoSave?: string;
+    color?: string;
+    itemProp?: string;
+    itemScope?: boolean;
+    itemType?: string;
+    itemID?: string;
+    itemRef?: string;
+    results?: number;
+    security?: string;
+    unselectable?: "on" | "off";
+    inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
+    is?: string;
+    'aria-activedescendant'?: string;
+    'aria-atomic'?: boolean | "true" | "false";
+    'aria-autocomplete'?: "none" | "list" | "inline" | "both";
+    'aria-braillelabel'?: string;
+    'aria-brailleroledescription'?: string;
+    'aria-busy'?: boolean | "true" | "false";
+    'aria-checked'?: boolean | "true" | "false" | "mixed";
+    'aria-colcount'?: number;
+    'aria-colindex'?: number;
+    'aria-colindextext'?: string;
+    'aria-colspan'?: number;
+    'aria-controls'?: string;
+    'aria-current'?: boolean | "time" | "page" | "step" | "true" | "false" | "location" | "date";
+    'aria-describedby'?: string;
+    'aria-description'?: string;
+    'aria-details'?: string;
+    'aria-disabled'?: boolean | "true" | "false";
+    'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup";
+    'aria-errormessage'?: string;
+    'aria-expanded'?: boolean | "true" | "false";
+    'aria-flowto'?: string;
+    'aria-grabbed'?: boolean | "true" | "false";
+    'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
+    'aria-hidden'?: boolean | "true" | "false";
+    'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling";
+    'aria-keyshortcuts'?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-level'?: number;
+    'aria-live'?: "off" | "assertive" | "polite";
+    'aria-modal'?: boolean | "true" | "false";
+    'aria-multiline'?: boolean | "true" | "false";
+    'aria-multiselectable'?: boolean | "true" | "false";
+    'aria-orientation'?: "horizontal" | "vertical";
+    'aria-owns'?: string;
+    'aria-placeholder'?: string;
+    'aria-posinset'?: number;
+    'aria-pressed'?: boolean | "true" | "false" | "mixed";
+    'aria-readonly'?: boolean | "true" | "false";
+    'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+    'aria-required'?: boolean | "true" | "false";
+    'aria-roledescription'?: string;
+    'aria-rowcount'?: number;
+    'aria-rowindex'?: number;
+    'aria-rowindextext'?: string;
+    'aria-rowspan'?: number;
+    'aria-selected'?: boolean | "true" | "false";
+    'aria-setsize'?: number;
+    'aria-sort'?: "none" | "ascending" | "descending" | "other";
+    'aria-valuemax'?: number;
+    'aria-valuemin'?: number;
+    'aria-valuenow'?: number;
+    'aria-valuetext'?: string;
+    children?: React.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    };
+    onCopy?: React.ClipboardEventHandler<HTMLLIElement>;
+    onCopyCapture?: React.ClipboardEventHandler<HTMLLIElement>;
+    onCut?: React.ClipboardEventHandler<HTMLLIElement>;
+    onCutCapture?: React.ClipboardEventHandler<HTMLLIElement>;
+    onPaste?: React.ClipboardEventHandler<HTMLLIElement>;
+    onPasteCapture?: React.ClipboardEventHandler<HTMLLIElement>;
+    onCompositionEnd?: React.CompositionEventHandler<HTMLLIElement>;
+    onCompositionEndCapture?: React.CompositionEventHandler<HTMLLIElement>;
+    onCompositionStart?: React.CompositionEventHandler<HTMLLIElement>;
+    onCompositionStartCapture?: React.CompositionEventHandler<HTMLLIElement>;
+    onCompositionUpdate?: React.CompositionEventHandler<HTMLLIElement>;
+    onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLLIElement>;
+    onFocus?: React.FocusEventHandler<HTMLLIElement>;
+    onFocusCapture?: React.FocusEventHandler<HTMLLIElement>;
+    onBlur?: React.FocusEventHandler<HTMLLIElement>;
+    onBlurCapture?: React.FocusEventHandler<HTMLLIElement>;
+    onChange?: React.FormEventHandler<HTMLLIElement>;
+    onChangeCapture?: React.FormEventHandler<HTMLLIElement>;
+    onBeforeInput?: React.FormEventHandler<HTMLLIElement>;
+    onBeforeInputCapture?: React.FormEventHandler<HTMLLIElement>;
+    onInput?: React.FormEventHandler<HTMLLIElement>;
+    onInputCapture?: React.FormEventHandler<HTMLLIElement>;
+    onReset?: React.FormEventHandler<HTMLLIElement>;
+    onResetCapture?: React.FormEventHandler<HTMLLIElement>;
+    onSubmit?: React.FormEventHandler<HTMLLIElement>;
+    onSubmitCapture?: React.FormEventHandler<HTMLLIElement>;
+    onInvalid?: React.FormEventHandler<HTMLLIElement>;
+    onInvalidCapture?: React.FormEventHandler<HTMLLIElement>;
+    onLoad?: React.ReactEventHandler<HTMLLIElement>;
+    onLoadCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onError?: React.ReactEventHandler<HTMLLIElement>;
+    onErrorCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLLIElement>;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLLIElement>;
+    onKeyPress?: React.KeyboardEventHandler<HTMLLIElement>;
+    onKeyPressCapture?: React.KeyboardEventHandler<HTMLLIElement>;
+    onKeyUp?: React.KeyboardEventHandler<HTMLLIElement>;
+    onKeyUpCapture?: React.KeyboardEventHandler<HTMLLIElement>;
+    onAbort?: React.ReactEventHandler<HTMLLIElement>;
+    onAbortCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onCanPlay?: React.ReactEventHandler<HTMLLIElement>;
+    onCanPlayCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onCanPlayThrough?: React.ReactEventHandler<HTMLLIElement>;
+    onCanPlayThroughCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onDurationChange?: React.ReactEventHandler<HTMLLIElement>;
+    onDurationChangeCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onEmptied?: React.ReactEventHandler<HTMLLIElement>;
+    onEmptiedCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onEncrypted?: React.ReactEventHandler<HTMLLIElement>;
+    onEncryptedCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onEnded?: React.ReactEventHandler<HTMLLIElement>;
+    onEndedCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onLoadedData?: React.ReactEventHandler<HTMLLIElement>;
+    onLoadedDataCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onLoadedMetadata?: React.ReactEventHandler<HTMLLIElement>;
+    onLoadedMetadataCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onLoadStart?: React.ReactEventHandler<HTMLLIElement>;
+    onLoadStartCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onPause?: React.ReactEventHandler<HTMLLIElement>;
+    onPauseCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onPlay?: React.ReactEventHandler<HTMLLIElement>;
+    onPlayCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onPlaying?: React.ReactEventHandler<HTMLLIElement>;
+    onPlayingCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onProgress?: React.ReactEventHandler<HTMLLIElement>;
+    onProgressCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onRateChange?: React.ReactEventHandler<HTMLLIElement>;
+    onRateChangeCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onResize?: React.ReactEventHandler<HTMLLIElement>;
+    onResizeCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onSeeked?: React.ReactEventHandler<HTMLLIElement>;
+    onSeekedCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onSeeking?: React.ReactEventHandler<HTMLLIElement>;
+    onSeekingCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onStalled?: React.ReactEventHandler<HTMLLIElement>;
+    onStalledCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onSuspend?: React.ReactEventHandler<HTMLLIElement>;
+    onSuspendCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onTimeUpdate?: React.ReactEventHandler<HTMLLIElement>;
+    onTimeUpdateCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onVolumeChange?: React.ReactEventHandler<HTMLLIElement>;
+    onVolumeChangeCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onWaiting?: React.ReactEventHandler<HTMLLIElement>;
+    onWaitingCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onAuxClick?: React.MouseEventHandler<HTMLLIElement>;
+    onAuxClickCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onClick?: React.MouseEventHandler<HTMLLIElement>;
+    onClickCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLLIElement>;
+    onContextMenuCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onDoubleClick?: React.MouseEventHandler<HTMLLIElement>;
+    onDoubleClickCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onDrag?: React.DragEventHandler<HTMLLIElement>;
+    onDragCapture?: React.DragEventHandler<HTMLLIElement>;
+    onDragEnd?: React.DragEventHandler<HTMLLIElement>;
+    onDragEndCapture?: React.DragEventHandler<HTMLLIElement>;
+    onDragEnter?: React.DragEventHandler<HTMLLIElement>;
+    onDragEnterCapture?: React.DragEventHandler<HTMLLIElement>;
+    onDragExit?: React.DragEventHandler<HTMLLIElement>;
+    onDragExitCapture?: React.DragEventHandler<HTMLLIElement>;
+    onDragLeave?: React.DragEventHandler<HTMLLIElement>;
+    onDragLeaveCapture?: React.DragEventHandler<HTMLLIElement>;
+    onDragOver?: React.DragEventHandler<HTMLLIElement>;
+    onDragOverCapture?: React.DragEventHandler<HTMLLIElement>;
+    onDragStart?: React.DragEventHandler<HTMLLIElement>;
+    onDragStartCapture?: React.DragEventHandler<HTMLLIElement>;
+    onDrop?: React.DragEventHandler<HTMLLIElement>;
+    onDropCapture?: React.DragEventHandler<HTMLLIElement>;
+    onMouseDown?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseDownCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseEnter?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseMove?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseMoveCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseOut?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseOutCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseOver?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseOverCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseUp?: React.MouseEventHandler<HTMLLIElement>;
+    onMouseUpCapture?: React.MouseEventHandler<HTMLLIElement>;
+    onSelect?: React.ReactEventHandler<HTMLLIElement>;
+    onSelectCapture?: React.ReactEventHandler<HTMLLIElement>;
+    onTouchCancel?: React.TouchEventHandler<HTMLLIElement>;
+    onTouchCancelCapture?: React.TouchEventHandler<HTMLLIElement>;
+    onTouchEnd?: React.TouchEventHandler<HTMLLIElement>;
+    onTouchEndCapture?: React.TouchEventHandler<HTMLLIElement>;
+    onTouchMove?: React.TouchEventHandler<HTMLLIElement>;
+    onTouchMoveCapture?: React.TouchEventHandler<HTMLLIElement>;
+    onTouchStart?: React.TouchEventHandler<HTMLLIElement>;
+    onTouchStartCapture?: React.TouchEventHandler<HTMLLIElement>;
+    onPointerDown?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerDownCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerMove?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerMoveCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerUp?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerUpCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerCancel?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerCancelCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerEnter?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerEnterCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerLeave?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerLeaveCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerOver?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerOverCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerOut?: React.PointerEventHandler<HTMLLIElement>;
+    onPointerOutCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onGotPointerCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onLostPointerCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLLIElement>;
+    onScroll?: React.UIEventHandler<HTMLLIElement>;
+    onScrollCapture?: React.UIEventHandler<HTMLLIElement>;
+    onWheel?: React.WheelEventHandler<HTMLLIElement>;
+    onWheelCapture?: React.WheelEventHandler<HTMLLIElement>;
+    onAnimationStart?: React.AnimationEventHandler<HTMLLIElement>;
+    onAnimationStartCapture?: React.AnimationEventHandler<HTMLLIElement>;
+    onAnimationEnd?: React.AnimationEventHandler<HTMLLIElement>;
+    onAnimationEndCapture?: React.AnimationEventHandler<HTMLLIElement>;
+    onAnimationIteration?: React.AnimationEventHandler<HTMLLIElement>;
+    onAnimationIterationCapture?: React.AnimationEventHandler<HTMLLIElement>;
+    onTransitionEnd?: React.TransitionEventHandler<HTMLLIElement>;
+    onTransitionEndCapture?: React.TransitionEventHandler<HTMLLIElement>;
+}>;
+export {};
+//# sourceMappingURL=Select.d.ts.map

package/build/select/Select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Select.d.ts","sourceRoot":"","sources":["../../src/select/Select.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,SAAS,EAA+B,MAAM,OAAO,CAAC;AAKtE,UAAU,MAAM;IACd,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAEjD,UAAU,KAAK;IACb,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAED,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,KAAK,EAAE,KAAK,2CAiE1C;AAoCD,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBX,CAAC"}

package/build/select/Select.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import styled from "styled-components";
+import Arrow from "./icons/arrow-bottom.svg";
+import useOutsideAlerter from "../outside-alerter/useOutsideAlerter";
+export default function Select(props) {
+    const { onChange } = props;
+    const [options, setOptions] = useState(null);
+    const [isListVisible, setListVisibility] = useState(false);
+    const [selectedOption, setSelectedOption] = useState(null);
+    const ref = useRef(null);
+    const { hasClickedOutside, onReset: onResetOutsideAlerter } = useOutsideAlerter(ref);
+    const handleSelectedOptionClick = () => {
+        onResetOutsideAlerter();
+        setListVisibility(!isListVisible);
+    };
+    const handleOptionClick = (option) => {
+        setSelectedOption(option);
+        setListVisibility(false);
+        if (onChange) {
+            onChange(option);
+        }
+    };
+    useEffect(() => {
+        setOptions(props.options.map((option, index) => (Object.assign(Object.assign({}, option), { id: index }))));
+    }, [props.options]);
+    useEffect(() => {
+        if (options) {
+            setSelectedOption(options[0]);
+        }
+    }, [options]);
+    useEffect(() => {
+        if (hasClickedOutside) {
+            setListVisibility(false);
+        }
+    }, [hasClickedOutside]);
+    if (!options || !selectedOption) {
+        return null;
+    }
+    return (_jsxs(Container, { className: "select", ref: ref, children: [_jsxs(SelectedOptionContainer, { onClick: handleSelectedOptionClick, children: [_jsx(SelectedOptionText, { children: selectedOption.label }), _jsx(SelectedOptionArrow, { src: Arrow })] }), isListVisible && (_jsx(OptionsList, { className: "select-options", children: options
+                    .filter((option) => option.id !== selectedOption.id)
+                    .map((option) => (_jsx(Option, { onClick: () => handleOptionClick(option), children: option.label }, option.id))) }))] }));
+}
+const Container = styled.div `
+  width: fit-content;
+`;
+const SelectedOptionContainer = styled.div `
+  display: flex;
+  align-items: center;
+  cursor: pointer;
+  user-select: none;
+  padding: 10px;
+  background-color: white;
+  border-radius: 5px;
+`;
+const SelectedOptionText = styled.span `
+  padding-right: 10px;
+  border-right: 1px solid black;
+`;
+const SelectedOptionArrow = styled.img `
+  width: 15px;
+  margin-left: 10px;
+`;
+const OptionsList = styled.ul `
+  width: 100%;
+  list-style: none;
+  padding: 0;
+  margin: 10px 0 0 0;
+  user-select: none;
+  background-color: white;
+  border-radius: 5px;
+`;
+const Option = styled.li `
+  padding: 10px;
+  cursor: pointer;
+
+  &:hover {
+    background-color: #ecf0f1;
+
+    &:first-child {
+      border-radius: 5px 5px 0 0;
+    }
+
+    &:last-child {
+      border-radius: 0 0 5px 5px;
+    }
+
+    &:only-child {
+      border-radius: 5px;
+    }
+  }
+`;