@pathscale/ui 0.0.125 → 0.0.126

package/dist/components/steps/Steps.d.ts

@@ -0,0 +1,18 @@
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+type ElementType = keyof JSX.IntrinsicElements;
+type StepsBaseProps = {
+    vertical?: boolean;
+    horizontal?: boolean;
+    as?: ElementType;
+    class?: string;
+    className?: string;
+    style?: JSX.CSSProperties;
+    children?: JSX.Element;
+};
+type PropsOf<E extends ElementType> = JSX.IntrinsicElements[E];
+export type StepsProps<E extends ElementType = "ul"> = Omit<PropsOf<E>, keyof StepsBaseProps> & StepsBaseProps & IComponentBaseProps;
+declare const _default: (<E extends ElementType = "ul">(props: StepsProps<E>) => JSX.Element) & {
+    Step: <E extends keyof JSX.IntrinsicElements = "li">(props: import("./Step").StepProps<E>) => JSX.Element;
+};
+export default _default;

package/dist/components/steps/index.d.ts

@@ -0,0 +1,2 @@
+import Steps from "./Steps";
+export default Steps;

package/dist/components/streaming-table/StreamingTable.d.ts

@@ -0,0 +1,28 @@
+import type { TableProps } from "../table";
+import type { StreamingColumnDef, StreamingConfig, SortingState } from "./types";
+export type StreamingTableProps<TData> = {
+    data: TData[];
+    columns: StreamingColumnDef<TData>[];
+    getRowId?: (row: TData) => string;
+    streamingConfig?: StreamingConfig;
+    /** Enable filtering (default: false) */
+    enableFiltering?: boolean;
+    /** External control of filter value */
+    filterValue?: string;
+    /** Callback when filter changes */
+    onFilterChange?: (value: string) => void;
+    /** Custom global filter function (filters across all columns) */
+    globalFilterFn?: (row: TData, filterValue: string, columns: StreamingColumnDef<TData>[]) => boolean;
+    /** Enable pagination (default: false) */
+    enablePagination?: boolean;
+    /** Number of rows per page (default: 10) */
+    pageSize?: number;
+    /** Initial page index (default: 0) */
+    initialPage?: number;
+    /** Enable sorting (default: false) */
+    enableSorting?: boolean;
+    /** Initial sorting state (default: null) */
+    initialSorting?: SortingState;
+} & Omit<TableProps, "children">;
+declare const StreamingTable: <TData>(props: StreamingTableProps<TData>) => import("solid-js").JSX.Element;
+export default StreamingTable;

package/dist/components/streaming-table/createRowStore.d.ts

@@ -0,0 +1,7 @@
+export interface RowStore<T> {
+    id: string;
+    data: () => T;
+    patch: (partial: Partial<T>) => void;
+    replace: (newData: T) => void;
+}
+export declare function createRowStore<T>(id: string, initial: T): RowStore<T>;

package/dist/components/streaming-table/createStreamingTableStore.d.ts

@@ -0,0 +1,13 @@
+import { type RowStore } from "./createRowStore";
+export interface StreamingTableStore<T> {
+    rows: () => RowStore<T>[];
+    loadInitial: (rows: T[], getId: (row: T) => string) => void;
+    upsertRow: (row: T, getId: (row: T) => string) => void;
+    upsertRows: (rows: T[], getId: (row: T) => string) => void;
+    updateRow: (id: string, patch: Partial<T>) => void;
+    removeRow: (id: string) => void;
+    appendRow: (row: T, getId: (row: T) => string) => void;
+    appendRows: (rows: T[], getId: (row: T) => string) => void;
+    truncateToSize: (maxSize: number) => void;
+}
+export declare function createStreamingTableStore<T>(): StreamingTableStore<T>;

package/dist/components/streaming-table/index.d.ts

@@ -0,0 +1,5 @@
+export { default as StreamingTable } from "./StreamingTable";
+export type { StreamingTableProps } from "./StreamingTable";
+export type { StreamingColumnDef, StreamingConfig } from "./types";
+export { createStreamingTableStore } from "./createStreamingTableStore";
+export type { StreamingTableStore } from "./createStreamingTableStore";

package/dist/components/streaming-table/types.d.ts

