@nlabs/gothamui 1.8.0

package/lib/components/Notify/README.md

@@ -0,0 +1,103 @@
+# Notify Component
+
+The Notify component provides a customizable notification system for displaying alerts, messages, and interactive notifications to users.
+
+## Features
+
+- **Multiple Severity Levels**: Support for error, warning, info, and success notifications
+- **Customizable Positioning**: Position notifications at any corner or edge of the screen
+- **Auto-dismiss**: Automatically hide notifications after a configurable duration
+- **Interactive Actions**: Add buttons or icon buttons for user interaction
+- **Tailwind CSS Styling**: Fully styled with Tailwind CSS for easy customization
+
+## Usage
+
+```tsx
+import {GothamActions} from '@actions/GothamActions';
+
+// Basic notification
+GothamActions.notify({
+  message: 'This is a basic notification',
+  autoHideDuration: 5000
+});
+
+// Notification with severity
+GothamActions.notify({
+  message: 'Operation completed successfully',
+  severity: 'success'
+});
+
+// Notification with custom position
+GothamActions.notify({
+  message: 'This appears in the top right',
+  anchorOrigin: {
+    horizontal: 'right',
+    vertical: 'top'
+  }
+});
+
+// Notification with actions
+GothamActions.notify({
+  message: 'Would you like to undo?',
+  actions: [
+    {
+      label: 'Undo',
+      onClick: (key) => {
+        console.log('Undo clicked', key);
+        // Perform undo action
+      }
+    },
+    {
+      icon: 'close',
+      onClick: (key) => {
+        console.log('Close clicked', key);
+        GothamActions.notifyClose();
+      }
+    }
+  ]
+});
+```
+
+## Props
+
+The `GothamNotifyParams` interface accepts the following properties:
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `message` | ReactElement \| string | - | The content of the notification |
+| `severity` | 'error' \| 'warning' \| 'info' \| 'success' | - | The severity level of the notification |
+| `autoHideDuration` | number | 3000 | Time in milliseconds before automatically dismissing |
+| `anchorOrigin` | { horizontal: 'left' \| 'center' \| 'right', vertical: 'top' \| 'bottom' } | { horizontal: 'left', vertical: 'bottom' } | Position of the notification |
+| `actions` | GothamNotifyAction[] | [] | Array of action buttons to display |
+
+### GothamNotifyAction
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `icon` | string | Icon name to display (uses the Svg component) |
+| `label` | string | Text label for the button |
+| `onClick` | (key: string) => void | Callback function when the action is clicked |
+
+## Implementation Details
+
+The Notify component uses:
+
+- **Headless UI's Transition** for smooth enter/exit animations
+- **Custom Button and IconButton components** built with Tailwind CSS
+- **Custom Alert component** with appropriate styling for each severity level
+- **ArkhamJS Flux architecture** for state management and event handling
+
+## Tailwind CSS Classes
+
+The component uses the following Tailwind CSS utility classes:
+
+- Positioning: `fixed`, `top-4`, `bottom-4`, `left-4`, `right-4`, etc.
+- Layout: `flex`, `items-center`, `justify-between`, etc.
+- Spacing: `p-4`, `m-4`, `space-x-2`, etc.
+- Visual: `shadow-lg`, `rounded-lg`, `bg-white`, etc.
+- Colors: `bg-red-500`, `bg-blue-500`, `bg-green-500`, `bg-yellow-500`, etc.
+- Transitions: `transform`, `transition`, `duration-300`, etc.
+
+## Customization
+
+To customize the appearance of the notifications, you can modify the Tailwind CSS classes in the component or extend the Tailwind configuration to include your project's design tokens.

package/lib/components/Pagination/Pagination.d.ts

@@ -0,0 +1,18 @@
+export type PaginationVariant = 'centered' | 'simple';
+export type PaginationResultLabel = 'items' | 'results';
+export interface PaginationProps {
+    readonly className?: string;
+    readonly currentPage: number;
+    readonly pageSize?: number;
+    readonly nextLabel?: string;
+    readonly onPageChange?: (page: number) => void;
+    readonly pageLabel?: (page: number) => string;
+    readonly previousLabel?: string;
+    readonly resultLabel?: PaginationResultLabel;
+    readonly showLabels?: boolean;
+    readonly siblingCount?: number;
+    readonly totalItems?: number;
+    readonly totalPages: number;
+    readonly variant?: PaginationVariant;
+}
+export declare const Pagination: ({ className, currentPage, pageSize, nextLabel, onPageChange, pageLabel, previousLabel, resultLabel, showLabels, siblingCount, totalItems, totalPages, variant }: PaginationProps) => import("react").JSX.Element | null;

package/lib/components/Pagination/Pagination.js

