@pathscale/ui 1.3.0 → 1.4.0

package/dist/components/color-slider/ColorSlider.recipe.js

@@ -0,0 +1,49 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    base: "color-slider",
+    slot: {
+        track: "color-slider__track",
+        thumb: "color-slider__thumb"
+    },
+    flag: {
+        alpha: "color-slider--alpha",
+        dragging: "color-slider--dragging"
+    }
+};
+const componentRecipe = recipe({
+    component: "color-slider",
+    slots: {
+        "color-slider": {},
+        "color-slider-thumb": {},
+        "color-slider-track": {},
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            "color-slider": {
+                base: "",
+                axes: {}
+            },
+            "color-slider-thumb": {
+                base: "",
+                axes: {}
+            },
+            "color-slider-track": {
+                base: "",
+                axes: {}
+            },
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            "color-slider": 0,
+            "color-slider-thumb": 1,
+            "color-slider-track": 2,
+            root: 3
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/color-slider/index.d.ts

@@ -1,3 +1,3 @@
-import ColorSlider from "./ColorSlider";
-export type { ColorSliderProps, ColorSliderType } from "./ColorSlider";
+import ColorSlider from "./ColorSlider.generated";
+export type { ColorSliderProps, ColorSliderType } from "./ColorSlider.generated";
 export default ColorSlider;

package/dist/components/color-slider/index.js

@@ -1,3 +1,3 @@
-import ColorSlider from "./ColorSlider.js";
-const color_slider = ColorSlider;
+import ColorSlider_generated from "./ColorSlider.generated.js";
+const color_slider = ColorSlider_generated;
 export default color_slider;

package/dist/components/color-swatch/ColorSwatch.generated.d.ts

@@ -0,0 +1,18 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./ColorSwatch.css";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type ColorSwatchShape = "circle" | "square";
+export type ColorSwatchSize = "xs" | "sm" | "md" | "lg" | "xl";
+export type ColorSwatchProps = Omit<JSX.ButtonHTMLAttributes<HTMLButtonElement>, "onChange" | "onSelect"> & IComponentBaseProps & {
+    color: string;
+    colorName?: string;
+    shape?: ColorSwatchShape;
+    size?: ColorSwatchSize;
+    isSelected?: boolean;
+    isDisabled?: boolean;
+    onSelect?: (color: string) => void;
+    onChange?: (color: string) => void;
+};
+declare const ColorSwatch: __LayoutComponent<ColorSwatchProps>;
+export default ColorSwatch;

package/dist/components/color-swatch/ColorSwatch.generated.js

@@ -0,0 +1,139 @@
+import { memo, mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./ColorSwatch.css";
+import { splitProps, useContext } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { ColorSwatchPickerContext } from "../color-swatch-picker/ColorSwatchPicker.generated.js";
+import { CLASSES, componentRecipe } from "./ColorSwatch.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<button>");
+const invokeEventHandler = (handler, event)=>{
+    if ("function" == typeof handler) return void handler(event);
+    if (Array.isArray(handler) && "function" == typeof handler[0]) handler[0](handler[1], event);
+};
+const __solidLayoutColorSwatch = (_stable, p)=>{
+    const picker = useContext(ColorSwatchPickerContext);
+    const [local, others] = splitProps(p, [
+        "class",
+        "className",
+        "color",
+        "colorName",
+        "shape",
+        "size",
+        "isSelected",
+        "isDisabled",
+        "disabled",
+        "onSelect",
+        "onChange",
+        "onClick",
+        "onKeyDown",
+        "style",
+        "dataTheme",
+        "aria-label",
+        "role",
+        "tabIndex"
+    ]);
+    const isInsidePicker = ()=>Boolean(picker);
+    const hasPickerSelection = ()=>picker ? void 0 !== picker.value() : false;
+    const shape = ()=>local.shape ?? "circle";
+    const size = ()=>local.size ?? "md";
+    const isDisabled = ()=>{
+        const localDisabled = Boolean(local.isDisabled) || Boolean(local.disabled);
+        const pickerDisabled = picker ? picker.isDisabled() : false;
+        return localDisabled || pickerDisabled;
+    };
+    const isSelected = ()=>{
+        if (void 0 !== local.isSelected) return Boolean(local.isSelected);
+        if (!picker) return false;
+        return picker.value() === local.color;
+    };
+    const emitSelection = ()=>{
+        local.onSelect?.(local.color);
+        local.onChange?.(local.color);
+        picker?.select(local.color);
+    };
+    const handleClick = (event)=>{
+        invokeEventHandler(local.onClick, event);
+        if (event.defaultPrevented || isDisabled()) return;
+        emitSelection();
+    };
+    const handleKeyDown = (event)=>{
+        invokeEventHandler(local.onKeyDown, event);
+        if (event.defaultPrevented || isDisabled()) return;
+        if ("Enter" === event.key || " " === event.key) {
+            event.preventDefault();
+            emitSelection();
+        }
+    };
+    const style = ()=>{
+        const userStyle = local.style;
+        return {
+            "--color-swatch-current": local.color,
+            ...userStyle
+        };
+    };
+    const tabIndex = ()=>{
+        if (void 0 !== local.tabIndex) return local.tabIndex;
+        if (!isInsidePicker()) return;
+        if (!hasPickerSelection()) return 0;
+        return isSelected() ? 0 : -1;
+    };
+    return (()=>{
+        var _el$ = _tmpl$();
+        spread(_el$, mergeProps(others, {
+            type: "button",
+            get ["class"] () {
+                return twMerge(CLASSES.base, CLASSES.shape[shape()], CLASSES.size[size()], local.class, local.className);
+            },
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            "data-slot": "color-swatch",
+            get ["data-color-value"] () {
+                return local.color;
+            },
+            get ["data-picker-item"] () {
+                return isInsidePicker() ? "true" : "false";
+            },
+            get ["data-selected"] () {
+                return isSelected() ? "true" : "false";
+            },
+            get ["data-disabled"] () {
+                return isDisabled() ? "true" : "false";
+            },
+            get disabled () {
+                return isDisabled();
+            },
+            get role () {
+                return local.role ?? (isInsidePicker() ? "radio" : "option");
+            },
+            get tabIndex () {
+                return tabIndex();
+            },
+            get ["aria-label"] () {
+                return local["aria-label"] ?? local.colorName ?? `Color ${local.color}`;
+            },
+            get ["aria-selected"] () {
+                return isSelected() ? "true" : "false";
+            },
+            get ["aria-checked"] () {
+                return memo(()=>!!isInsidePicker())() ? isSelected() ? "true" : "false" : void 0;
+            },
+            get ["aria-disabled"] () {
+                return isDisabled() ? "true" : "false";
+            },
+            get style () {
+                return style();
+            },
+            onClick: handleClick,
+            onKeyDown: handleKeyDown
+        }), false, false);
+        return _el$;
+    })();
+};
+const ColorSwatch = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutColorSwatch,
+    embedded: true
+});
+const ColorSwatch_generated = ColorSwatch;
+export default ColorSwatch_generated;

package/dist/components/color-swatch/ColorSwatch.recipe.d.ts

@@ -0,0 +1,21 @@
+export declare const CLASSES: {
+    readonly base: "color-swatch";
+    readonly shape: {
+        readonly circle: "color-swatch--circle";
+        readonly square: "color-swatch--square";
+    };
+    readonly size: {
+        readonly xs: "color-swatch--xs";
+        readonly sm: "color-swatch--sm";
+        readonly md: "color-swatch--md";
+        readonly lg: "color-swatch--lg";
+        readonly xl: "color-swatch--xl";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "color-swatch";
+    readonly slots: {
+        readonly "color-swatch": {};
+        readonly root: {};
+    };
+}>;

package/dist/components/color-swatch/ColorSwatch.recipe.js

@@ -0,0 +1,40 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    base: "color-swatch",
+    shape: {
+        circle: "color-swatch--circle",
+        square: "color-swatch--square"
+    },
+    size: {
+        xs: "color-swatch--xs",
+        sm: "color-swatch--sm",
+        md: "color-swatch--md",
+        lg: "color-swatch--lg",
+        xl: "color-swatch--xl"
+    }
+};
+const componentRecipe = recipe({
+    component: "color-swatch",
+    slots: {
+        "color-swatch": {},
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            "color-swatch": {
+                base: "",
+                axes: {}
+            },
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            "color-swatch": 0,
+            root: 1
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/color-swatch/index.d.ts

@@ -1,3 +1,3 @@
-import ColorSwatch from "./ColorSwatch";
-export type { ColorSwatchProps, ColorSwatchShape, ColorSwatchSize } from "./ColorSwatch";
+import ColorSwatch from "./ColorSwatch.generated";
+export type { ColorSwatchProps, ColorSwatchShape, ColorSwatchSize } from "./ColorSwatch.generated";
 export default ColorSwatch;

package/dist/components/color-swatch/index.js

@@ -1,3 +1,3 @@
-import ColorSwatch from "./ColorSwatch.js";
-const color_swatch = ColorSwatch;
+import ColorSwatch_generated from "./ColorSwatch.generated.js";
+const color_swatch = ColorSwatch_generated;
 export default color_swatch;

package/dist/components/color-swatch-picker/ColorSwatchPicker.generated.d.ts

@@ -0,0 +1,19 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./ColorSwatchPicker.css";
+import { type Accessor, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type ColorSwatchPickerContextValue = {
+    value: Accessor<string | undefined>;
+    isDisabled: Accessor<boolean>;
+    select: (value: string) => void;
+};
+export declare const ColorSwatchPickerContext: import("solid-js").Context<ColorSwatchPickerContextValue | undefined>;
+export type ColorSwatchPickerProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange"> & IComponentBaseProps & {
+    children: JSX.Element;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    isDisabled?: boolean;
+};
+declare const ColorSwatchPicker: __LayoutComponent<ColorSwatchPickerProps>;
+export { ColorSwatchPicker as default, ColorSwatchPicker };

package/dist/components/color-swatch-picker/ColorSwatchPicker.generated.js

@@ -0,0 +1,116 @@
+import { createComponent, insert, mergeProps, spread, template, use } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./ColorSwatchPicker.css";
+import { createContext, createMemo, createSignal, splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./ColorSwatchPicker.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<div>");
+const invokeEventHandler = (handler, event)=>{
+    if ("function" == typeof handler) return void handler(event);
+    if (Array.isArray(handler) && "function" == typeof handler[0]) handler[0](handler[1], event);
+};
+const ColorSwatchPickerContext = createContext();
+const __solidLayoutColorSwatchPicker = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "class",
+        "className",
+        "children",
+        "value",
+        "defaultValue",
+        "onChange",
+        "isDisabled",
+        "dataTheme",
+        "role",
+        "onKeyDown"
+    ]);
+    const [internalValue, setInternalValue] = createSignal(local.defaultValue);
+    let rootRef;
+    const isControlled = ()=>void 0 !== local.value;
+    const currentValue = ()=>isControlled() ? local.value : internalValue();
+    const isDisabled = ()=>Boolean(local.isDisabled);
+    const setValue = (next)=>{
+        if (isDisabled()) return;
+        if (!isControlled()) setInternalValue(next);
+        local.onChange?.(next);
+    };
+    const getEnabledItems = ()=>{
+        if (!rootRef) return [];
+        return Array.from(rootRef.querySelectorAll('[data-picker-item="true"][data-disabled="false"]'));
+    };
+    const findFocusedOrSelectedIndex = (items)=>{
+        if (!items.length) return -1;
+        const active = document.activeElement;
+        const focusedIndex = items.findIndex((item)=>item === active);
+        if (focusedIndex >= 0) return focusedIndex;
+        const selected = currentValue();
+        if (!selected) return 0;
+        const selectedIndex = items.findIndex((item)=>item.dataset.colorValue === selected);
+        return selectedIndex >= 0 ? selectedIndex : 0;
+    };
+    const handleKeyDown = (event)=>{
+        invokeEventHandler(local.onKeyDown, event);
+        if (event.defaultPrevented || isDisabled()) return;
+        const key = event.key;
+        const moveNext = "ArrowRight" === key || "ArrowDown" === key;
+        const movePrev = "ArrowLeft" === key || "ArrowUp" === key;
+        const moveFirst = "Home" === key;
+        const moveLast = "End" === key;
+        if (!moveNext && !movePrev && !moveFirst && !moveLast) return;
+        const items = getEnabledItems();
+        if (!items.length) return;
+        event.preventDefault();
+        const currentIndex = findFocusedOrSelectedIndex(items);
+        let nextIndex = currentIndex;
+        if (moveFirst) nextIndex = 0;
+        else if (moveLast) nextIndex = items.length - 1;
+        else if (moveNext) nextIndex = (currentIndex + 1 + items.length) % items.length;
+        else if (movePrev) nextIndex = (currentIndex - 1 + items.length) % items.length;
+        const nextItem = items[nextIndex];
+        if (!nextItem) return;
+        nextItem.focus();
+        const nextColor = nextItem.dataset.colorValue;
+        if (nextColor) setValue(nextColor);
+    };
+    const context = createMemo(()=>({
+            value: currentValue,
+            isDisabled,
+            select: setValue
+        }));
+    return createComponent(ColorSwatchPickerContext.Provider, {
+        get value () {
+            return context();
+        },
+        get children () {
+            var _el$ = _tmpl$();
+            var _ref$ = rootRef;
+            "function" == typeof _ref$ ? use(_ref$, _el$) : rootRef = _el$;
+            spread(_el$, mergeProps(others, ()=>({
+                    class: twMerge(CLASSES.base, local.class, local.className)
+                }), {
+                get ["data-theme"] () {
+                    return local.dataTheme;
+                },
+                "data-slot": "color-swatch-picker",
+                get ["data-disabled"] () {
+                    return isDisabled() ? "true" : "false";
+                },
+                get role () {
+                    return local.role ?? "radiogroup";
+                },
+                get ["aria-disabled"] () {
+                    return isDisabled() ? "true" : "false";
+                },
+                onKeyDown: handleKeyDown
+            }), false, true);
+            insert(_el$, ()=>local.children);
+            return _el$;
+        }
+    });
+};
+const ColorSwatchPicker = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutColorSwatchPicker,
+    embedded: true
+});
+export default ColorSwatchPicker;
+export { ColorSwatchPicker, ColorSwatchPickerContext };