@@ -0,0 +1,46 @@
+import type { JSX } from "solid-js";
+export type SortDirection = "asc" | "desc" | null;
+export interface SortingState {
+    columnId: string | null;
+    direction: SortDirection;
+}
+export interface StreamingColumnDef<T> {
+    /** Unique identifier for the column (required for sorting) */
+    id?: string;
+    /** Header text or JSX element */
+    header: JSX.Element | string;
+    /** For simple field access */
+    accessorKey?: keyof T & string;
+    /** For computed access */
+    accessorFn?: (row: T) => any;
+    /** Custom cell renderer */
+    cell?: (ctx: {
+        row: {
+            original: T;
+        };
+    }) => JSX.Element;
+    /** Custom sorting function */
+    sortingFn?: (rowA: T, rowB: T) => number;
+    /** Extra config (sorting, filters, etc.) */
+    meta?: Record<string, any>;
+    /** Enable column filter */
+    enableColumnFilter?: boolean;
+    /** Enable sorting for this column */
+    enableSorting?: boolean;
+    /** Custom filter function for this column */
+    filterFn?: (row: T, filterValue: string) => boolean;
+}
+export interface StreamingConfig {
+    /** Maximum buffer size (default: 1000) */
+    maxBufferSize?: number;
+    /** Append-only mode - don't remove stale rows (default: false) */
+    appendMode?: boolean;
+}
+export interface PaginationConfig {
+    /** Enable pagination (default: false) */
+    enablePagination?: boolean;
+    /** Number of rows per page (default: 10) */
+    pageSize?: number;
+    /** Initial page index (default: 0) */
+    initialPage?: number;
+}

package/dist/components/svgbackground/SvgBackground.d.ts

@@ -0,0 +1,21 @@
+import { type JSX } from "solid-js";
+export interface SvgBackgroundProps {
+    /** Primary gradient color (CSS color value) */
+    colorStart?: string;
+    /** Secondary gradient color (CSS color value) */
+    colorEnd?: string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Background opacity (0-1) */
+    opacity?: number;
+    /** Blur intensity (0-100) */
+    blurIntensity?: number;
+    /** Density of shapes (any positive number) */
+    density?: number;
+    /** Darkness overlay (0-1) */
+    darkness?: number;
+    class?: string;
+    style?: JSX.CSSProperties;
+    children?: JSX.Element;
+}
+export default function SvgBackground(props: SvgBackgroundProps): JSX.Element;

package/dist/components/svgbackground/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SvgBackground } from "./SvgBackground";
+export type { SvgBackgroundProps } from "./SvgBackground";

package/dist/components/swap/Swap.d.ts

@@ -0,0 +1,12 @@
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type SwapProps = Omit<JSX.LabelHTMLAttributes<HTMLLabelElement>, "onClick" | "onChange"> & IComponentBaseProps & {
+    onElement: JSX.Element;
+    offElement: JSX.Element;
+    active?: boolean;
+    rotate?: boolean;
+    flip?: boolean;
+    onClick?: JSX.EventHandlerUnion<HTMLInputElement, MouseEvent>;
+    onChange?: JSX.EventHandlerUnion<HTMLInputElement, Event>;
+};
+export default function Swap(props: SwapProps): JSX.Element;

package/dist/components/swap/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Swap";

package/dist/components/table/EnhancedTable.d.ts

