@pathscale/ui 0.0.1 → 0.0.2

package/dist/Accordion-nwuRbRRw.d.ts

@@ -0,0 +1,27 @@
+import { Component, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const accordionContainerVariants: {
+    (props?: (ConfigVariants<{
+        expanded: {
+            true: string;
+            false: string;
+        };
+        disabled: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("disabled" | "expanded")[];
+};
+
+type AccordionProps = {
+    expanded?: boolean;
+    disabled?: boolean;
+    headerIsTrigger?: boolean;
+    header: JSX.Element;
+    content: JSX.Element;
+} & VariantProps<typeof accordionContainerVariants> & JSX.HTMLAttributes<HTMLDivElement>;
+declare const Accordion: Component<AccordionProps>;
+
+export { Accordion as A, type AccordionProps as a };

package/dist/Checkbox-BjaweaOH.d.ts

@@ -0,0 +1,40 @@
+import { Component, ComponentProps, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const checkboxVariants: {
+    (props?: (ConfigVariants<{
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        color: {
+            primary: string;
+            success: string;
+            warning: string;
+            danger: string;
+        };
+        checked: {
+            true: string;
+            false: string;
+        };
+        indeterminate: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "color" | "checked" | "indeterminate")[];
+};
+
+type CheckboxProps = VariantProps<typeof checkboxVariants> & ClassProps & Omit<ComponentProps<"input">, "onChange" | "onFocus" | "onBlur"> & {
+    indeterminate?: boolean;
+    label?: JSX.Element;
+    onChange?: JSX.EventHandlerUnion<HTMLInputElement, Event>;
+    onFocus?: JSX.EventHandlerUnion<HTMLInputElement, FocusEvent>;
+    onBlur?: JSX.EventHandlerUnion<HTMLInputElement, FocusEvent>;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+};
+declare const Checkbox: Component<CheckboxProps>;
+
+export { Checkbox as C, type CheckboxProps as a };

package/dist/Pagination-BlrjElGg.d.ts

@@ -0,0 +1,43 @@
+import { Component, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const paginationItemVariants: {
+    (props?: (ConfigVariants<{
+        active: {
+            true: string;
+            false: string;
+        };
+        rounded: {
+            true: string;
+            false: string;
+        };
+        simple: {
+            true: string;
+            false: string;
+        };
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        disabled: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "rounded" | "disabled" | "active" | "simple")[];
+};
+
+type PaginationProps = {
+    total: number;
+    perPage?: number;
+    current: number;
+    onChange: (page: number) => void;
+    rangeBefore?: number;
+    rangeAfter?: number;
+    simple?: boolean;
+    children?: JSX.Element;
+} & VariantProps<typeof paginationItemVariants> & JSX.HTMLAttributes<HTMLElement>;
+declare const Pagination: Component<PaginationProps>;
+
+export { Pagination as P, type PaginationProps as a };

package/dist/Progress-a616LgE0.d.ts

@@ -0,0 +1,5 @@
+import { Component } from 'solid-js';
+
+declare const Progress: Component;
+
+export { Progress as P };

package/dist/Select-CP-TUHJv.d.ts

@@ -0,0 +1,44 @@
+import { Component, ComponentProps, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const selectVariants: {
+    (props?: (ConfigVariants<{
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        color: {
+            primary: string;
+            info: string;
+            success: string;
+            warning: string;
+            danger: string;
+        };
+        loading: {
+            true: string;
+            false: string;
+        };
+        expanded: {
+            true: string;
+            false: string;
+        };
+        rounded: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "rounded" | "loading" | "color" | "expanded")[];
+};
+
+type SelectProps = VariantProps<typeof selectVariants> & ClassProps & ComponentProps<"select"> & {
+    placeholder?: string;
+    nativeSize?: string | number;
+    value?: string | number | null;
+    onChange?: JSX.EventHandlerUnion<HTMLSelectElement, Event>;
+    onFocus?: JSX.EventHandlerUnion<HTMLSelectElement, FocusEvent>;
+    onBlur?: JSX.EventHandlerUnion<HTMLSelectElement, FocusEvent>;
+};
+declare const Select: Component<SelectProps>;
+
+export { Select as S, type SelectProps as a };

package/dist/Switch-3IXS_68H.d.ts

@@ -0,0 +1,72 @@
+import { Component, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const switchVariants: {
+    (props?: (ConfigVariants<{
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        disabled: {
+            true: string;
+            false: string;
+        };
+        rounded: {
+            true: string;
+            false: string;
+        };
+        outlined: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "rounded" | "outlined" | "disabled")[];
+};
+declare const checkVariants: {
+    (props?: (ConfigVariants<{
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        color: {
+            blue: string;
+            green: string;
+            red: string;
+            yellow: string;
+            gray: string;
+        };
+        passiveColor: {
+            blue: string;
+            green: string;
+            red: string;
+            yellow: string;
+            gray: string;
+        };
+        rounded: {
+            true: string;
+            false: string;
+        };
+        outlined: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "rounded" | "outlined" | "color" | "passiveColor")[];
+};
+
+type SwitchProps = {
+    children?: JSX.Element;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+    name?: string;
+    required?: boolean;
+    disabled?: boolean;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+} & VariantProps<typeof switchVariants> & VariantProps<typeof checkVariants> & Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "onChange">;
+declare const Switch: Component<SwitchProps>;
+
+export { Switch as S, type SwitchProps as a };

package/dist/Tabs-BNR3p92D.d.ts

@@ -0,0 +1,42 @@
+import { Component, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const tabsNavVariants: {
+    (props?: (ConfigVariants<{
+        type: {
+            basic: string;
+            boxed: string;
+            toggle: string;
+            "toggle-rounded": string;
+        };
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        alignment: {
+            left: string;
+            center: string;
+            right: string;
+        };
+        expanded: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "type" | "expanded" | "alignment")[];
+};
+
+type TabItem = {
+    label: string;
+    content: JSX.Element;
+    disabled?: boolean;
+};
+type TabsProps = {
+    items: TabItem[];
+    value?: number;
+    onChange?: (index: number) => void;
+} & VariantProps<typeof tabsNavVariants>;
+declare const Tabs: Component<TabsProps>;
+
+export { Tabs as T, type TabsProps as a };

package/dist/Tag-BPrhn-Ne.d.ts

@@ -0,0 +1,42 @@
+import { Component, ComponentProps, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const tagVariants: {
+    (props?: (ConfigVariants<{
+        size: {
+            normal: string;
+            medium: string;
+            large: string;
+        };
+        type: {
+            primary: string;
+            info: string;
+            success: string;
+            warning: string;
+            danger: string;
+            dark: string;
+            light: string;
+        };
+        rounded: {
+            true: string;
+            false: string;
+        };
+        closable: {
+            true: string;
+            false: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "rounded" | "type" | "closable")[];
+};
+
+type TagProps = VariantProps<typeof tagVariants> & ClassProps & ComponentProps<"span"> & {
+    closable?: boolean;
+    attached?: boolean;
+    ariaCloseLabel?: string;
+    onClose?: (e: MouseEvent) => void;
+    closeIcon?: JSX.Element;
+    children?: JSX.Element;
+};
+declare const Tag: Component<TagProps>;
+
+export { Tag as T, type TagProps as a };

package/dist/Tooltip-BfPongoz.d.ts

@@ -0,0 +1,53 @@
+import { Component, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const tooltipVariants: {
+    (props?: (ConfigVariants<{
+        type: {
+            info: string;
+            success: string;
+            warning: string;
+            danger: string;
+            primary: string;
+            gray: string;
+        };
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        rounded: {
+            true: string;
+            false: string;
+        };
+        dashed: {
+            true: string;
+            false: string;
+        };
+        multilined: {
+            true: string;
+            false: string;
+        };
+        animated: {
+            true: string;
+            false: string;
+        };
+        position: {
+            top: string;
+            bottom: string;
+            left: string;
+            right: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "rounded" | "type" | "dashed" | "multilined" | "animated" | "position")[];
+};
+
+type TooltipProps = {
+    label: string;
+    delay?: number;
+    always?: boolean;
+    children?: JSX.Element;
+} & VariantProps<typeof tooltipVariants> & JSX.HTMLAttributes<HTMLSpanElement>;
+declare const Tooltip: Component<TooltipProps>;
+
+export { Tooltip as T, type TooltipProps as a };

package/dist/Upload-BrFuZ4JA.d.ts

@@ -0,0 +1,39 @@
+import { Component, JSX } from 'solid-js';
+import { C as ConfigVariants, a as ClassProps, V as VariantProps } from './classes-B_S9K-9I.js';
+
+declare const uploadWrapperVariants: {
+    (props?: (ConfigVariants<{
+        style: {
+            boxed: string;
+            button: string;
+        };
+        color: {
+            primary: string;
+            success: string;
+            info: string;
+            warning: string;
+            danger: string;
+            gray: string;
+        };
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+    }> & ClassProps) | undefined): string;
+    variantKeys: ("size" | "style" | "color")[];
+};
+
+type UploadProps = {
+    icon?: JSX.Element;
+    label?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    accept?: string;
+    dragDrop?: boolean;
+    name?: string;
+    onChange?: (files: File | File[]) => void;
+} & VariantProps<typeof uploadWrapperVariants> & JSX.InputHTMLAttributes<HTMLInputElement>;
+declare const Upload: Component<UploadProps>;
+
+export { Upload as U, type UploadProps as a };

package/dist/chunk/3IHANYRN.js

@@ -0,0 +1,98 @@
+import { cva, classes } from './HKS7ET6T.js';
+import { template, spread, mergeProps, insert, createComponent, memo } from 'solid-js/web';
+import { splitProps, createMemo, untrack, Show } from 'solid-js';
+
+// src/components/select/Select.styles.ts
+var selectVariants = cva(
+  [
+    "relative inline-flex items-center appearance-none",
+    "border outline-none",
+    "transition bg-white text-black",
+    "disabled:opacity-50 disabled:cursor-not-allowed"
+  ],
+  {
+    variants: {
+      size: {
+        sm: "text-sm px-2 py-1",
+        md: "text-base px-3 py-2",
+        lg: "text-lg px-4 py-2"
+      },
+      color: {
+        primary: "border-gray-300 focus:border-primary",
+        info: "border-blue-300 focus:border-blue-500",
+        success: "border-green-300 focus:border-green-500",
+        warning: "border-yellow-300 focus:border-yellow-500",
+        danger: "border-red-300 focus:border-red-500"
+      },
+      loading: {
+        true: "cursor-wait opacity-75",
+        false: ""
+      },
+      expanded: {
+        true: "w-full",
+        false: "w-fit"
+      },
+      rounded: {
+        true: "rounded",
+        false: "rounded-none"
+      }
+    },
+    defaultVariants: {
+      size: "md",
+      color: "primary",
+      loading: false,
+      expanded: false,
+      rounded: false
+    }
+  }
+);
+
+// src/components/select/Select.tsx
+var _tmpl$ = /* @__PURE__ */ template(`<option value disabled hidden>`);
+var _tmpl$2 = /* @__PURE__ */ template(`<select>`);
+var Select = (props) => {
+  const [localProps, variantProps, otherProps] = splitProps(props, ["placeholder", "value", "nativeSize", "onChange", "onBlur", "onFocus"], ["class", ...selectVariants.variantKeys]);
+  const empty = createMemo(() => untrack(() => localProps.value === null || localProps.value === void 0));
+  const selectClasses = createMemo(() => classes(selectVariants(variantProps), variantProps.class));
+  return (() => {
+    var _el$ = _tmpl$2();
+    spread(_el$, mergeProps({
+      get ["class"]() {
+        return selectClasses();
+      },
+      get size() {
+        return localProps.nativeSize;
+      },
+      get value() {
+        return localProps.value;
+      },
+      get onChange() {
+        return localProps.onChange;
+      },
+      get onFocus() {
+        return localProps.onFocus;
+      },
+      get onBlur() {
+        return localProps.onBlur;
+      }
+    }, otherProps), false, true);
+    insert(_el$, createComponent(Show, {
+      get when() {
+        return memo(() => !!localProps.placeholder)() && empty();
+      },
+      get children() {
+        var _el$2 = _tmpl$();
+        insert(_el$2, () => localProps.placeholder);
+        return _el$2;
+      }
+    }), null);
+    insert(_el$, () => props.children, null);
+    return _el$;
+  })();
+};
+var Select_default = Select;
+
+// src/components/select/index.ts
+var select_default = Select_default;
+
+export { select_default };

package/dist/chunk/4TWLQ3IA.js

@@ -0,0 +1,103 @@
+import { cva } from './HKS7ET6T.js';
+import { template, spread, insert, createComponent, effect, className } from 'solid-js/web';
+import { splitProps, Show } from 'solid-js';
+
+// src/components/tooltip/Tooltip.styles.ts
+var tooltipVariants = cva(
+  [
+    "absolute z-10 px-3 py-1 text-white text-sm",
+    "opacity-0 group-hover:opacity-100",
+    "pointer-events-none transition-opacity duration-200",
+    "max-w-xs break-words",
+    "after:content-[''] after:absolute after:w-2 after:h-2 after:rotate-45 after:bg-inherit"
+  ].join(" "),
+  {
+    variants: {
+      type: {
+        info: "bg-blue-500",
+        success: "bg-green-500",
+        warning: "bg-yellow-500",
+        danger: "bg-red-500",
+        primary: "bg-indigo-500",
+        gray: "bg-gray-700"
+      },
+      size: {
+        sm: "text-xs",
+        md: "text-sm",
+        lg: "text-base"
+      },
+      rounded: {
+        true: "rounded",
+        false: "rounded-none"
+      },
+      dashed: {
+        true: "border border-white border-dashed",
+        false: ""
+      },
+      multilined: {
+        true: "whitespace-pre-wrap",
+        false: "whitespace-nowrap"
+      },
+      animated: {
+        true: "transition-opacity duration-300 ease-in-out",
+        false: ""
+      },
+      position: {
+        top: "bottom-full left-1/2 -translate-x-1/2 mb-1 after:top-full after:left-1/2 after:-translate-x-1/2 after:-mt-1",
+        bottom: "top-full left-1/2 -translate-x-1/2 mt-1 after:bottom-full after:left-1/2 after:-translate-x-1/2 after:-mb-1",
+        left: "right-full top-1/2 -translate-y-1/2 mr-1 after:left-full after:top-1/2 after:-translate-y-1/2 after:-ml-1",
+        right: "left-full top-1/2 -translate-y-1/2 ml-1 after:right-full after:top-1/2 after:-translate-y-1/2 after:-mr-1"
+      }
+    },
+    defaultVariants: {
+      type: "primary",
+      size: "md",
+      rounded: true,
+      dashed: false,
+      multilined: false,
+      animated: true,
+      position: "top"
+    }
+  }
+);
+
+// src/components/tooltip/Tooltip.tsx
+var _tmpl$ = /* @__PURE__ */ template(`<span>`);
+var _tmpl$2 = /* @__PURE__ */ template(`<span class="relative inline-block group">`);
+var Tooltip = (props) => {
+  const [local, variantProps, otherProps] = splitProps(props, ["label", "delay", "always", "children"], ["type", "size", "position", "rounded", "dashed", "multilined", "animated"]);
+  return (() => {
+    var _el$ = _tmpl$2();
+    spread(_el$, otherProps, false, true);
+    insert(_el$, () => local.children, null);
+    insert(_el$, createComponent(Show, {
+      get when() {
+        return local.label;
+      },
+      get children() {
+        var _el$2 = _tmpl$();
+        _el$2.style.setProperty("pointer-events", "none");
+        insert(_el$2, () => local.label);
+        effect((_p$) => {
+          var _v$ = tooltipVariants(variantProps), _v$2 = `${local.delay ?? 0}ms`, _v$3 = local.always ? 1 : void 0;
+          _v$ !== _p$.e && className(_el$2, _p$.e = _v$);
+          _v$2 !== _p$.t && ((_p$.t = _v$2) != null ? _el$2.style.setProperty("transition-delay", _v$2) : _el$2.style.removeProperty("transition-delay"));
+          _v$3 !== _p$.a && ((_p$.a = _v$3) != null ? _el$2.style.setProperty("opacity", _v$3) : _el$2.style.removeProperty("opacity"));
+          return _p$;
+        }, {
+          e: void 0,
+          t: void 0,
+          a: void 0
+        });
+        return _el$2;
+      }
+    }), null);
+    return _el$;
+  })();
+};
+var Tooltip_default = Tooltip;
+
+// src/components/tooltip/index.ts
+var tooltip_default = Tooltip_default;
+
+export { tooltip_default };