@pathscale/ui 1.1.56 → 1.1.57

package/dist/components/scroll-shadow/ScrollShadow.js

@@ -0,0 +1,87 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__ from "solid-js/web";
+import "./ScrollShadow.css";
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+import * as __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__ from "tailwind-merge";
+import * as __WEBPACK_EXTERNAL_MODULE__ScrollShadow_classes_js_12f8416d__ from "./ScrollShadow.classes.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useScrollShadow_js_5837647e__ from "./useScrollShadow.js";
+var _tmpl$ = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.template)("<div>");
+const ScrollShadow = (props)=>{
+    const [local, others] = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.splitProps)(props, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "size",
+        "offset",
+        "visibility",
+        "isEnabled",
+        "orientation",
+        "variant",
+        "hideScrollBar",
+        "onVisibilityChange",
+        "ref"
+    ]);
+    let containerRef;
+    const size = ()=>local.size ?? 40;
+    const offset = ()=>local.offset ?? 0;
+    const variant = ()=>local.variant ?? "fade";
+    const visibility = ()=>local.visibility ?? "auto";
+    const orientation = ()=>local.orientation ?? "vertical";
+    const isEnabled = ()=>local.isEnabled ?? true;
+    (0, __WEBPACK_EXTERNAL_MODULE__useScrollShadow_js_5837647e__.useScrollShadow)({
+        containerRef: ()=>containerRef,
+        orientation,
+        offset,
+        visibility,
+        isEnabled,
+        onVisibilityChange: ()=>local.onVisibilityChange
+    });
+    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createEffect)(()=>{
+        const el = containerRef;
+        if (!el) return;
+        if (!isEnabled()) return void (0, __WEBPACK_EXTERNAL_MODULE__useScrollShadow_js_5837647e__.clearScrollShadowDataAttributes)(el);
+        const currentVisibility = visibility();
+        if ("auto" === currentVisibility) return;
+        (0, __WEBPACK_EXTERNAL_MODULE__useScrollShadow_js_5837647e__.applyControlledScrollShadowVisibility)(el, currentVisibility, orientation());
+    });
+    const classes = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>(0, __WEBPACK_EXTERNAL_MODULE_tailwind_merge_e05e3e95__.twMerge)(__WEBPACK_EXTERNAL_MODULE__ScrollShadow_classes_js_12f8416d__.CLASSES.base, __WEBPACK_EXTERNAL_MODULE__ScrollShadow_classes_js_12f8416d__.CLASSES.orientation[orientation()], __WEBPACK_EXTERNAL_MODULE__ScrollShadow_classes_js_12f8416d__.CLASSES.variant[variant()], local.hideScrollBar && __WEBPACK_EXTERNAL_MODULE__ScrollShadow_classes_js_12f8416d__.CLASSES.flag.hideScrollBar, local.class, local.className));
+    const style = (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createMemo)(()=>{
+        if ("string" == typeof local.style) {
+            const trimmed = local.style.trim();
+            const suffix = trimmed.length > 0 && !trimmed.endsWith(";") ? ";" : "";
+            return `${trimmed}${suffix} --scroll-shadow-size: ${size()}px;`;
+        }
+        return {
+            ...local.style ?? {},
+            "--scroll-shadow-size": `${size()}px`
+        };
+    });
+    return (()=>{
+        var _el$ = _tmpl$();
+        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.use)((el)=>{
+            containerRef = el;
+            if ("function" == typeof local.ref) local.ref(el);
+        }, _el$);
+        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.spread)(_el$, (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.mergeProps)(others, ()=>({
+                class: classes()
+            }), {
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get ["data-orientation"] () {
+                return orientation();
+            },
+            get ["data-scroll-shadow-size"] () {
+                return size();
+            },
+            get style () {
+                return style();
+            }
+        }), false, true);
+        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_web_35d951b7__.insert)(_el$, ()=>local.children);
+        return _el$;
+    })();
+};
+const scroll_shadow_ScrollShadow = ScrollShadow;
+export { scroll_shadow_ScrollShadow as default };

package/dist/components/scroll-shadow/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./ScrollShadow";
+export type { ScrollShadowProps, ScrollShadowVisibility, ScrollShadowOrientation, ScrollShadowVariant, } from "./ScrollShadow";