@@ -0,0 +1,45 @@
+import { type Accessor, type JSX } from "solid-js";
+import { type ColumnDef, type SortingState, type ColumnFiltersState, type PaginationState, type OnChangeFn, type ExpandedState } from "@tanstack/solid-table";
+import { type TableProps } from "./Table";
+export type EnhancedTableProps<TData> = Omit<TableProps, "children"> & {
+    data: TData[];
+    columns: ColumnDef<TData, any>[];
+    sorting?: Accessor<SortingState>;
+    setSorting?: OnChangeFn<SortingState>;
+    columnFilters?: Accessor<ColumnFiltersState>;
+    setColumnFilters?: OnChangeFn<ColumnFiltersState>;
+    pagination?: Accessor<PaginationState>;
+    setPagination?: OnChangeFn<PaginationState>;
+    globalFilter?: Accessor<string>;
+    setGlobalFilter?: OnChangeFn<string>;
+    rowSelection?: Accessor<Record<string, boolean>>;
+    setRowSelection?: OnChangeFn<Record<string, boolean>>;
+    expanded?: Accessor<ExpandedState>;
+    setExpanded?: OnChangeFn<ExpandedState>;
+    enableSorting?: boolean;
+    enableFilters?: boolean;
+    enablePagination?: boolean;
+    enableRowSelection?: boolean;
+    expandable?: {
+        expandedRowRender: (props: {
+            row: any;
+        }) => JSX.Element;
+    };
+    renderEmpty?: () => JSX.Element;
+    loading?: boolean;
+    renderLoading?: () => JSX.Element;
+    filterIcon: JSX.Element;
+    sortAscIcon: JSX.Element;
+    sortDescIcon: JSX.Element;
+    sortNeutralIcon?: JSX.Element;
+    expandIcon?: JSX.Element;
+    collapseIcon?: JSX.Element;
+    filterPanelClass?: string;
+    paginationPosition?: "bottomLeft" | "bottomCenter" | "bottomRight";
+    firstPageIcon?: JSX.Element;
+    prevPageIcon?: JSX.Element;
+    nextPageIcon?: JSX.Element;
+    lastPageIcon?: JSX.Element;
+};
+declare function EnhancedTable<TData>(props: EnhancedTableProps<TData>): JSX.Element;
+export default EnhancedTable;

package/dist/components/table/Table.d.ts

@@ -0,0 +1,18 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps, ComponentSize } from "../types";
+export type TableProps = JSX.HTMLAttributes<HTMLTableElement> & IComponentBaseProps & {
+    size?: ComponentSize;
+    zebra?: boolean;
+    pinRows?: boolean;
+    pinCols?: boolean;
+    hover?: boolean;
+};
+declare const _default: Component<TableProps> & {
+    Head: Component<import("./TableHead").TableHeadProps>;
+    Body: Component<import("./TableBody").TableBodyProps>;
+    Row: Component<import("./TableRow").TableRowProps>;
+    Footer: Component<import("./TableFooter").TableFooterProps>;
+    Cell: Component<import("./TableCell").TableCellProps>;
+    HeadCell: Component<import("./TableHeadCell").TableHeadCellProps>;
+};
+export default _default;

package/dist/components/table/TableBody.d.ts

@@ -0,0 +1,5 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type TableBodyProps = JSX.HTMLAttributes<HTMLTableSectionElement> & IComponentBaseProps;
+declare const TableBody: Component<TableBodyProps>;
+export default TableBody;

package/dist/components/table/TableCell.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type TableCellProps = JSX.HTMLAttributes<HTMLTableCellElement> & IComponentBaseProps & {
+    colSpan?: number;
+};
+declare const TableCell: Component<TableCellProps>;
+export default TableCell;

package/dist/components/table/TableFooter.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type TableFooterProps = JSX.HTMLAttributes<HTMLTableSectionElement> & IComponentBaseProps & {
+    noCell?: boolean;
+};
+declare const TableFooter: Component<TableFooterProps>;
+export default TableFooter;

package/dist/components/table/TableHead.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type TableHeadProps = JSX.HTMLAttributes<HTMLTableSectionElement> & IComponentBaseProps & {
+    noCell?: boolean;
+};
+declare const TableHead: Component<TableHeadProps>;
+export default TableHead;

package/dist/components/table/TableHeadCell.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type TableHeadCellProps = JSX.HTMLAttributes<HTMLTableCellElement> & IComponentBaseProps & {
+    colSpan?: number;
+};
+declare const TableHeadCell: Component<TableHeadCellProps>;
+export default TableHeadCell;

package/dist/components/table/TableRow.d.ts

@@ -0,0 +1,8 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type TableRowProps = JSX.HTMLAttributes<HTMLTableRowElement> & IComponentBaseProps & {
+    active?: boolean;
+    noCell?: boolean;
+};
+declare const TableRow: Component<TableRowProps>;
+export default TableRow;

package/dist/components/table/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Table";
+export type { TableProps } from "./Table";
+export { default as EnhancedTable } from "./EnhancedTable";
+export type { EnhancedTableProps } from "./EnhancedTable";

package/dist/components/tabs/RadioTab.d.ts

