@wallarm-org/design-system 0.3.1 → 0.4.0

package/dist/components/Table/primitives/TBody.d.ts

@@ -0,0 +1 @@
+export declare const TBody: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & import("react").RefAttributes<HTMLTableSectionElement>>;

package/dist/components/Table/primitives/TBody.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../../utils/cn.js";
+const TBody = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx("tbody", {
+        ref: ref,
+        className: cn(className),
+        ...props
+    }));
+TBody.displayName = 'TBody';
+export { TBody };

package/dist/components/Table/primitives/THead.d.ts

@@ -0,0 +1 @@
+export declare const THead: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & import("react").RefAttributes<HTMLTableSectionElement>>;

package/dist/components/Table/primitives/THead.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../../utils/cn.js";
+const THead = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx("thead", {
+        ref: ref,
+        className: cn(className),
+        ...props
+    }));
+THead.displayName = 'THead';
+export { THead };

package/dist/components/Table/primitives/Td.d.ts

@@ -0,0 +1,7 @@
+import { type ComponentPropsWithRef } from 'react';
+import type { VariantProps } from 'class-variance-authority';
+import { tableBodyCellVariants } from '../classes';
+type TdVariantProps = VariantProps<typeof tableBodyCellVariants>;
+type TdProps = Omit<ComponentPropsWithRef<'td'>, keyof TdVariantProps> & TdVariantProps;
+export declare const Td: import("react").ForwardRefExoticComponent<Omit<TdProps, "ref"> & import("react").RefAttributes<HTMLTableCellElement>>;
+export {};

package/dist/components/Table/primitives/Td.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../../utils/cn.js";
+import { tableBodyCellVariants } from "../classes.js";
+const Td = /*#__PURE__*/ forwardRef(({ className, pinned, lastPinnedLeft, expanded, ...props }, ref)=>{
+    const hasVariants = void 0 !== pinned || void 0 !== lastPinnedLeft || void 0 !== expanded;
+    return /*#__PURE__*/ jsx("td", {
+        ref: ref,
+        className: cn(hasVariants ? tableBodyCellVariants({
+            pinned,
+            lastPinnedLeft,
+            expanded
+        }) : void 0, className),
+        ...props
+    });
+});
+Td.displayName = 'Td';
+export { Td };

package/dist/components/Table/primitives/Th.d.ts

@@ -0,0 +1,7 @@
+import { type ComponentPropsWithRef } from 'react';
+import type { VariantProps } from 'class-variance-authority';
+import { tableHeadCellVariants } from '../classes';
+type ThVariantProps = VariantProps<typeof tableHeadCellVariants>;
+type ThProps = Omit<ComponentPropsWithRef<'th'>, keyof ThVariantProps> & ThVariantProps;
+export declare const Th: import("react").ForwardRefExoticComponent<Omit<ThProps, "ref"> & import("react").RefAttributes<HTMLTableCellElement>>;
+export {};

package/dist/components/Table/primitives/Th.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../../utils/cn.js";
+import { tableHeadCellVariants } from "../classes.js";
+const Th = /*#__PURE__*/ forwardRef(({ className, interactive, sorted, pinned, lastPinnedLeft, draggable, ...props }, ref)=>/*#__PURE__*/ jsx("th", {
+        ref: ref,
+        scope: "col",
+        className: cn(tableHeadCellVariants({
+            interactive,
+            sorted,
+            pinned,
+            lastPinnedLeft,
+            draggable
+        }), className),
+        ...props
+    }));
+Th.displayName = 'Th';
+export { Th };

package/dist/components/Table/primitives/Tr.d.ts

@@ -0,0 +1 @@
+export declare const Tr: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & import("react").RefAttributes<HTMLTableRowElement>>;

package/dist/components/Table/primitives/Tr.js

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../../utils/cn.js";
+import { tableRowVariants } from "../classes.js";
+const Tr = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx("tr", {
+        ref: ref,
+        className: cn(tableRowVariants(), className),
+        ...props
+    }));
+Tr.displayName = 'Tr';
+export { Tr };

package/dist/components/Table/primitives/index.d.ts