package/dist/components/scroll-shadow/index.js

@@ -0,0 +1,3 @@
+import * as __WEBPACK_EXTERNAL_MODULE__ScrollShadow_js_a859c3d0__ from "./ScrollShadow.js";
+var __webpack_exports__default = __WEBPACK_EXTERNAL_MODULE__ScrollShadow_js_a859c3d0__["default"];
+export { __webpack_exports__default as default };

package/dist/components/scroll-shadow/useScrollShadow.d.ts

@@ -0,0 +1,13 @@
+import { type Accessor } from "solid-js";
+import type { ScrollShadowOrientation, ScrollShadowVisibility } from "./ScrollShadow";
+export interface UseScrollShadowProps {
+    containerRef: Accessor<HTMLElement | undefined>;
+    orientation: Accessor<ScrollShadowOrientation>;
+    offset: Accessor<number>;
+    visibility: Accessor<ScrollShadowVisibility>;
+    isEnabled: Accessor<boolean>;
+    onVisibilityChange?: Accessor<((visibility: ScrollShadowVisibility) => void) | undefined>;
+}
+export declare const clearScrollShadowDataAttributes: (el: HTMLElement) => void;
+export declare const applyControlledScrollShadowVisibility: (el: HTMLElement, visibility: ScrollShadowVisibility, orientation: ScrollShadowOrientation) => void;
+export declare const useScrollShadow: (props: UseScrollShadowProps) => void;

package/dist/components/scroll-shadow/useScrollShadow.js

@@ -0,0 +1,97 @@
+import * as __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__ from "solid-js";
+const clearScrollShadowDataAttributes = (el)=>{
+    delete el.dataset.topScroll;
+    delete el.dataset.bottomScroll;
+    delete el.dataset.topBottomScroll;
+    delete el.dataset.leftScroll;
+    delete el.dataset.rightScroll;
+    delete el.dataset.leftRightScroll;
+};
+const applyControlledScrollShadowVisibility = (el, visibility, orientation)=>{
+    clearScrollShadowDataAttributes(el);
+    if ("both" === visibility) {
+        if ("vertical" === orientation) el.dataset.topBottomScroll = "true";
+        else el.dataset.leftRightScroll = "true";
+        return;
+    }
+    if ("none" === visibility || "auto" === visibility) return;
+    if ("top" === visibility) el.dataset.topScroll = "true";
+    else if ("bottom" === visibility) el.dataset.bottomScroll = "true";
+    else if ("left" === visibility) el.dataset.leftScroll = "true";
+    else if ("right" === visibility) el.dataset.rightScroll = "true";
+};
+const resolveVisibilityFromOverflow = (orientation, hasScrollBefore, hasScrollAfter)=>{
+    if (hasScrollBefore && hasScrollAfter) return "both";
+    if (hasScrollBefore) return "vertical" === orientation ? "top" : "left";
+    if (hasScrollAfter) return "vertical" === orientation ? "bottom" : "right";
+    return "none";
+};
+const applyAutoVisibilityDataAttributes = (el, orientation, hasScrollBefore, hasScrollAfter)=>{
+    if ("vertical" === orientation) {
+        if (hasScrollBefore && hasScrollAfter) {
+            el.dataset.topBottomScroll = "true";
+            delete el.dataset.topScroll;
+            delete el.dataset.bottomScroll;
+            return;
+        }
+        el.dataset.topScroll = String(hasScrollBefore);
+        el.dataset.bottomScroll = String(hasScrollAfter);
+        delete el.dataset.topBottomScroll;
+        return;
+    }
+    if (hasScrollBefore && hasScrollAfter) {
+        el.dataset.leftRightScroll = "true";
+        delete el.dataset.leftScroll;
+        delete el.dataset.rightScroll;
+        return;
+    }
+    el.dataset.leftScroll = String(hasScrollBefore);
+    el.dataset.rightScroll = String(hasScrollAfter);
+    delete el.dataset.leftRightScroll;
+};
+const useScrollShadow = (props)=>{
+    (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.createEffect)(()=>{
+        const el = props.containerRef();
+        const isEnabled = props.isEnabled();
+        const visibility = props.visibility();
+        const orientation = props.orientation();
+        const offset = props.offset();
+        const onVisibilityChange = props.onVisibilityChange?.();
+        if (!el) return;
+        if (!isEnabled) return void clearScrollShadowDataAttributes(el);
+        if ("auto" !== visibility) return;
+        let prevState = null;
+        let rafId = null;
+        const checkOverflow = ()=>{
+            const scrollStart = "vertical" === orientation ? el.scrollTop : el.scrollLeft;
+            const scrollSize = "vertical" === orientation ? el.scrollHeight : el.scrollWidth;
+            const clientSize = "vertical" === orientation ? el.clientHeight : el.clientWidth;
+            const hasScrollBefore = scrollStart > offset;
+            const hasScrollAfter = scrollStart + clientSize + offset < scrollSize;
+            if (prevState && prevState.hasScrollBefore === hasScrollBefore && prevState.hasScrollAfter === hasScrollAfter) return;
+            prevState = {
+                hasScrollBefore,
+                hasScrollAfter
+            };
+            if (null !== rafId) cancelAnimationFrame(rafId);
+            rafId = requestAnimationFrame(()=>{
+                rafId = null;
+                applyAutoVisibilityDataAttributes(el, orientation, hasScrollBefore, hasScrollAfter);
+                onVisibilityChange?.(resolveVisibilityFromOverflow(orientation, hasScrollBefore, hasScrollAfter));
+            });
+        };
+        checkOverflow();
+        el.addEventListener("scroll", checkOverflow, {
+            passive: true
+        });
+        const resizeObserver = "undefined" != typeof ResizeObserver ? new ResizeObserver(()=>checkOverflow()) : void 0;
+        resizeObserver?.observe(el);
+        (0, __WEBPACK_EXTERNAL_MODULE_solid_js_aeefcc6d__.onCleanup)(()=>{
+            el.removeEventListener("scroll", checkOverflow);
+            resizeObserver?.disconnect();
+            if (null !== rafId) cancelAnimationFrame(rafId);
+            prevState = null;
+        });
+    });
+};
+export { applyControlledScrollShadowVisibility, clearScrollShadowDataAttributes, useScrollShadow };