@@ -0,0 +1,16 @@
+import { type JSX } from "solid-js";
+import type { ComponentColor } from "../types";
+export type RadioTabProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "type" | "color"> & {
+    color?: ComponentColor;
+    bgColor?: string;
+    borderColor?: string;
+    active?: boolean;
+    disabled?: boolean;
+    label: string;
+    name: string;
+    contentClassName?: string;
+    children?: JSX.Element;
+    className?: string;
+};
+declare const RadioTab: (props: RadioTabProps) => JSX.Element;
+export default RadioTab;

package/dist/components/tabs/Tab.d.ts

@@ -0,0 +1,12 @@
+import { type JSX } from "solid-js";
+import type { ComponentColor } from "../types";
+export type TabProps = Omit<JSX.AnchorHTMLAttributes<HTMLAnchorElement>, "color"> & {
+    color?: ComponentColor;
+    bgColor?: string;
+    borderColor?: string;
+    active?: boolean;
+    disabled?: boolean;
+    className?: string;
+};
+declare const Tab: (props: TabProps) => JSX.Element;
+export default Tab;

package/dist/components/tabs/Tabs.d.ts

@@ -0,0 +1,12 @@
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps, ComponentSize, ComponentPosition } from "../types";
+export type TabsProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps & {
+    variant?: "bordered" | "lift" | "boxed";
+    size?: ComponentSize;
+    position?: Extract<ComponentPosition, "top" | "bottom">;
+};
+declare const _default: ((props: TabsProps) => JSX.Element) & {
+    Tab: (props: import("./Tab").TabProps) => JSX.Element;
+    RadioTab: (props: import("./RadioTab").RadioTabProps) => JSX.Element;
+};
+export default _default;

package/dist/components/tabs/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Tabs";
+export type { TabProps } from "./Tab";
+export type { TabsProps } from "./Tabs";
+export type { RadioTabProps } from "./RadioTab";

package/dist/components/textarea/Textarea.d.ts

@@ -0,0 +1,14 @@
+import { type JSX } from "solid-js";
+import type { ComponentColor, ComponentSize, IComponentBaseProps } from "../types";
+type TextareaBaseProps = {
+    color?: ComponentColor;
+    size?: ComponentSize;
+    dataTheme?: string;
+    class?: string;
+    className?: string;
+    style?: JSX.CSSProperties;
+    resize?: "none" | "x" | "y" | "both";
+};
+export type TextareaProps = TextareaBaseProps & IComponentBaseProps & Omit<JSX.TextareaHTMLAttributes<HTMLTextAreaElement>, keyof TextareaBaseProps>;
+declare const Textarea: (props: TextareaProps) => JSX.Element;
+export default Textarea;

package/dist/components/textarea/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Textarea";

package/dist/components/theme-color-picker/ThemeColorPicker.d.ts

@@ -0,0 +1,23 @@
+import { type Component, type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export interface ThemeColorPickerProps extends IComponentBaseProps {
+    /**
+     * Prefix for localStorage keys (e.g., "myapp" becomes "myapp_hue_shift")
+     * @default "theme"
+     */
+    storagePrefix?: string;
+    /**
+     * Callback when color changes
+     */
+    onColorChange?: (hue: number | null, saturation: number) => void;
+    /**
+     * ARIA label for the button
+     */
+    "aria-label"?: string;
+    /**
+     * Custom button content (defaults to palette icon)
+     */
+    children?: JSX.Element;
+}
+declare const ThemeColorPicker: Component<ThemeColorPickerProps>;
+export default ThemeColorPicker;

package/dist/components/theme-color-picker/hueShift.d.ts

@@ -0,0 +1,14 @@
+declare function resetHueShift(): void;
+export interface HueShiftStore {
+    hueShift: () => number | null;
+    hueSaturation: () => number;
+    setHueShift: (hue: number | null, saturation?: number) => void;
+    isAvailable: () => boolean;
+}
+/**
+ * Creates a hue shift store with configurable storage prefix.
+ * @param storagePrefix - Prefix for localStorage keys (e.g., "myapp" becomes "myapp_hue_shift")
+ */
+export declare function createHueShiftStore(storagePrefix: string): HueShiftStore;
+export declare function getDefaultHueShiftStore(): HueShiftStore;
+export { resetHueShift };

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

@@ -0,0 +1,3 @@
+export { default as ThemeColorPicker } from "./ThemeColorPicker";
+export type { ThemeColorPickerProps } from "./ThemeColorPicker";
+export { createHueShiftStore, getDefaultHueShiftStore, resetHueShift, type HueShiftStore, } from "./hueShift";

package/dist/components/timeline/Timeline.d.ts

@@ -0,0 +1,11 @@
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+type TimelineProps = IComponentBaseProps & JSX.HTMLAttributes<HTMLUListElement> & {
+    vertical?: boolean;
+    horizontal?: boolean;
+    responsive?: boolean;
+    snap?: boolean;
+    compact?: boolean;
+};
+declare const Timeline: (props: TimelineProps) => JSX.Element;
+export default Timeline;

package/dist/components/timeline/TimelineEnd.d.ts

@@ -0,0 +1,6 @@
+import { type JSX } from "solid-js";
+export type TimelineEndProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    box?: boolean;
+};
+declare const TimelineEnd: (props: TimelineEndProps) => JSX.Element;
+export default TimelineEnd;

