solid-element-ui 0.2.1 → 0.2.2

package/dist/src/accordion/accordion.d.ts

@@ -0,0 +1,76 @@
+import { AccordionRootProps } from '@kobalte/core/accordion';
+import { JSX } from 'solid-js';
+import { VariantProps } from 'tailwind-variants';
+declare const accordionStyles: import('tailwind-variants').TVReturnType<{
+    [key: string]: {
+        [key: string]: import('tailwind-variants').ClassValue | {
+            root?: import('tailwind-variants').ClassValue;
+            item?: import('tailwind-variants').ClassValue;
+            header?: import('tailwind-variants').ClassValue;
+            contentInner?: import('tailwind-variants').ClassValue;
+            icon?: import('tailwind-variants').ClassValue;
+            trigger?: import('tailwind-variants').ClassValue;
+            content?: import('tailwind-variants').ClassValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import('tailwind-variants').ClassValue | {
+            root?: import('tailwind-variants').ClassValue;
+            item?: import('tailwind-variants').ClassValue;
+            header?: import('tailwind-variants').ClassValue;
+            contentInner?: import('tailwind-variants').ClassValue;
+            icon?: import('tailwind-variants').ClassValue;
+            trigger?: import('tailwind-variants').ClassValue;
+            content?: import('tailwind-variants').ClassValue;
+        };
+    };
+} | {}, {
+    root: string;
+    item: string;
+    header: string;
+    trigger: string[];
+    content: string[];
+    contentInner: string;
+    icon: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import('tailwind-variants').ClassValue | {
+            root?: import('tailwind-variants').ClassValue;
+            item?: import('tailwind-variants').ClassValue;
+            header?: import('tailwind-variants').ClassValue;
+            contentInner?: import('tailwind-variants').ClassValue;
+            icon?: import('tailwind-variants').ClassValue;
+            trigger?: import('tailwind-variants').ClassValue;
+            content?: import('tailwind-variants').ClassValue;
+        };
+    };
+} | {}, {
+    root: string;
+    item: string;
+    header: string;
+    trigger: string[];
+    content: string[];
+    contentInner: string;
+    icon: string;
+}, import('tailwind-variants').TVReturnType<unknown, {
+    root: string;
+    item: string;
+    header: string;
+    trigger: string[];
+    content: string[];
+    contentInner: string;
+    icon: string;
+}, undefined, unknown, unknown, undefined>>;
+export interface AccordionItem {
+    value: string;
+    title: JSX.Element;
+    content: JSX.Element;
+    disabled?: boolean;
+}
+interface AccordionProps extends AccordionRootProps, VariantProps<typeof accordionStyles> {
+    items: AccordionItem[];
+    class?: string;
+}
+export declare const Accordion: (props: AccordionProps) => JSX.Element;
+export {};

package/dist/src/alert/alert.d.ts

@@ -0,0 +1,86 @@
+import { Alert as KAlert } from '@kobalte/core/alert';
+import { JSX, ComponentProps } from 'solid-js';
+import { VariantProps } from 'tailwind-variants';
+declare const alertStyles: import('tailwind-variants').TVReturnType<{
+    variant: {
+        info: {
+            root: string;
+            icon: string;
+        };
+        success: {
+            root: string;
+            icon: string;
+        };
+        warning: {
+            root: string;
+            icon: string;
+        };
+        danger: {
+            root: string;
+            icon: string;
+        };
+    };
+}, {
+    root: string;
+    content: string;
+    title: string;
+    children: string;
+    icon: string;
+}, undefined, {
+    variant: {
+        info: {
+            root: string;
+            icon: string;
+        };
+        success: {
+            root: string;
+            icon: string;
+        };
+        warning: {
+            root: string;
+            icon: string;
+        };
+        danger: {
+            root: string;
+            icon: string;
+        };
+    };
+}, {
+    root: string;
+    content: string;
+    title: string;
+    children: string;
+    icon: string;
+}, import('tailwind-variants').TVReturnType<{
+    variant: {
+        info: {
+            root: string;
+            icon: string;
+        };
+        success: {
+            root: string;
+            icon: string;
+        };
+        warning: {
+            root: string;
+            icon: string;
+        };
+        danger: {
+            root: string;
+            icon: string;
+        };
+    };
+}, {
+    root: string;
+    content: string;
+    title: string;
+    children: string;
+    icon: string;
+}, undefined, unknown, unknown, undefined>>;
+type AlertVariants = VariantProps<typeof alertStyles>;
+export interface AlertProps extends ComponentProps<typeof KAlert>, AlertVariants {
+    title?: string;
+    icon?: boolean | JSX.Element;
+}
+export declare const Alert: (props: AlertProps) => JSX.Element;
+export {};

