@rovula/ui 0.0.9 → 0.0.11

package/dist/cjs/types/components/Table/Table.stories.d.ts

@@ -0,0 +1,283 @@
+import React from "react";
+declare const meta: {
+    title: string;
+    component: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+    tags: string[];
+    parameters: {
+        layout: string;
+    };
+    decorators: ((Story: import("@storybook/types").PartialStoryFn<import("@storybook/react").ReactRenderer, {
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        autoFocus?: boolean | undefined;
+        className?: string | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+        contextMenu?: string | undefined;
+        dir?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        hidden?: boolean | undefined;
+        id?: string | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        slot?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        style?: React.CSSProperties | undefined;
+        tabIndex?: number | undefined;
+        title?: string | undefined;
+        translate?: "yes" | "no" | undefined;
+        radioGroup?: string | undefined;
+        role?: React.AriaRole | undefined;
+        about?: string | undefined;
+        content?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCapitalize?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        color?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        inputMode?: "search" | "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+        is?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "true" | "false") | undefined;
+        "aria-autocomplete"?: "list" | "none" | "inline" | "both" | undefined;
+        "aria-braillelabel"?: string | undefined;
+        "aria-brailleroledescription"?: string | undefined;
+        "aria-busy"?: (boolean | "true" | "false") | undefined;
+        "aria-checked"?: boolean | "true" | "false" | "mixed" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colindextext"?: string | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-current"?: boolean | "true" | "false" | "date" | "time" | "step" | "page" | "location" | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-description"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "true" | "false") | undefined;
+        "aria-dropeffect"?: "link" | "none" | "copy" | "execute" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "true" | "false") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+        "aria-haspopup"?: boolean | "true" | "false" | "dialog" | "grid" | "listbox" | "menu" | "tree" | undefined;
+        "aria-hidden"?: (boolean | "true" | "false") | undefined;
+        "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "true" | "false") | undefined;
+        "aria-multiline"?: (boolean | "true" | "false") | undefined;
+        "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+        "aria-orientation"?: "horizontal" | "vertical" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "true" | "false" | "mixed" | undefined;
+        "aria-readonly"?: (boolean | "true" | "false") | undefined;
+        "aria-relevant"?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "true" | "false") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowindextext"?: string | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "true" | "false") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        children?: React.ReactNode;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: React.ClipboardEventHandler<HTMLTableElement> | undefined;
+        onCopyCapture?: React.ClipboardEventHandler<HTMLTableElement> | undefined;
+        onCut?: React.ClipboardEventHandler<HTMLTableElement> | undefined;
+        onCutCapture?: React.ClipboardEventHandler<HTMLTableElement> | undefined;
+        onPaste?: React.ClipboardEventHandler<HTMLTableElement> | undefined;
+        onPasteCapture?: React.ClipboardEventHandler<HTMLTableElement> | undefined;
+        onCompositionEnd?: React.CompositionEventHandler<HTMLTableElement> | undefined;
+        onCompositionEndCapture?: React.CompositionEventHandler<HTMLTableElement> | undefined;
+        onCompositionStart?: React.CompositionEventHandler<HTMLTableElement> | undefined;
+        onCompositionStartCapture?: React.CompositionEventHandler<HTMLTableElement> | undefined;
+        onCompositionUpdate?: React.CompositionEventHandler<HTMLTableElement> | undefined;
+        onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLTableElement> | undefined;
+        onFocus?: React.FocusEventHandler<HTMLTableElement> | undefined;
+        onFocusCapture?: React.FocusEventHandler<HTMLTableElement> | undefined;
+        onBlur?: React.FocusEventHandler<HTMLTableElement> | undefined;
+        onBlurCapture?: React.FocusEventHandler<HTMLTableElement> | undefined;
+        onChange?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onChangeCapture?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onBeforeInput?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onBeforeInputCapture?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onInput?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onInputCapture?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onReset?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onResetCapture?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onSubmit?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onSubmitCapture?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onInvalid?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onInvalidCapture?: React.FormEventHandler<HTMLTableElement> | undefined;
+        onLoad?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onLoadCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onError?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onErrorCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onKeyDown?: React.KeyboardEventHandler<HTMLTableElement> | undefined;
+        onKeyDownCapture?: React.KeyboardEventHandler<HTMLTableElement> | undefined;
+        onKeyPress?: React.KeyboardEventHandler<HTMLTableElement> | undefined;
+        onKeyPressCapture?: React.KeyboardEventHandler<HTMLTableElement> | undefined;
+        onKeyUp?: React.KeyboardEventHandler<HTMLTableElement> | undefined;
+        onKeyUpCapture?: React.KeyboardEventHandler<HTMLTableElement> | undefined;
+        onAbort?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onAbortCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onCanPlay?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onCanPlayCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onCanPlayThrough?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onCanPlayThroughCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onDurationChange?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onDurationChangeCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onEmptied?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onEmptiedCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onEncrypted?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onEncryptedCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onEnded?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onEndedCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onLoadedData?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onLoadedDataCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onLoadedMetadata?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onLoadedMetadataCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onLoadStart?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onLoadStartCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onPause?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onPauseCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onPlay?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onPlayCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onPlaying?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onPlayingCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onProgress?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onProgressCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onRateChange?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onRateChangeCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onResize?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onResizeCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onSeeked?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onSeekedCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onSeeking?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onSeekingCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onStalled?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onStalledCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onSuspend?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onSuspendCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onTimeUpdate?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onTimeUpdateCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onVolumeChange?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onVolumeChangeCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onWaiting?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onWaitingCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onAuxClick?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onAuxClickCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onClick?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onClickCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onContextMenu?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onContextMenuCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onDoubleClick?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onDoubleClickCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onDrag?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragEnd?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragEndCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragEnter?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragEnterCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragExit?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragExitCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragLeave?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragLeaveCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragOver?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragOverCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragStart?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDragStartCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDrop?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onDropCapture?: React.DragEventHandler<HTMLTableElement> | undefined;
+        onMouseDown?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseDownCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseEnter?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseLeave?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseMove?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseMoveCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseOut?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseOutCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseOver?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseOverCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseUp?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onMouseUpCapture?: React.MouseEventHandler<HTMLTableElement> | undefined;
+        onSelect?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onSelectCapture?: React.ReactEventHandler<HTMLTableElement> | undefined;
+        onTouchCancel?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onTouchCancelCapture?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onTouchEnd?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onTouchEndCapture?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onTouchMove?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onTouchMoveCapture?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onTouchStart?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onTouchStartCapture?: React.TouchEventHandler<HTMLTableElement> | undefined;
+        onPointerDown?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerDownCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerMove?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerMoveCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerUp?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerUpCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerCancel?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerCancelCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerEnter?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerLeave?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerOver?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerOverCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerOut?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onPointerOutCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onGotPointerCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onLostPointerCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLTableElement> | undefined;
+        onScroll?: React.UIEventHandler<HTMLTableElement> | undefined;
+        onScrollCapture?: React.UIEventHandler<HTMLTableElement> | undefined;
+        onWheel?: React.WheelEventHandler<HTMLTableElement> | undefined;
+        onWheelCapture?: React.WheelEventHandler<HTMLTableElement> | undefined;
+        onAnimationStart?: React.AnimationEventHandler<HTMLTableElement> | undefined;
+        onAnimationStartCapture?: React.AnimationEventHandler<HTMLTableElement> | undefined;
+        onAnimationEnd?: React.AnimationEventHandler<HTMLTableElement> | undefined;
+        onAnimationEndCapture?: React.AnimationEventHandler<HTMLTableElement> | undefined;
+        onAnimationIteration?: React.AnimationEventHandler<HTMLTableElement> | undefined;
+        onAnimationIterationCapture?: React.AnimationEventHandler<HTMLTableElement> | undefined;
+        onTransitionEnd?: React.TransitionEventHandler<HTMLTableElement> | undefined;
+        onTransitionEndCapture?: React.TransitionEventHandler<HTMLTableElement> | undefined;
+        ref?: React.LegacyRef<HTMLTableElement> | undefined;
+        key?: React.Key | null | undefined;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+};
+export default meta;
+export declare const Default: {
+    args: {};
+    render: (args: {}) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/cjs/types/components/Tabs/Tabs.d.ts

@@ -1,11 +1,13 @@
-import React from "react";
-interface Tab {
+import React, { ReactElement } from "react";
+type Tab = {
     label: string;
+    startTabContent?: ReactElement;
+    endTabContent?: ReactElement;
     content: React.ReactNode;
-}
-interface TabsProps {
+};
+type TabsProps = {
     tabs: Tab[];
     initialTab?: number;
-}
+};
 declare const Tabs: React.FC<TabsProps>;
 export default Tabs;

package/dist/cjs/types/components/Tabs/Tabs.stories.d.ts

@@ -0,0 +1,49 @@
+import React from "react";
+declare const meta: {
+    title: string;
+    component: React.FC<{
+        tabs: {
+            label: string;
+            startTabContent?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+            endTabContent?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+            content: React.ReactNode;
+        }[];
+        initialTab?: number | undefined;
+    }>;
+    tags: string[];
+    parameters: {
+        layout: string;
+    };
+    decorators: ((Story: import("@storybook/types").PartialStoryFn<import("@storybook/react").ReactRenderer, {
+        tabs: {
+            label: string;
+            startTabContent?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+            endTabContent?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+            content: React.ReactNode;
+        }[];
+        initialTab?: number | undefined;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+};
+export default meta;
+export declare const Default: {
+    args: {
+        initialTab: number;
+        tabs: {
+            label: string;
+            content: import("react/jsx-runtime").JSX.Element;
+        }[];
+    };
+    render: (args: {}) => import("react/jsx-runtime").JSX.Element;
+};
+export declare const CustomTab: {
+    args: {
+        initialTab: number;
+        tabs: {
+            startTabContent: import("react/jsx-runtime").JSX.Element;
+            endTabContent: import("react/jsx-runtime").JSX.Element;
+            label: string;
+            content: import("react/jsx-runtime").JSX.Element;
+        }[];
+    };
+    render: (args: {}) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/cjs/types/components/Text/Text.d.ts

@@ -1,5 +1,5 @@
-import React, { FC } from "react";
-type TextProps = {
+import React from "react";
+export type TextProps = {
     variant?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "subtitile1" | "subtitile2" | "subtitile3" | "subtitile4" | "subtitile5" | "subtitile6" | "body1" | "body2" | "body3" | "body4" | "small1" | "small2" | "small3" | "label1" | "label2";
     color?: "primary" | "secondary" | "success" | "tertiary" | "info" | "warning" | "error";
     children?: React.ReactNode;
@@ -8,5 +8,5 @@ type TextProps = {
     style?: React.CSSProperties;
     id?: string;
 };
-declare const Text: FC<TextProps>;
+declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<keyof JSX.IntrinsicElements | undefined>>;
 export default Text;

package/dist/cjs/types/components/Text/Text.stories.d.ts

@@ -1,15 +1,7 @@
 import React from "react";
 declare const meta: {
     title: string;
-    component: React.FC<{
-        variant?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "subtitile1" | "subtitile2" | "subtitile3" | "subtitile4" | "subtitile5" | "subtitile6" | "body1" | "body2" | "body3" | "body4" | "small1" | "small2" | "small3" | "label1" | "label2" | undefined;
-        color?: "primary" | "secondary" | "tertiary" | "success" | "info" | "warning" | "error" | undefined;
-        children?: React.ReactNode;
-        className?: string | undefined;
-        tag?: keyof JSX.IntrinsicElements | undefined;
-        style?: React.CSSProperties | undefined;
-        id?: string | undefined;
-    }>;
+    component: React.ForwardRefExoticComponent<import("./Text").TextProps & React.RefAttributes<keyof JSX.IntrinsicElements | undefined>>;
     tags: string[];
     parameters: {
         layout: string;
@@ -22,6 +14,8 @@ declare const meta: {
         tag?: keyof JSX.IntrinsicElements | undefined;
         style?: React.CSSProperties | undefined;
         id?: string | undefined;
+        ref?: React.LegacyRef<keyof JSX.IntrinsicElements | undefined> | undefined;
+        key?: React.Key | null | undefined;
     }>) => import("react/jsx-runtime").JSX.Element)[];
 };
 export default meta;

package/dist/cjs/types/components/TextInput/TextInput.d.ts

@@ -1,4 +1,4 @@
-import React, { FC, ReactNode } from "react";
+import React, { ReactNode } from "react";
 export type InputProps = {
     id?: string;
     label?: string;
@@ -15,6 +15,24 @@ export type InputProps = {
     hasClearIcon?: boolean;
     endIcon?: ReactNode;
     className?: string;
+    labelClassName?: string;
 } & Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">;
-declare const TextInput: FC<InputProps>;
+export declare const TextInput: React.ForwardRefExoticComponent<{
+    id?: string | undefined;
+    label?: string | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    rounded?: "none" | "normal" | "full" | undefined;
+    variant?: "outline" | "flat" | "underline" | undefined;
+    type?: React.HTMLInputTypeAttribute | undefined;
+    helperText?: string | undefined;
+    errorMessage?: string | undefined;
+    fullwidth?: boolean | undefined;
+    disabled?: boolean | undefined;
+    error?: boolean | undefined;
+    required?: boolean | undefined;
+    hasClearIcon?: boolean | undefined;
+    endIcon?: ReactNode;
+    className?: string | undefined;
+    labelClassName?: string | undefined;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> & React.RefAttributes<HTMLInputElement>>;
 export default TextInput;

package/dist/cjs/types/components/TextInput/TextInput.stories.d.ts

@@ -1,7 +1,24 @@
 import React from "react";
 declare const meta: {
     title: string;
-    component: React.FC<import("./TextInput").InputProps>;
+    component: React.ForwardRefExoticComponent<{
+        id?: string | undefined;
+        label?: string | undefined;
+        size?: "sm" | "md" | "lg" | undefined;
+        rounded?: "none" | "normal" | "full" | undefined;
+        variant?: "outline" | "flat" | "underline" | undefined;
+        type?: React.HTMLInputTypeAttribute | undefined;
+        helperText?: string | undefined;
+        errorMessage?: string | undefined;
+        fullwidth?: boolean | undefined;
+        disabled?: boolean | undefined;
+        error?: boolean | undefined;
+        required?: boolean | undefined;
+        hasClearIcon?: boolean | undefined;
+        endIcon?: React.ReactNode;
+        className?: string | undefined;
+        labelClassName?: string | undefined;
+    } & Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> & React.RefAttributes<HTMLInputElement>>;
     tags: string[];
     parameters: {
         layout: string;
@@ -22,6 +39,7 @@ declare const meta: {
         hasClearIcon?: boolean | undefined;
         endIcon?: React.ReactNode;
         className?: string | undefined;
+        labelClassName?: string | undefined;
         color?: string | undefined;
         title?: string | undefined;
         children?: React.ReactNode;
@@ -312,6 +330,8 @@ declare const meta: {
         src?: string | undefined;
         step?: string | number | undefined;
         width?: string | number | undefined;
+        ref?: React.LegacyRef<HTMLInputElement> | undefined;
+        key?: React.Key | null | undefined;
     }>) => import("react/jsx-runtime").JSX.Element)[];
 };
 export default meta;
@@ -322,3 +342,10 @@ export declare const Default: {
     };
     render: (args: {}) => import("react/jsx-runtime").JSX.Element;
 };
+export declare const CustomLabel: {
+    args: {
+        label: string;
+        fullwidth: boolean;
+    };
+    render: (args: {}) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/cjs/types/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/cjs/types/index.d.ts

@@ -1,8 +1,17 @@
 import "./theme/global.css";
 export { default as Button } from "./components/Button/Button";
-export { default as Table } from "./components/Table/Table";
 export { default as TextInput } from "./components/TextInput/TextInput";
 export { default as Text } from "./components/Text/Text";
 export { default as Tabs } from "./components/Tabs/Tabs";
 export { default as Dropdown } from "./components/Dropdown/Dropdown";
+export { Checkbox } from "./components/Checkbox/Checkbox";
+export { Label } from "./components/Label/Label";
+export { Input } from "./components/Input/Input";
+export * from "./components/Table/Table";
+export * from "./components/Dialog/Dialog";
+export * from "./components/AlertDialog/AlertDialog";
+export type { ButtonProps } from "./components/Button/Button";
+export type { InputProps } from "./components/TextInput/TextInput";
+export type { DropdownProps } from "./components/Dropdown/Dropdown";
 export { resloveTimestamp, getStartDateOfDay, getEndDateOfDay, getStartEndTimestampOfDay, getTimestampUTC, } from "./utils/datetime";
+export { cn } from "./utils/cn";

package/dist/cjs/types/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/components/AlertDialog/Alert.stories.js

@@ -0,0 +1,39 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, AlertDialogTrigger, } from "./AlertDialog";
+// More on how to set up stories at: https://storybook.js.org/docs/7.0/react/writing-stories/introduction
+var meta = {
+    title: "Components/Alert",
+    component: AlertDialog,
+    tags: ["autodocs"],
+    parameters: {
+        // More on how to position stories at: https://storybook.js.org/docs/7.0/react/configure/story-layout
+        layout: "fullscreen",
+    },
+    decorators: [
+        function (Story) { return (_jsx("div", { className: "p-5 flex w-full", children: _jsx(Story, {}) })); },
+    ],
+};
+export default meta;
+export var Default = {
+    args: {
+    // label: "Lorem Ipsum",
+    // value: "Lorem Ipsum",
+    // fullwidth: true,
+    },
+    render: function (args) {
+        console.log("args ", args);
+        var props = __assign({}, args);
+        return (_jsx("div", { className: "flex flex-row gap-4 w-full", children: _jsxs(AlertDialog, { children: [_jsx(AlertDialogTrigger, { children: "Open" }), _jsxs(AlertDialogContent, { children: [_jsxs(AlertDialogHeader, { children: [_jsx(AlertDialogTitle, { children: "Are you absolutely sure?" }), _jsx(AlertDialogDescription, { children: "This action cannot be undone. This will permanently delete your account and remove your data from our servers." })] }), _jsxs(AlertDialogFooter, { children: [_jsx(AlertDialogCancel, { children: "Cancel" }), _jsx(AlertDialogAction, { children: "Continue" })] })] })] }) }));
+    },
+};

package/dist/components/AlertDialog/AlertDialog.js

@@ -0,0 +1,73 @@
+"use client";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+import { cn } from "@/utils/cn";
+import { buttonVariants } from "../Button/Button.styles";
+var AlertDialog = AlertDialogPrimitive.Root;
+var AlertDialogTrigger = AlertDialogPrimitive.Trigger;
+var AlertDialogPortal = AlertDialogPrimitive.Portal;
+var AlertDialogOverlay = React.forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx(AlertDialogPrimitive.Overlay, __assign({ className: cn("fixed inset-0 bg-popup-overlay z-50 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0", className) }, props, { ref: ref })));
+});
+AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName;
+var AlertDialogContent = React.forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsxs(AlertDialogPortal, { children: [_jsx(AlertDialogOverlay, {}), _jsx(AlertDialogPrimitive.Content, __assign({ ref: ref, className: cn("fixed text-textcolor-grey-dark left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-6 border bg-popup-background p-8 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-[var(--popup-rounded)]", className) }, props))] }));
+});
+AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName;
+var AlertDialogHeader = function (_a) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx("div", __assign({ className: cn("flex flex-col space-y-2 text-center sm:text-left", className) }, props)));
+};
+AlertDialogHeader.displayName = "AlertDialogHeader";
+var AlertDialogFooter = function (_a) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx("div", __assign({ className: cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className) }, props)));
+};
+AlertDialogFooter.displayName = "AlertDialogFooter";
+var AlertDialogTitle = React.forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx(AlertDialogPrimitive.Title, __assign({ ref: ref, className: cn("typography-h5", className) }, props)));
+});
+AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName;
+var AlertDialogDescription = React.forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx(AlertDialogPrimitive.Description, __assign({ ref: ref, className: cn("text-sm", className) }, props)));
+});
+AlertDialogDescription.displayName =
+    AlertDialogPrimitive.Description.displayName;
+var AlertDialogAction = React.forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx(AlertDialogPrimitive.Action, __assign({ ref: ref, className: cn(buttonVariants({ fullwidth: false }), className) }, props)));
+});
+AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName;
+var AlertDialogCancel = React.forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx(AlertDialogPrimitive.Cancel, __assign({ ref: ref, className: cn(buttonVariants({ fullwidth: false, variant: "outline" }), "mt-2 sm:mt-0", className) }, props)));
+});
+AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };