@plumile/ui 0.1.55 → 0.1.57

package/lib/components/select/SimpleSelect.css.d.ts

@@ -0,0 +1,23 @@
+import { type RecipeVariants } from '@vanilla-extract/recipes';
+export declare const container: string;
+export declare const label: string;
+export declare const trigger: import("@vanilla-extract/recipes").RuntimeFn<{
+    variant: {
+        default: string;
+        brand: string;
+    };
+}>;
+export declare const triggerOpen: string;
+export declare const valueText: string;
+export declare const triggerIcon: string;
+export declare const triggerIconOpen: string;
+export declare const triggerIconBrand: string;
+export declare const menu: string;
+export declare const menuOpen: string;
+export declare const optionButton: string;
+export declare const optionSelected: string;
+export declare const optionDescription: string;
+export declare const menuSeparator: string;
+export declare const actionsContainer: string;
+export type SimpleSelectVariants = RecipeVariants<typeof trigger>;
+//# sourceMappingURL=SimpleSelect.css.d.ts.map

package/lib/components/select/SimpleSelect.css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleSelect.css.d.ts","sourceRoot":"","sources":["../../../src/components/select/SimpleSelect.css.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAKvE,eAAO,MAAM,SAAS,QAGpB,CAAC;AAEH,eAAO,MAAM,KAAK,QAQhB,CAAC;AA6DH,eAAO,MAAM,OAAO;;;;;EAWlB,CAAC;AAEH,eAAO,MAAM,WAAW,QAGtB,CAAC;AAEH,eAAO,MAAM,SAAS,QAMpB,CAAC;AAEH,eAAO,MAAM,WAAW,QAUtB,CAAC;AAEH,eAAO,MAAM,eAAe,QAG1B,CAAC;AAEH,eAAO,MAAM,gBAAgB,QAE3B,CAAC;AAEH,eAAO,MAAM,IAAI,QAkBf,CAAC;AAEH,eAAO,MAAM,QAAQ,QAInB,CAAC;AAEH,eAAO,MAAM,YAAY,QAoBvB,CAAC;AAEH,eAAO,MAAM,cAAc,QAGzB,CAAC;AAEH,eAAO,MAAM,iBAAiB,QAG5B,CAAC;AAEH,eAAO,MAAM,aAAa,QAKxB,CAAC;AAEH,eAAO,MAAM,gBAAgB,QAG3B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC"}

package/lib/components/select/SimpleSelect.css.js

