@pathscale/ui 1.3.1 → 1.4.0

package/dist/components/toolbar/Toolbar.recipe.d.ts

@@ -0,0 +1,17 @@
+export declare const CLASSES: {
+    readonly base: "toolbar";
+    readonly orientation: {
+        readonly horizontal: "toolbar--horizontal";
+        readonly vertical: "toolbar--vertical";
+    };
+    readonly flag: {
+        readonly attached: "toolbar--attached";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "toolbar";
+    readonly slots: {
+        readonly root: {};
+        readonly toolbar: {};
+    };
+}>;

package/dist/components/toolbar/Toolbar.recipe.js

@@ -0,0 +1,36 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    base: "toolbar",
+    orientation: {
+        horizontal: "toolbar--horizontal",
+        vertical: "toolbar--vertical"
+    },
+    flag: {
+        attached: "toolbar--attached"
+    }
+};
+const componentRecipe = recipe({
+    component: "toolbar",
+    slots: {
+        root: {},
+        toolbar: {}
+    },
+    _layouts: {
+        slots: {
+            root: {
+                base: "",
+                axes: {}
+            },
+            toolbar: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            root: 0,
+            toolbar: 1
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/toolbar/index.d.ts

@@ -1 +1 @@
-export { default, Toolbar, ToolbarRoot, type ToolbarProps, type ToolbarRootProps, type ToolbarOrientation, } from "./Toolbar";
+export { default, Toolbar, ToolbarRoot, type ToolbarProps, type ToolbarRootProps, type ToolbarOrientation, } from "./Toolbar.generated";

package/dist/components/toolbar/index.js

@@ -1 +1 @@
-export { Toolbar, ToolbarRoot, default } from "./Toolbar.js";
+export { Toolbar, ToolbarRoot, default } from "./Toolbar.generated.js";

package/dist/components/tooltip/Tooltip.generated.d.ts

@@ -0,0 +1,39 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./Tooltip.css";
+import { type JSX } from "solid-js";
+import { type OverlayPlacement } from "../_shared/overlayPosition";
+import type { IComponentBaseProps } from "../types";
+export type TooltipPlacement = OverlayPlacement;
+export type TooltipRootProps = IComponentBaseProps & {
+    children: JSX.Element;
+    placement?: TooltipPlacement;
+    autoFlip?: boolean;
+    sideOffset?: number;
+    showArrow?: boolean;
+    delay?: number;
+    closeDelay?: number;
+    isOpen?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+};
+export type TooltipTriggerProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
+    children: JSX.Element;
+};
+export type TooltipContentProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
+    children: JSX.Element;
+};
+export type TooltipArrowProps = JSX.HTMLAttributes<HTMLSpanElement> & IComponentBaseProps & {
+    children?: JSX.Element;
+};
+declare const TooltipRoot: __LayoutComponent<TooltipRootProps>;
+declare const TooltipTrigger: __LayoutComponent<TooltipTriggerProps>;
+declare const TooltipContent: __LayoutComponent<TooltipContentProps>;
+declare const TooltipArrow: __LayoutComponent<TooltipArrowProps>;
+declare const Tooltip: __LayoutComponent<TooltipRootProps> & {
+    Root: __LayoutComponent<TooltipRootProps>;
+    Trigger: __LayoutComponent<TooltipTriggerProps>;
+    Content: __LayoutComponent<TooltipContentProps>;
+    Arrow: __LayoutComponent<TooltipArrowProps>;
+};
+export default Tooltip;
+export { TooltipRoot, TooltipTrigger, TooltipContent, TooltipArrow };

package/dist/components/tooltip/Tooltip.generated.js

@@ -0,0 +1,292 @@
+import { Portal, createComponent, insert, mergeProps, spread, template, use } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./Tooltip.css";
+import { Show, createContext, createEffect, createSignal, onCleanup, splitProps, useContext } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { createOverlayPosition } from "../_shared/overlayPosition.js";
+import { CLASSES, componentRecipe } from "./Tooltip.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<span>"), _tmpl$2 = /*#__PURE__*/ template("<div>"), _tmpl$3 = /*#__PURE__*/ template('<svg aria-hidden=true data-slot=tooltip-arrow-svg height=12 viewBox="0 0 12 12"width=12 xmlns=http://www.w3.org/2000/svg><path d="M0 0C5.48483 8 6.5 8 12 0Z"fill=currentColor>');
+const TooltipContext = createContext();
+const useTooltipContext = ()=>{
+    const ctx = useContext(TooltipContext);
+    if (!ctx) throw new Error("Tooltip compound components must be used within <Tooltip>");
+    return ctx;
+};
+const __solidLayoutTooltipRoot = (_stable, p)=>{
+    const [local, _others] = splitProps(p, [
+        "children",
+        "placement",
+        "autoFlip",
+        "sideOffset",
+        "showArrow",
+        "delay",
+        "closeDelay",
+        "isOpen",
+        "defaultOpen",
+        "onOpenChange",
+        "dataTheme",
+        "class",
+        "className",
+        "style"
+    ]);
+    const [internalOpen, setInternalOpen] = createSignal(Boolean(local.defaultOpen));
+    const [triggerRef, setTriggerRef] = createSignal();
+    const [contentRef, setContentRef] = createSignal();
+    const [resolvedPlacement, setResolvedPlacement] = createSignal(local.placement ?? "top");
+    let delayTimer;
+    let closeTimer;
+    const isControlled = ()=>void 0 !== local.isOpen;
+    const isOpen = ()=>isControlled() ? Boolean(local.isOpen) : internalOpen();
+    const setIsOpen = (v)=>{
+        if (!isControlled()) setInternalOpen(v);
+        local.onOpenChange?.(v);
+    };
+    const openTooltip = ()=>{
+        clearTimeout(closeTimer);
+        clearTimeout(delayTimer);
+        delayTimer = setTimeout(()=>setIsOpen(true), local.delay ?? 0);
+    };
+    const closeTooltip = ()=>{
+        clearTimeout(delayTimer);
+        clearTimeout(closeTimer);
+        closeTimer = setTimeout(()=>setIsOpen(false), local.closeDelay ?? 100);
+    };
+    onCleanup(()=>{
+        clearTimeout(delayTimer);
+        clearTimeout(closeTimer);
+    });
+    const ctx = {
+        isOpen,
+        setIsOpen,
+        openTooltip,
+        closeTooltip,
+        preferredPlacement: ()=>local.placement ?? "top",
+        placement: ()=>resolvedPlacement(),
+        setPlacement: setResolvedPlacement,
+        autoFlip: ()=>local.autoFlip ?? true,
+        sideOffset: ()=>local.sideOffset ?? 12,
+        showArrow: ()=>Boolean(local.showArrow),
+        triggerRef,
+        setTriggerRef,
+        contentRef,
+        setContentRef,
+        dataTheme: ()=>local.dataTheme
+    };
+    return createComponent(TooltipContext.Provider, {
+        value: ctx,
+        get children () {
+            var _el$ = _tmpl$();
+            spread(_el$, mergeProps(()=>({
+                    class: twMerge(CLASSES.base, local.class, local.className)
+                }), {
+                "data-slot": "tooltip-root",
+                get ["data-theme"] () {
+                    return local.dataTheme;
+                },
+                get style () {
+                    return local.style;
+                }
+            }), false, true);
+            insert(_el$, ()=>local.children);
+            return _el$;
+        }
+    });
+};
+const TooltipRoot = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutTooltipRoot,
+    embedded: true
+});
+const __solidLayoutTooltipTrigger = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "onMouseEnter",
+        "onMouseLeave",
+        "onFocusIn",
+        "onFocusOut"
+    ]);
+    const ctx = useTooltipContext();
+    const handleMouseEnter = (e)=>{
+        ctx.openTooltip();
+        if ("function" == typeof local.onMouseEnter) local.onMouseEnter(e);
+    };
+    const handleMouseLeave = (e)=>{
+        ctx.closeTooltip();
+        if ("function" == typeof local.onMouseLeave) local.onMouseLeave(e);
+    };
+    const handleFocusIn = (e)=>{
+        ctx.openTooltip();
+        if ("function" == typeof local.onFocusIn) local.onFocusIn(e);
+    };
+    const handleFocusOut = (e)=>{
+        ctx.setIsOpen(false);
+        if ("function" == typeof local.onFocusOut) local.onFocusOut(e);
+    };
+    return (()=>{
+        var _el$2 = _tmpl$2();
+        use((el)=>ctx.setTriggerRef(el), _el$2);
+        spread(_el$2, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.slot.trigger, local.class, local.className)
+            }), {
+            "data-slot": "tooltip-trigger",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            },
+            onMouseEnter: handleMouseEnter,
+            onMouseLeave: handleMouseLeave,
+            onFocusIn: handleFocusIn,
+            onFocusOut: handleFocusOut
+        }), false, true);
+        insert(_el$2, ()=>local.children);
+        return _el$2;
+    })();
+};
+const TooltipTrigger = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutTooltipTrigger,
+    embedded: true
+});
+const __solidLayoutTooltipContent = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "onMouseEnter",
+        "onMouseLeave"
+    ]);
+    const ctx = useTooltipContext();
+    const overlayPosition = createOverlayPosition({
+        open: ctx.isOpen,
+        triggerRef: ctx.triggerRef,
+        overlayRef: ctx.contentRef,
+        placement: ctx.preferredPlacement,
+        offset: ctx.sideOffset,
+        autoFlip: ctx.autoFlip,
+        align: ()=>"center"
+    });
+    createEffect(()=>{
+        ctx.setPlacement(overlayPosition.placement());
+    });
+    const style = ()=>{
+        const overlayStyle = overlayPosition.style();
+        if ("string" == typeof local.style) return [
+            local.style,
+            Object.entries(overlayStyle).map(([key, value])=>`${key}: ${String(value)}`).join("; ")
+        ].filter(Boolean).join("; ");
+        return {
+            ...local.style ?? {},
+            ...overlayStyle
+        };
+    };
+    const handleMouseEnter = (event)=>{
+        ctx.openTooltip();
+        if ("function" == typeof local.onMouseEnter) local.onMouseEnter(event);
+    };
+    const handleMouseLeave = (event)=>{
+        ctx.closeTooltip();
+        if ("function" == typeof local.onMouseLeave) local.onMouseLeave(event);
+    };
+    return createComponent(Show, {
+        get when () {
+            return ctx.isOpen();
+        },
+        get children () {
+            return createComponent(Portal, {
+                get children () {
+                    var _el$3 = _tmpl$2();
+                    use((el)=>ctx.setContentRef(el), _el$3);
+                    spread(_el$3, mergeProps(others, {
+                        role: "tooltip"
+                    }, ()=>({
+                            class: twMerge(CLASSES.slot.content, local.class, local.className)
+                        }), {
+                        "data-slot": "tooltip-content",
+                        get ["data-placement"] () {
+                            return ctx.placement();
+                        },
+                        get ["data-open"] () {
+                            return ctx.isOpen() ? "true" : "false";
+                        },
+                        get ["data-theme"] () {
+                            return local.dataTheme ?? ctx.dataTheme();
+                        },
+                        get style () {
+                            return style();
+                        },
+                        onMouseEnter: handleMouseEnter,
+                        onMouseLeave: handleMouseLeave
+                    }), false, true);
+                    insert(_el$3, ()=>local.children);
+                    return _el$3;
+                }
+            });
+        }
+    });
+};
+const TooltipContent = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutTooltipContent,
+    embedded: true
+});
+const __solidLayoutTooltipArrow = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    const ctx = useTooltipContext();
+    const defaultArrow = _tmpl$3();
+    return (()=>{
+        var _el$5 = _tmpl$();
+        spread(_el$5, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.slot.arrow, local.class, local.className)
+            }), {
+            "data-slot": "tooltip-arrow",
+            get ["data-placement"] () {
+                return ctx.placement();
+            },
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            },
+            "aria-hidden": "true"
+        }), false, true);
+        insert(_el$5, createComponent(Show, {
+            get when () {
+                return local.children;
+            },
+            fallback: defaultArrow,
+            get children () {
+                return local.children;
+            }
+        }));
+        return _el$5;
+    })();
+};
+const TooltipArrow = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutTooltipArrow,
+    embedded: true
+});
+const Tooltip = Object.assign(TooltipRoot, {
+    Root: TooltipRoot,
+    Trigger: TooltipTrigger,
+    Content: TooltipContent,
+    Arrow: TooltipArrow
+});
+const Tooltip_generated = Tooltip;
+export default Tooltip_generated;
+export { TooltipArrow, TooltipContent, TooltipRoot, TooltipTrigger };

