entangle-ui 0.8.2 → 0.10.0

package/dist/esm/components/controls/FileTree/useFileTreeDrop.js

@@ -0,0 +1,115 @@
+"use client";
+import { useState, useCallback } from 'react';
+import '../../../utils/devWarn.js';
+import { useLatest } from '../../../hooks/useLatest/useLatest.js';
+import '../../../hooks/useBreakpoint/useBreakpoint.js';
+import './../../../assets/src/theme/lightTheme.css.ts.vanilla-Ct6f9Iym.css';
+import '../../../node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js';
+import './../../../assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
+import 'react/jsx-runtime';
+import './../../../assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
+import '../../../hooks/useNavigationHistory/useNavigationHistory.js';
+
+/** True when the drag carries OS files (vs. a text/element drag). */
+function hasFiles(event) {
+    return Array.from(event.dataTransfer.types).includes('Files');
+}
+/** True when the drag is leaving the element entirely (not into a descendant). */
+function leftElement(event) {
+    const related = event.relatedTarget;
+    return !(related && event.currentTarget.contains(related));
+}
+function extractFiles(event) {
+    return Array.from(event.dataTransfer.files);
+}
+/**
+ * External file-import drag-and-drop for FileTree. Per-node `dragover` resolves
+ * (and highlights) the destination folder and stops propagation; the container
+ * handles drops on empty space (→ root) and clears the highlight when the drag
+ * leaves the tree, so there's no row-to-row flicker. All handlers have stable
+ * identities and read the latest props through `useLatest` (patterns #3 / #11).
+ */
+function useFileTreeDrop({ onImport, nodeById, parentFolderById, }) {
+    // `null` = no active target; otherwise the destination folder id (`null`
+    // folderId = the tree root).
+    const [target, setTarget] = useState(null);
+    const onImportRef = useLatest(onImport);
+    const nodeByIdRef = useLatest(nodeById);
+    const parentFolderByIdRef = useLatest(parentFolderById);
+    const enabled = onImport !== undefined;
+    /** The folder a drop on `node` should target (a folder targets itself; a file
+     * targets its parent folder, or the root). */
+    const resolveTargetFolder = useCallback((nodeId) => {
+        const node = nodeByIdRef.current.get(nodeId);
+        if (node?.kind === 'folder')
+            return node;
+        return parentFolderByIdRef.current.get(nodeId) ?? null;
+    }, [nodeByIdRef, parentFolderByIdRef]);
+    const setTargetFolder = useCallback((folderId) => {
+        setTarget(prev => prev !== null && prev.folderId === folderId ? prev : { folderId });
+    }, []);
+    const clearTarget = useCallback(() => {
+        setTarget(prev => (prev === null ? prev : null));
+    }, []);
+    const onNodeDragOver = useCallback((node, event) => {
+        if (onImportRef.current === undefined || !hasFiles(event))
+            return;
+        event.preventDefault();
+        // Owned by the row — keep the container from re-targeting the root.
+        event.stopPropagation();
+        event.dataTransfer.dropEffect = 'copy';
+        setTargetFolder(resolveTargetFolder(node.id)?.id ?? null);
+    }, [onImportRef, resolveTargetFolder, setTargetFolder]);
+    const onNodeDrop = useCallback((node, event) => {
+        const onImportCb = onImportRef.current;
+        if (onImportCb === undefined)
+            return;
+        const files = extractFiles(event);
+        if (files.length === 0) {
+            clearTarget();
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        onImportCb({ files, targetFolder: resolveTargetFolder(node.id) });
+        clearTarget();
+    }, [onImportRef, resolveTargetFolder, clearTarget]);
+    const onRootDragOver = useCallback((event) => {
+        if (onImportRef.current === undefined || !hasFiles(event))
+            return;
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'copy';
+        setTargetFolder(null);
+    }, [onImportRef, setTargetFolder]);
+    const onRootDragLeave = useCallback((event) => {
+        if (!leftElement(event))
+            return;
+        clearTarget();
+    }, [clearTarget]);
+    const onRootDrop = useCallback((event) => {
+        const onImportCb = onImportRef.current;
+        if (onImportCb === undefined)
+            return;
+        const files = extractFiles(event);
+        if (files.length === 0) {
+            clearTarget();
+            return;
+        }
+        event.preventDefault();
+        onImportCb({ files, targetFolder: null });
+        clearTarget();
+    }, [onImportRef, clearTarget]);
+    return {
+        enabled,
+        dropTargetId: target?.folderId ?? null,
+        rootActive: target !== null && target.folderId === null,
+        onNodeDragOver,
+        onNodeDrop,
+        onRootDragOver,
+        onRootDragLeave,
+        onRootDrop,
+    };
+}
+
+export { useFileTreeDrop };
+//# sourceMappingURL=useFileTreeDrop.js.map

package/dist/esm/components/controls/FileTree/useFileTreeDrop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFileTreeDrop.js","sources":["../../../../../../src/components/controls/FileTree/useFileTreeDrop.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAoCA;AACA;AACE;AACF;AAEA;AACA;AACE;AACA;AACF;AAEA;;AAEA;AAEA;;;;;;AAMG;AACG;;;;AAWJ;AACA;AACA;AAEA;AAEA;AAC8C;AAC9C;;AAGI;AAA6B;;AAE/B;AAIF;;;AAMA;AACE;;;;;;;;AASE;AACA;;;AAOA;;;AAEA;AACA;AACE;;;;;AAKF;AACA;;AAKJ;;;;AAII;;AAEF;AAIF;AAEI;;AACA;AACF;AAIF;AAEI;;;AAEA;AACA;AACE;;;;;AAKF;AACF;;;AAMA;;;;;;;;AAQJ;;"}

package/dist/esm/components/controls/FileUploader/FileUploader.css.js

@@ -0,0 +1,20 @@
+import './../../../assets/src/components/controls/FileUploader/FileUploader.css.ts.vanilla-T4nRiI7s.css';
+import { createRuntimeFn } from '@vanilla-extract/recipes/createRuntimeFn';
+
+var containerStyle = 'FileUploader_containerStyle__yf371x0';
+var dropZoneHintStyle = 'FileUploader_dropZoneHintStyle__yf371xc';
+var dropZonePrimaryStyle = 'FileUploader_dropZonePrimaryStyle__yf371xb';
+var dropZoneRecipe = createRuntimeFn({defaultClassName:'FileUploader_dropZoneRecipe__yf371x1',variantClassNames:{size:{sm:'FileUploader_dropZoneRecipe_size_sm__yf371x2',md:'FileUploader_dropZoneRecipe_size_md__yf371x3',lg:'FileUploader_dropZoneRecipe_size_lg__yf371x4'},dragging:{true:'FileUploader_dropZoneRecipe_dragging_true__yf371x5',false:'FileUploader_dropZoneRecipe_dragging_false__yf371x6'},disabled:{true:'FileUploader_dropZoneRecipe_disabled_true__yf371x7',false:'FileUploader_dropZoneRecipe_disabled_false__yf371x8'},error:{true:'FileUploader_dropZoneRecipe_error_true__yf371x9',false:'FileUploader_dropZoneRecipe_error_false__yf371xa'}},defaultVariants:{size:'md',dragging:false,disabled:false,error:false},compoundVariants:[]});
+var fileListStyle = 'FileUploader_fileListStyle__yf371xe';
+var fileMetaStyle = 'FileUploader_fileMetaStyle__yf371xk';
+var fileNameStyle = 'FileUploader_fileNameStyle__yf371xl';
+var fileRowRecipe = createRuntimeFn({defaultClassName:'FileUploader_fileRowRecipe__yf371xf',variantClassNames:{status:{pending:'FileUploader_fileRowRecipe_status_pending__yf371xg',uploading:'FileUploader_fileRowRecipe_status_uploading__yf371xh',done:'FileUploader_fileRowRecipe_status_done__yf371xi',error:'FileUploader_fileRowRecipe_status_error__yf371xj'}},defaultVariants:{status:'pending'},compoundVariants:[]});
+var fileSubStyle = 'FileUploader_fileSubStyle__yf371xm';
+var hiddenInputStyle = 'FileUploader_hiddenInputStyle__yf371xd';
+var progressBarStyle = 'FileUploader_progressBarStyle__yf371xn';
+var progressFillRecipe = createRuntimeFn({defaultClassName:'FileUploader_progressFillRecipe__yf371xo',variantClassNames:{status:{pending:'FileUploader_progressFillRecipe_status_pending__yf371xp',uploading:'FileUploader_progressFillRecipe_status_uploading__yf371xq',done:'FileUploader_progressFillRecipe_status_done__yf371xr',error:'FileUploader_progressFillRecipe_status_error__yf371xs'}},defaultVariants:{status:'uploading'},compoundVariants:[]});
+var removeButtonStyle = 'FileUploader_removeButtonStyle__yf371xt';
+var statusBadgeRecipe = createRuntimeFn({defaultClassName:'FileUploader_statusBadgeRecipe__yf371xu',variantClassNames:{status:{pending:'FileUploader_statusBadgeRecipe_status_pending__yf371xv',uploading:'FileUploader_statusBadgeRecipe_status_uploading__yf371xw',done:'FileUploader_statusBadgeRecipe_status_done__yf371xx',error:'FileUploader_statusBadgeRecipe_status_error__yf371xy'}},defaultVariants:{status:'pending'},compoundVariants:[]});
+
+export { containerStyle, dropZoneHintStyle, dropZonePrimaryStyle, dropZoneRecipe, fileListStyle, fileMetaStyle, fileNameStyle, fileRowRecipe, fileSubStyle, hiddenInputStyle, progressBarStyle, progressFillRecipe, removeButtonStyle, statusBadgeRecipe };
+//# sourceMappingURL=FileUploader.css.js.map

package/dist/esm/components/controls/FileUploader/FileUploader.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileUploader.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/components/controls/FileUploader/FileUploader.js

@@ -0,0 +1,261 @@
+"use client";
+import { jsxs, jsx } from 'react/jsx-runtime';
+import React, { useId, useRef, useState, useCallback, useMemo } from 'react';
+import { FormHelperText } from '../../form/FormHelperText.js';
+import { FormLabel } from '../../form/FormLabel.js';
+import { CloudUploadIcon } from '../../Icons/CloudUploadIcon.js';
+import { TrashIcon } from '../../Icons/TrashIcon.js';
+import { useControlledState } from '../../../hooks/useControlledState/useControlledState.js';
+import { useMergedRef } from '../../../hooks/useMergedRef/useMergedRef.js';
+import { cx } from '../../../utils/cx.js';
+import { dropZonePrimaryStyle, dropZoneHintStyle, hiddenInputStyle, dropZoneRecipe, fileListStyle, containerStyle, fileMetaStyle, fileNameStyle, fileSubStyle, statusBadgeRecipe, progressBarStyle, progressFillRecipe, removeButtonStyle, fileRowRecipe } from './FileUploader.css.js';
+
+let __fileUploaderIdCounter = 0;
+function nextFileId() {
+    __fileUploaderIdCounter += 1;
+    return `eui-file-${String(Date.now())}-${String(__fileUploaderIdCounter)}`;
+}
+const SIZE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return '';
+    if (bytes === 0)
+        return '0 B';
+    const exponent = Math.min(SIZE_UNITS.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+    const value = bytes / Math.pow(1024, exponent);
+    const formatted = value >= 100 || exponent === 0 ? value.toFixed(0) : value.toFixed(1);
+    return `${formatted} ${SIZE_UNITS[exponent] ?? ''}`;
+}
+function fileMatchesAccept(file, accept) {
+    const tokens = accept
+        .split(',')
+        .map(t => t.trim().toLowerCase())
+        .filter(Boolean);
+    if (tokens.length === 0)
+        return true;
+    const name = file.name.toLowerCase();
+    const type = file.type.toLowerCase();
+    for (const token of tokens) {
+        if (token.startsWith('.')) {
+            if (name.endsWith(token))
+                return true;
+        }
+        else if (token.endsWith('/*')) {
+            const prefix = token.slice(0, -2);
+            if (type.startsWith(`${prefix}/`))
+                return true;
+        }
+        else if (token === type) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Drag-and-drop file uploader with click-to-browse fallback. Renders a list
+ * of uploaded items with per-file status (`pending` / `uploading` / `done` /
+ * `error`) and an animated progress bar.
+ *
+ * The component itself is purely presentational around the file list — it
+ * does not perform the actual upload. The consumer is expected to:
+ *   1. Listen to `onFilesAdd` (or `onChange`) to know which files were
+ *      accepted by the uploader.
+ *   2. Drive the upload (fetch / XHR / SDK) externally.
+ *   3. Reflect progress back into the component by passing a controlled
+ *      `value` and updating the `status` / `progress` of each item.
+ *
+ * @example
+ * ```tsx
+ * const [items, setItems] = useState<FileUploaderItem[]>([]);
+ * <FileUploader
+ *   value={items}
+ *   onChange={setItems}
+ *   accept="image/*,.pdf"
+ *   maxSize={5 * 1024 * 1024}
+ *   onFilesAdd={files => uploadAll(files, setItems)}
+ * />
+ * ```
+ */
+function FileUploader({ value, defaultValue, onChange, onFilesAdd, onFileRemove, onReject, accept, multiple = true, maxFiles, maxSize, minSize, validate, renderItem, size = 'md', label, helperText, error = false, errorMessage, disabled = false, required = false, dropZoneText = 'Drag files here or click to browse', dropZoneHint, name, className, style, testId, id: idProp, ref, ...rest }) {
+    const autoId = useId();
+    const fieldId = idProp ?? autoId;
+    const labelId = `${fieldId}-label`;
+    const helperId = `${fieldId}-helper`;
+    const inputRef = useRef(null);
+    const dropZoneRef = useRef(null);
+    const containerRef = useRef(null);
+    const setContainerRef = useMergedRef(containerRef, ref);
+    const [items, setItems] = useControlledState({
+        value,
+        defaultValue,
+        onChange,
+        fallback: [],
+    });
+    const [dragging, setDragging] = useState(false);
+    const dragCounterRef = useRef(0);
+    const validateFile = useCallback((file, currentCount) => {
+        if (typeof maxFiles === 'number' && currentCount >= maxFiles) {
+            return 'max-files';
+        }
+        if (accept && !fileMatchesAccept(file, accept)) {
+            return 'wrong-type';
+        }
+        if (typeof maxSize === 'number' && file.size > maxSize) {
+            return 'too-large';
+        }
+        if (typeof minSize === 'number' && file.size < minSize) {
+            return 'too-small';
+        }
+        if (validate) {
+            const result = validate(file);
+            if (result === false)
+                return 'invalid';
+            if (typeof result === 'string')
+                return result;
+        }
+        return null;
+    }, [accept, maxFiles, maxSize, minSize, validate]);
+    const acceptFiles = useCallback((incoming) => {
+        if (incoming.length === 0)
+            return;
+        const accepted = [];
+        const newItems = [];
+        let count = items.length;
+        const list = multiple ? incoming : incoming.slice(0, 1);
+        for (const file of list) {
+            const rejection = validateFile(file, count);
+            if (rejection) {
+                onReject?.(file, rejection);
+                continue;
+            }
+            accepted.push(file);
+            newItems.push({
+                id: nextFileId(),
+                file,
+                status: 'pending',
+            });
+            count += 1;
+        }
+        if (newItems.length === 0)
+            return;
+        // In single mode, replace any existing item.
+        const next = multiple ? [...items, ...newItems] : newItems;
+        setItems(next);
+        onFilesAdd?.(accepted);
+    }, [items, multiple, onFilesAdd, onReject, setItems, validateFile]);
+    const removeAt = useCallback((index) => {
+        if (index < 0 || index >= items.length)
+            return;
+        const removed = items[index];
+        const next = items.slice(0, index).concat(items.slice(index + 1));
+        setItems(next);
+        if (removed)
+            onFileRemove?.(removed);
+    }, [items, onFileRemove, setItems]);
+    const handleInputChange = useCallback((event) => {
+        const list = event.target.files;
+        if (!list)
+            return;
+        acceptFiles(Array.from(list));
+        // Reset so selecting the same file again still fires onChange.
+        event.target.value = '';
+    }, [acceptFiles]);
+    const openPicker = useCallback(() => {
+        if (disabled)
+            return;
+        inputRef.current?.click();
+    }, [disabled]);
+    const handleZoneKeyDown = useCallback((event) => {
+        if (disabled)
+            return;
+        if (event.key === 'Enter' || event.key === ' ') {
+            event.preventDefault();
+            openPicker();
+        }
+    }, [disabled, openPicker]);
+    const handleDragEnter = useCallback((event) => {
+        if (disabled)
+            return;
+        event.preventDefault();
+        dragCounterRef.current += 1;
+        if (dragCounterRef.current === 1)
+            setDragging(true);
+    }, [disabled]);
+    const handleDragOver = useCallback((event) => {
+        if (disabled)
+            return;
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'copy';
+    }, [disabled]);
+    const handleDragLeave = useCallback((event) => {
+        if (disabled)
+            return;
+        event.preventDefault();
+        dragCounterRef.current = Math.max(0, dragCounterRef.current - 1);
+        if (dragCounterRef.current === 0)
+            setDragging(false);
+    }, [disabled]);
+    const handleDrop = useCallback((event) => {
+        if (disabled)
+            return;
+        event.preventDefault();
+        dragCounterRef.current = 0;
+        setDragging(false);
+        const dt = event.dataTransfer;
+        const dropped = [];
+        if (dt.files.length > 0) {
+            dropped.push(...Array.from(dt.files));
+        }
+        else if (dt.items.length > 0) {
+            for (const item of Array.from(dt.items)) {
+                if (item.kind === 'file') {
+                    const f = item.getAsFile();
+                    if (f)
+                        dropped.push(f);
+                }
+            }
+        }
+        acceptFiles(dropped);
+    }, [acceptFiles, disabled]);
+    const showHelperText = error && errorMessage ? errorMessage : helperText;
+    const renderRow = (item, index) => {
+        if (renderItem) {
+            return (jsx(React.Fragment, { children: renderItem({
+                    item,
+                    index,
+                    disabled,
+                    remove: () => {
+                        removeAt(index);
+                    },
+                }) }, item.id));
+        }
+        const progress = Math.max(0, Math.min(100, item.progress ?? 0));
+        const sub = item.errorMessage ?? formatBytes(item.file.size);
+        return (jsxs("div", { className: fileRowRecipe({ status: item.status }), "data-testid": testId ? `${testId}-item-${item.id}` : undefined, children: [jsxs("div", { className: fileMetaStyle, children: [jsx("span", { className: fileNameStyle, title: item.file.name, children: item.file.name }), jsxs("span", { className: fileSubStyle, children: [jsx("span", { className: statusBadgeRecipe({ status: item.status }), children: item.status }), jsx("span", { children: sub })] }), (item.status === 'uploading' ||
+                            (item.status === 'pending' && progress > 0)) && (jsx("div", { className: progressBarStyle, "aria-hidden": "true", children: jsx("div", { className: progressFillRecipe({ status: item.status }), style: { width: `${String(progress)}%` } }) }))] }), jsx("button", { type: "button", className: removeButtonStyle, "aria-label": `Remove ${item.file.name}`, disabled: disabled, onClick: () => {
+                        removeAt(index);
+                    }, children: jsx(TrashIcon, { size: "sm", decorative: true }) })] }, item.id));
+    };
+    const acceptHint = useMemo(() => {
+        if (dropZoneHint !== undefined)
+            return dropZoneHint;
+        const parts = [];
+        if (accept)
+            parts.push(accept);
+        if (typeof maxSize === 'number')
+            parts.push(`up to ${formatBytes(maxSize)}`);
+        if (typeof maxFiles === 'number')
+            parts.push(`max ${String(maxFiles)} files`);
+        return parts.length > 0 ? parts.join(' • ') : null;
+    }, [accept, dropZoneHint, maxFiles, maxSize]);
+    return (jsxs("div", { ref: setContainerRef, className: cx(containerStyle, className), style: style, "data-testid": testId, ...rest, children: [label && (jsx(FormLabel, { id: labelId, htmlFor: fieldId, required: required, disabled: disabled, children: label })), jsxs("div", { ref: dropZoneRef, role: "button", tabIndex: disabled ? -1 : 0, "aria-disabled": disabled || undefined, "aria-labelledby": label ? labelId : undefined, "aria-describedby": showHelperText ? helperId : undefined, className: dropZoneRecipe({
+                    size,
+                    dragging,
+                    disabled,
+                    error,
+                }), onClick: openPicker, onKeyDown: handleZoneKeyDown, onDragEnter: handleDragEnter, onDragOver: handleDragOver, onDragLeave: handleDragLeave, onDrop: handleDrop, "data-testid": testId ? `${testId}-dropzone` : undefined, children: [jsx(CloudUploadIcon, { size: size === 'lg' ? 32 : size === 'sm' ? 18 : 24, decorative: true }), jsx("span", { className: dropZonePrimaryStyle, children: dropZoneText }), acceptHint && jsx("span", { className: dropZoneHintStyle, children: acceptHint }), jsx("input", { ref: inputRef, id: fieldId, type: "file", name: name, accept: accept, multiple: multiple, required: required, disabled: disabled, onChange: handleInputChange, className: hiddenInputStyle, "aria-hidden": "true", tabIndex: -1, "data-testid": testId ? `${testId}-input` : undefined })] }), items.length > 0 && (jsx("div", { className: fileListStyle, children: items.map((item, idx) => renderRow(item, idx)) })), showHelperText && (jsx(FormHelperText, { id: helperId, error: error, children: showHelperText }))] }));
+}
+FileUploader.displayName = 'FileUploader';
+
+export { FileUploader };
+//# sourceMappingURL=FileUploader.js.map

package/dist/esm/components/controls/FileUploader/FileUploader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileUploader.js","sources":["../../../../../../src/components/controls/FileUploader/FileUploader.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAmCA;AACA;;AAEE;AACF;AAEA;AAEA;;AAC4C;;AACzB;AACjB;AAIA;;;AAIF;AAEA;;;AAGK;;AAEH;AAAyB;;;AAKzB;AACE;AACE;AAA0B;;AACrB;;AAEL;AAAmC;;AAC9B;AACL;;;AAGJ;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;;AAgCD;AACA;AACA;AACA;AAEA;AACA;AACA;;AAGA;;;;AAIE;AACD;;AAGD;;;AAKM;;;AAGA;;;AAGA;;;AAGA;;;AAGA;;AACsB;;AACU;;AAElC;AACF;AAIF;AAEI;;;;AAGA;AAEA;AAEA;;;AAGI;;;AAGF;;;;AAIE;AACD;;;AAIH;;;AAGA;;AAEA;AACF;AAIF;;;AAGI;;;AAGA;AAAa;;AAKjB;AAEI;AACA;;;;AAGA;AACF;AAIF;AACE;;AACA;AACF;AAEA;AAEI;;AACA;;AAEE;;AAEJ;AAIF;AAEI;;;AAEA;AACA;;AACF;AAIF;AAEI;;;AAEA;AACF;AAIF;AAEI;;;AAEA;AACA;;AACF;AAIF;AAEI;;;AAEA;;AAEA;;;AAGE;;;AAEA;AACE;AACE;AACA;AAAO;;;;;AAKf;AAIF;AAEA;;AAEI;;;;;;;AASK;;;AAMP;AAEA;AAiBQ;;AAgBF;AAMR;AAEA;;AACkC;;AAEhC;AAAY;;;;;AAKZ;;;;;;;;AAgFJ;AAEA;;"}

package/dist/esm/components/controls/MultiSelect/MultiSelect.css.js

@@ -0,0 +1,23 @@
+import './../../../assets/src/components/controls/MultiSelect/MultiSelect.css.ts.vanilla-CdYayqaF.css';
+import { createRuntimeFn } from '@vanilla-extract/recipes/createRuntimeFn';
+
+var checkboxRecipe = createRuntimeFn({defaultClassName:'MultiSelect_checkboxRecipe__1a6uxqy1e',variantClassNames:{selected:{true:'MultiSelect_checkboxRecipe_selected_true__1a6uxqy1f',false:'MultiSelect_checkboxRecipe_selected_false__1a6uxqy1g'}},defaultVariants:{selected:false},compoundVariants:[]});
+var chevronRecipe = createRuntimeFn({defaultClassName:'MultiSelect_chevronRecipe__1a6uxqyy',variantClassNames:{open:{true:'MultiSelect_chevronRecipe_open_true__1a6uxqyz',false:'MultiSelect_chevronRecipe_open_false__1a6uxqy10'}},defaultVariants:{open:false},compoundVariants:[]});
+var chipLabelStyle = 'MultiSelect_chipLabelStyle__1a6uxqyt';
+var chipRecipe = createRuntimeFn({defaultClassName:'MultiSelect_chipRecipe__1a6uxqyp',variantClassNames:{size:{sm:'MultiSelect_chipRecipe_size_sm__1a6uxqyq',md:'MultiSelect_chipRecipe_size_md__1a6uxqyr',lg:'MultiSelect_chipRecipe_size_lg__1a6uxqys'}},defaultVariants:{size:'md'},compoundVariants:[]});
+var chipRemoveStyle = 'MultiSelect_chipRemoveStyle__1a6uxqyu';
+var clearButtonStyle = 'MultiSelect_clearButtonStyle__1a6uxqyx';
+var containerStyle = 'MultiSelect_containerStyle__1a6uxqy0';
+var dropdownStyle = 'MultiSelect_dropdownStyle__1a6uxqy12';
+var emptyMessageStyle = 'MultiSelect_emptyMessageStyle__1a6uxqy1d';
+var groupLabelStyle = 'MultiSelect_groupLabelStyle__1a6uxqy1c';
+var moreBadgeStyle = 'MultiSelect_moreBadgeStyle__1a6uxqyv';
+var optionItemRecipe = createRuntimeFn({defaultClassName:'MultiSelect_optionItemRecipe__1a6uxqy15',variantClassNames:{active:{true:'MultiSelect_optionItemRecipe_active_true__1a6uxqy16',false:'MultiSelect_optionItemRecipe_active_false__1a6uxqy17'},selected:{true:'MultiSelect_optionItemRecipe_selected_true__1a6uxqy18',false:'MultiSelect_optionItemRecipe_selected_false__1a6uxqy19'},disabled:{true:'MultiSelect_optionItemRecipe_disabled_true__1a6uxqy1a',false:'MultiSelect_optionItemRecipe_disabled_false__1a6uxqy1b'}},defaultVariants:{active:false,selected:false,disabled:false},compoundVariants:[]});
+var optionsListStyle = 'MultiSelect_optionsListStyle__1a6uxqy14';
+var placeholderStyle = 'MultiSelect_placeholderStyle__1a6uxqyw';
+var searchInputStyle = 'MultiSelect_searchInputStyle__1a6uxqy13';
+var triggerContentStyle = 'MultiSelect_triggerContentStyle__1a6uxqyo';
+var triggerRecipe = createRuntimeFn({defaultClassName:'MultiSelect_triggerRecipe__1a6uxqy1',variantClassNames:{size:{sm:'MultiSelect_triggerRecipe_size_sm__1a6uxqy2',md:'MultiSelect_triggerRecipe_size_md__1a6uxqy3',lg:'MultiSelect_triggerRecipe_size_lg__1a6uxqy4'},variant:{'default':'MultiSelect_triggerRecipe_variant_default__1a6uxqy5',ghost:'MultiSelect_triggerRecipe_variant_ghost__1a6uxqy6',filled:'MultiSelect_triggerRecipe_variant_filled__1a6uxqy7'},open:{true:'MultiSelect_triggerRecipe_open_true__1a6uxqy8',false:'MultiSelect_triggerRecipe_open_false__1a6uxqy9'},error:{true:'MultiSelect_triggerRecipe_error_true__1a6uxqya',false:'MultiSelect_triggerRecipe_error_false__1a6uxqyb'},disabled:{true:'MultiSelect_triggerRecipe_disabled_true__1a6uxqyc',false:'MultiSelect_triggerRecipe_disabled_false__1a6uxqyd'},empty:{true:'MultiSelect_triggerRecipe_empty_true__1a6uxqye',false:'MultiSelect_triggerRecipe_empty_false__1a6uxqyf'}},defaultVariants:{size:'md',variant:'default',open:false,disabled:false,error:false,empty:true},compoundVariants:[[{open:true},'MultiSelect_triggerRecipe_compound_0__1a6uxqyg'],[{error:true,variant:'default'},'MultiSelect_triggerRecipe_compound_1__1a6uxqyh'],[{error:true,variant:'filled'},'MultiSelect_triggerRecipe_compound_2__1a6uxqyi'],[{open:true,variant:'default'},'MultiSelect_triggerRecipe_compound_3__1a6uxqyj'],[{open:true,variant:'filled'},'MultiSelect_triggerRecipe_compound_4__1a6uxqyk'],[{empty:true,variant:'default'},'MultiSelect_triggerRecipe_compound_5__1a6uxqyl'],[{empty:true,variant:'ghost'},'MultiSelect_triggerRecipe_compound_6__1a6uxqym'],[{empty:true,variant:'filled'},'MultiSelect_triggerRecipe_compound_7__1a6uxqyn']]});
+
+export { checkboxRecipe, chevronRecipe, chipLabelStyle, chipRecipe, chipRemoveStyle, clearButtonStyle, containerStyle, dropdownStyle, emptyMessageStyle, groupLabelStyle, moreBadgeStyle, optionItemRecipe, optionsListStyle, placeholderStyle, searchInputStyle, triggerContentStyle, triggerRecipe };
+//# sourceMappingURL=MultiSelect.css.js.map

package/dist/esm/components/controls/MultiSelect/MultiSelect.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiSelect.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}