@@ -0,0 +1,175 @@
+import { style } from '@vanilla-extract/css';
+import { recipe } from '@vanilla-extract/recipes';
+import { sprinkles } from '../../theme/sprinkles.css.js';
+import { vars } from '../../theme/themeContract.js';
+export const container = sprinkles({
+    position: 'relative',
+    width: 'full',
+});
+export const label = sprinkles({
+    display: 'block',
+    marginBottom: 2,
+    fontSize: 'xs',
+    fontWeight: 'semibold',
+    letterSpacing: 'wider',
+    textTransform: 'uppercase',
+    color: 'textMuted',
+});
+const triggerBase = style([
+    sprinkles({
+        width: 'full',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        gap: 2,
+        paddingY: 2,
+        paddingX: 3,
+        borderRadius: 'xl',
+        fontSize: 'sm',
+        fontWeight: 'semibold',
+        textAlign: 'left',
+        cursor: 'pointer',
+        transitionProperty: 'colors',
+        transitionDuration: 150,
+        transitionTimingFunction: 'ease',
+    }),
+    {
+        selectors: {
+            '&:disabled': {
+                opacity: 0.6,
+                cursor: 'not-allowed',
+            },
+        },
+    },
+]);
+const defaultTrigger = sprinkles({
+    borderWidth: 'px',
+    borderStyle: 'solid',
+    borderColor: 'border',
+    backgroundColor: 'white',
+    color: 'text',
+});
+const brandTrigger = style([
+    sprinkles({
+        color: 'brandWhite',
+        borderWidth: 'default',
+        borderStyle: 'solid',
+        borderColor: 'brandPrimaryRed',
+        backgroundImage: 'brandDiagonal',
+    }),
+    {
+        selectors: {
+            '&:hover': {
+                filter: 'brightness(0.98)',
+            },
+            '&:focus-visible': {
+                outline: 'none',
+                boxShadow: `0 0 0 2px ${vars.colors.brandSecondaryOrange}`,
+            },
+        },
+    },
+]);
+export const trigger = recipe({
+    base: triggerBase,
+    variants: {
+        variant: {
+            default: defaultTrigger,
+            brand: brandTrigger,
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+    },
+});
+export const triggerOpen = sprinkles({
+    borderBottomLeftRadius: 'none',
+    borderBottomRightRadius: 'none',
+});
+export const valueText = sprinkles({
+    flex: 1,
+    minWidth: 0,
+    whiteSpace: 'nowrap',
+    overflow: 'hidden',
+    textOverflow: 'ellipsis',
+});
+export const triggerIcon = sprinkles({
+    display: 'grid',
+    alignItems: 'center',
+    justifyContent: 'center',
+    width: 4,
+    height: 4,
+    color: 'textMuted',
+    transitionProperty: 'default',
+    transitionDuration: 150,
+    transitionTimingFunction: 'ease',
+});
+export const triggerIconOpen = sprinkles({
+    rotate: 180,
+    color: 'text',
+});
+export const triggerIconBrand = sprinkles({
+    color: 'brandWhite',
+});
+export const menu = sprinkles({
+    position: 'absolute',
+    top: 'full',
+    left: 0,
+    right: 0,
+    zIndex: 10,
+    display: 'flex',
+    flexDirection: 'column',
+    gap: 1,
+    padding: 1,
+    borderRadius: 'xl',
+    borderWidth: 'default',
+    borderStyle: 'solid',
+    borderColor: 'border',
+    backgroundColor: 'white',
+    boxShadow: 'lg',
+    maxHeight: 72,
+    overflowY: 'auto',
+});
+export const menuOpen = sprinkles({
+    borderTopLeftRadius: 'none',
+    borderTopRightRadius: 'none',
+    marginTop: '-px',
+});
+export const optionButton = sprinkles({
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'flex-start',
+    gap: 1,
+    width: 'full',
+    borderWidth: 0,
+    borderStyle: 'none',
+    borderRadius: 'lg',
+    backgroundColor: 'transparent',
+    paddingY: 2,
+    paddingX: 3,
+    fontSize: 'sm',
+    fontWeight: 'medium',
+    color: 'text',
+    textAlign: 'left',
+    cursor: 'pointer',
+    transitionProperty: 'colors',
+    transitionDuration: 120,
+    transitionTimingFunction: 'ease',
+});
+export const optionSelected = sprinkles({
+    color: 'text',
+});
+export const optionDescription = sprinkles({
+    fontSize: 'xs',
+    color: 'textMuted',
+});
+export const menuSeparator = sprinkles({
+    height: 'px',
+    marginY: 1,
+    marginX: 2,
+    backgroundColor: 'border',
+});
+export const actionsContainer = sprinkles({
+    paddingY: 1,
+    paddingX: 2,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SimpleSelect.css.js","sourceRoot":"","sources":["../../../src/components/select/SimpleSelect.css.ts"],"names":[],"mappings":"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","sourcesContent":["import { style } from '@vanilla-extract/css';\nimport { recipe, type RecipeVariants } from '@vanilla-extract/recipes';\n\nimport { sprinkles } from '../../theme/sprinkles.css.js';\nimport { vars } from '../../theme/themeContract.js';\n\nexport const container = sprinkles({\n  position: 'relative',\n  width: 'full',\n});\n\nexport const label = sprinkles({\n  display: 'block',\n  marginBottom: 2,\n  fontSize: 'xs',\n  fontWeight: 'semibold',\n  letterSpacing: 'wider',\n  textTransform: 'uppercase',\n  color: 'textMuted',\n});\n\nconst triggerBase = style([\n  sprinkles({\n    width: 'full',\n    display: 'flex',\n    alignItems: 'center',\n    justifyContent: 'space-between',\n    gap: 2,\n    paddingY: 2,\n    paddingX: 3,\n    borderRadius: 'xl',\n    fontSize: 'sm',\n    fontWeight: 'semibold',\n    textAlign: 'left',\n    cursor: 'pointer',\n    transitionProperty: 'colors',\n    transitionDuration: 150,\n    transitionTimingFunction: 'ease',\n  }),\n  {\n    selectors: {\n      '&:disabled': {\n        opacity: 0.6,\n        cursor: 'not-allowed',\n      },\n    },\n  },\n]);\n\nconst defaultTrigger = sprinkles({\n  borderWidth: 'px',\n  borderStyle: 'solid',\n  borderColor: 'border',\n  backgroundColor: 'white',\n  color: 'text',\n});\n\nconst brandTrigger = style([\n  sprinkles({\n    color: 'brandWhite',\n    borderWidth: 'default',\n    borderStyle: 'solid',\n    borderColor: 'brandPrimaryRed',\n    backgroundImage: 'brandDiagonal',\n  }),\n  {\n    // boxShadow: `0 0 0 1px ${vars.colors.brandPrimaryRed}`,\n    selectors: {\n      '&:hover': {\n        filter: 'brightness(0.98)',\n      },\n      '&:focus-visible': {\n        outline: 'none',\n        // borderColor: vars.colors.brandPrimaryRed,\n        boxShadow: `0 0 0 2px ${vars.colors.brandSecondaryOrange}`,\n      },\n    },\n  },\n]);\n\nexport const trigger = recipe({\n  base: triggerBase,\n  variants: {\n    variant: {\n      default: defaultTrigger,\n      brand: brandTrigger,\n    },\n  },\n  defaultVariants: {\n    variant: 'default',\n  },\n});\n\nexport const triggerOpen = sprinkles({\n  borderBottomLeftRadius: 'none',\n  borderBottomRightRadius: 'none',\n});\n\nexport const valueText = sprinkles({\n  flex: 1,\n  minWidth: 0,\n  whiteSpace: 'nowrap',\n  overflow: 'hidden',\n  textOverflow: 'ellipsis',\n});\n\nexport const triggerIcon = sprinkles({\n  display: 'grid',\n  alignItems: 'center',\n  justifyContent: 'center',\n  width: 4,\n  height: 4,\n  color: 'textMuted',\n  transitionProperty: 'default',\n  transitionDuration: 150,\n  transitionTimingFunction: 'ease',\n});\n\nexport const triggerIconOpen = sprinkles({\n  rotate: 180,\n  color: 'text',\n});\n\nexport const triggerIconBrand = sprinkles({\n  color: 'brandWhite',\n});\n\nexport const menu = sprinkles({\n  position: 'absolute',\n  top: 'full',\n  left: 0,\n  right: 0,\n  zIndex: 10,\n  display: 'flex',\n  flexDirection: 'column',\n  gap: 1,\n  padding: 1,\n  borderRadius: 'xl',\n  borderWidth: 'default',\n  borderStyle: 'solid',\n  borderColor: 'border',\n  backgroundColor: 'white',\n  boxShadow: 'lg',\n  maxHeight: 72,\n  overflowY: 'auto',\n});\n\nexport const menuOpen = sprinkles({\n  borderTopLeftRadius: 'none',\n  borderTopRightRadius: 'none',\n  marginTop: '-px',\n});\n\nexport const optionButton = sprinkles({\n  display: 'flex',\n  flexDirection: 'column',\n  alignItems: 'flex-start',\n  gap: 1,\n  width: 'full',\n  borderWidth: 0,\n  borderStyle: 'none',\n  borderRadius: 'lg',\n  backgroundColor: 'transparent',\n  paddingY: 2,\n  paddingX: 3,\n  fontSize: 'sm',\n  fontWeight: 'medium',\n  color: 'text',\n  textAlign: 'left',\n  cursor: 'pointer',\n  transitionProperty: 'colors',\n  transitionDuration: 120,\n  transitionTimingFunction: 'ease',\n});\n\nexport const optionSelected = sprinkles({\n  // backgroundColor: vars.colors['slate-100'],\n  color: 'text',\n});\n\nexport const optionDescription = sprinkles({\n  fontSize: 'xs',\n  color: 'textMuted',\n});\n\nexport const menuSeparator = sprinkles({\n  height: 'px',\n  marginY: 1,\n  marginX: 2,\n  backgroundColor: 'border',\n});\n\nexport const actionsContainer = sprinkles({\n  paddingY: 1,\n  paddingX: 2,\n});\n\nexport type SimpleSelectVariants = RecipeVariants<typeof trigger>;\n"]}

package/lib/components/select/SimpleSelect.d.ts

@@ -0,0 +1,22 @@
+import { type JSX, type ReactNode } from 'react';
+export type SimpleSelectOption = {
+    id: string;
+    label: string;
+    value: string;
+    description?: string | null;
+};
+type ActionSlot = ReactNode | ((closeMenu: () => void) => ReactNode);
+type Props = {
+    options: readonly SimpleSelectOption[];
+    value: string;
+    onChange: (value: string) => void;
+    label?: ReactNode;
+    placeholder?: string;
+    actionsSlot?: ActionSlot;
+    isDisabled?: boolean;
+    className?: string;
+    variant?: 'default' | 'brand';
+};
+export declare const SimpleSelect: ({ actionsSlot, className, isDisabled, label, onChange, options, placeholder, value, variant, }: Props) => JSX.Element;
+export {};
+//# sourceMappingURL=SimpleSelect.d.ts.map

package/lib/components/select/SimpleSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleSelect.d.ts","sourceRoot":"","sources":["../../../src/components/select/SimpleSelect.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,GAAG,EAER,KAAK,SAAS,EAOf,MAAM,OAAO,CAAC;AAQf,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,KAAK,UAAU,GAAG,SAAS,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,IAAI,KAAK,SAAS,CAAC,CAAC;AAErE,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,gGAU1B,KAAK,KAAG,GAAG,CAAC,OAuTd,CAAC"}

package/lib/components/select/SimpleSelect.js

@@ -0,0 +1,218 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useId, useMemo, useRef, useState, } from 'react';
+import { ChevronDownSvg } from '../../icons/ChevronDownSvg.js';
+import * as styles from './SimpleSelect.css.js';
+import { cx } from '../../theme/tools.js';
+import { useUiTranslation } from '../../i18n/useUiTranslation.js';
+export const SimpleSelect = ({ actionsSlot, className, isDisabled = false, label, onChange, options, placeholder, value, variant = 'default', }) => {
+    const { t } = useUiTranslation();
+    const [isOpen, setIsOpen] = useState(false);
+    const resolvedPlaceholder = placeholder ?? t('common.select.placeholder');
+    const [focusedIndex, setFocusedIndex] = useState(-1);
+    const containerRef = useRef(null);
+    const triggerRef = useRef(null);
+    const optionRefs = useRef(new Map());
+    const listboxId = useId();
+    const selectedOption = useMemo(() => {
+        return (options.find((option) => {
+            return option.value === value;
+        }) ?? null);
+    }, [options, value]);
+    useEffect(() => {
+        if (!isOpen) {
+            return;
+        }
+        const selectedIndex = options.findIndex((option) => {
+            return option.value === value;
+        });
+        let nextIndex = 0;
+        if (selectedIndex >= 0) {
+            nextIndex = selectedIndex;
+        }
+        setFocusedIndex(nextIndex);
+    }, [isOpen, options, value]);
+    useEffect(() => {
+        if (!isOpen) {
+            return;
+        }
+        if (focusedIndex < 0 || focusedIndex >= options.length) {
+            return;
+        }
+        const option = options[focusedIndex];
+        if (option == null) {
+            return;
+        }
+        const node = optionRefs.current.get(option.id);
+        node?.focus();
+    }, [focusedIndex, isOpen, options]);
+    useEffect(() => {
+        if (!isOpen) {
+            return () => { };
+        }
+        const handleClick = (event) => {
+            if (containerRef.current?.contains(event.target)) {
+                return;
+            }
+            setIsOpen(false);
+        };
+        const handleKeyDown = (event) => {
+            if (event.key === 'Escape') {
+                setIsOpen(false);
+                triggerRef.current?.focus();
+            }
+        };
+        document.addEventListener('mousedown', handleClick);
+        window.addEventListener('keydown', handleKeyDown);
+        return () => {
+            document.removeEventListener('mousedown', handleClick);
+            window.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [isOpen]);
+    useEffect(() => {
+        optionRefs.current.clear();
+    }, [options]);
+    const closeMenu = useCallback(() => {
+        setIsOpen(false);
+        requestAnimationFrame(() => {
+            triggerRef.current?.focus();
+        });
+    }, []);
+    const handleToggle = () => {
+        if (isDisabled) {
+            return;
+        }
+        setIsOpen((prev) => {
+            return !prev;
+        });
+    };
+    const handleSelect = (nextValue) => {
+        onChange(nextValue);
+        closeMenu();
+    };
+    const handleTriggerKeyDown = (event) => {
+        if (isDisabled) {
+            return;
+        }
+        if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+            event.preventDefault();
+            setIsOpen(true);
+        }
+    };
+    const moveFocus = (direction) => {
+        if (options.length === 0) {
+            return;
+        }
+        setFocusedIndex((prev) => {
+            if (prev < 0) {
+                let fallbackIndex = options.length - 1;
+                if (direction === 1) {
+                    fallbackIndex = 0;
+                }
+                return fallbackIndex;
+            }
+            const nextIndex = (prev + direction + options.length) % options.length;
+            return nextIndex;
+        });
+    };
+    const handleListKeyDown = (event) => {
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                moveFocus(1);
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                moveFocus(-1);
+                break;
+            case 'Home':
+                event.preventDefault();
+                setFocusedIndex(0);
+                break;
+            case 'End':
+                event.preventDefault();
+                setFocusedIndex(options.length - 1);
+                break;
+            case 'Enter':
+            case ' ': {
+                event.preventDefault();
+                if (focusedIndex >= 0 && focusedIndex < options.length) {
+                    const option = options[focusedIndex];
+                    if (option != null) {
+                        handleSelect(option.value);
+                    }
+                }
+                break;
+            }
+            case 'Escape':
+                event.preventDefault();
+                setIsOpen(false);
+                triggerRef.current?.focus();
+                break;
+            default:
+                break;
+        }
+    };
+    const registerOptionRef = (optionId) => {
+        return (node) => {
+            optionRefs.current.set(optionId, node);
+        };
+    };
+    let labelId;
+    if (label != null) {
+        labelId = `${listboxId}-label`;
+    }
+    const renderActionsSlot = () => {
+        if (typeof actionsSlot === 'function') {
+            return actionsSlot(closeMenu);
+        }
+        return actionsSlot ?? null;
+    };
+    const optionItems = options.map((option, index) => {
+        const isSelected = option.value === value;
+        const optionClassName = cx(styles.optionButton, {
+            [styles.optionSelected]: isSelected,
+        });
+        let optionTabIndex = -1;
+        if (focusedIndex === index) {
+            optionTabIndex = 0;
+        }
+        let descriptionNode = null;
+        if (option.description != null && option.description !== '') {
+            descriptionNode = (_jsx("span", { className: styles.optionDescription, children: option.description }));
+        }
+        return (_jsx("li", { role: "presentation", children: _jsxs("button", { ref: registerOptionRef(option.id), type: "button", role: "option", "aria-selected": isSelected, className: optionClassName, tabIndex: optionTabIndex, onClick: () => {
+                    handleSelect(option.value);
+                }, onMouseEnter: () => {
+                    setFocusedIndex(index);
+                }, children: [_jsx("span", { children: option.label }), descriptionNode] }) }, option.id));
+    });
+    let activeOptionId;
+    if (focusedIndex >= 0 && focusedIndex < options.length) {
+        activeOptionId = options[focusedIndex]?.id;
+    }
+    let labelNode = null;
+    if (label != null) {
+        labelNode = (_jsx("span", { id: labelId, className: styles.label, children: label }));
+    }
+    let ariaControls;
+    if (isOpen) {
+        ariaControls = listboxId;
+    }
+    let actionsSlotNode = null;
+    if (actionsSlot != null) {
+        actionsSlotNode = (_jsxs(_Fragment, { children: [_jsx("li", { role: "presentation", children: _jsx("div", { className: styles.menuSeparator, role: "separator" }) }), _jsx("li", { role: "presentation", children: _jsx("div", { className: styles.actionsContainer, children: renderActionsSlot() }) })] }));
+    }
+    let menuNode = null;
+    if (isOpen) {
+        menuNode = (_jsxs("ul", { id: listboxId, className: cx(styles.menu, styles.menuOpen), role: "listbox", "aria-activedescendant": activeOptionId, tabIndex: -1, onKeyDown: handleListKeyDown, children: [optionItems, actionsSlotNode] }));
+    }
+    const triggerClassName = cx(styles.trigger({ variant }), {
+        [styles.triggerOpen]: isOpen,
+    });
+    const triggerIconClassName = cx(styles.triggerIcon, {
+        [styles.triggerIconOpen]: isOpen,
+        [styles.triggerIconBrand]: variant === 'brand',
+    });
+    return (_jsxs("div", { className: cx(styles.container, className), ref: containerRef, children: [labelNode, _jsxs("button", { ref: triggerRef, type: "button", className: triggerClassName, "aria-haspopup": "listbox", "aria-expanded": isOpen, "aria-controls": ariaControls, "aria-labelledby": labelId, onClick: handleToggle, onKeyDown: handleTriggerKeyDown, disabled: isDisabled, children: [_jsx("span", { className: styles.valueText, children: selectedOption?.label ?? resolvedPlaceholder }), _jsx("span", { className: triggerIconClassName, children: _jsx(ChevronDownSvg, { width: 16, height: 16, "aria-hidden": "true" }) })] }), menuNode] }));
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SimpleSelect.js","sourceRoot":"","sources":["../../../src/components/select/SimpleSelect.tsx"],"names":[],"mappings":"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","sourcesContent":["import {\n  type JSX,\n  type KeyboardEvent as ReactKeyboardEvent,\n  type ReactNode,\n  useCallback,\n  useEffect,\n  useId,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\n\nimport { ChevronDownSvg } from '../../icons/ChevronDownSvg.js';\n\nimport * as styles from './SimpleSelect.css.js';\nimport { cx } from '../../theme/tools.js';\nimport { useUiTranslation } from '../../i18n/useUiTranslation.js';\n\nexport type SimpleSelectOption = {\n  id: string;\n  label: string;\n  value: string;\n  description?: string | null;\n};\n\ntype ActionSlot = ReactNode | ((closeMenu: () => void) => ReactNode);\n\ntype Props = {\n  options: readonly SimpleSelectOption[];\n  value: string;\n  onChange: (value: string) => void;\n  label?: ReactNode;\n  placeholder?: string;\n  actionsSlot?: ActionSlot;\n  isDisabled?: boolean;\n  className?: string;\n  variant?: 'default' | 'brand';\n};\n\nexport const SimpleSelect = ({\n  actionsSlot,\n  className,\n  isDisabled = false,\n  label,\n  onChange,\n  options,\n  placeholder,\n  value,\n  variant = 'default',\n}: Props): JSX.Element => {\n  const { t } = useUiTranslation();\n  const [isOpen, setIsOpen] = useState(false);\n  const resolvedPlaceholder = placeholder ?? t('common.select.placeholder');\n  const [focusedIndex, setFocusedIndex] = useState<number>(-1);\n  const containerRef = useRef<HTMLDivElement | null>(null);\n  const triggerRef = useRef<HTMLButtonElement | null>(null);\n  const optionRefs = useRef<Map<string, HTMLButtonElement | null>>(new Map());\n  const listboxId = useId();\n\n  const selectedOption = useMemo(() => {\n    return (\n      options.find((option) => {\n        return option.value === value;\n      }) ?? null\n    );\n  }, [options, value]);\n\n  useEffect(() => {\n    if (!isOpen) {\n      return;\n    }\n\n    const selectedIndex = options.findIndex((option) => {\n      return option.value === value;\n    });\n    let nextIndex = 0;\n    if (selectedIndex >= 0) {\n      nextIndex = selectedIndex;\n    }\n    setFocusedIndex(nextIndex);\n  }, [isOpen, options, value]);\n\n  useEffect(() => {\n    if (!isOpen) {\n      return;\n    }\n    if (focusedIndex < 0 || focusedIndex >= options.length) {\n      return;\n    }\n    const option = options[focusedIndex];\n    if (option == null) {\n      return;\n    }\n    const node = optionRefs.current.get(option.id);\n    node?.focus();\n  }, [focusedIndex, isOpen, options]);\n\n  useEffect(() => {\n    if (!isOpen) {\n      return () => {};\n    }\n\n    const handleClick = (event: MouseEvent) => {\n      if (containerRef.current?.contains(event.target as Node)) {\n        return;\n      }\n      setIsOpen(false);\n    };\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if (event.key === 'Escape') {\n        setIsOpen(false);\n        triggerRef.current?.focus();\n      }\n    };\n\n    document.addEventListener('mousedown', handleClick);\n    window.addEventListener('keydown', handleKeyDown);\n\n    return () => {\n      document.removeEventListener('mousedown', handleClick);\n      window.removeEventListener('keydown', handleKeyDown);\n    };\n  }, [isOpen]);\n\n  useEffect(() => {\n    optionRefs.current.clear();\n  }, [options]);\n\n  const closeMenu = useCallback(() => {\n    setIsOpen(false);\n    requestAnimationFrame(() => {\n      triggerRef.current?.focus();\n    });\n  }, []);\n\n  const handleToggle = (): void => {\n    if (isDisabled) {\n      return;\n    }\n    setIsOpen((prev) => {\n      return !prev;\n    });\n  };\n\n  const handleSelect = (nextValue: string): void => {\n    onChange(nextValue);\n    closeMenu();\n  };\n\n  const handleTriggerKeyDown = (\n    event: ReactKeyboardEvent<HTMLButtonElement>,\n  ) => {\n    if (isDisabled) {\n      return;\n    }\n\n    if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {\n      event.preventDefault();\n      setIsOpen(true);\n    }\n  };\n\n  const moveFocus = (direction: 1 | -1): void => {\n    if (options.length === 0) {\n      return;\n    }\n    setFocusedIndex((prev) => {\n      if (prev < 0) {\n        let fallbackIndex = options.length - 1;\n        if (direction === 1) {\n          fallbackIndex = 0;\n        }\n        return fallbackIndex;\n      }\n      const nextIndex = (prev + direction + options.length) % options.length;\n      return nextIndex;\n    });\n  };\n\n  const handleListKeyDown = (event: ReactKeyboardEvent<HTMLUListElement>) => {\n    switch (event.key) {\n      case 'ArrowDown':\n        event.preventDefault();\n        moveFocus(1);\n        break;\n      case 'ArrowUp':\n        event.preventDefault();\n        moveFocus(-1);\n        break;\n      case 'Home':\n        event.preventDefault();\n        setFocusedIndex(0);\n        break;\n      case 'End':\n        event.preventDefault();\n        setFocusedIndex(options.length - 1);\n        break;\n      case 'Enter':\n      case ' ': {\n        event.preventDefault();\n        if (focusedIndex >= 0 && focusedIndex < options.length) {\n          const option = options[focusedIndex];\n          if (option != null) {\n            handleSelect(option.value);\n          }\n        }\n        break;\n      }\n      case 'Escape':\n        event.preventDefault();\n        setIsOpen(false);\n        triggerRef.current?.focus();\n        break;\n      default:\n        break;\n    }\n  };\n\n  const registerOptionRef = (optionId: string) => {\n    return (node: HTMLButtonElement | null) => {\n      optionRefs.current.set(optionId, node);\n    };\n  };\n\n  let labelId: string | undefined;\n  if (label != null) {\n    labelId = `${listboxId}-label`;\n  }\n\n  const renderActionsSlot = (): ReactNode | null => {\n    if (typeof actionsSlot === 'function') {\n      return actionsSlot(closeMenu);\n    }\n    return actionsSlot ?? null;\n  };\n\n  const optionItems = options.map((option, index) => {\n    const isSelected = option.value === value;\n    const optionClassName = cx(styles.optionButton, {\n      [styles.optionSelected]: isSelected,\n    });\n    let optionTabIndex = -1;\n    if (focusedIndex === index) {\n      optionTabIndex = 0;\n    }\n\n    let descriptionNode: JSX.Element | null = null;\n    if (option.description != null && option.description !== '') {\n      descriptionNode = (\n        <span className={styles.optionDescription}>{option.description}</span>\n      );\n    }\n\n    return (\n      <li key={option.id} role=\"presentation\">\n        <button\n          ref={registerOptionRef(option.id)}\n          type=\"button\"\n          role=\"option\"\n          aria-selected={isSelected}\n          className={optionClassName}\n          tabIndex={optionTabIndex}\n          onClick={() => {\n            handleSelect(option.value);\n          }}\n          onMouseEnter={() => {\n            setFocusedIndex(index);\n          }}\n        >\n          <span>{option.label}</span>\n          {descriptionNode}\n        </button>\n      </li>\n    );\n  });\n\n  let activeOptionId: string | undefined;\n  if (focusedIndex >= 0 && focusedIndex < options.length) {\n    activeOptionId = options[focusedIndex]?.id;\n  }\n\n  let labelNode: JSX.Element | null = null;\n  if (label != null) {\n    labelNode = (\n      <span id={labelId} className={styles.label}>\n        {label}\n      </span>\n    );\n  }\n\n  let ariaControls: string | undefined;\n  if (isOpen) {\n    ariaControls = listboxId;\n  }\n\n  let actionsSlotNode: ReactNode | null = null;\n  if (actionsSlot != null) {\n    actionsSlotNode = (\n      <>\n        <li role=\"presentation\">\n          <div className={styles.menuSeparator} role=\"separator\" />\n        </li>\n        <li role=\"presentation\">\n          <div className={styles.actionsContainer}>{renderActionsSlot()}</div>\n        </li>\n      </>\n    );\n  }\n\n  let menuNode: JSX.Element | null = null;\n  if (isOpen) {\n    menuNode = (\n      <ul\n        id={listboxId}\n        className={cx(styles.menu, styles.menuOpen)}\n        role=\"listbox\"\n        aria-activedescendant={activeOptionId}\n        tabIndex={-1}\n        onKeyDown={handleListKeyDown}\n      >\n        {optionItems}\n        {actionsSlotNode}\n      </ul>\n    );\n  }\n\n  const triggerClassName = cx(styles.trigger({ variant }), {\n    [styles.triggerOpen]: isOpen,\n  });\n  const triggerIconClassName = cx(styles.triggerIcon, {\n    [styles.triggerIconOpen]: isOpen,\n    [styles.triggerIconBrand]: variant === 'brand',\n  });\n\n  return (\n    <div className={cx(styles.container, className)} ref={containerRef}>\n      {labelNode}\n      <button\n        ref={triggerRef}\n        type=\"button\"\n        className={triggerClassName}\n        aria-haspopup=\"listbox\"\n        aria-expanded={isOpen}\n        aria-controls={ariaControls}\n        aria-labelledby={labelId}\n        onClick={handleToggle}\n        onKeyDown={handleTriggerKeyDown}\n        disabled={isDisabled}\n      >\n        <span className={styles.valueText}>\n          {selectedOption?.label ?? resolvedPlaceholder}\n        </span>\n        <span className={triggerIconClassName}>\n          <ChevronDownSvg width={16} height={16} aria-hidden=\"true\" />\n        </span>\n      </button>\n      {menuNode}\n    </div>\n  );\n};\n"]}

package/lib/components/subscriptions/RefetchNeededBanner.css.d.ts

@@ -0,0 +1,5 @@
+export declare const root: string;
+export declare const content: string;
+export declare const title: string;
+export declare const message: string;
+//# sourceMappingURL=RefetchNeededBanner.css.d.ts.map

package/lib/components/subscriptions/RefetchNeededBanner.css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefetchNeededBanner.css.d.ts","sourceRoot":"","sources":["../../../src/components/subscriptions/RefetchNeededBanner.css.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,QAaf,CAAC;AAEH,eAAO,MAAM,OAAO,QAKlB,CAAC;AAEH,eAAO,MAAM,KAAK,QAIhB,CAAC;AAEH,eAAO,MAAM,OAAO,QAIlB,CAAC"}

package/lib/components/subscriptions/RefetchNeededBanner.css.js

@@ -0,0 +1,32 @@
+import { sprinkles } from '../../theme/sprinkles.css.js';
+export const root = sprinkles({
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    gap: 3,
+    paddingY: 3,
+    paddingX: 4,
+    borderRadius: 'md',
+    borderWidth: 'default',
+    borderStyle: 'solid',
+    borderColor: 'amber-200',
+    backgroundColor: 'amber-50',
+    color: 'amber-900',
+});
+export const content = sprinkles({
+    display: 'flex',
+    flexDirection: 'column',
+    gap: 1,
+    minWidth: 0,
+});
+export const title = sprinkles({
+    margin: 0,
+    fontWeight: 'semibold',
+    fontSize: 'sm',
+});
+export const message = sprinkles({
+    margin: 0,
+    fontSize: 'sm',
+    lineHeight: 1.4,
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXRjaE5lZWRlZEJhbm5lci5jc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29tcG9uZW50cy9zdWJzY3JpcHRpb25zL1JlZmV0Y2hOZWVkZWRCYW5uZXIuY3NzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUV6RCxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDO0lBQzVCLE9BQU8sRUFBRSxNQUFNO0lBQ2YsVUFBVSxFQUFFLFFBQVE7SUFDcEIsY0FBYyxFQUFFLGVBQWU7SUFDL0IsR0FBRyxFQUFFLENBQUM7SUFDTixRQUFRLEVBQUUsQ0FBQztJQUNYLFFBQVEsRUFBRSxDQUFDO0lBQ1gsWUFBWSxFQUFFLElBQUk7SUFDbEIsV0FBVyxFQUFFLFNBQVM7SUFDdEIsV0FBVyxFQUFFLE9BQU87SUFDcEIsV0FBVyxFQUFFLFdBQVc7SUFDeEIsZUFBZSxFQUFFLFVBQVU7SUFDM0IsS0FBSyxFQUFFLFdBQVc7Q0FDbkIsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLFNBQVMsQ0FBQztJQUMvQixPQUFPLEVBQUUsTUFBTTtJQUNmLGFBQWEsRUFBRSxRQUFRO0lBQ3ZCLEdBQUcsRUFBRSxDQUFDO0lBQ04sUUFBUSxFQUFFLENBQUM7Q0FDWixDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQUcsU0FBUyxDQUFDO0lBQzdCLE1BQU0sRUFBRSxDQUFDO0lBQ1QsVUFBVSxFQUFFLFVBQVU7SUFDdEIsUUFBUSxFQUFFLElBQUk7Q0FDZixDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDO0lBQy9CLE1BQU0sRUFBRSxDQUFDO0lBQ1QsUUFBUSxFQUFFLElBQUk7SUFDZCxVQUFVLEVBQUUsR0FBRztDQUNoQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzcHJpbmtsZXMgfSBmcm9tICcuLi8uLi90aGVtZS9zcHJpbmtsZXMuY3NzLmpzJztcblxuZXhwb3J0IGNvbnN0IHJvb3QgPSBzcHJpbmtsZXMoe1xuICBkaXNwbGF5OiAnZmxleCcsXG4gIGFsaWduSXRlbXM6ICdjZW50ZXInLFxuICBqdXN0aWZ5Q29udGVudDogJ3NwYWNlLWJldHdlZW4nLFxuICBnYXA6IDMsXG4gIHBhZGRpbmdZOiAzLFxuICBwYWRkaW5nWDogNCxcbiAgYm9yZGVyUmFkaXVzOiAnbWQnLFxuICBib3JkZXJXaWR0aDogJ2RlZmF1bHQnLFxuICBib3JkZXJTdHlsZTogJ3NvbGlkJyxcbiAgYm9yZGVyQ29sb3I6ICdhbWJlci0yMDAnLFxuICBiYWNrZ3JvdW5kQ29sb3I6ICdhbWJlci01MCcsXG4gIGNvbG9yOiAnYW1iZXItOTAwJyxcbn0pO1xuXG5leHBvcnQgY29uc3QgY29udGVudCA9IHNwcmlua2xlcyh7XG4gIGRpc3BsYXk6ICdmbGV4JyxcbiAgZmxleERpcmVjdGlvbjogJ2NvbHVtbicsXG4gIGdhcDogMSxcbiAgbWluV2lkdGg6IDAsXG59KTtcblxuZXhwb3J0IGNvbnN0IHRpdGxlID0gc3ByaW5rbGVzKHtcbiAgbWFyZ2luOiAwLFxuICBmb250V2VpZ2h0OiAnc2VtaWJvbGQnLFxuICBmb250U2l6ZTogJ3NtJyxcbn0pO1xuXG5leHBvcnQgY29uc3QgbWVzc2FnZSA9IHNwcmlua2xlcyh7XG4gIG1hcmdpbjogMCxcbiAgZm9udFNpemU6ICdzbScsXG4gIGxpbmVIZWlnaHQ6IDEuNCxcbn0pO1xuIl19

package/lib/components/subscriptions/RefetchNeededBanner.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from 'react';
+type Props = {
+    reason: string;
+    onReload: () => void;
+    className?: string;
+};
+export declare const RefetchNeededBanner: ({ reason, onReload, className, }: Props) => JSX.Element;
+export {};
+//# sourceMappingURL=RefetchNeededBanner.d.ts.map

package/lib/components/subscriptions/RefetchNeededBanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefetchNeededBanner.d.ts","sourceRoot":"","sources":["../../../src/components/subscriptions/RefetchNeededBanner.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,OAAO,CAAC;AAQjC,KAAK,KAAK,GAAG;IACX,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,kCAIjC,KAAK,KAAG,GAAG,CAAC,OAoBd,CAAC"}

package/lib/components/subscriptions/RefetchNeededBanner.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../atomic/atoms/button/Button.js';
+import { cx } from '../../theme/tools.js';
+import { useUiTranslation } from '../../i18n/useUiTranslation.js';
+import * as styles from './RefetchNeededBanner.css.js';
+export const RefetchNeededBanner = ({ reason, onReload, className, }) => {
+    const { t } = useUiTranslation();
+    let message = t('subscriptions.refetchNeeded.messages.default');
+    if (reason === 'CURSOR_REPLAY_UNAVAILABLE') {
+        message = t('subscriptions.refetchNeeded.messages.cursorReplayUnavailable');
+    }
+    else if (reason === 'BUFFER_OVERFLOW') {
+        message = t('subscriptions.refetchNeeded.messages.bufferOverflow');
+    }
+    return (_jsxs("div", { className: cx(styles.root, className), children: [_jsxs("div", { className: styles.content, children: [_jsx("p", { className: styles.title, children: t('subscriptions.refetchNeeded.title') }), _jsx("p", { className: styles.message, children: message })] }), _jsx(Button, { type: "button", variant: "secondary", size: "small", onClick: onReload, children: t('subscriptions.refetchNeeded.actions.reload') })] }));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/atomic/atoms/badge/Badge.js

@@ -1,17 +1,18 @@
-import { jsx as f } from "react/jsx-runtime";
-import { badge as i } from "./badge.css.js";
-import { cx as m } from "../../../theme/tools.js";
-const d = ({
-  children: o,
-  tone: r,
-  className: t,
-  loading: e = !1
-}) => {
-  let a = "off";
-  return e && (a = "on"), /* @__PURE__ */ f("span", { className: m(i({ tone: r, loading: a }), t), children: o });
+import { badge as e } from "./badge.css.js";
+import { cx as t } from "../../../theme/tools.js";
+import { jsx as n } from "react/jsx-runtime";
+//#region src/atomic/atoms/badge/Badge.tsx
+var r = ({ children: r, tone: i, className: a, loading: o = !1 }) => {
+	let s = "off";
+	return o && (s = "on"), /* @__PURE__ */ n("span", {
+		className: t(e({
+			tone: i,
+			loading: s
+		}), a),
+		children: r
+	});
 };
-export {
-  d as Badge,
-  d as default
-};
-//# sourceMappingURL=Badge.js.map
+//#endregion
+export { r as Badge, r as default };
+
+//# sourceMappingURL=Badge.js.map

package/lib/esm/atomic/atoms/badge/Badge.js.map

@@ -1 +1 @@
-{"version":3,"file":"Badge.js","sources":["../../../../../src/atomic/atoms/badge/Badge.tsx"],"sourcesContent":["import { type JSX, type ReactNode } from 'react';\n\nimport { badge } from './badge.css.js';\nimport { cx } from '../../../theme/tools.js';\n\ntype Props = {\n  children: ReactNode;\n  tone?: BadgeTone;\n  className?: string;\n  loading?: boolean;\n};\n\ntype BadgeTone =\n  | 'neutral'\n  | 'info'\n  | 'success'\n  | 'warning'\n  | 'danger'\n  | 'accent';\n\nexport const Badge = ({\n  children,\n  tone,\n  className,\n  loading = false,\n}: Props): JSX.Element => {\n  let loadingVariant: 'on' | 'off' = 'off';\n  if (loading) {\n    loadingVariant = 'on';\n  }\n\n  return (\n    <span className={cx(badge({ tone, loading: loadingVariant }), className)}>\n      {children}\n    </span>\n  );\n};\n\nexport default Badge;\n"],"names":["Badge","children","tone","className","loading","loadingVariant","jsx","cx","badge"],"mappings":";;;AAoBO,MAAMA,IAAQ,CAAC;AAAA,EACpB,UAAAC;AAAA,EACA,MAAAC;AAAA,EACA,WAAAC;AAAA,EACA,SAAAC,IAAU;AACZ,MAA0B;AACxB,MAAIC,IAA+B;AACnC,SAAID,MACFC,IAAiB,OAIjB,gBAAAC,EAAC,QAAA,EAAK,WAAWC,EAAGC,EAAM,EAAE,MAAAN,GAAM,SAASG,EAAA,CAAgB,GAAGF,CAAS,GACpE,UAAAF,EAAA,CACH;AAEJ;"}
+{"version":3,"file":"Badge.js","names":[],"sources":["../../../../../src/atomic/atoms/badge/Badge.tsx"],"sourcesContent":["import { type JSX, type ReactNode } from 'react';\n\nimport { badge } from './badge.css.js';\nimport { cx } from '../../../theme/tools.js';\n\ntype Props = {\n  children: ReactNode;\n  tone?: BadgeTone;\n  className?: string;\n  loading?: boolean;\n};\n\ntype BadgeTone =\n  | 'neutral'\n  | 'info'\n  | 'success'\n  | 'warning'\n  | 'danger'\n  | 'accent';\n\nexport const Badge = ({\n  children,\n  tone,\n  className,\n  loading = false,\n}: Props): JSX.Element => {\n  let loadingVariant: 'on' | 'off' = 'off';\n  if (loading) {\n    loadingVariant = 'on';\n  }\n\n  return (\n    <span className={cx(badge({ tone, loading: loadingVariant }), className)}>\n      {children}\n    </span>\n  );\n};\n\nexport default Badge;\n"],"mappings":";;;;AAoBA,IAAa,KAAS,EACpB,aACA,SACA,cACA,aAAU,SACc;CACxB,IAAI,IAA+B;AAKnC,QAJI,MACF,IAAiB,OAIjB,kBAAC,QAAD;EAAM,WAAW,EAAG,EAAM;GAAE;GAAM,SAAS;GAAgB,CAAC,EAAE,EAAU;EACrE;EACI,CAAA"}