package/dist/components/timeline/TimelineItem.d.ts

@@ -0,0 +1,8 @@
+import { type JSX } from "solid-js";
+export type TimelineItemProps = JSX.HTMLAttributes<HTMLLIElement> & {
+    connect?: "both" | "start" | "end";
+    startClassName?: string;
+    endClassName?: string;
+};
+declare const TimelineItem: (props: TimelineItemProps) => JSX.Element;
+export default TimelineItem;

package/dist/components/timeline/TimelineMiddle.d.ts

@@ -0,0 +1,4 @@
+import { type JSX } from "solid-js";
+export type TimelineMiddleProps = JSX.HTMLAttributes<HTMLDivElement>;
+declare const TimelineMiddle: (props: TimelineMiddleProps) => JSX.Element;
+export default TimelineMiddle;

package/dist/components/timeline/TimelineStart.d.ts

@@ -0,0 +1,6 @@
+import { type JSX } from "solid-js";
+export type TimelineStartProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    box?: boolean;
+};
+declare const TimelineStart: (props: TimelineStartProps) => JSX.Element;
+export default TimelineStart;

package/dist/components/timeline/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Timeline } from "./Timeline";
+export { default as TimelineItem } from "./TimelineItem";
+export { default as TimelineStart } from "./TimelineStart";
+export { default as TimelineMiddle } from "./TimelineMiddle";
+export { default as TimelineEnd } from "./TimelineEnd";

package/dist/components/toast/Toast.d.ts

@@ -0,0 +1,21 @@
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+declare const horizontalOptions: {
+    readonly start: "toast-start";
+    readonly center: "toast-center";
+    readonly end: "toast-end";
+};
+declare const verticalOptions: {
+    readonly top: "toast-top";
+    readonly middle: "toast-middle";
+    readonly bottom: "toast-bottom";
+};
+type ToastPosition = {
+    horizontal?: keyof typeof horizontalOptions;
+    vertical?: keyof typeof verticalOptions;
+};
+export type ToastProps = ToastPosition & IComponentBaseProps & {
+    max?: number;
+} & Omit<JSX.HTMLAttributes<HTMLDivElement>, keyof ToastPosition | "max">;
+declare const Toast: (props: ToastProps) => JSX.Element;
+export default Toast;

package/dist/components/toast/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Toast";

package/dist/components/toastcontainer/ToastContainer.d.ts

@@ -0,0 +1,2 @@
+import { type Component } from "solid-js";
+export declare const ToastContainer: Component;

package/dist/components/toastcontainer/ToastStack.d.ts

@@ -0,0 +1,17 @@
+import { type Component, type JSX } from "solid-js";
+import type { ToastProps } from "../toast/Toast";
+import type { MotionPreset } from "../../motion";
+import { type ToastItem } from "../../stores/toastStore";
+export type ToastRenderer = (toast: ToastItem, dismiss: () => void) => JSX.Element;
+export type ToastStackProps = ToastProps & {
+    motionPreset?: MotionPreset;
+    motionPresetName?: string;
+    reduceMotion?: boolean;
+    renderToast?: ToastRenderer;
+    expandOnClick?: boolean;
+    collapsedCount?: number;
+    collapsedOffset?: number;
+    collapsedScale?: number;
+};
+export declare const ToastStack: Component<ToastStackProps>;
+export default ToastStack;

