@pathscale/ui 1.3.1 → 1.4.0

package/dist/components/combo-box/ComboBox.recipe.d.ts

@@ -0,0 +1,60 @@
+export declare const CLASSES: {
+    readonly Root: {
+        readonly base: "combo-box";
+        readonly variant: {
+            readonly primary: "combo-box--primary";
+            readonly secondary: "combo-box--secondary";
+        };
+        readonly flag: {
+            readonly fullWidth: "combo-box--full-width";
+        };
+    };
+    readonly InputGroup: {
+        readonly base: "combo-box__input-group";
+        readonly flag: {
+            readonly fullWidth: "combo-box__input-group--full-width";
+        };
+    };
+    readonly Input: {
+        readonly base: "combo-box__input";
+    };
+    readonly Trigger: {
+        readonly base: "combo-box__trigger";
+        readonly icon: "combo-box__trigger-icon";
+    };
+    readonly Popover: {
+        readonly base: "combo-box__popover";
+    };
+    readonly List: {
+        readonly base: "combo-box__list";
+        readonly empty: "combo-box__empty";
+    };
+    readonly Option: {
+        readonly base: "combo-box__option";
+        readonly label: "combo-box__option-label";
+        readonly indicator: "combo-box__option-indicator";
+    };
+    readonly Icon: {
+        readonly base: "combo-box__icon";
+        readonly start: "combo-box__icon--start";
+        readonly end: "combo-box__icon--end";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "combo-box";
+    readonly slots: {
+        readonly combobox: {};
+        readonly "combobox-empty-state": {};
+        readonly "combobox-input": {};
+        readonly "combobox-input-group": {};
+        readonly "combobox-list": {};
+        readonly "combobox-option": {};
+        readonly "combobox-option-end-icon": {};
+        readonly "combobox-popover": {};
+        readonly "combobox-start-icon": {};
+        readonly "combobox-trigger": {};
+        readonly "combobox-trigger-end-icon": {};
+        readonly "combobox-trigger-start-icon": {};
+        readonly root: {};
+    };
+}>;

package/dist/components/combo-box/ComboBox.recipe.js

@@ -0,0 +1,134 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    Root: {
+        base: "combo-box",
+        variant: {
+            primary: "combo-box--primary",
+            secondary: "combo-box--secondary"
+        },
+        flag: {
+            fullWidth: "combo-box--full-width"
+        }
+    },
+    InputGroup: {
+        base: "combo-box__input-group",
+        flag: {
+            fullWidth: "combo-box__input-group--full-width"
+        }
+    },
+    Input: {
+        base: "combo-box__input"
+    },
+    Trigger: {
+        base: "combo-box__trigger",
+        icon: "combo-box__trigger-icon"
+    },
+    Popover: {
+        base: "combo-box__popover"
+    },
+    List: {
+        base: "combo-box__list",
+        empty: "combo-box__empty"
+    },
+    Option: {
+        base: "combo-box__option",
+        label: "combo-box__option-label",
+        indicator: "combo-box__option-indicator"
+    },
+    Icon: {
+        base: "combo-box__icon",
+        start: "combo-box__icon--start",
+        end: "combo-box__icon--end"
+    }
+};
+const componentRecipe = recipe({
+    component: "combo-box",
+    slots: {
+        combobox: {},
+        "combobox-empty-state": {},
+        "combobox-input": {},
+        "combobox-input-group": {},
+        "combobox-list": {},
+        "combobox-option": {},
+        "combobox-option-end-icon": {},
+        "combobox-popover": {},
+        "combobox-start-icon": {},
+        "combobox-trigger": {},
+        "combobox-trigger-end-icon": {},
+        "combobox-trigger-start-icon": {},
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            combobox: {
+                base: "",
+                axes: {}
+            },
+            "combobox-empty-state": {
+                base: "",
+                axes: {}
+            },
+            "combobox-input": {
+                base: "",
+                axes: {}
+            },
+            "combobox-input-group": {
+                base: "",
+                axes: {}
+            },
+            "combobox-list": {
+                base: "",
+                axes: {}
+            },
+            "combobox-option": {
+                base: "",
+                axes: {}
+            },
+            "combobox-option-end-icon": {
+                base: "",
+                axes: {}
+            },
+            "combobox-popover": {
+                base: "",
+                axes: {}
+            },
+            "combobox-start-icon": {
+                base: "",
+                axes: {}
+            },
+            "combobox-trigger": {
+                base: "",
+                axes: {}
+            },
+            "combobox-trigger-end-icon": {
+                base: "",
+                axes: {}
+            },
+            "combobox-trigger-start-icon": {
+                base: "",
+                axes: {}
+            },
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            combobox: 0,
+            "combobox-empty-state": 1,
+            "combobox-input": 2,
+            "combobox-input-group": 3,
+            "combobox-list": 4,
+            "combobox-option": 5,
+            "combobox-option-end-icon": 6,
+            "combobox-popover": 7,
+            "combobox-start-icon": 8,
+            "combobox-trigger": 9,
+            "combobox-trigger-end-icon": 10,
+            "combobox-trigger-start-icon": 11,
+            root: 12
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/combo-box/index.d.ts

@@ -1 +1 @@
-export { default, ComboBox, ComboBoxRoot, ComboBoxInputGroup, ComboBoxInput, ComboBoxTrigger, ComboBoxPopover, ComboBoxList, type ComboBoxProps, type ComboBoxRootProps, type ComboBoxInputGroupProps, type ComboBoxInputProps, type ComboBoxTriggerProps, type ComboBoxPopoverProps, type ComboBoxListProps, type ComboBoxListRenderItem, type ComboBoxVariant, type ComboBoxMenuTrigger, type ComboBoxItem, type ComboBoxKey, } from "./ComboBox";
+export { default, ComboBox, ComboBoxRoot, ComboBoxInputGroup, ComboBoxInput, ComboBoxTrigger, ComboBoxPopover, ComboBoxList, type ComboBoxProps, type ComboBoxRootProps, type ComboBoxInputGroupProps, type ComboBoxInputProps, type ComboBoxTriggerProps, type ComboBoxPopoverProps, type ComboBoxListProps, type ComboBoxListRenderItem, type ComboBoxVariant, type ComboBoxMenuTrigger, type ComboBoxItem, type ComboBoxKey, } from "./ComboBox.generated";

package/dist/components/combo-box/index.js

@@ -1,3 +1 @@
-import { ComboBox as external_ComboBox_js_ComboBox, ComboBoxInput, ComboBoxInputGroup, ComboBoxList, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger } from "./ComboBox.js";
-export default external_ComboBox_js_ComboBox;
-export { ComboBoxInput, ComboBoxInputGroup, ComboBoxList, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger, external_ComboBox_js_ComboBox as ComboBox };
+export { ComboBox, ComboBoxInput, ComboBoxInputGroup, ComboBoxList, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger, default } from "./ComboBox.generated.js";

package/dist/components/date-field/DateField.generated.d.ts

@@ -0,0 +1,65 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./DateField.css";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type DateFieldVariant = "primary" | "secondary";
+export type DateFieldRenderProps = {
+    value: string;
+    isInvalid: boolean;
+    isDisabled: boolean;
+    isRequired: boolean;
+};
+export type DateFieldRootProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children" | "onChange" | "onBlur"> & IComponentBaseProps & {
+    children?: JSX.Element | ((props: DateFieldRenderProps) => JSX.Element);
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onBlur?: JSX.EventHandlerUnion<HTMLInputElement, FocusEvent>;
+    fullWidth?: boolean;
+    variant?: DateFieldVariant;
+    isDisabled?: boolean;
+    disabled?: boolean;
+    isInvalid?: boolean;
+    isRequired?: boolean;
+    required?: boolean;
+};
+export type DateFieldGroupProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element | ((props: DateFieldRenderProps) => JSX.Element);
+};
+export type DateFieldInputProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "value" | "onInput" | "type"> & IComponentBaseProps & {
+    onInput?: JSX.EventHandlerUnion<HTMLInputElement, InputEvent>;
+};
+export type DateFieldInputContainerProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps;
+export type DateFieldSegmentValue = {
+    type?: string;
+    text?: string;
+    isPlaceholder?: boolean;
+    isFocused?: boolean;
+    isInvalid?: boolean;
+    isDisabled?: boolean;
+};
+export type DateFieldSegmentProps = JSX.HTMLAttributes<HTMLSpanElement> & IComponentBaseProps & {
+    segment?: DateFieldSegmentValue;
+};
+export type DateFieldPrefixProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps;
+export type DateFieldSuffixProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps;
+declare const DateFieldRoot: __LayoutComponent<DateFieldRootProps>;
+declare const DateFieldGroup: __LayoutComponent<DateFieldGroupProps>;
+declare const DateFieldInput: __LayoutComponent<DateFieldInputProps>;
+declare const DateFieldInputContainer: __LayoutComponent<DateFieldInputContainerProps>;
+declare const DateFieldSegment: __LayoutComponent<DateFieldSegmentProps>;
+declare const DateFieldPrefix: __LayoutComponent<DateFieldPrefixProps>;
+declare const DateFieldSuffix: __LayoutComponent<DateFieldSuffixProps>;
+declare const DateField: __LayoutComponent<DateFieldRootProps> & {
+    Root: __LayoutComponent<DateFieldRootProps>;
+    Group: __LayoutComponent<DateFieldGroupProps>;
+    Input: __LayoutComponent<DateFieldInputProps>;
+    InputContainer: __LayoutComponent<DateFieldInputContainerProps>;
+    Segment: __LayoutComponent<DateFieldSegmentProps>;
+    Prefix: __LayoutComponent<DateFieldPrefixProps>;
+    Suffix: __LayoutComponent<DateFieldSuffixProps>;
+};
+export default DateField;
+export { DateField, DateFieldRoot, DateFieldGroup, DateFieldInput, DateFieldInputContainer, DateFieldSegment, DateFieldPrefix, DateFieldSuffix, };
+export type { DateFieldRootProps as DateFieldProps };

package/dist/components/date-field/DateField.generated.js

@@ -0,0 +1,365 @@
+import { createComponent, insert, memo, mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./DateField.css";
+import { createContext, createSignal, splitProps, useContext } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./DateField.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<div>"), _tmpl$2 = /*#__PURE__*/ template("<input>"), _tmpl$3 = /*#__PURE__*/ template("<span>");
+const DateFieldContext = createContext();
+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 __solidLayoutDateFieldRoot = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "name",
+        "value",
+        "defaultValue",
+        "onChange",
+        "onBlur",
+        "fullWidth",
+        "variant",
+        "isDisabled",
+        "disabled",
+        "isInvalid",
+        "isRequired",
+        "required"
+    ]);
+    const [internalValue, setInternalValue] = createSignal(local.defaultValue ?? "");
+    const isControlled = ()=>void 0 !== local.value;
+    const value = ()=>isControlled() ? local.value ?? "" : internalValue();
+    const variant = ()=>local.variant ?? "primary";
+    const fullWidth = ()=>Boolean(local.fullWidth);
+    const isDisabled = ()=>Boolean(local.isDisabled) || Boolean(local.disabled);
+    const isInvalid = ()=>Boolean(local.isInvalid);
+    const isRequired = ()=>Boolean(local.isRequired) || Boolean(local.required);
+    const setValue = (nextValue)=>{
+        if (!isControlled()) setInternalValue(nextValue);
+        local.onChange?.(nextValue);
+    };
+    const renderProps = ()=>({
+            value: value(),
+            isInvalid: isInvalid(),
+            isDisabled: isDisabled(),
+            isRequired: isRequired()
+        });
+    const contextValue = {
+        value,
+        name: ()=>local.name,
+        variant,
+        fullWidth,
+        isDisabled,
+        isInvalid,
+        isRequired,
+        onBlur: ()=>local.onBlur,
+        setValue
+    };
+    return createComponent(DateFieldContext.Provider, {
+        value: contextValue,
+        get children () {
+            var _el$ = _tmpl$();
+            spread(_el$, mergeProps(others, ()=>({
+                    class: twMerge(CLASSES.Root.base, CLASSES.Root.variant[variant()], fullWidth() && CLASSES.Root.flag.fullWidth, local.class, local.className)
+                }), {
+                "data-slot": "date-field",
+                get ["data-invalid"] () {
+                    return isInvalid() ? "true" : void 0;
+                },
+                get ["data-disabled"] () {
+                    return isDisabled() ? "true" : void 0;
+                },
+                get ["data-required"] () {
+                    return isRequired() ? "true" : void 0;
+                },
+                get ["aria-invalid"] () {
+                    return isInvalid() ? "true" : void 0;
+                },
+                get ["aria-disabled"] () {
+                    return isDisabled() ? "true" : void 0;
+                },
+                get ["data-theme"] () {
+                    return local.dataTheme;
+                },
+                get style () {
+                    return local.style;
+                }
+            }), false, true);
+            insert(_el$, (()=>{
+                var _c$ = memo(()=>"function" == typeof local.children);
+                return ()=>_c$() ? local.children(renderProps()) : memo(()=>!!local.children)() ? local.children : createComponent(DateFieldGroup, {
+                        get children () {
+                            return createComponent(DateFieldInput, {});
+                        }
+                    });
+            })());
+            return _el$;
+        }
+    });
+};
+const DateFieldRoot = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutDateFieldRoot,
+    embedded: true
+});
+const __solidLayoutDateFieldGroup = (_stable, p)=>{
+    const context = useContext(DateFieldContext);
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    const renderProps = ()=>({
+            value: context?.value() ?? "",
+            isInvalid: context?.isInvalid() ?? false,
+            isDisabled: context?.isDisabled() ?? false,
+            isRequired: context?.isRequired() ?? false
+        });
+    return (()=>{
+        var _el$2 = _tmpl$();
+        spread(_el$2, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Group.base, CLASSES.Group.variant[context?.variant() ?? "primary"], context?.fullWidth() && CLASSES.Group.flag.fullWidth, local.class, local.className)
+            }), {
+            "data-slot": "date-input-group",
+            get ["data-invalid"] () {
+                return context?.isInvalid() ? "true" : void 0;
+            },
+            get ["data-disabled"] () {
+                return context?.isDisabled() ? "true" : void 0;
+            },
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$2, (()=>{
+            var _c$2 = memo(()=>"function" == typeof local.children);
+            return ()=>_c$2() ? local.children(renderProps()) : local.children;
+        })());
+        return _el$2;
+    })();
+};
+const DateFieldGroup = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutDateFieldGroup,
+    embedded: true
+});
+const __solidLayoutDateFieldInput = (_stable, p)=>{
+    const context = useContext(DateFieldContext);
+    const [local, others] = splitProps(p, [
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "onInput",
+        "onBlur",
+        "name"
+    ]);
+    const handleInput = (event)=>{
+        invokeEventHandler(local.onInput, event);
+        if (event.defaultPrevented) return;
+        context?.setValue(event.currentTarget.value);
+    };
+    const handleBlur = (event)=>{
+        invokeEventHandler(local.onBlur, event);
+        invokeEventHandler(context?.onBlur(), event);
+    };
+    return (()=>{
+        var _el$3 = _tmpl$2();
+        spread(_el$3, mergeProps(others, {
+            type: "date"
+        }, ()=>({
+                class: twMerge(CLASSES.Input.base, local.class, local.className)
+            }), {
+            "data-slot": "date-input-group-input",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            },
+            get name () {
+                return local.name ?? context?.name();
+            },
+            get value () {
+                return context?.value() ?? "";
+            },
+            get disabled () {
+                return context?.isDisabled();
+            },
+            get required () {
+                return context?.isRequired();
+            },
+            get ["aria-invalid"] () {
+                return context?.isInvalid() ? "true" : void 0;
+            },
+            get ["aria-disabled"] () {
+                return context?.isDisabled() ? "true" : void 0;
+            },
+            onInput: handleInput,
+            onBlur: handleBlur
+        }), false, false);
+        return _el$3;
+    })();
+};
+const DateFieldInput = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutDateFieldInput,
+    embedded: true
+});
+const __solidLayoutDateFieldInputContainer = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    return (()=>{
+        var _el$4 = _tmpl$();
+        spread(_el$4, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.InputContainer.base, local.class, local.className)
+            }), {
+            "data-slot": "date-input-group-input-container",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$4, ()=>local.children);
+        return _el$4;
+    })();
+};
+const DateFieldInputContainer = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutDateFieldInputContainer,
+    embedded: true
+});
+const __solidLayoutDateFieldSegment = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "segment"
+    ]);
+    return (()=>{
+        var _el$5 = _tmpl$3();
+        spread(_el$5, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Segment.base, local.class, local.className)
+            }), {
+            "data-slot": "date-input-group-segment",
+            get ["data-type"] () {
+                return local.segment?.type;
+            },
+            get ["data-placeholder"] () {
+                return local.segment?.isPlaceholder ? "true" : void 0;
+            },
+            get ["data-invalid"] () {
+                return local.segment?.isInvalid ? "true" : void 0;
+            },
+            get ["data-focused"] () {
+                return local.segment?.isFocused ? "true" : void 0;
+            },
+            get ["data-disabled"] () {
+                return local.segment?.isDisabled ? "true" : void 0;
+            },
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$5, ()=>local.children ?? local.segment?.text);
+        return _el$5;
+    })();
+};
+const DateFieldSegment = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutDateFieldSegment,
+    embedded: true
+});
+const __solidLayoutDateFieldPrefix = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    return (()=>{
+        var _el$6 = _tmpl$();
+        spread(_el$6, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Prefix.base, local.class, local.className)
+            }), {
+            "data-slot": "date-input-group-prefix",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$6, ()=>local.children);
+        return _el$6;
+    })();
+};
+const DateFieldPrefix = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutDateFieldPrefix,
+    embedded: true
+});
+const __solidLayoutDateFieldSuffix = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    return (()=>{
+        var _el$7 = _tmpl$();
+        spread(_el$7, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Suffix.base, local.class, local.className)
+            }), {
+            "data-slot": "date-input-group-suffix",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$7, ()=>local.children);
+        return _el$7;
+    })();
+};
+const DateFieldSuffix = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutDateFieldSuffix,
+    embedded: true
+});
+const DateField = Object.assign(DateFieldRoot, {
+    Root: DateFieldRoot,
+    Group: DateFieldGroup,
+    Input: DateFieldInput,
+    InputContainer: DateFieldInputContainer,
+    Segment: DateFieldSegment,
+    Prefix: DateFieldPrefix,
+    Suffix: DateFieldSuffix
+});
+const DateField_generated = DateField;
+export default DateField_generated;
+export { DateField, DateFieldGroup, DateFieldInput, DateFieldInputContainer, DateFieldPrefix, DateFieldRoot, DateFieldSegment, DateFieldSuffix };