package/dist/components/color-swatch-picker/ColorSwatchPicker.recipe.d.ts

@@ -0,0 +1,10 @@
+export declare const CLASSES: {
+    readonly base: "color-swatch-picker";
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "color-swatch-picker";
+    readonly slots: {
+        readonly "color-swatch-picker": {};
+        readonly root: {};
+    };
+}>;

package/dist/components/color-swatch-picker/ColorSwatchPicker.recipe.js

@@ -0,0 +1,29 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    base: "color-swatch-picker"
+};
+const componentRecipe = recipe({
+    component: "color-swatch-picker",
+    slots: {
+        "color-swatch-picker": {},
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            "color-swatch-picker": {
+                base: "",
+                axes: {}
+            },
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            "color-swatch-picker": 0,
+            root: 1
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/color-swatch-picker/index.d.ts

@@ -1,3 +1,3 @@
-export { default, ColorSwatchPicker } from "./ColorSwatchPicker";
-export type { ColorSwatchPickerProps, ColorSwatchPickerContextValue } from "./ColorSwatchPicker";
-export { ColorSwatchPickerContext } from "./ColorSwatchPicker";
+export { default, ColorSwatchPicker } from "./ColorSwatchPicker.generated";
+export type { ColorSwatchPickerProps, ColorSwatchPickerContextValue } from "./ColorSwatchPicker.generated";
+export { ColorSwatchPickerContext } from "./ColorSwatchPicker.generated";

package/dist/components/color-swatch-picker/index.js

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

package/dist/components/color-wheel-flower/ColorWheelFlower.generated.d.ts

@@ -0,0 +1,13 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./ColorWheelFlower.css";
+import { type ColorWheelFlowerMode } from "./ColorWheelFlower.palette";
+export interface ColorWheelFlowerProps {
+    class?: string;
+    className?: string;
+    /** Explicit mode. Omit to follow the root `data-theme` attribute. */
+    mode?: ColorWheelFlowerMode;
+    /** Exactly 31 literal colors, ordered outer ring, middle ring, inner ring, center. */
+    palette?: readonly string[];
+}
+declare const ColorWheelFlower: __LayoutComponent<ColorWheelFlowerProps>;
+export default ColorWheelFlower;