@@ -0,0 +1,225 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+import { ChevronLeft } from 'lucide-react';
+const clampPage = (page, totalPages)=>Math.min(Math.max(page, 1), Math.max(totalPages, 1));
+const createRange = (start, end)=>Array.from({
+        length: end - start + 1
+    }, (_, index)=>start + index);
+const getPaginationItems = (currentPage, totalPages, siblingCount)=>{
+    if (totalPages <= 0) {
+        return [];
+    }
+    const safeCurrentPage = clampPage(currentPage, totalPages);
+    const totalPageNumbers = siblingCount + 5;
+    if (totalPages <= totalPageNumbers) {
+        return createRange(1, totalPages).map((page)=>({
+                page,
+                type: 'page'
+            }));
+    }
+    const leftSiblingIndex = Math.max(safeCurrentPage - siblingCount, 1);
+    const rightSiblingIndex = Math.min(safeCurrentPage + siblingCount, totalPages);
+    const shouldShowLeftEllipsis = leftSiblingIndex > 2;
+    const shouldShowRightEllipsis = rightSiblingIndex < totalPages - 1;
+    if (!shouldShowLeftEllipsis) {
+        const leftRange = createRange(1, 3 + siblingCount * 2);
+        return [
+            ...leftRange.map((page)=>({
+                    page,
+                    type: 'page'
+                })),
+            {
+                id: 'ellipsis-right',
+                type: 'ellipsis'
+            },
+            {
+                page: totalPages,
+                type: 'page'
+            }
+        ];
+    }
+    if (!shouldShowRightEllipsis) {
+        const rightRange = createRange(totalPages - (2 + siblingCount * 2), totalPages);
+        return [
+            {
+                page: 1,
+                type: 'page'
+            },
+            {
+                id: 'ellipsis-left',
+                type: 'ellipsis'
+            },
+            ...rightRange.map((page)=>({
+                    page,
+                    type: 'page'
+                }))
+        ];
+    }
+    const middleRange = createRange(leftSiblingIndex, rightSiblingIndex);
+    return [
+        {
+            page: 1,
+            type: 'page'
+        },
+        {
+            id: 'ellipsis-left',
+            type: 'ellipsis'
+        },
+        ...middleRange.map((page)=>({
+                page,
+                type: 'page'
+            })),
+        {
+            id: 'ellipsis-right',
+            type: 'ellipsis'
+        },
+        {
+            page: totalPages,
+            type: 'page'
+        }
+    ];
+};
+const buttonBaseClasses = [
+    'inline-flex',
+    'items-center',
+    'text-sm',
+    'font-medium',
+    'transition-colors',
+    'disabled:pointer-events-none',
+    'disabled:opacity-50'
+].join(' ');
+const PaginationButton = ({ children, className, ...props })=>/*#__PURE__*/ _jsx("button", {
+        className: cn(buttonBaseClasses, className),
+        type: "button",
+        ...props,
+        children: children
+    });
+export const Pagination = ({ className, currentPage, pageSize = 10, nextLabel = 'Next', onPageChange, pageLabel = (page)=>page.toString(), previousLabel = 'Previous', resultLabel = 'results', showLabels = true, siblingCount = 1, totalItems, totalPages, variant = 'simple' })=>{
+    const safeCurrentPage = clampPage(currentPage, totalPages);
+    const safeTotalItems = totalItems ?? totalPages * pageSize;
+    const rangeStart = safeTotalItems === 0 ? 0 : (safeCurrentPage - 1) * pageSize + 1;
+    const rangeEnd = Math.min(safeCurrentPage * pageSize, safeTotalItems);
+    const isPreviousDisabled = safeCurrentPage <= 1;
+    const isNextDisabled = safeCurrentPage >= totalPages;
+    const handlePageChange = (page)=>{
+        if (page === safeCurrentPage || page < 1 || page > totalPages) {
+            return;
+        }
+        onPageChange?.(page);
+    };
+    if (totalPages <= 1) {
+        return null;
+    }
+    if (variant === 'centered') {
+        return /*#__PURE__*/ _jsxs("nav", {
+            "aria-label": "Pagination",
+            className: cn('flex items-center justify-between border-t border-gray-200 px-4 sm:px-0 dark:border-white/10', className),
+            children: [
+                /*#__PURE__*/ _jsx("div", {
+                    className: "-mt-px flex w-0 flex-1",
+                    children: /*#__PURE__*/ _jsxs(PaginationButton, {
+                        "aria-label": previousLabel,
+                        className: "border-t-2 border-transparent pt-4 pr-1 text-gray-500 hover:border-gray-300 hover:text-gray-700 dark:text-gray-400 dark:hover:border-white/20 dark:hover:text-gray-200",
+                        disabled: isPreviousDisabled,
+                        onClick: ()=>handlePageChange(safeCurrentPage - 1),
+                        children: [
+                            /*#__PURE__*/ _jsx(ChevronLeft, {
+                                "aria-hidden": "true",
+                                className: "mr-3 size-5 text-gray-400 dark:text-gray-500"
+                            }),
+                            showLabels ? previousLabel : /*#__PURE__*/ _jsx("span", {
+                                className: "sr-only",
+                                children: previousLabel
+                            })
+                        ]
+                    })
+                }),
+                /*#__PURE__*/ _jsx("div", {
+                    className: "hidden md:-mt-px md:flex",
+                    children: getPaginationItems(safeCurrentPage, totalPages, siblingCount).map((item)=>item.type === 'ellipsis' ? /*#__PURE__*/ _jsx("span", {
+                            className: "inline-flex items-center border-t-2 border-transparent px-4 pt-4 text-sm font-medium text-gray-500 dark:text-gray-400",
+                            children: "..."
+                        }, item.id) : /*#__PURE__*/ _jsx(PaginationButton, {
+                            "aria-current": item.page === safeCurrentPage ? 'page' : undefined,
+                            "aria-label": pageLabel(item.page),
+                            className: cn('border-t-2 px-4 pt-4', item.page === safeCurrentPage ? 'border-indigo-500 text-indigo-600 dark:border-indigo-400 dark:text-indigo-400' : 'border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700 dark:text-gray-400 dark:hover:border-white/20 dark:hover:text-gray-200'),
+                            onClick: ()=>handlePageChange(item.page),
+                            children: item.page
+                        }, item.page))
+                }),
+                /*#__PURE__*/ _jsx("div", {
+                    className: "-mt-px flex w-0 flex-1 justify-end",
+                    children: /*#__PURE__*/ _jsxs(PaginationButton, {
+                        "aria-label": nextLabel,
+                        className: "border-t-2 border-transparent pt-4 pl-1 text-gray-500 hover:border-gray-300 hover:text-gray-700 dark:text-gray-400 dark:hover:border-white/20 dark:hover:text-gray-200",
+                        disabled: isNextDisabled,
+                        onClick: ()=>handlePageChange(safeCurrentPage + 1),
+                        children: [
+                            showLabels ? nextLabel : /*#__PURE__*/ _jsx("span", {
+                                className: "sr-only",
+                                children: nextLabel
+                            }),
+                            /*#__PURE__*/ _jsx(ChevronLeft, {
+                                "aria-hidden": "true",
+                                className: "ml-3 size-5 rotate-180 text-gray-400 dark:text-gray-500"
+                            })
+                        ]
+                    })
+                })
+            ]
+        });
+    }
+    return /*#__PURE__*/ _jsxs("nav", {
+        "aria-label": "Pagination",
+        className: cn('flex items-center justify-between border-t border-gray-200 bg-white px-4 py-3 sm:px-6 dark:border-white/10 dark:bg-transparent', className),
+        children: [
+            /*#__PURE__*/ _jsx("div", {
+                className: "hidden sm:block",
+                children: /*#__PURE__*/ _jsxs("p", {
+                    className: "text-sm text-gray-700 dark:text-gray-300",
+                    children: [
+                        "Showing ",
+                        /*#__PURE__*/ _jsx("span", {
+                            className: "font-medium",
+                            children: rangeStart
+                        }),
+                        " to ",
+                        /*#__PURE__*/ _jsx("span", {
+                            className: "font-medium",
+                            children: rangeEnd
+                        }),
+                        " of",
+                        ' ',
+                        /*#__PURE__*/ _jsx("span", {
+                            className: "font-medium",
+                            children: safeTotalItems
+                        }),
+                        " ",
+                        resultLabel
+                    ]
+                })
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-1 justify-between sm:justify-end",
+                children: [
+                    /*#__PURE__*/ _jsx(PaginationButton, {
+                        "aria-label": previousLabel,
+                        className: "relative rounded-md bg-white px-3 py-2 font-semibold text-gray-700 inset-ring inset-ring-gray-300 hover:bg-gray-50 dark:bg-white/10 dark:text-gray-200 dark:inset-ring-white/5 dark:hover:bg-white/20",
+                        disabled: isPreviousDisabled,
+                        onClick: ()=>handlePageChange(safeCurrentPage - 1),
+                        children: previousLabel
+                    }),
+                    /*#__PURE__*/ _jsx(PaginationButton, {
+                        "aria-label": nextLabel,
+                        className: "relative ml-3 rounded-md bg-white px-3 py-2 font-semibold text-gray-700 inset-ring inset-ring-gray-300 hover:bg-gray-50 dark:bg-white/10 dark:text-gray-200 dark:inset-ring-white/5 dark:hover:bg-white/20",
+                        disabled: isNextDisabled,
+                        onClick: ()=>handlePageChange(safeCurrentPage + 1),
+                        children: nextLabel
+                    })
+                ]
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Pagination/Pagination.tsx"],"sourcesContent":["import {cn} from '@nlabs/utils';\nimport {ChevronLeft} from 'lucide-react';\n\nimport type {ButtonHTMLAttributes, ReactNode} from 'react';\n\nexport type PaginationVariant = 'centered' | 'simple';\nexport type PaginationResultLabel = 'items' | 'results';\n\nexport interface PaginationProps {\n  readonly className?: string;\n  readonly currentPage: number;\n  readonly pageSize?: number;\n  readonly nextLabel?: string;\n  readonly onPageChange?: (page: number) => void;\n  readonly pageLabel?: (page: number) => string;\n  readonly previousLabel?: string;\n  readonly resultLabel?: PaginationResultLabel;\n  readonly showLabels?: boolean;\n  readonly siblingCount?: number;\n  readonly totalItems?: number;\n  readonly totalPages: number;\n  readonly variant?: PaginationVariant;\n}\n\nconst clampPage = (page: number, totalPages: number) => Math.min(Math.max(page, 1), Math.max(totalPages, 1));\n\nconst createRange = (start: number, end: number) =>\n  Array.from({length: end - start + 1}, (_, index) => start + index);\n\nconst getPaginationItems = (currentPage: number, totalPages: number, siblingCount: number) => {\n  if(totalPages <= 0) {\n    return [];\n  }\n\n  const safeCurrentPage = clampPage(currentPage, totalPages);\n  const totalPageNumbers = siblingCount + 5;\n\n  if(totalPages <= totalPageNumbers) {\n    return createRange(1, totalPages).map((page) => ({page, type: 'page'} as const));\n  }\n\n  const leftSiblingIndex = Math.max(safeCurrentPage - siblingCount, 1);\n  const rightSiblingIndex = Math.min(safeCurrentPage + siblingCount, totalPages);\n  const shouldShowLeftEllipsis = leftSiblingIndex > 2;\n  const shouldShowRightEllipsis = rightSiblingIndex < totalPages - 1;\n\n  if(!shouldShowLeftEllipsis) {\n    const leftRange = createRange(1, 3 + siblingCount * 2);\n    return [\n      ...leftRange.map((page) => ({page, type: 'page'} as const)),\n      {id: 'ellipsis-right', type: 'ellipsis'} as const,\n      {page: totalPages, type: 'page'} as const\n    ];\n  }\n\n  if(!shouldShowRightEllipsis) {\n    const rightRange = createRange(totalPages - (2 + siblingCount * 2), totalPages);\n    return [\n      {page: 1, type: 'page'} as const,\n      {id: 'ellipsis-left', type: 'ellipsis'} as const,\n      ...rightRange.map((page) => ({page, type: 'page'} as const))\n    ];\n  }\n\n  const middleRange = createRange(leftSiblingIndex, rightSiblingIndex);\n  return [\n    {page: 1, type: 'page'} as const,\n    {id: 'ellipsis-left', type: 'ellipsis'} as const,\n    ...middleRange.map((page) => ({page, type: 'page'} as const)),\n    {id: 'ellipsis-right', type: 'ellipsis'} as const,\n    {page: totalPages, type: 'page'} as const\n  ];\n};\n\nconst buttonBaseClasses = [\n  'inline-flex',\n  'items-center',\n  'text-sm',\n  'font-medium',\n  'transition-colors',\n  'disabled:pointer-events-none',\n  'disabled:opacity-50'\n].join(' ');\n\nconst PaginationButton = ({\n  children,\n  className,\n  ...props\n}: ButtonHTMLAttributes<HTMLButtonElement> & {readonly children: ReactNode}) => (\n  <button\n    className={cn(buttonBaseClasses, className)}\n    type=\"button\"\n    {...props}\n  >\n    {children}\n  </button>\n);\n\nexport const Pagination = ({\n  className,\n  currentPage,\n  pageSize = 10,\n  nextLabel = 'Next',\n  onPageChange,\n  pageLabel = (page) => page.toString(),\n  previousLabel = 'Previous',\n  resultLabel = 'results',\n  showLabels = true,\n  siblingCount = 1,\n  totalItems,\n  totalPages,\n  variant = 'simple'\n}: PaginationProps) => {\n  const safeCurrentPage = clampPage(currentPage, totalPages);\n  const safeTotalItems = totalItems ?? totalPages * pageSize;\n  const rangeStart = safeTotalItems === 0 ? 0 : (safeCurrentPage - 1) * pageSize + 1;\n  const rangeEnd = Math.min(safeCurrentPage * pageSize, safeTotalItems);\n  const isPreviousDisabled = safeCurrentPage <= 1;\n  const isNextDisabled = safeCurrentPage >= totalPages;\n\n  const handlePageChange = (page: number) => {\n    if(page === safeCurrentPage || page < 1 || page > totalPages) {\n      return;\n    }\n\n    onPageChange?.(page);\n  };\n\n  if(totalPages <= 1) {\n    return null;\n  }\n\n  if(variant === 'centered') {\n    return (\n      <nav\n        aria-label=\"Pagination\"\n        className={cn(\n          'flex items-center justify-between border-t border-gray-200 px-4 sm:px-0 dark:border-white/10',\n          className\n        )}\n      >\n        <div className=\"-mt-px flex w-0 flex-1\">\n          <PaginationButton\n            aria-label={previousLabel}\n            className=\"border-t-2 border-transparent pt-4 pr-1 text-gray-500 hover:border-gray-300 hover:text-gray-700 dark:text-gray-400 dark:hover:border-white/20 dark:hover:text-gray-200\"\n            disabled={isPreviousDisabled}\n            onClick={() => handlePageChange(safeCurrentPage - 1)}\n          >\n            <ChevronLeft aria-hidden=\"true\" className=\"mr-3 size-5 text-gray-400 dark:text-gray-500\" />\n            {showLabels ? previousLabel : <span className=\"sr-only\">{previousLabel}</span>}\n          </PaginationButton>\n        </div>\n\n        <div className=\"hidden md:-mt-px md:flex\">\n          {getPaginationItems(safeCurrentPage, totalPages, siblingCount).map((item) => item.type === 'ellipsis' ? (\n            <span\n              key={item.id}\n              className=\"inline-flex items-center border-t-2 border-transparent px-4 pt-4 text-sm font-medium text-gray-500 dark:text-gray-400\"\n            >\n              ...\n            </span>\n          ) : (\n            <PaginationButton\n              key={item.page}\n              aria-current={item.page === safeCurrentPage ? 'page' : undefined}\n              aria-label={pageLabel(item.page)}\n              className={cn(\n                'border-t-2 px-4 pt-4',\n                item.page === safeCurrentPage\n                  ? 'border-indigo-500 text-indigo-600 dark:border-indigo-400 dark:text-indigo-400'\n                  : 'border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700 dark:text-gray-400 dark:hover:border-white/20 dark:hover:text-gray-200'\n              )}\n              onClick={() => handlePageChange(item.page)}\n            >\n              {item.page}\n            </PaginationButton>\n          ))}\n        </div>\n\n        <div className=\"-mt-px flex w-0 flex-1 justify-end\">\n          <PaginationButton\n            aria-label={nextLabel}\n            className=\"border-t-2 border-transparent pt-4 pl-1 text-gray-500 hover:border-gray-300 hover:text-gray-700 dark:text-gray-400 dark:hover:border-white/20 dark:hover:text-gray-200\"\n            disabled={isNextDisabled}\n            onClick={() => handlePageChange(safeCurrentPage + 1)}\n          >\n            {showLabels ? nextLabel : <span className=\"sr-only\">{nextLabel}</span>}\n            <ChevronLeft aria-hidden=\"true\" className=\"ml-3 size-5 rotate-180 text-gray-400 dark:text-gray-500\" />\n          </PaginationButton>\n        </div>\n      </nav>\n    );\n  }\n\n  return (\n    <nav\n      aria-label=\"Pagination\"\n      className={cn(\n        'flex items-center justify-between border-t border-gray-200 bg-white px-4 py-3 sm:px-6 dark:border-white/10 dark:bg-transparent',\n        className\n      )}\n    >\n      <div className=\"hidden sm:block\">\n        <p className=\"text-sm text-gray-700 dark:text-gray-300\">\n          Showing <span className=\"font-medium\">{rangeStart}</span> to <span className=\"font-medium\">{rangeEnd}</span> of{' '}\n          <span className=\"font-medium\">{safeTotalItems}</span> {resultLabel}\n        </p>\n      </div>\n\n      <div className=\"flex flex-1 justify-between sm:justify-end\">\n        <PaginationButton\n          aria-label={previousLabel}\n          className=\"relative rounded-md bg-white px-3 py-2 font-semibold text-gray-700 inset-ring inset-ring-gray-300 hover:bg-gray-50 dark:bg-white/10 dark:text-gray-200 dark:inset-ring-white/5 dark:hover:bg-white/20\"\n          disabled={isPreviousDisabled}\n          onClick={() => handlePageChange(safeCurrentPage - 1)}\n        >\n          {previousLabel}\n        </PaginationButton>\n        <PaginationButton\n          aria-label={nextLabel}\n          className=\"relative ml-3 rounded-md bg-white px-3 py-2 font-semibold text-gray-700 inset-ring inset-ring-gray-300 hover:bg-gray-50 dark:bg-white/10 dark:text-gray-200 dark:inset-ring-white/5 dark:hover:bg-white/20\"\n          disabled={isNextDisabled}\n          onClick={() => handlePageChange(safeCurrentPage + 1)}\n        >\n          {nextLabel}\n        </PaginationButton>\n      </div>\n    </nav>\n  );\n};\n"],"names":["cn","ChevronLeft","clampPage","page","totalPages","Math","min","max","createRange","start","end","Array","from","length","_","index","getPaginationItems","currentPage","siblingCount","safeCurrentPage","totalPageNumbers","map","type","leftSiblingIndex","rightSiblingIndex","shouldShowLeftEllipsis","shouldShowRightEllipsis","leftRange","id","rightRange","middleRange","buttonBaseClasses","join","PaginationButton","children","className","props","button","Pagination","pageSize","nextLabel","onPageChange","pageLabel","toString","previousLabel","resultLabel","showLabels","totalItems","variant","safeTotalItems","rangeStart","rangeEnd","isPreviousDisabled","isNextDisabled","handlePageChange","nav","aria-label","div","disabled","onClick","aria-hidden","span","item","aria-current","undefined","p"],"mappings":";AAAA,SAAQA,EAAE,QAAO,eAAe;AAChC,SAAQC,WAAW,QAAO,eAAe;AAuBzC,MAAMC,YAAY,CAACC,MAAcC,aAAuBC,KAAKC,GAAG,CAACD,KAAKE,GAAG,CAACJ,MAAM,IAAIE,KAAKE,GAAG,CAACH,YAAY;AAEzG,MAAMI,cAAc,CAACC,OAAeC,MAClCC,MAAMC,IAAI,CAAC;QAACC,QAAQH,MAAMD,QAAQ;IAAC,GAAG,CAACK,GAAGC,QAAUN,QAAQM;AAE9D,MAAMC,qBAAqB,CAACC,aAAqBb,YAAoBc;IACnE,IAAGd,cAAc,GAAG;QAClB,OAAO,EAAE;IACX;IAEA,MAAMe,kBAAkBjB,UAAUe,aAAab;IAC/C,MAAMgB,mBAAmBF,eAAe;IAExC,IAAGd,cAAcgB,kBAAkB;QACjC,OAAOZ,YAAY,GAAGJ,YAAYiB,GAAG,CAAC,CAAClB,OAAU,CAAA;gBAACA;gBAAMmB,MAAM;YAAM,CAAA;IACtE;IAEA,MAAMC,mBAAmBlB,KAAKE,GAAG,CAACY,kBAAkBD,cAAc;IAClE,MAAMM,oBAAoBnB,KAAKC,GAAG,CAACa,kBAAkBD,cAAcd;IACnE,MAAMqB,yBAAyBF,mBAAmB;IAClD,MAAMG,0BAA0BF,oBAAoBpB,aAAa;IAEjE,IAAG,CAACqB,wBAAwB;QAC1B,MAAME,YAAYnB,YAAY,GAAG,IAAIU,eAAe;QACpD,OAAO;eACFS,UAAUN,GAAG,CAAC,CAAClB,OAAU,CAAA;oBAACA;oBAAMmB,MAAM;gBAAM,CAAA;YAC/C;gBAACM,IAAI;gBAAkBN,MAAM;YAAU;YACvC;gBAACnB,MAAMC;gBAAYkB,MAAM;YAAM;SAChC;IACH;IAEA,IAAG,CAACI,yBAAyB;QAC3B,MAAMG,aAAarB,YAAYJ,aAAc,CAAA,IAAIc,eAAe,CAAA,GAAId;QACpE,OAAO;YACL;gBAACD,MAAM;gBAAGmB,MAAM;YAAM;YACtB;gBAACM,IAAI;gBAAiBN,MAAM;YAAU;eACnCO,WAAWR,GAAG,CAAC,CAAClB,OAAU,CAAA;oBAACA;oBAAMmB,MAAM;gBAAM,CAAA;SACjD;IACH;IAEA,MAAMQ,cAActB,YAAYe,kBAAkBC;IAClD,OAAO;QACL;YAACrB,MAAM;YAAGmB,MAAM;QAAM;QACtB;YAACM,IAAI;YAAiBN,MAAM;QAAU;WACnCQ,YAAYT,GAAG,CAAC,CAAClB,OAAU,CAAA;gBAACA;gBAAMmB,MAAM;YAAM,CAAA;QACjD;YAACM,IAAI;YAAkBN,MAAM;QAAU;QACvC;YAACnB,MAAMC;YAAYkB,MAAM;QAAM;KAChC;AACH;AAEA,MAAMS,oBAAoB;IACxB;IACA;IACA;IACA;IACA;IACA;IACA;CACD,CAACC,IAAI,CAAC;AAEP,MAAMC,mBAAmB,CAAC,EACxBC,QAAQ,EACRC,SAAS,EACT,GAAGC,OACsE,iBACzE,KAACC;QACCF,WAAWnC,GAAG+B,mBAAmBI;QACjCb,MAAK;QACJ,GAAGc,KAAK;kBAERF;;AAIL,OAAO,MAAMI,aAAa,CAAC,EACzBH,SAAS,EACTlB,WAAW,EACXsB,WAAW,EAAE,EACbC,YAAY,MAAM,EAClBC,YAAY,EACZC,YAAY,CAACvC,OAASA,KAAKwC,QAAQ,EAAE,EACrCC,gBAAgB,UAAU,EAC1BC,cAAc,SAAS,EACvBC,aAAa,IAAI,EACjB5B,eAAe,CAAC,EAChB6B,UAAU,EACV3C,UAAU,EACV4C,UAAU,QAAQ,EACF;IAChB,MAAM7B,kBAAkBjB,UAAUe,aAAab;IAC/C,MAAM6C,iBAAiBF,cAAc3C,aAAamC;IAClD,MAAMW,aAAaD,mBAAmB,IAAI,IAAI,AAAC9B,CAAAA,kBAAkB,CAAA,IAAKoB,WAAW;IACjF,MAAMY,WAAW9C,KAAKC,GAAG,CAACa,kBAAkBoB,UAAUU;IACtD,MAAMG,qBAAqBjC,mBAAmB;IAC9C,MAAMkC,iBAAiBlC,mBAAmBf;IAE1C,MAAMkD,mBAAmB,CAACnD;QACxB,IAAGA,SAASgB,mBAAmBhB,OAAO,KAAKA,OAAOC,YAAY;YAC5D;QACF;QAEAqC,eAAetC;IACjB;IAEA,IAAGC,cAAc,GAAG;QAClB,OAAO;IACT;IAEA,IAAG4C,YAAY,YAAY;QACzB,qBACE,MAACO;YACCC,cAAW;YACXrB,WAAWnC,GACT,gGACAmC;;8BAGF,KAACsB;oBAAItB,WAAU;8BACb,cAAA,MAACF;wBACCuB,cAAYZ;wBACZT,WAAU;wBACVuB,UAAUN;wBACVO,SAAS,IAAML,iBAAiBnC,kBAAkB;;0CAElD,KAAClB;gCAAY2D,eAAY;gCAAOzB,WAAU;;4BACzCW,aAAaF,8BAAgB,KAACiB;gCAAK1B,WAAU;0CAAWS;;;;;8BAI7D,KAACa;oBAAItB,WAAU;8BACZnB,mBAAmBG,iBAAiBf,YAAYc,cAAcG,GAAG,CAAC,CAACyC,OAASA,KAAKxC,IAAI,KAAK,2BACzF,KAACuC;4BAEC1B,WAAU;sCACX;2BAFM2B,KAAKlC,EAAE,kBAMd,KAACK;4BAEC8B,gBAAcD,KAAK3D,IAAI,KAAKgB,kBAAkB,SAAS6C;4BACvDR,cAAYd,UAAUoB,KAAK3D,IAAI;4BAC/BgC,WAAWnC,GACT,wBACA8D,KAAK3D,IAAI,KAAKgB,kBACV,kFACA;4BAENwC,SAAS,IAAML,iBAAiBQ,KAAK3D,IAAI;sCAExC2D,KAAK3D,IAAI;2BAXL2D,KAAK3D,IAAI;;8BAgBpB,KAACsD;oBAAItB,WAAU;8BACb,cAAA,MAACF;wBACCuB,cAAYhB;wBACZL,WAAU;wBACVuB,UAAUL;wBACVM,SAAS,IAAML,iBAAiBnC,kBAAkB;;4BAEjD2B,aAAaN,0BAAY,KAACqB;gCAAK1B,WAAU;0CAAWK;;0CACrD,KAACvC;gCAAY2D,eAAY;gCAAOzB,WAAU;;;;;;;IAKpD;IAEA,qBACE,MAACoB;QACCC,cAAW;QACXrB,WAAWnC,GACT,kIACAmC;;0BAGF,KAACsB;gBAAItB,WAAU;0BACb,cAAA,MAAC8B;oBAAE9B,WAAU;;wBAA2C;sCAC9C,KAAC0B;4BAAK1B,WAAU;sCAAee;;wBAAkB;sCAAI,KAACW;4BAAK1B,WAAU;sCAAegB;;wBAAgB;wBAAI;sCAChH,KAACU;4BAAK1B,WAAU;sCAAec;;wBAAsB;wBAAEJ;;;;0BAI3D,MAACY;gBAAItB,WAAU;;kCACb,KAACF;wBACCuB,cAAYZ;wBACZT,WAAU;wBACVuB,UAAUN;wBACVO,SAAS,IAAML,iBAAiBnC,kBAAkB;kCAEjDyB;;kCAEH,KAACX;wBACCuB,cAAYhB;wBACZL,WAAU;wBACVuB,UAAUL;wBACVM,SAAS,IAAML,iBAAiBnC,kBAAkB;kCAEjDqB;;;;;;AAKX,EAAE"}

package/lib/components/Pagination/Pagination.stories.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Pagination as PaginationComponent } from './Pagination.js';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+const PaginationStory = (args)=>{
+    const [currentPage, setCurrentPage] = useState(args.currentPage);
+    return /*#__PURE__*/ _jsx("div", {
+        className: "w-full max-w-4xl bg-white p-6 dark:bg-black-dark",
+        children: /*#__PURE__*/ _jsx(PaginationComponent, {
+            ...args,
+            currentPage: currentPage,
+            onPageChange: setCurrentPage
+        })
+    });
+};
+const meta = {
+    argTypes: {
+        currentPage: {
+            control: 'number'
+        },
+        pageSize: {
+            control: 'number'
+        },
+        siblingCount: {
+            control: 'number'
+        },
+        totalItems: {
+            control: 'number'
+        },
+        totalPages: {
+            control: 'number'
+        },
+        variant: {
+            control: 'select',
+            options: [
+                'centered',
+                'simple'
+            ]
+        }
+    },
+    component: PaginationComponent,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Pagination'
+};
+export default meta;
+export const Centered = {
+    args: {
+        currentPage: 2,
+        totalPages: 10,
+        variant: 'centered'
+    },
+    play: interactWithCanvas,
+    render: PaginationStory
+};
+export const Simple = {
+    args: {
+        currentPage: 1,
+        pageSize: 10,
+        totalItems: 97,
+        totalPages: 10,
+        variant: 'simple'
+    },
+    play: interactWithCanvas,
+    render: PaginationStory
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/PasswordStrengthMeter/PasswordStrengthMeter.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes } from 'react';
+export type PasswordStrength = {
+    readonly label: string;
+    readonly score: number;
+};
+export interface PasswordStrengthMeterProps extends HTMLAttributes<HTMLDivElement> {
+    readonly password: string;
+}
+export declare const getPasswordStrength: (password: string) => PasswordStrength;
+declare const PasswordStrengthMeterComponent: ({ className, password, ...props }: PasswordStrengthMeterProps) => import("react").JSX.Element | null;
+export declare const PasswordStrengthMeter: import("react").MemoExoticComponent<typeof PasswordStrengthMeterComponent>;
+export {};

package/lib/components/PasswordStrengthMeter/PasswordStrengthMeter.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+import { memo } from 'react';
+export const getPasswordStrength = (password)=>{
+    if (password.length < 8) {
+        return {
+            label: 'Too short',
+            score: 0
+        };
+    }
+    const checks = [
+        true,
+        /[A-Za-z]/.test(password),
+        /\d/.test(password),
+        /[^A-Za-z0-9]/.test(password)
+    ];
+    const score = checks.filter(Boolean).length;
+    const labels = [
+        'Too short',
+        'Weak',
+        'Fair',
+        'Good',
+        'Strong'
+    ];
+    return {
+        label: labels[score] || 'Strong',
+        score
+    };
+};
+const getSegmentClass = (score, segment)=>{
+    if (segment > score) {
+        return 'bg-muted dark:bg-muted-dark';
+    }
+    if (score <= 1) {
+        return 'bg-red-500';
+    }
+    if (score === 2) {
+        return 'bg-amber-500';
+    }
+    if (score === 3) {
+        return 'bg-primary dark:bg-primary-dark';
+    }
+    return 'bg-emerald-600';
+};
+const PasswordStrengthMeterComponent = ({ className, password, ...props })=>{
+    if (!password) {
+        return null;
+    }
+    const strength = getPasswordStrength(password);
+    const segments = [
+        1,
+        2,
+        3,
+        4
+    ];
+    return /*#__PURE__*/ _jsxs("div", {
+        "aria-label": `Password strength: ${strength.label}`,
+        className: cn('grid gap-1.5', className),
+        "data-slot": "password-strength-meter",
+        role: "status",
+        ...props,
+        children: [
+            /*#__PURE__*/ _jsx("div", {
+                "aria-hidden": true,
+                className: "grid grid-cols-4 gap-1.5",
+                children: segments.map((segment)=>/*#__PURE__*/ _jsx("span", {
+                        className: cn('h-1.5 rounded-full transition-colors', getSegmentClass(strength.score, segment))
+                    }, segment))
+            }),
+            /*#__PURE__*/ _jsxs("p", {
+                className: "m-0 flex items-center justify-between text-xs text-muted-foreground dark:text-muted-foreground-dark",
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        children: "Password strength"
+                    }),
+                    /*#__PURE__*/ _jsx("strong", {
+                        className: "text-foreground dark:text-foreground-dark",
+                        children: strength.label
+                    })
+                ]
+            })
+        ]
+    });
+};
+export const PasswordStrengthMeter = /*#__PURE__*/ memo(PasswordStrengthMeterComponent);
+PasswordStrengthMeter.displayName = 'PasswordStrengthMeter';
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/PasswordStrengthMeter/PasswordStrengthMeter.stories.js

@@ -0,0 +1,16 @@
+import { PasswordStrengthMeter } from './PasswordStrengthMeter.js';
+const meta = {
+    component: PasswordStrengthMeter,
+    parameters: {
+        layout: 'padded'
+    },
+    title: 'Application UI/Forms/PasswordStrengthMeter'
+};
+export default meta;
+export const Default = {
+    args: {
+        password: 'CorrectHorse123!'
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy9jb21wb25lbnRzL1Bhc3N3b3JkU3RyZW5ndGhNZXRlci9QYXNzd29yZFN0cmVuZ3RoTWV0ZXIuc3Rvcmllcy50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQYXNzd29yZFN0cmVuZ3RoTWV0ZXJ9IGZyb20gJy4vUGFzc3dvcmRTdHJlbmd0aE1ldGVyLmpzJztcblxuaW1wb3J0IHR5cGUge01ldGEsIFN0b3J5T2JqfSBmcm9tICdAbmxhYnMvbGV4L3N0b3J5Ym9vayc7XG5cbmNvbnN0IG1ldGE6IE1ldGE8dHlwZW9mIFBhc3N3b3JkU3RyZW5ndGhNZXRlcj4gPSB7XG4gIGNvbXBvbmVudDogUGFzc3dvcmRTdHJlbmd0aE1ldGVyLFxuICBwYXJhbWV0ZXJzOiB7XG4gICAgbGF5b3V0OiAncGFkZGVkJ1xuICB9LFxuICB0aXRsZTogJ0FwcGxpY2F0aW9uIFVJL0Zvcm1zL1Bhc3N3b3JkU3RyZW5ndGhNZXRlcidcbn07XG5cbmV4cG9ydCBkZWZhdWx0IG1ldGE7XG5cbnR5cGUgU3RvcnkgPSBTdG9yeU9iajx0eXBlb2YgUGFzc3dvcmRTdHJlbmd0aE1ldGVyPjtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHQ6IFN0b3J5ID0ge1xuICBhcmdzOiB7XG4gICAgcGFzc3dvcmQ6ICdDb3JyZWN0SG9yc2UxMjMhJ1xuICB9XG59O1xuIl0sIm5hbWVzIjpbIlBhc3N3b3JkU3RyZW5ndGhNZXRlciIsIm1ldGEiLCJjb21wb25lbnQiLCJwYXJhbWV0ZXJzIiwibGF5b3V0IiwidGl0bGUiLCJEZWZhdWx0IiwiYXJncyIsInBhc3N3b3JkIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFRQSxxQkFBcUIsUUFBTyw2QkFBNkI7QUFJakUsTUFBTUMsT0FBMkM7SUFDL0NDLFdBQVdGO0lBQ1hHLFlBQVk7UUFDVkMsUUFBUTtJQUNWO0lBQ0FDLE9BQU87QUFDVDtBQUVBLGVBQWVKLEtBQUs7QUFJcEIsT0FBTyxNQUFNSyxVQUFpQjtJQUM1QkMsTUFBTTtRQUNKQyxVQUFVO0lBQ1o7QUFDRixFQUFFIn0=

package/lib/components/PaymentMethodPanel/PaymentMethodPanel.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface PaymentMethodPanelProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    readonly actionIcon?: ReactNode;
+    readonly addLabel?: string;
+    readonly brand?: string;
+    readonly description?: ReactNode;
+    readonly emptyDescription?: ReactNode;
+    readonly emptyTitle?: ReactNode;
+    readonly isAdding?: boolean;
+    readonly isRemoving?: boolean;
+    readonly last4?: string;
+    readonly onAdd: () => void;
+    readonly onRemove?: () => void;
+    readonly removeLabel?: string;
+    readonly replaceLabel?: string;
+    readonly title?: ReactNode;
+}
+export declare const PaymentMethodPanel: (paymentMethodPanelProps: PaymentMethodPanelProps) => import("react").JSX.Element;