package/dist/components/search-field/SearchField.classes.d.ts

@@ -0,0 +1,27 @@
+export declare const CLASSES: {
+    readonly Root: {
+        readonly base: "search-field";
+        readonly variant: {
+            readonly primary: "search-field--primary";
+            readonly secondary: "search-field--secondary";
+        };
+        readonly flag: {
+            readonly fullWidth: "search-field--full-width";
+        };
+    };
+    readonly Group: {
+        readonly base: "search-field__group";
+        readonly flag: {
+            readonly fullWidth: "search-field__group--full-width";
+        };
+    };
+    readonly Input: {
+        readonly base: "search-field__input";
+    };
+    readonly SearchIcon: {
+        readonly base: "search-field__search-icon";
+    };
+    readonly ClearButton: {
+        readonly base: "search-field__clear-button";
+    };
+};

package/dist/components/search-field/SearchField.classes.js

@@ -0,0 +1,28 @@
+const CLASSES = {
+    Root: {
+        base: "search-field",
+        variant: {
+            primary: "search-field--primary",
+            secondary: "search-field--secondary"
+        },
+        flag: {
+            fullWidth: "search-field--full-width"
+        }
+    },
+    Group: {
+        base: "search-field__group",
+        flag: {
+            fullWidth: "search-field__group--full-width"
+        }
+    },
+    Input: {
+        base: "search-field__input"
+    },
+    SearchIcon: {
+        base: "search-field__search-icon"
+    },
+    ClearButton: {
+        base: "search-field__clear-button"
+    }
+};
+export { CLASSES };

package/dist/components/search-field/SearchField.css