package/dist/components/date-field/DateField.recipe.d.ts

@@ -0,0 +1,50 @@
+export declare const CLASSES: {
+    readonly Root: {
+        readonly base: "date-field";
+        readonly variant: {
+            readonly primary: "date-field--primary";
+            readonly secondary: "date-field--secondary";
+        };
+        readonly flag: {
+            readonly fullWidth: "date-field--full-width";
+        };
+    };
+    readonly Group: {
+        readonly base: "date-input-group";
+        readonly variant: {
+            readonly primary: "date-input-group--primary";
+            readonly secondary: "date-input-group--secondary";
+        };
+        readonly flag: {
+            readonly fullWidth: "date-input-group--full-width";
+        };
+    };
+    readonly Input: {
+        readonly base: "date-input-group__input";
+    };
+    readonly InputContainer: {
+        readonly base: "date-input-group__input-container";
+    };
+    readonly Segment: {
+        readonly base: "date-input-group__segment";
+    };
+    readonly Prefix: {
+        readonly base: "date-input-group__prefix";
+    };
+    readonly Suffix: {
+        readonly base: "date-input-group__suffix";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "date-field";
+    readonly slots: {
+        readonly "date-field": {};
+        readonly "date-input-group": {};
+        readonly "date-input-group-input": {};
+        readonly "date-input-group-input-container": {};
+        readonly "date-input-group-prefix": {};
+        readonly "date-input-group-segment": {};
+        readonly "date-input-group-suffix": {};
+        readonly root: {};
+    };
+}>;