@@ -0,0 +1,5 @@
+export { TBody } from './TBody';
+export { Td } from './Td';
+export { THead } from './THead';
+export { Th } from './Th';
+export { Tr } from './Tr';

package/dist/components/Table/primitives/index.js

@@ -0,0 +1,6 @@
+import { TBody } from "./TBody.js";
+import { Td } from "./Td.js";
+import { THead } from "./THead.js";
+import { Th } from "./Th.js";
+import { Tr } from "./Tr.js";
+export { TBody, THead, Td, Th, Tr };

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

@@ -0,0 +1,129 @@
+import type { ReactNode } from 'react';
+import type { RowData } from '@tanstack/react-table';
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        headerClassName?: string;
+        cellClassName?: string;
+        /** Sort label type — controls the wording in the sort submenu */
+        sortType?: 'text' | 'number' | 'date' | 'duration' | 'score' | 'boolean' | 'version' | 'severity' | 'size';
+    }
+}
+/** Sorting state: array of `{ id, desc }` */
+export type TableSortingState = {
+    id: string;
+    desc: boolean;
+}[];
+/** Row selection state: `{ [rowId]: boolean }` */
+export type TableRowSelectionState = Record<string, boolean>;
+/** Column sizing state: `{ [columnId]: number }` */
+export type TableColumnSizingState = Record<string, number>;
+/** Column pinning state */
+export type TableColumnPinningState = {
+    left?: string[];
+    right?: string[];
+};
+/** Expanded state: `true` (all) or `{ [rowId]: boolean }` */
+export type TableExpandedState = true | Record<string, boolean>;
+/** Grouping state: array of column IDs */
+export type TableGroupingState = string[];
+/** Column visibility state: `{ [columnId]: boolean }` */
+export type TableVisibilityState = Record<string, boolean>;
+/** State updater — value or functional update */
+export type TableUpdater<T> = T | ((prev: T) => T);
+/** onChange callback */
+export type TableOnChangeFn<T> = (updaterOrValue: TableUpdater<T>) => void;
+/** Public row interface — structural subset of TanStack Row<T> */
+export interface TableRow<T> {
+    id: string;
+    original: T;
+    subRows: TableRow<T>[];
+    getIsExpanded: () => boolean;
+    getToggleExpandedHandler: () => () => void;
+    getIsSelected: () => boolean;
+    getToggleSelectedHandler: () => (event: unknown) => void;
+    getIsGrouped: () => boolean;
+}
+/** Public cell context — structural subset of TanStack CellContext<T, V> */
+export interface TableCellContext<T, V> {
+    getValue: () => V;
+    row: TableRow<T>;
+}
+/** Column meta — mirrors the ColumnMeta augmentation */
+export interface TableColumnMeta {
+    headerClassName?: string;
+    cellClassName?: string;
+    sortType?: 'text' | 'number' | 'date' | 'duration' | 'score' | 'boolean' | 'version' | 'severity' | 'size';
+}
+/** Shared column properties */
+export interface TableColumnBase<T, V> {
+    header?: string | ((ctx: {
+        column: {
+            id: string;
+        };
+    }) => ReactNode);
+    cell?: (ctx: TableCellContext<T, V>) => ReactNode;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+    enableSorting?: boolean;
+    enableResizing?: boolean;
+    enableColumnPinning?: boolean;
+    enableHiding?: boolean;
+    meta?: TableColumnMeta;
+}
+/** Accessor column — maps to a data property */
+export interface TableAccessorColumnDef<T, V = unknown> extends TableColumnBase<T, V> {
+    accessorKey: keyof T & string;
+    id?: string;
+}
+/** Display column — no data accessor, render-only */
+export interface TableDisplayColumnDef<T> extends TableColumnBase<T, never> {
+    id: string;
+    accessorKey?: never;
+}
+/**
+ * Union column def type.
+ * `any` is required: V is invariant (contravariant callback params like `cell`),
+ * so `unknown` would reject concrete types like `TableAccessorColumnDef<T, string>`.
+ * This mirrors TanStack Table's own `ColumnDef<T, any>`.
+ */
+export type TableColumnDef<T> = TableAccessorColumnDef<T, any> | TableDisplayColumnDef<T>;
+export interface TableProps<T> {
+    /** Data array for rows */
+    data: T[];
+    /** Column definitions */
+    columns: TableColumnDef<T>[];
+    /** Show skeleton rows */
+    isLoading?: boolean;
+    /** Slot for TableActionBar, TableEmptyState, and other compound components */
+    children?: ReactNode;
+    /** Row id accessor for stable row identity */
+    getRowId?: (row: T, index: number) => string;
+    /** Accessible label for the table */
+    'aria-label'?: string;
+    sorting?: TableSortingState;
+    onSortingChange?: TableOnChangeFn<TableSortingState>;
+    rowSelection?: TableRowSelectionState;
+    onRowSelectionChange?: TableOnChangeFn<TableRowSelectionState>;
+    columnSizing?: TableColumnSizingState;
+    onColumnSizingChange?: TableOnChangeFn<TableColumnSizingState>;
+    columnPinning?: TableColumnPinningState;
+    onColumnPinningChange?: TableOnChangeFn<TableColumnPinningState>;
+    columnOrder?: string[];
+    onColumnOrderChange?: TableOnChangeFn<string[]>;
+    grouping?: TableGroupingState;
+    onGroupingChange?: TableOnChangeFn<TableGroupingState>;
+    renderGroupRow?: (row: TableRow<T>) => ReactNode;
+    /** Sub-row accessor for hierarchical/tree data (used with renderGroupRow) */
+    getSubRows?: (row: T) => T[] | undefined;
+    expanded?: TableExpandedState;
+    onExpandedChange?: TableOnChangeFn<TableExpandedState>;
+    renderExpandedRow?: (row: TableRow<T>) => ReactNode;
+    columnVisibility?: TableVisibilityState;
+    onColumnVisibilityChange?: TableOnChangeFn<TableVisibilityState>;
+    defaultColumnVisibility?: TableVisibilityState;
+    defaultColumnOrder?: string[];
+    virtualized?: boolean;
+    estimateRowHeight?: (index: number) => number;
+    overscan?: number;
+}

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