package/dist/src/alert-dialog/alert-dialog.d.ts

@@ -0,0 +1,11 @@
+import { AlertDialog as KAlertDialog } from '@kobalte/core/alert-dialog';
+import { JSX, ComponentProps } from 'solid-js';
+interface AlertDialogProps extends ComponentProps<typeof KAlertDialog> {
+    trigger: JSX.Element;
+    title: string;
+    description?: string;
+    action: JSX.Element;
+    cancel?: JSX.Element;
+}
+export declare const AlertDialog: (props: AlertDialogProps) => JSX.Element;
+export {};

package/dist/src/badge/badge.d.ts

@@ -0,0 +1,33 @@
+import { Badge as KBadge } from '@kobalte/core/badge';
+import { ComponentProps } from 'solid-js';
+import { VariantProps } from 'tailwind-variants';
+declare const badgeStyles: import('tailwind-variants').TVReturnType<{
+    variant: {
+        default: string;
+        secondary: string;
+        outline: string;
+        success: string;
+        danger: string;
+    };
+}, undefined, "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none", {
+    variant: {
+        default: string;
+        secondary: string;
+        outline: string;
+        success: string;
+        danger: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    variant: {
+        default: string;
+        secondary: string;
+        outline: string;
+        success: string;
+        danger: string;
+    };
+}, undefined, "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none", unknown, unknown, undefined>>;
+type BadgeVariants = VariantProps<typeof badgeStyles>;
+export interface BadgeProps extends ComponentProps<typeof KBadge>, BadgeVariants {
+}
+export declare const Badge: (props: BadgeProps) => import("solid-js").JSX.Element;
+export {};

package/dist/src/breadcrumbs/breadcrumbs.d.ts

@@ -0,0 +1,14 @@
+import { Breadcrumbs as KBreadcrumbs } from '@kobalte/core/breadcrumbs';
+import { JSX, ComponentProps } from 'solid-js';
+export interface BreadcrumbItem {
+    title: JSX.Element;
+    href?: string;
+    current?: boolean;
+    disabled?: boolean;
+}
+interface BreadcrumbsProps extends ComponentProps<typeof KBreadcrumbs> {
+    items: BreadcrumbItem[];
+    separatorIcon?: JSX.Element;
+}
+export declare const Breadcrumbs: (props: BreadcrumbsProps) => JSX.Element;
+export {};

package/dist/src/button/button.d.ts

@@ -0,0 +1,165 @@
+import { Button as KButton } from '@kobalte/core/button';
+import { JSX, ComponentProps } from 'solid-js';
+import { VariantProps } from 'tailwind-variants';
+declare const buttonStyles: import('tailwind-variants').TVReturnType<{
+    size: {
+        sm: {
+            base: string;
+        };
+        md: {
+            base: string;
+        };
+        lg: {
+            base: string;
+        };
+    };
+    loading: {
+        true: {
+            base: string;
+        };
+    };
+    variant: {
+        default: {
+            base: string;
+        };
+        outline: {
+            base: string;
+        };
+        dashed: {
+            base: string;
+        };
+        filled: {
+            base: string;
+        };
+        text: {
+            base: string;
+        };
+    };
+    color: {
+        primary: {
+            base: string;
+        };
+        success: {
+            base: string;
+        };
+        warning: {
+            base: string;
+        };
+        danger: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    icon: string;
+}, undefined, {
+    size: {
+        sm: {
+            base: string;
+        };
+        md: {
+            base: string;
+        };
+        lg: {
+            base: string;
+        };
+    };
+    loading: {
+        true: {
+            base: string;
+        };
+    };
+    variant: {
+        default: {
+            base: string;
+        };
+        outline: {
+            base: string;
+        };
+        dashed: {
+            base: string;
+        };
+        filled: {
+            base: string;
+        };
+        text: {
+            base: string;
+        };
+    };
+    color: {
+        primary: {
+            base: string;
+        };
+        success: {
+            base: string;
+        };
+        warning: {
+            base: string;
+        };
+        danger: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    icon: string;
+}, import('tailwind-variants').TVReturnType<{
+    size: {
+        sm: {
+            base: string;
+        };
+        md: {
+            base: string;
+        };
+        lg: {
+            base: string;
+        };
+    };
+    loading: {
+        true: {
+            base: string;
+        };
+    };
+    variant: {
+        default: {
+            base: string;
+        };
+        outline: {
+            base: string;
+        };
+        dashed: {
+            base: string;
+        };
+        filled: {
+            base: string;
+        };
+        text: {
+            base: string;
+        };
+    };
+    color: {
+        primary: {
+            base: string;
+        };
+        success: {
+            base: string;
+        };
+        warning: {
+            base: string;
+        };
+        danger: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    icon: string;
+}, undefined, unknown, unknown, undefined>>;
+type ButtonVariants = VariantProps<typeof buttonStyles>;
+export interface ButtonProps extends ComponentProps<typeof KButton>, ButtonVariants {
+    loading?: boolean;
+    leftIcon?: JSX.Element;
+    rightIcon?: JSX.Element;
+}
+export declare const Button: (props: ButtonProps) => JSX.Element;
+export {};

package/dist/src/checkbox/checkbox.d.ts

@@ -0,0 +1,6 @@
+import { Checkbox as KCheckbox } from '@kobalte/core/checkbox';
+import { ComponentProps, JSX } from 'solid-js';
+export interface CheckboxProps extends ComponentProps<typeof KCheckbox> {
+    label?: JSX.Element;
+}
+export declare const Checkbox: (props: CheckboxProps) => JSX.Element;

package/dist/src/collapsible/collapsible.d.ts

@@ -0,0 +1,8 @@
+import { Collapsible as KCollapsible } from '@kobalte/core/collapsible';
+import { JSX, ComponentProps } from 'solid-js';
+interface CollapsibleProps extends ComponentProps<typeof KCollapsible> {
+    title: JSX.Element;
+    children: JSX.Element;
+}
+export declare const Collapsible: (props: CollapsibleProps) => JSX.Element;
+export {};

package/dist/src/color-area/color-area.d.ts

@@ -0,0 +1,5 @@
+import { ColorArea as KColorArea } from '@kobalte/core/color-area';
+import { ComponentProps } from 'solid-js';
+export interface ColorAreaProps extends ComponentProps<typeof KColorArea> {
+}
+export declare const ColorArea: (props: ColorAreaProps) => import("solid-js").JSX.Element;

package/dist/src/color-channel-field/color-channel-field.d.ts

@@ -0,0 +1,6 @@
+import { ColorChannelField as KColorChannelField } from '@kobalte/core/color-channel-field';
+import { ComponentProps } from 'solid-js';
+export interface ColorChannelFieldProps extends ComponentProps<typeof KColorChannelField> {
+    label?: string;
+}
+export declare const ColorChannelField: (props: ColorChannelFieldProps) => import("solid-js").JSX.Element;

package/dist/src/color-field/color-field.d.ts

@@ -0,0 +1,8 @@
+import { ColorField as KColorField } from '@kobalte/core/color-field';
+import { ComponentProps } from 'solid-js';
+export interface ColorFieldProps extends ComponentProps<typeof KColorField> {
+    label?: string;
+    desc?: string;
+    error?: string;
+}
+export declare const ColorField: (props: ColorFieldProps) => import("solid-js").JSX.Element;

package/dist/src/color-slider/color-slider.d.ts

@@ -0,0 +1,7 @@
+import { ColorSlider as KColorSlider } from '@kobalte/core/color-slider';
+import { ComponentProps } from 'solid-js';
+export interface ColorSliderProps extends ComponentProps<typeof KColorSlider> {
+    label?: string;
+    showValue?: boolean;
+}
+export declare const ColorSlider: (props: ColorSliderProps) => import("solid-js").JSX.Element;

package/dist/src/color-swatch/color-swatch.d.ts

@@ -0,0 +1,5 @@
+import { ColorSwatch as KColorSwatch } from '@kobalte/core/color-swatch';
+import { ComponentProps } from 'solid-js';
+export interface ColorSwatchProps extends ComponentProps<typeof KColorSwatch> {
+}
+export declare const ColorSwatch: (props: ColorSwatchProps) => import("solid-js").JSX.Element;

package/dist/src/color-wheel/color-wheel.d.ts

@@ -0,0 +1,6 @@
+import { ColorWheel as KColorWheel } from '@kobalte/core/color-wheel';
+import { ComponentProps } from 'solid-js';
+export interface ColorWheelProps extends ComponentProps<typeof KColorWheel> {
+    size?: number;
+}
+export declare const ColorWheel: (props: ColorWheelProps) => import("solid-js").JSX.Element;

package/dist/src/combobox/combobox.d.ts

@@ -0,0 +1,11 @@
+import { Combobox as KCombobox } from '@kobalte/core/combobox';
+import { ComponentProps } from 'solid-js';
+export type ComboboxProps<T> = ComponentProps<typeof KCombobox<T>> & {
+    label?: string;
+    placeholder?: string;
+    class?: string;
+};
+export declare const Combobox: <T extends string | object>(props: ComboboxProps<T>) => import("solid-js").JSX.Element;
+export declare const ComboboxItem: (props: {
+    item: any;
+}) => import("solid-js").JSX.Element;

package/dist/src/context-menu/context-menu.d.ts

@@ -0,0 +1,15 @@
+import { JSX } from 'solid-js';
+export type ContextMenuItemConfig = {
+    label: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    separator?: boolean;
+    children?: ContextMenuItemConfig[];
+};
+interface UnifiedContextMenuProps {
+    items: ContextMenuItemConfig[];
+    children: JSX.Element;
+    class?: string;
+}
+export declare const ContextMenu: (props: UnifiedContextMenuProps) => JSX.Element;
+export {};

package/dist/src/dialog/dialog.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from 'solid-js';
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: JSX.Element;
+    title: string;
+    description?: string;
+    children: JSX.Element;
+    footer?: JSX.Element;
+    class?: string;
+}
+export declare const Dialog: (props: DialogProps) => JSX.Element;
+export {};

package/dist/src/dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,16 @@
+import { JSX } from 'solid-js';
+export type DropdownItemConfig = {
+    label: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    separator?: boolean;
+    children?: DropdownItemConfig[];
+};
+interface DropdownMenuProps {
+    trigger: JSX.Element;
+    items: DropdownItemConfig[];
+    placement?: "bottom" | "bottom-start" | "bottom-end" | "top" | "left" | "right";
+    class?: string;
+}
+export declare const DropdownMenu: (props: DropdownMenuProps) => JSX.Element;
+export {};

package/dist/src/file-field/file-field.d.ts

@@ -0,0 +1,71 @@
+import { TextField as KTextField } from '@kobalte/core/text-field';
+import { ComponentProps } from 'solid-js';
+import { VariantProps } from 'tailwind-variants';
+declare const fileFieldStyles: import('tailwind-variants').TVReturnType<{
+    validationState: {
+        valid: {};
+        invalid: {
+            dropzone: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            dropzone: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    dropzone: string[];
+    icon: string;
+    description: string;
+    errorMessage: string;
+}, undefined, {
+    validationState: {
+        valid: {};
+        invalid: {
+            dropzone: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            dropzone: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    dropzone: string[];
+    icon: string;
+    description: string;
+    errorMessage: string;
+}, import('tailwind-variants').TVReturnType<{
+    validationState: {
+        valid: {};
+        invalid: {
+            dropzone: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            dropzone: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    dropzone: string[];
+    icon: string;
+    description: string;
+    errorMessage: string;
+}, undefined, unknown, unknown, undefined>>;
+type FileFieldVariants = VariantProps<typeof fileFieldStyles>;
+export interface FileFieldProps extends Omit<ComponentProps<typeof KTextField>, "value" | "onChange">, FileFieldVariants {
+    label?: string;
+    description?: string;
+    accept?: string;
+    multiple?: boolean;
+    onChange?: (files: File[]) => void;
+}
+export declare const FileField: (props: FileFieldProps) => import("solid-js").JSX.Element;
+export {};

package/dist/src/hover-card/hover-card.d.ts

@@ -0,0 +1,56 @@
+import { HoverCard as KHoverCard } from '@kobalte/core/hover-card';
+import { ComponentProps, JSX } from 'solid-js';
+import { VariantProps } from 'tailwind-variants';
+declare const hoverCardStyles: import('tailwind-variants').TVReturnType<{
+    size: {
+        sm: {
+            content: string;
+        };
+        md: {
+            content: string;
+        };
+        lg: {
+            content: string;
+        };
+    };
+}, {
+    content: string[];
+    arrow: string;
+}, undefined, {
+    size: {
+        sm: {
+            content: string;
+        };
+        md: {
+            content: string;
+        };
+        lg: {
+            content: string;
+        };
+    };
+}, {
+    content: string[];
+    arrow: string;
+}, import('tailwind-variants').TVReturnType<{
+    size: {
+        sm: {
+            content: string;
+        };
+        md: {
+            content: string;
+        };
+        lg: {
+            content: string;
+        };
+    };
+}, {
+    content: string[];
+    arrow: string;
+}, undefined, unknown, unknown, undefined>>;
+type HoverCardVariants = VariantProps<typeof hoverCardStyles>;
+export interface HoverCardProps extends ComponentProps<typeof KHoverCard>, HoverCardVariants {
+    trigger: JSX.Element;
+    showArrow?: boolean;
+}
+export declare const HoverCard: (props: HoverCardProps) => JSX.Element;
+export {};