@@ -0,0 +1,183 @@
+@layer components {
+  .search-field {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .search-field[data-invalid="true"] [data-slot="description"],
+  .search-field[aria-invalid="true"] [data-slot="description"] {
+    display: none;
+  }
+
+  .search-field [data-slot="label"] {
+    width: fit-content;
+  }
+
+  .search-field [data-slot="description"] {
+    padding-inline: 0.25rem;
+  }
+
+  .search-field[data-empty="true"] [data-slot="search-field-clear-button"] {
+    pointer-events: none;
+    opacity: 0;
+  }
+
+  .search-field__group {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    height: 2.25rem;
+    overflow: hidden;
+    border-radius: var(--radius-field, 0.75rem);
+    border: var(--border-width-field, 1px) solid
+      var(--color-field-border, color-mix(in oklab, var(--color-base-content) 16%, transparent));
+    background-color: var(--color-field, var(--color-base-100));
+    color: var(--color-field-foreground, var(--color-base-content));
+    box-shadow:
+      0 1px 0 color-mix(in oklab, var(--color-base-content) 8%, transparent),
+      0 1px 0 color-mix(in oklab, var(--color-base-100) 60%, transparent) inset;
+    outline: none;
+    transition:
+      background-color 150ms var(--ease-smooth),
+      border-color 150ms var(--ease-smooth),
+      box-shadow 150ms var(--ease-out);
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .search-field__group {
+      transition: none;
+    }
+  }
+
+  @media (hover: hover) {
+    .search-field__group:hover:not(:focus-within):not([data-disabled="true"]) {
+      background-color: var(--color-field-hover, var(--color-base-200));
+      border-color: var(--color-field-border-hover, color-mix(in oklab, var(--color-base-content) 22%, transparent));
+    }
+  }
+
+  .search-field__group:focus-within,
+  .search-field__group[data-focus-within="true"] {
+    border-color: var(--color-field-border-focus, var(--color-accent));
+    background-color: var(--color-field-focus, var(--color-base-100));
+    box-shadow:
+      0 0 0 3px color-mix(in oklab, var(--color-accent) 22%, transparent),
+      0 1px 0 color-mix(in oklab, var(--color-accent) 24%, transparent);
+  }
+
+  .search-field__group[data-invalid="true"] {
+    border-color: var(--color-field-border-invalid, var(--color-danger));
+    background-color: var(--color-field-focus, var(--color-base-100));
+    box-shadow:
+      0 0 0 3px color-mix(in oklab, var(--color-danger) 20%, transparent),
+      0 1px 0 color-mix(in oklab, var(--color-danger) 20%, transparent);
+  }
+
+  .search-field__group[data-disabled="true"],
+  .search-field__group[aria-disabled="true"] {
+    cursor: not-allowed;
+    background-color: var(--color-base-200);
+    color: color-mix(in oklab, var(--color-base-content) 45%, transparent);
+    opacity: var(--disabled-opacity, 0.6);
+    box-shadow: none;
+  }
+
+  .search-field__input {
+    flex: 1;
+    min-width: 0;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    padding-block: 0.5rem;
+    padding-inline: 0.75rem;
+    font-size: 0.875rem;
+    line-height: 1.25rem;
+    color: inherit;
+    box-shadow: none;
+    outline: none;
+  }
+
+  .search-field__input::placeholder {
+    color: var(--color-field-placeholder, color-mix(in oklab, var(--color-base-content) 45%, transparent));
+  }
+
+  .search-field__input::-webkit-search-cancel-button,
+  .search-field__input::-webkit-search-decoration {
+    -webkit-appearance: none;
+    appearance: none;
+  }
+
+  .search-field__group:has([data-slot="search-field-search-icon"]) .search-field__input {
+    padding-inline-start: 0.5rem;
+  }
+
+  .search-field__group:has([slot="clear"]) .search-field__input {
+    padding-inline-end: 0.5rem;
+  }
+
+  .search-field__input:focus,
+  .search-field__input:focus-visible {
+    outline: none;
+  }
+
+  .search-field__search-icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    margin-inline-start: 0.75rem;
+    margin-inline-end: 0;
+    flex-shrink: 0;
+    width: 1rem;
+    height: 1rem;
+    color: var(--color-field-placeholder, color-mix(in oklab, var(--color-base-content) 45%, transparent));
+    pointer-events: none;
+  }
+
+  .search-field__search-icon > * {
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+  }
+
+  .search-field__clear-button {
+    margin-inline-end: 0.5rem;
+    flex-shrink: 0;
+    width: 1.25rem;
+    height: 1.25rem;
+  }
+
+  .search-field__clear-button > * {
+    width: 0.75rem;
+    height: 0.75rem;
+  }
+
+  .search-field--secondary .search-field__group {
+    box-shadow: none;
+    background-color: var(--search-field-group-bg, var(--color-default, var(--color-base-200)));
+  }
+
+  @media (hover: hover) {
+    .search-field--secondary .search-field__group:hover:not(:focus-within):not([data-disabled="true"]) {
+      background-color: var(--search-field-group-bg-hover, var(--color-default-hover, var(--color-base-300)));
+    }
+  }
+
+  .search-field--secondary .search-field__group:focus-within,
+  .search-field--secondary .search-field__group[data-focus-within="true"] {
+    background-color: var(--search-field-group-bg-focus, var(--color-default, var(--color-base-200)));
+  }
+
+  .search-field--secondary .search-field__group[data-invalid="true"] {
+    border-color: var(--color-field-border-invalid, var(--color-danger));
+    background-color: var(--search-field-group-bg-focus, var(--color-default, var(--color-base-200)));
+  }
+
+  .search-field--full-width {
+    width: 100%;
+  }
+
+  .search-field__group--full-width {
+    width: 100%;
+  }
+}