@@ -3,7 +3,7 @@ import { type VariantProps } from 'class-variance-authority';
 declare const textVariants: (props?: ({
     size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
     weight?: "bold" | "light" | "regular" | "medium" | null | undefined;
-    color?: "inherit" | "primary" | "primary-alt" | "secondary" | "secondary-alt" | "danger" | null | undefined;
+    color?: "inherit" | "primary" | "primary-alt" | "secondary" | "secondary-alt" | "tertiary-alt" | "danger" | null | undefined;
     align?: "left" | "center" | "right" | null | undefined;
     grow?: boolean | null | undefined;
     truncate?: boolean | null | undefined;

package/dist/components/Text/Text.js

@@ -22,6 +22,7 @@ const textVariants = cva('font-sans-display break-words', {
             'primary-alt': 'text-text-primary-alt',
             secondary: 'text-text-secondary',
             'secondary-alt': 'text-text-secondary-alt',
+            'tertiary-alt': 'text-text-tertiary-alt',
             danger: 'text-text-danger',
             inherit: 'text-inherit'
         },

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

@@ -1,3 +1,17 @@
-import type { FC } from 'react';
-import { type TooltipProps } from '@radix-ui/react-tooltip';
+import type { FC, ReactNode } from 'react';
+import { Tooltip as ArkUiTooltip } from '@ark-ui/react/tooltip';
+export interface TooltipProps {
+    children: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    openDelay?: number;
+    closeDelay?: number;
+    closeOnPointerDown?: boolean;
+    closeOnEscape?: boolean;
+    closeOnScroll?: boolean;
+    interactive?: boolean;
+    disabled?: boolean;
+    positioning?: ArkUiTooltip.RootProps['positioning'];
+}
 export declare const Tooltip: FC<TooltipProps>;

package/dist/components/Tooltip/Tooltip.figma.js

@@ -2,21 +2,18 @@ import { jsx, jsxs } from "react/jsx-runtime";
 import code_connect from "@figma/code-connect";
 import { Tooltip } from "./Tooltip.js";
 import { TooltipContent } from "./TooltipContent.js";
-import { TooltipProvider } from "./TooltipProvider.js";
 import { TooltipTrigger } from "./TooltipTrigger.js";
 const figmaNodeUrl = 'https://www.figma.com/design/VKb5gW46uSGw0rqrhZsbXT/wip-components?node-id=269-10037';
 code_connect.connect(Tooltip, figmaNodeUrl, {
     props: {
         content: code_connect.string('Name')
     },
-    example: ({ content })=>/*#__PURE__*/ jsx(TooltipProvider, {
-            children: /*#__PURE__*/ jsxs(Tooltip, {
-                children: [
-                    /*#__PURE__*/ jsx(TooltipTrigger, {}),
-                    /*#__PURE__*/ jsx(TooltipContent, {
-                        children: content
-                    })
-                ]
-            })
+    example: ({ content })=>/*#__PURE__*/ jsxs(Tooltip, {
+            children: [
+                /*#__PURE__*/ jsx(TooltipTrigger, {}),
+                /*#__PURE__*/ jsx(TooltipContent, {
+                    children: content
+                })
+            ]
         })
 });

package/dist/components/Tooltip/Tooltip.js

@@ -1,7 +1,31 @@
 import { jsx } from "react/jsx-runtime";
-import { Root } from "@radix-ui/react-tooltip";
-const Tooltip = (props)=>/*#__PURE__*/ jsx(Root, {
-        ...props
+import { Tooltip } from "@ark-ui/react/tooltip";
+const TOOLTIP_POSITIONING_DEFAULT = {
+    offset: {
+        mainAxis: 6
+    },
+    overflowPadding: 8
+};
+const Tooltip_Tooltip = ({ children, open, defaultOpen, onOpenChange, openDelay, closeDelay, closeOnPointerDown, closeOnEscape, closeOnScroll, interactive, disabled, positioning })=>{
+    const handleOpenChange = (details)=>{
+        onOpenChange?.(details.open);
+    };
+    return /*#__PURE__*/ jsx(Tooltip.Root, {
+        open: open,
+        defaultOpen: defaultOpen,
+        onOpenChange: handleOpenChange,
+        openDelay: openDelay,
+        closeDelay: closeDelay,
+        closeOnPointerDown: closeOnPointerDown,
+        closeOnEscape: closeOnEscape,
+        closeOnScroll: closeOnScroll,
+        interactive: interactive,
+        disabled: disabled,
+        positioning: positioning ?? TOOLTIP_POSITIONING_DEFAULT,
+        lazyMount: true,
+        unmountOnExit: true,
+        children: children
     });
-Tooltip.displayName = 'Tooltip';
-export { Tooltip };
+};
+Tooltip_Tooltip.displayName = 'Tooltip';
+export { Tooltip_Tooltip as Tooltip };

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

@@ -1,7 +1,7 @@
 import type { ComponentPropsWithoutRef, ElementRef, FC, Ref } from 'react';
-import { Content } from '@radix-ui/react-tooltip';
-type TooltipContentProps = ComponentPropsWithoutRef<typeof Content> & {
-    ref?: Ref<ElementRef<typeof Content>>;
+import { Tooltip as ArkUiTooltip } from '@ark-ui/react/tooltip';
+type TooltipContentProps = ComponentPropsWithoutRef<typeof ArkUiTooltip.Content> & {
+    ref?: Ref<ElementRef<typeof ArkUiTooltip.Content>>;
 };
 export declare const TooltipContent: FC<TooltipContentProps>;
 export {};

package/dist/components/Tooltip/TooltipContent.js

@@ -1,12 +1,13 @@
 import { jsx } from "react/jsx-runtime";
-import { Content, Portal } from "@radix-ui/react-tooltip";
+import { Portal } from "@ark-ui/react/portal";
+import { Tooltip } from "@ark-ui/react/tooltip";
 import { cva } from "class-variance-authority";
 import { cn } from "../../utils/cn.js";
 import { hasNonTextEnd } from "../../utils/hasNonTextEnd.js";
 const tooltipContentVariants = cva([
     'py-4 rounded-8 bg-component-tooltip-bg text-text-primary-alt-fixed text-xs font-medium',
     'z-50 overflow-hidden',
-    'animate-in fade-in-0 zoom-in-95 origin-[--radix-tooltip-content-transform-origin]',
+    'animate-in fade-in-0 zoom-in-95 origin-[--transform-origin]',
     'data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95',
     'data-[side=bottom]:slide-in-from-top-2',
     'data-[side=left]:slide-in-from-right-2',
@@ -21,16 +22,16 @@ const tooltipContentVariants = cva([
         }
     }
 });
-const TooltipContent = ({ children, sideOffset = 6, className, ref, ...props })=>/*#__PURE__*/ jsx(Portal, {
-        children: /*#__PURE__*/ jsx(Content, {
-            ref: ref,
-            sideOffset: sideOffset,
-            collisionPadding: 8,
-            className: cn(tooltipContentVariants({
-                hasNonTextEnd: hasNonTextEnd(children)
-            }), className),
-            ...props,
-            children: children
+const TooltipContent = ({ children, className, ref, ...props })=>/*#__PURE__*/ jsx(Portal, {
+        children: /*#__PURE__*/ jsx(Tooltip.Positioner, {
+            children: /*#__PURE__*/ jsx(Tooltip.Content, {
+                ref: ref,
+                className: cn(tooltipContentVariants({
+                    hasNonTextEnd: hasNonTextEnd(children)
+                }), className),
+                ...props,
+                children: children
+            })
         })
     });
 TooltipContent.displayName = 'TooltipContent';

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

@@ -1,2 +1,7 @@
-import { type TooltipTriggerProps } from '@radix-ui/react-tooltip';
-export declare const TooltipTrigger: import("react").ForwardRefExoticComponent<TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+import type { ComponentPropsWithoutRef, ElementRef, FC, Ref } from 'react';
+import { Tooltip as ArkUiTooltip } from '@ark-ui/react/tooltip';
+type TooltipTriggerProps = ComponentPropsWithoutRef<typeof ArkUiTooltip.Trigger> & {
+    ref?: Ref<ElementRef<typeof ArkUiTooltip.Trigger>>;
+};
+export declare const TooltipTrigger: FC<TooltipTriggerProps>;
+export {};

package/dist/components/Tooltip/TooltipTrigger.js

@@ -1,9 +1,8 @@
 import { jsx } from "react/jsx-runtime";
-import { forwardRef } from "react";
-import { Trigger } from "@radix-ui/react-tooltip";
-const TooltipTrigger = /*#__PURE__*/ forwardRef((props, ref)=>/*#__PURE__*/ jsx(Trigger, {
+import { Tooltip } from "@ark-ui/react/tooltip";
+const TooltipTrigger = ({ ref, ...props })=>/*#__PURE__*/ jsx(Tooltip.Trigger, {
         ref: ref,
         ...props
-    }));
+    });
 TooltipTrigger.displayName = 'TooltipTrigger';
 export { TooltipTrigger };

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

@@ -1,4 +1,3 @@
-export { Tooltip } from './Tooltip';
+export { Tooltip, type TooltipProps } from './Tooltip';
 export { TooltipContent } from './TooltipContent';
-export { TooltipProvider } from './TooltipProvider';
 export { TooltipTrigger } from './TooltipTrigger';

package/dist/components/Tooltip/index.js

@@ -1,5 +1,4 @@
 import { Tooltip } from "./Tooltip.js";
 import { TooltipContent } from "./TooltipContent.js";
-import { TooltipProvider } from "./TooltipProvider.js";
 import { TooltipTrigger } from "./TooltipTrigger.js";
-export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };
+export { Tooltip, TooltipContent, TooltipTrigger };

package/dist/hooks/index.d.ts

@@ -1,3 +1,4 @@
 export { useControlled } from './useControlled';
 export { useCopyToClipboard } from './useCopyToClipboard';
+export { useIsKeyPressed } from './useIsKeyPressed';
 export { type UseOverflowItemsOptions, type UseOverflowItemsResult, useOverflowItems, } from './useOverflowItems';

package/dist/hooks/index.js

@@ -1,4 +1,5 @@
 import { useControlled } from "./useControlled.js";
 import { useCopyToClipboard } from "./useCopyToClipboard.js";
+import { useIsKeyPressed } from "./useIsKeyPressed.js";
 import { useOverflowItems } from "./useOverflowItems.js";
-export { useControlled, useCopyToClipboard, useOverflowItems };
+export { useControlled, useCopyToClipboard, useIsKeyPressed, useOverflowItems };

package/dist/hooks/useIsKeyPressed.d.ts

@@ -0,0 +1 @@
+export declare const useIsKeyPressed: (targetKey: string) => React.RefObject<boolean>;

package/dist/hooks/useIsKeyPressed.js

@@ -0,0 +1,22 @@
+import { useEffect, useRef } from "react";
+const useIsKeyPressed = (targetKey)=>{
+    const ref = useRef(false);
+    useEffect(()=>{
+        const downHandler = ({ key })=>{
+            if (key === targetKey) ref.current = true;
+        };
+        const upHandler = ({ key })=>{
+            if (key === targetKey) ref.current = false;
+        };
+        window.addEventListener('keydown', downHandler);
+        window.addEventListener('keyup', upHandler);
+        return ()=>{
+            window.removeEventListener('keydown', downHandler);
+            window.removeEventListener('keyup', upHandler);
+        };
+    }, [
+        targetKey
+    ]);
+    return ref;
+};
+export { useIsKeyPressed };

package/dist/icons/Bug.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+import { type SvgIconProps } from './SvgIcon';
+export declare const Bug: FC<SvgIconProps>;

package/dist/icons/Bug.js

@@ -0,0 +1,98 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { SvgIcon } from "./SvgIcon.js";
+const Bug = (props)=>/*#__PURE__*/ jsxs(SvgIcon, {
+        ...props,
+        viewBox: "0 0 24 24",
+        children: [
+            /*#__PURE__*/ jsx("path", {
+                d: "M12 20v-9",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M14 7a4 4 0 0 1 4 4v3a6 6 0 0 1-12 0v-3a4 4 0 0 1 4-4z",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M14.12 3.88 16 2",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M21 21a4 4 0 0 0-3.81-4",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M21 5a4 4 0 0 1-3.55 3.97",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M22 13h-4",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M3 21a4 4 0 0 1 3.81-4",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M3 5a4 4 0 0 0 3.55 3.97",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M6 13H2",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "m8 2 1.88 1.88",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M9 7.13V6a3 3 0 1 1 6 0v1.13",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+            })
+        ]
+    });
+Bug.displayName = 'BugIcon';
+export { Bug };

package/dist/icons/EllipsisVertical.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+import { type SvgIconProps } from './SvgIcon';
+export declare const EllipsisVertical: FC<SvgIconProps>;

package/dist/icons/EllipsisVertical.js

@@ -0,0 +1,28 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { SvgIcon } from "./SvgIcon.js";
+const EllipsisVertical = (props)=>/*#__PURE__*/ jsxs(SvgIcon, {
+        ...props,
+        viewBox: "0 0 24 24",
+        children: [
+            /*#__PURE__*/ jsx("circle", {
+                cx: "12",
+                cy: "12",
+                r: "1",
+                fill: "currentColor"
+            }),
+            /*#__PURE__*/ jsx("circle", {
+                cx: "12",
+                cy: "5",
+                r: "1",
+                fill: "currentColor"
+            }),
+            /*#__PURE__*/ jsx("circle", {
+                cx: "12",
+                cy: "19",
+                r: "1",
+                fill: "currentColor"
+            })
+        ]
+    });
+EllipsisVertical.displayName = 'EllipsisVerticalIcon';
+export { EllipsisVertical };

package/dist/icons/Eye.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+import { type SvgIconProps } from './SvgIcon';
+export declare const Eye: FC<SvgIconProps>;