dabi-lib 1.0.1 → 1.0.2

package/dist/components/Accordion.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes } from 'react';
+type AccordionBaseProps = Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'>;
+type AccordionSingleProps = {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    collapsible?: boolean;
+    onValueChange?: (value: string | undefined) => void;
+};
+type AccordionMultipleProps = {
+    type?: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+};
+type AccordionProps = AccordionBaseProps & (AccordionSingleProps | AccordionMultipleProps);
+export declare const Accordion: import('react').ForwardRefExoticComponent<AccordionProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const AccordionItem: import('react').ForwardRefExoticComponent<{
+    value: string;
+} & HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+export declare const AccordionTrigger: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLButtonElement> & import('react').RefAttributes<HTMLButtonElement>>;
+export declare const AccordionContent: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/Alert.d.ts

@@ -0,0 +1,8 @@
+export interface AlertProps {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    message: string;
+    confirmText?: string;
+}
+export declare function Alert({ open, onClose, title, message, confirmText, }: AlertProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Button.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "filled" | "outlined" | "tonal" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    children: React.ReactNode;
+}
+export declare function Button({ variant, size, children, className, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ButtonGroup.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import { Separator } from './Separator';
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>): import("react/jsx-runtime").JSX.Element;
+export declare function ButtonGroupText({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export declare function ButtonGroupSeparator({ className, orientation, ...props }: React.ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Card.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'elevated' | 'filled' | 'outlined';
+}
+export declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Checkbox.d.ts

@@ -0,0 +1,8 @@
+export interface CheckboxProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    label?: string;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function Checkbox({ checked, onChange, label, disabled, className, }: CheckboxProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Chip.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+export type ChipProps = {
+    variant?: 'assist' | 'filter' | 'input' | 'suggestion';
+    label: string;
+    icon?: React.ReactNode;
+    avatar?: React.ReactNode;
+    onDelete?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    onClick?: () => void;
+    selected?: boolean;
+    colors?: {
+        backgroundColorClass?: string;
+        textColorClass?: string;
+        borderColorClass?: string;
+        hoverBackgroundColorClass?: string;
+        selectedBackgroundColorClass?: string;
+        selectedTextColorClass?: string;
+        selectedBorderColorClass?: string;
+        selectedHoverBackgroundColorClass?: string;
+    };
+};
+export declare const Chip: React.FC<ChipProps>;

package/dist/components/Confirm.d.ts

@@ -0,0 +1,10 @@
+export interface ConfirmProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    title: string;
+    message: string;
+    confirmText?: string;
+    cancelText?: string;
+}
+export declare function Confirm({ open, onClose, onConfirm, title, message, confirmText, cancelText, }: ConfirmProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/CopyButton.d.ts

@@ -0,0 +1,11 @@
+export type Size = "sm" | "md";
+export type Variant = "outlined" | "ghost";
+export interface CopyButtonProps {
+    text: string;
+    label?: string;
+    labelCopied?: string;
+    size?: Size;
+    variant?: Variant;
+    successulCallback?: () => void;
+}
+export declare function CopyButton({ text, label, labelCopied, variant, size, successulCallback }: CopyButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/DataTable.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { Alignment } from '../utils/datatable';
+export type ColumnDef<TData> = {
+    accessorKey: keyof TData | string;
+    header: React.ReactNode | (({ column }: {
+        column: ColumnDef<TData>;
+    }) => React.ReactNode);
+    cell?: ({ row }: {
+        row: TData;
+    }) => React.ReactNode;
+};
+export type DataTableProps<TData> = {
+    data: TData[];
+    columns?: ColumnDef<TData>[];
+    headerAlignment?: Alignment;
+    cellAlignment?: Alignment;
+};
+export declare function DataTable<TData extends object>({ data, columns, headerAlignment, cellAlignment, }: DataTableProps<TData>): import("react/jsx-runtime").JSX.Element;

package/dist/components/Dialog.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+export interface DialogProps {
+    open: boolean;
+    onClose: () => void;
+    children: ReactNode;
+    classNameOverlay?: string | undefined;
+}
+export declare function Dialog({ open, onClose, children, classNameOverlay }: DialogProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/FloatingActionButton.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface FloatingActionButtonProps {
+    icon: React.ReactNode;
+    label?: string;
+    extended?: boolean;
+    onClick?: () => void;
+    className?: string;
+}
+export declare const FloatingActionButton: React.FC<FloatingActionButtonProps>;

package/dist/components/Input.d.ts

@@ -0,0 +1,6 @@
+import { default as React, InputHTMLAttributes } from 'react';
+export interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    variant?: "default" | "ghost";
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/Item.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export interface ItemProps {
+    label: string;
+    description?: string;
+    leadingContent?: React.ReactNode;
+    trailingContent?: React.ReactNode;
+    clickable?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+    variant?: "first" | "last" | "none" | "rounded";
+}
+export declare function Item({ label, description, leadingContent, trailingContent, clickable, disabled, onClick, variant, }: ItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Pagination.d.ts

@@ -0,0 +1,13 @@
+import { Button } from './Button';
+import * as React from "react";
+declare function Pagination({ className, ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
+declare function PaginationContent({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
+declare function PaginationItem({ ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<React.ComponentProps<typeof Button>, "size"> & React.ComponentProps<"a">;
+declare function PaginationLink({ className, isActive, size, ...props }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
+declare function PaginationPrevious({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationNext({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

package/dist/components/Popover.d.ts

@@ -0,0 +1,12 @@
+import { Placement } from '@floating-ui/react';
+export interface PopoverProps {
+    trigger: React.ReactNode;
+    content: React.ReactNode;
+    onHover?: boolean;
+    className?: string;
+    placement?: Placement;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    fullWidth?: boolean;
+}
+export declare function Popover({ trigger, content, onHover, className, placement, open: controlledOpen, onOpenChange, fullWidth, }: PopoverProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Select.d.ts

@@ -0,0 +1,15 @@
+export interface SelectOption<T> {
+    value: T;
+    label: string;
+}
+export interface SelectProps<T> {
+    options: SelectOption<T>[];
+    value?: T | T[];
+    onChange: (value: T | T[]) => void;
+    multiple?: boolean;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    withSearch?: boolean;
+}
+export declare function Select<T>({ options, value, onChange, multiple, placeholder, className, disabled, withSearch, }: SelectProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/Separator.d.ts

@@ -0,0 +1,6 @@
+export type Orientation = "horizontal" | "vertical";
+export interface SeparatorProps {
+    orientation?: Orientation;
+    className?: string;
+}
+export declare function Separator({ orientation, className, }: SeparatorProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Sheet.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+export type SheetSide = "top" | "bottom" | "left" | "right";
+export interface SheetProps {
+    isOpen: boolean;
+    onClose: () => void;
+    side?: SheetSide;
+    children: React.ReactNode;
+    title?: string;
+    description?: string;
+    className?: string;
+}
+/**
+ * A Sheet component that slides in from different sides of the screen.
+ * Supports "top", "bottom", "left", and "right" positions.
+ */
+export declare function Sheet({ isOpen, onClose, side, children, title, description, className, }: SheetProps): React.ReactPortal | null;
+export declare function SheetHeader({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SheetFooter({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SheetTitle({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SheetDescription({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Skeleton.d.ts

@@ -0,0 +1,5 @@
+export interface SkeletonProps {
+    delay?: number;
+    className?: string;
+}
+export declare function Skeleton({ delay, className, ...props }: SkeletonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Spinner.d.ts

@@ -0,0 +1 @@
+export declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): import("react/jsx-runtime").JSX.Element;

package/dist/components/Status.d.ts

@@ -0,0 +1,6 @@
+export type StatusProps = {
+    variant?: "online" | "offline" | "maintenance" | "degraded";
+    text?: string;
+    ping?: boolean;
+};
+export declare function Status({ variant, text, ping }: StatusProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TagInput.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface TagInputProps {
+    tags: string[];
+    setTags: (tags: string[]) => void;
+    placeholder?: string;
+    suggestions?: string[];
+}
+export declare const TagInput: React.FC<TagInputProps>;

package/dist/components/Textarea.d.ts

@@ -0,0 +1,6 @@
+import { default as React, TextareaHTMLAttributes } from 'react';
+export interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+    variant?: "default" | "ghost";
+}
+export declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;

package/dist/components/Toaster.d.ts

@@ -0,0 +1 @@
+export declare function Toaster(): import("react/jsx-runtime").JSX.Element;

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,8 @@
+import { Placement } from '@floating-ui/react';
+export interface TooltipProps {
+    children: React.ReactNode;
+    content: React.ReactNode;
+    className?: string;
+    placement?: Placement;
+}
+export declare function Tooltip({ children, content, className, placement, }: TooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/command-menu/CommandMenu.d.ts

@@ -0,0 +1,18 @@
+export interface CommandMenuItemType {
+    id: string;
+    title: string;
+    description?: string;
+    onSelect: () => void;
+}
+export interface CommandMenuGroupType {
+    id: string;
+    heading: string;
+    items: CommandMenuItemType[];
+}
+export interface CommandMenuProps {
+    groups?: CommandMenuGroupType[];
+    items?: CommandMenuItemType[];
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function CommandMenu({ groups, items, open, onOpenChange, }: CommandMenuProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/command-menu/CommandMenuItem.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export interface CommandMenuItemProps {
+    children: React.ReactNode;
+    onSelect?: () => void;
+    isActive?: boolean;
+}
+export declare const CommandMenuItem: React.ForwardRefExoticComponent<CommandMenuItemProps & React.RefAttributes<HTMLLIElement>>;

package/dist/core/Router.d.ts

@@ -0,0 +1,62 @@
+import { ColumnDef } from '../components/DataTable';
+import { SheetSide } from '../components/Sheet';
+type DestinationType = "screen" | "dialog" | "bottomSheet" | "sheet" | "list";
+export type Guard = (params?: any) => boolean | Promise<boolean>;
+export interface RouteConfig {
+    path: string;
+    component?: React.ComponentType<any>;
+    type: DestinationType;
+    side?: SheetSide;
+    title?: string;
+    description?: string;
+    className?: string;
+    listOptions?: {
+        columns: ColumnDef<any>[];
+        data: any[];
+    };
+    canActivate?: Guard[];
+    canDeactivate?: Guard[];
+}
+interface NavContextType {
+    navigate: (path: string, params?: any) => void;
+    popBackStack: () => void;
+    currentRoute: string;
+}
+export declare const useNavigation: () => NavContextType;
+export declare class RouteBuilder {
+    routes: Record<string, RouteConfig>;
+    screen(path: string, component: React.ComponentType<any>, options?: {
+        canActivate?: Guard[];
+        canDeactivate?: Guard[];
+    }): void;
+    dialog(path: string, component: React.ComponentType<any>, options?: {
+        canActivate?: Guard[];
+        canDeactivate?: Guard[];
+    }): void;
+    bottomSheet(path: string, component: React.ComponentType<any>, options?: {
+        canActivate?: Guard[];
+        canDeactivate?: Guard[];
+    }): void;
+    sheet(path: string, component: React.ComponentType<any>, options?: {
+        side?: SheetSide;
+        title?: string;
+        description?: string;
+        className?: string;
+        canActivate?: Guard[];
+        canDeactivate?: Guard[];
+    }): void;
+    list<T>(path: string, options: {
+        title: string;
+        description?: string;
+        columns: ColumnDef<T>[];
+        data: T[];
+        canActivate?: Guard[];
+        canDeactivate?: Guard[];
+    }): void;
+}
+interface NavHostProps {
+    startDestination: string;
+    builder: (builder: RouteBuilder) => void;
+}
+export declare const NavHost: React.FC<NavHostProps>;
+export {};

package/dist/db/index.d.ts

@@ -0,0 +1,8 @@
+import { default as Database } from 'better-sqlite3';
+import * as schema from './schema';
+export declare const db: import('drizzle-orm/better-sqlite3').BetterSQLite3Database<typeof schema> & {
+    $client: Database.Database;
+};
+export declare function initDb(path: string): import('drizzle-orm/better-sqlite3').BetterSQLite3Database<typeof schema> & {
+    $client: Database.Database;
+};

package/dist/hooks/useAlert.d.ts

@@ -0,0 +1,9 @@
+import { JSX } from 'react';
+import { AlertProps } from '../components/Alert';
+type AlertOptions = Omit<AlertProps, 'open' | 'onClose'>;
+type UseAlertReturn = {
+    alert: (options: AlertOptions) => Promise<void>;
+    AlertDialog: () => JSX.Element | null;
+};
+export declare const useAlert: () => UseAlertReturn;
+export {};

package/dist/hooks/useConfirm.d.ts

@@ -0,0 +1,9 @@
+import { JSX } from 'react';
+import { ConfirmProps } from '../components/Confirm';
+type ConfirmOptions = Omit<ConfirmProps, 'open' | 'onClose' | 'onConfirm'>;
+type UseConfirmReturn = {
+    confirm: (options: ConfirmOptions) => Promise<boolean>;
+    ConfirmationDialog: () => JSX.Element | null;
+};
+export declare const useConfirm: () => UseConfirmReturn;
+export {};

package/dist/hooks/useToast.d.ts

@@ -0,0 +1,4 @@
+import { toast } from 'sonner';
+export declare function useToast(): {
+    toast: typeof toast;
+};