package/dist/components/search-field/SearchField.d.ts

@@ -0,0 +1,53 @@
+import "./SearchField.css";
+import { type Component, type JSX, type ParentComponent } from "solid-js";
+import { type CloseButtonProps } from "../close-button";
+import type { IComponentBaseProps } from "../types";
+export type SearchFieldVariant = "primary" | "secondary";
+export type SearchFieldRenderProps = {
+    value: string;
+    isEmpty: boolean;
+    isInvalid: boolean;
+    isDisabled: boolean;
+};
+export type SearchFieldRootProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children" | "onChange" | "onBlur"> & IComponentBaseProps & {
+    children?: JSX.Element | ((props: SearchFieldRenderProps) => JSX.Element);
+    startIcon?: JSX.Element;
+    endIcon?: JSX.Element;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onBlur?: JSX.EventHandlerUnion<HTMLInputElement, FocusEvent>;
+    fullWidth?: boolean;
+    variant?: SearchFieldVariant;
+    isDisabled?: boolean;
+    disabled?: boolean;
+    isInvalid?: boolean;
+};
+export type SearchFieldGroupProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element | ((props: SearchFieldRenderProps) => JSX.Element);
+};
+export type SearchFieldInputProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "value" | "onInput" | "type"> & IComponentBaseProps & {
+    onInput?: JSX.EventHandlerUnion<HTMLInputElement, InputEvent>;
+};
+export type SearchFieldSearchIconProps = JSX.HTMLAttributes<HTMLSpanElement> & IComponentBaseProps & {
+    children?: JSX.Element;
+};
+export type SearchFieldClearButtonProps = Omit<CloseButtonProps, "onClick"> & IComponentBaseProps & {
+    onClick?: JSX.EventHandlerUnion<HTMLButtonElement, MouseEvent>;
+};
+declare const SearchFieldRoot: ParentComponent<SearchFieldRootProps>;
+declare const SearchFieldGroup: ParentComponent<SearchFieldGroupProps>;
+declare const SearchFieldInput: Component<SearchFieldInputProps>;
+declare const SearchFieldSearchIcon: Component<SearchFieldSearchIconProps>;
+declare const SearchFieldClearButton: Component<SearchFieldClearButtonProps>;
+declare const SearchField: ParentComponent<SearchFieldRootProps> & {
+    Root: ParentComponent<SearchFieldRootProps>;
+    Group: ParentComponent<SearchFieldGroupProps>;
+    Input: Component<SearchFieldInputProps>;
+    SearchIcon: Component<SearchFieldSearchIconProps>;
+    ClearButton: Component<SearchFieldClearButtonProps>;
+};
+export default SearchField;
+export { SearchField, SearchFieldRoot, SearchFieldGroup, SearchFieldInput, SearchFieldSearchIcon, SearchFieldClearButton, };
+export type { SearchFieldRootProps as SearchFieldProps };