package/dist/components/tooltip/Tooltip.recipe.d.ts

@@ -0,0 +1,19 @@
+export declare const CLASSES: {
+    readonly base: "tooltip";
+    readonly slot: {
+        readonly trigger: "tooltip__trigger";
+        readonly content: "tooltip__content";
+        readonly arrow: "tooltip__arrow";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "tooltip";
+    readonly slots: {
+        readonly root: {};
+        readonly "tooltip-arrow": {};
+        readonly "tooltip-arrow-svg": {};
+        readonly "tooltip-content": {};
+        readonly "tooltip-root": {};
+        readonly "tooltip-trigger": {};
+    };
+}>;

package/dist/components/tooltip/Tooltip.recipe.js

@@ -0,0 +1,58 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    base: "tooltip",
+    slot: {
+        trigger: "tooltip__trigger",
+        content: "tooltip__content",
+        arrow: "tooltip__arrow"
+    }
+};
+const componentRecipe = recipe({
+    component: "tooltip",
+    slots: {
+        root: {},
+        "tooltip-arrow": {},
+        "tooltip-arrow-svg": {},
+        "tooltip-content": {},
+        "tooltip-root": {},
+        "tooltip-trigger": {}
+    },
+    _layouts: {
+        slots: {
+            root: {
+                base: "",
+                axes: {}
+            },
+            "tooltip-arrow": {
+                base: "",
+                axes: {}
+            },
+            "tooltip-arrow-svg": {
+                base: "",
+                axes: {}
+            },
+            "tooltip-content": {
+                base: "",
+                axes: {}
+            },
+            "tooltip-root": {
+                base: "",
+                axes: {}
+            },
+            "tooltip-trigger": {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            root: 0,
+            "tooltip-arrow": 1,
+            "tooltip-arrow-svg": 2,
+            "tooltip-content": 3,
+            "tooltip-root": 4,
+            "tooltip-trigger": 5
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/tooltip/index.d.ts

@@ -1 +1 @@
-export { default, TooltipRoot, TooltipTrigger, TooltipContent, TooltipArrow, type TooltipPlacement, type TooltipRootProps, type TooltipTriggerProps, type TooltipContentProps, type TooltipArrowProps, } from "./Tooltip";
+export { default, TooltipRoot, TooltipTrigger, TooltipContent, TooltipArrow, type TooltipPlacement, type TooltipRootProps, type TooltipTriggerProps, type TooltipContentProps, type TooltipArrowProps, } from "./Tooltip.generated";

package/dist/components/tooltip/index.js

@@ -1 +1 @@
-export { TooltipArrow, TooltipContent, TooltipRoot, TooltipTrigger, default } from "./Tooltip.js";
+export { TooltipArrow, TooltipContent, TooltipRoot, TooltipTrigger, default } from "./Tooltip.generated.js";

package/dist/components/video-preview/VideoPreview.generated.d.ts

@@ -0,0 +1,22 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import { type Accessor, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+type VideoPreviewBaseProps = {
+    /**
+     * Reactive accessor for the MediaStream to display
+     */
+    stream: Accessor<MediaStream | null>;
+    /**
+     * Whether the video should be muted
+     * @default true
+     */
+    muted?: boolean;
+    /**
+     * Whether to mirror the video (applies scaleX(-1))
+     * @default false
+     */
+    mirror?: boolean;
+};
+export type VideoPreviewProps = VideoPreviewBaseProps & IComponentBaseProps & Omit<JSX.VideoHTMLAttributes<HTMLVideoElement>, keyof VideoPreviewBaseProps>;
+export declare const VideoPreview: __LayoutComponent<VideoPreviewProps>;
+export default VideoPreview;

package/dist/components/video-preview/VideoPreview.generated.js

@@ -0,0 +1,63 @@
+import { createComponent, mergeProps, spread, template, use } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import { Show, createEffect, onCleanup, splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./VideoPreview.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<video>");
+const __solidLayoutVideoPreview = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "stream",
+        "muted",
+        "mirror",
+        "dataTheme",
+        "class",
+        "className",
+        "style"
+    ]);
+    const muted = ()=>local.muted ?? true;
+    const mirror = ()=>local.mirror ?? false;
+    return createComponent(Show, {
+        get when () {
+            return local.stream();
+        },
+        children: (stream)=>{
+            let videoRef;
+            createEffect(()=>{
+                videoRef.srcObject = stream();
+            });
+            onCleanup(()=>{
+                videoRef.srcObject = null;
+            });
+            return (()=>{
+                var _el$ = _tmpl$();
+                var _ref$ = videoRef;
+                "function" == typeof _ref$ ? use(_ref$, _el$) : videoRef = _el$;
+                spread(_el$, mergeProps(others, {
+                    autoplay: true,
+                    playsinline: true,
+                    get muted () {
+                        return muted();
+                    },
+                    get ["data-theme"] () {
+                        return local.dataTheme;
+                    }
+                }, ()=>({
+                        class: twMerge(mirror() && CLASSES.mirror, local.class, local.className)
+                    }), {
+                    get style () {
+                        return local.style;
+                    }
+                }), false, false);
+                return _el$;
+            })();
+        }
+    });
+};
+const VideoPreview = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutVideoPreview,
+    embedded: true
+});
+const VideoPreview_generated = VideoPreview;
+export default VideoPreview_generated;
+export { VideoPreview };

package/dist/components/video-preview/VideoPreview.recipe.d.ts

@@ -0,0 +1,9 @@
+export declare const CLASSES: {
+    readonly mirror: "-scale-x-100";
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "video-preview";
+    readonly slots: {
+        readonly root: {};
+    };
+}>;

package/dist/components/video-preview/VideoPreview.recipe.js

@@ -0,0 +1,23 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    mirror: "-scale-x-100"
+};
+const componentRecipe = recipe({
+    component: "video-preview",
+    slots: {
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            root: 0
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/video-preview/index.d.ts

@@ -1,2 +1,2 @@
-export { default as VideoPreview } from "./VideoPreview";
-export type { VideoPreviewProps } from "./VideoPreview";
+export { default as VideoPreview } from "./VideoPreview.generated";
+export type { VideoPreviewProps } from "./VideoPreview.generated";

package/dist/components/video-preview/index.js

@@ -1 +1 @@
-export { default as VideoPreview } from "./VideoPreview.js";
+export { default as VideoPreview } from "./VideoPreview.generated.js";

package/dist/index.d.ts

@@ -36,7 +36,8 @@ export type { ColorSwatchPickerProps } from "./components/color-swatch-picker";
 export { default as ColorPicker } from "./components/color-picker";
 export type { ColorPickerProps, ColorPickerAreaProps, ColorPickerSliderProps, ColorPickerFieldProps, } from "./components/color-picker";
 export { ColorWheelFlower } from "./components/color-wheel-flower";
-export type { ColorWheelFlowerProps } from "./components/color-wheel-flower";
+export { COLOR_WHEEL_FLOWER_COLOR_COUNT, COLOR_WHEEL_FLOWER_PALETTES, resolveColorWheelFlowerPalette, } from "./components/color-wheel-flower";
+export type { ColorWheelFlowerMode, ColorWheelFlowerProps, } from "./components/color-wheel-flower";
 export { default as Description, DescriptionRoot, } from "./components/description";
 export type { DescriptionProps, DescriptionRootProps, } from "./components/description";
 export { default as DateField, DateFieldRoot, DateFieldGroup, DateFieldInput, DateFieldInputContainer, DateFieldSegment, DateFieldPrefix, DateFieldSuffix, } from "./components/date-field";
@@ -120,8 +121,8 @@ export { default as Meter, MeterRoot, MeterOutput, MeterTrack, MeterFill, } from
 export type { MeterProps, MeterRootProps, MeterOutputProps, MeterTrackProps, MeterFillProps, MeterSize, MeterColor, MeterRenderState, } from "./components/meter";
 export { default as Navbar } from "./components/navbar";
 export type { NavbarProps } from "./components/navbar";
-export type { NavbarStackProps } from "./components/navbar/NavbarStack";
-export type { NavbarRowProps } from "./components/navbar/NavbarRow";
+export type { NavbarStackProps } from "./components/navbar/NavbarStack.generated";
+export type { NavbarRowProps } from "./components/navbar/NavbarRow.generated";
 export { default as NumberField, NumberFieldRoot, NumberFieldGroup, NumberFieldInput, NumberFieldIncrementButton, NumberFieldDecrementButton, } from "./components/number-field";
 export type { NumberFieldProps, NumberFieldRootProps, NumberFieldGroupProps, NumberFieldInputProps, NumberFieldIncrementButtonProps, NumberFieldDecrementButtonProps, NumberFieldVariant, NumberFieldRenderProps, } from "./components/number-field";
 export { default as NoiseBackground } from "./components/noise-background";

package/dist/index.js

@@ -21,7 +21,7 @@ export { default as ColorSlider } from "./components/color-slider/index.js";
 export { default as ColorSwatch } from "./components/color-swatch/index.js";
 export { default as ColorSwatchPicker } from "./components/color-swatch-picker/index.js";
 export { default as ColorPicker } from "./components/color-picker/index.js";
-export { ColorWheelFlower } from "./components/color-wheel-flower/index.js";
+export { COLOR_WHEEL_FLOWER_COLOR_COUNT, COLOR_WHEEL_FLOWER_PALETTES, ColorWheelFlower, resolveColorWheelFlowerPalette } from "./components/color-wheel-flower/index.js";
 export { DescriptionRoot, default as Description } from "./components/description/index.js";
 export { DateFieldGroup, DateFieldInput, DateFieldInputContainer, DateFieldPrefix, DateFieldRoot, DateFieldSegment, DateFieldSuffix, default as DateField } from "./components/date-field/index.js";
 export { default as DatePicker } from "./components/date-picker/index.js";