package/dist/components/toastcontainer/index.d.ts

@@ -0,0 +1,3 @@
+export { ToastContainer } from "./ToastContainer";
+export { ToastStack } from "./ToastStack";
+export type { ToastStackProps, ToastRenderer } from "./ToastStack";

package/dist/components/toggle/Toggle.d.ts

@@ -0,0 +1,19 @@
+import { type JSX } from "solid-js";
+import type { ComponentColor, ComponentSize, IComponentBaseProps } from "../types";
+type ToggleBaseProps = {
+    color?: ComponentColor;
+    size?: ComponentSize;
+    dataTheme?: string;
+    class?: string;
+    className?: string;
+    style?: JSX.CSSProperties;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+    "aria-labelledby"?: string;
+    "aria-checked"?: boolean;
+};
+export type ToggleProps = ToggleBaseProps & IComponentBaseProps & Omit<JSX.InputHTMLAttributes<HTMLInputElement>, keyof ToggleBaseProps>;
+declare const Toggle: (props: ToggleProps) => JSX.Element;
+export default Toggle;

package/dist/components/toggle/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Toggle";

package/dist/components/tooltip/Tooltip.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+import type { ComponentColor, ComponentPosition, IComponentBaseProps } from "../types";
+type TooltipBaseProps = {
+    message: string;
+    open?: boolean;
+    color?: ComponentColor;
+    position?: ComponentPosition;
+    dataTheme?: string;
+    class?: string;
+    className?: string;
+    style?: JSX.CSSProperties;
+};
+export type TooltipProps = TooltipBaseProps & IComponentBaseProps & Omit<JSX.HTMLAttributes<HTMLDivElement>, keyof TooltipBaseProps>;
+declare const Tooltip: (props: TooltipProps) => JSX.Element;
+export default Tooltip;

package/dist/components/tooltip/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Tooltip";

package/dist/components/types.d.ts

@@ -0,0 +1,15 @@
+import type { JSX } from "solid-js";
+export interface IComponentBaseProps {
+    dataTheme?: string;
+    class?: string;
+    className?: string;
+    style?: JSX.CSSProperties;
+}
+export type ResponsiveBreakpoints = "base" | "sm" | "md" | "lg" | "xl";
+export type ResponsiveProp<T> = T | Partial<Record<ResponsiveBreakpoints, T>>;
+export declare const breakpoints: readonly ["base", "sm", "md", "lg", "xl"];
+export type ComponentSize = "xs" | "sm" | "md" | "lg" | "xl";
+export type ComponentShape = "circle" | "square" | "rounded";
+export type ComponentColor = "neutral" | "primary" | "secondary" | "accent" | "info" | "success" | "warning" | "error" | "ghost";
+export type ComponentVariant = "soft" | "dash" | "outline" | "filled" | "ghost" | "outlined";
+export type ComponentPosition = "top" | "bottom" | "left" | "right";

package/dist/components/utils.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from "solid-js";
+import type { ResponsiveProp } from "./types";
+export declare function wrapWithElementIfInvalid({ node, wrapper, className, }: {
+    node: JSX.Element | string | number | null | undefined;
+    wrapper?: keyof JSX.IntrinsicElements;
+    className?: string;
+}): JSX.Element;
+export declare function mapResponsiveProp<T extends string | boolean>(prop: ResponsiveProp<T> | undefined, classMap: Record<string, string>): string[];
+export declare function useDesktop(breakpoint?: number): import("solid-js").Accessor<boolean>;

package/dist/components/windowmockup/WindowMockup.d.ts

@@ -0,0 +1,11 @@
+import { type ParentComponent, type JSX } from "solid-js";
+import type { IComponentBaseProps, ComponentColor } from "../types";
+export type WindowMockupColors = Exclude<ComponentColor, "ghost">;
+export type WindowMockupProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps & {
+    frameColor?: WindowMockupColors;
+    backgroundColor?: WindowMockupColors;
+    border?: boolean;
+    borderColor?: WindowMockupColors;
+};
+declare const WindowMockup: ParentComponent<WindowMockupProps>;
+export default WindowMockup;

package/dist/components/windowmockup/index.d.ts

@@ -0,0 +1 @@
+export { default, type WindowMockupProps } from "./WindowMockup";