atomicuilibrary 0.0.1

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

@@ -0,0 +1,166 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { AnimationEffect, FourSidePosition, FourCornerPosition, TriggerType, BasicSize, TooltipShape } from '../../types/common.type';
+import { TooltipVariant } from './types';
+import { AnimationEasing } from '../../types/animation.type';
+export declare class Tooltip {
+    el: HTMLElement;
+    /** Tooltip content text */
+    content: string;
+    /** Tooltip position relative to target */
+    position: FourSidePosition | FourCornerPosition | 'auto';
+    /** Trigger type for showing tooltip */
+    trigger: TriggerType;
+    /** Visual variant/theme */
+    variant: TooltipVariant;
+    /** Animation type */
+    animation: AnimationEffect;
+    /** Show arrow pointer */
+    arrow: boolean;
+    /** Delay before showing (ms) */
+    showDelay: number;
+    /** Delay before hiding (ms) */
+    hideDelay: number;
+    /** Maximum width in pixels */
+    maxWidth: number;
+    /** Offset from target (px) */
+    offset: number;
+    /** Enable HTML content */
+    html: boolean;
+    /** Allow tooltip to be interactive (hoverable) */
+    interactive: boolean;
+    /** Disable the tooltip */
+    disabled: boolean;
+    /** Custom CSS class */
+    customClass: string;
+    /** z-index value */
+    zIndex: number;
+    /** Follow mouse cursor (only works with hover trigger) */
+    followCursor: boolean;
+    /** Auto-flip when out of viewport */
+    autoFlip: boolean;
+    /** Show tooltip immediately on load */
+    visible: boolean;
+    /** Custom background color (overrides variant) */
+    customColor: string;
+    /** Custom text color */
+    textColor: string;
+    /** Transition duration in milliseconds */
+    transitionDuration: number;
+    /** Transition timing function */
+    transitionTiming: AnimationEasing;
+    /** Arrow size in pixels */
+    arrowSize: number;
+    /** Open tooltip at mouse click position (click trigger only) */
+    openAtMousePosition: boolean;
+    /** Track mouse movement and update tooltip position */
+    trackMouse: boolean;
+    /** Mouse tracking update interval in ms (for performance) */
+    trackInterval: number;
+    /** Auto-shift tooltip to stay in viewport */
+    autoShift: boolean;
+    /** Show close button */
+    closable: boolean;
+    /** Enable keyboard shortcuts (ESC to close, Tab navigation) */
+    keyboard: boolean;
+    /** Render tooltip in portal (document.body) */
+    portal: boolean;
+    /** Allow nested tooltips */
+    allowNested: boolean;
+    /** Loading state */
+    loading: boolean;
+    /** Size variant */
+    size: BasicSize;
+    /** Long press duration for touch devices (ms) */
+    longPressDuration: number;
+    /** Boundary element selector to constrain tooltip */
+    boundary: string;
+    /** Group ID for shared tooltips */
+    groupId: string;
+    /** Sticky tooltip (requires manual close) */
+    sticky: boolean;
+    /** Show header slot */
+    showHeader: boolean;
+    /** Show footer slot */
+    showFooter: boolean;
+    /** Close on click outside */
+    closeOnClickOutside: boolean;
+    /** Elevation level (0-5) */
+    elevation: number;
+    /** Tooltip shape */
+    shape: TooltipShape;
+    /** Show premium glow effect */
+    showGlow: boolean;
+    isVisible: boolean;
+    isPositioned: boolean;
+    currentPosition: string;
+    cursorX: number;
+    cursorY: number;
+    mouseClickX: number;
+    mouseClickY: number;
+    touchStartTime: number;
+    isTouchDevice: boolean;
+    tooltipShow: EventEmitter<{
+        position: string;
+    }>;
+    tooltipHide: EventEmitter<void>;
+    tooltipClick: EventEmitter<MouseEvent>;
+    tooltipMouseEnter: EventEmitter<MouseEvent>;
+    tooltipMouseLeave: EventEmitter<MouseEvent>;
+    tooltipMouseMove: EventEmitter<{
+        x: number;
+        y: number;
+    }>;
+    tooltipClose: EventEmitter<void>;
+    tooltipKeydown: EventEmitter<KeyboardEvent>;
+    tooltipTouchStart: EventEmitter<TouchEvent>;
+    tooltipTouchEnd: EventEmitter<TouchEvent>;
+    private targetElement;
+    private tooltipElement;
+    private defaultSlotSource;
+    private headerSlotSource;
+    private footerSlotSource;
+    private defaultSlotTarget;
+    private headerSlotTarget;
+    private footerSlotTarget;
+    private showTimeout;
+    private hideTimeout;
+    private observer;
+    private trackIntervalId;
+    private lastTrackTime;
+    private resizeObserver;
+    private updateRetries;
+    private static groupListeners;
+    private notifyGroupChange;
+    private handleGroupChange;
+    watchVisible(newValue: boolean): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    setupEventListeners(): void;
+    removeEventListeners(): void;
+    clearTimeouts(): void;
+    handleMouseEnter: (e: MouseEvent) => void;
+    handleMouseLeave: (e: MouseEvent) => void;
+    handleMouseMove: (e: MouseEvent) => void;
+    handleClick: (e: MouseEvent) => void;
+    handleDocumentClick: (e: MouseEvent) => void;
+    handleFocus: () => void;
+    handleBlur: () => void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    handleTouchStart: (e: TouchEvent) => void;
+    handleTouchEnd: (e: TouchEvent) => void;
+    handleTouchCancel: () => void;
+    handleClose: () => void;
+    handleWindowEvents: () => void;
+    private addWindowListeners;
+    private removeWindowListeners;
+    handleTooltipMouseEnter: () => void;
+    handleTooltipMouseLeave: () => void;
+    private migrateSlotsToTooltip;
+    private restoreSlotsToHost;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    forceHide(): Promise<void>;
+    toggle(): Promise<void>;
+    updatePosition(): void;
+    render(): any;
+}

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

@@ -0,0 +1,3 @@
+import { TriggerType } from '../../types/common.type';
+export { TooltipVariant, TooltipPosition, TooltipAnimation } from '../../types/common.type';
+export type TooltipTrigger = TriggerType;

package/dist/types/components/top-bar/top-bar.d.ts

@@ -0,0 +1,76 @@
+export interface TopBarAction {
+    id: string;
+    icon: string;
+    iconLibrary?: string;
+    label: string;
+    badge?: string;
+    onClick?: () => void;
+}
+export interface UserMenuItem {
+    id: string;
+    label: string;
+    icon?: string;
+    iconLibrary?: string;
+    onClick?: () => void;
+    divider?: boolean;
+}
+export declare class TopBar {
+    /**
+     * Company name
+     */
+    companyName: string;
+    /**
+     * Company logo/icon
+     */
+    companyLogo: string;
+    /**
+     * User name
+     */
+    userName: string;
+    /**
+     * User avatar/icon
+     */
+    userAvatar: string;
+    /**
+     * Library for the company logo/icon
+     */
+    companyLogoLibrary: 'se' | 'fontawesome' | 'icons8' | 'iconoir' | 'ionicons' | 'lucide' | 'bootstrap' | 'default';
+    /**
+     * Library for the user avatar/icon
+     */
+    userAvatarLibrary: 'se' | 'fontawesome' | 'icons8' | 'iconoir' | 'ionicons' | 'lucide' | 'bootstrap' | 'default';
+    /**
+     * Default library for actions and menu items
+     */
+    iconLibrary: 'se' | 'fontawesome' | 'icons8' | 'iconoir' | 'ionicons' | 'lucide' | 'bootstrap' | 'default';
+    /**
+     * Action icons as JSON string
+     */
+    actions: string | TopBarAction[];
+    /**
+     * User menu items as JSON string
+     */
+    userMenuItems: string | UserMenuItem[];
+    /**
+     * Background color
+     */
+    backgroundColor: string;
+    /**
+     * Text color
+     */
+    textColor: string;
+    /**
+     * Show shadow
+     */
+    showShadow: boolean;
+    isUserMenuOpen: boolean;
+    private userMenuRef;
+    private parseActions;
+    private parseUserMenuItems;
+    private handleUserProfileClick;
+    private handleUserMenuItemClick;
+    private handleClickOutside;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    render(): any;
+}

package/dist/types/components/transfer-list/transfer-list.d.ts

@@ -0,0 +1,137 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { GlassVariant, TransferItem, TransferMode } from './types';
+import { IconLibrary, Orientation, SortOrder, SourceTarget } from '../../types/common.type';
+export declare class TransferList {
+    /** Source items (left list) */
+    sourceItems: TransferItem[] | string;
+    /** Target items (right list) */
+    targetItems: TransferItem[] | string;
+    /** Titles for source and target lists */
+    titles: string[] | string;
+    /** Enable search functionality */
+    searchable: boolean;
+    /** Enable sorting functionality */
+    sortable: boolean;
+    /** Enable reordering in target list */
+    allowReorder: boolean;
+    /** Maximum number of items allowed in target list */
+    max: number;
+    /** Placeholder for search input */
+    searchPlaceholder: string;
+    /** Show select all checkbox */
+    showSelectAll: boolean;
+    /** Disabled state */
+    disabled: boolean;
+    /** Height of each list */
+    height: string;
+    /** Mode of the transfer list */
+    mode: TransferMode;
+    /** Enable drag and drop */
+    enableDrag: boolean;
+    /** Enable one-way mode (copy instead of move) */
+    oneWay: boolean;
+    /** Pagination support */
+    pagination: boolean;
+    pageSize: number;
+    /** Columns for table mode */
+    columns: {
+        title: string;
+        dataIndex: string;
+    }[];
+    /** Loading state */
+    loading: boolean;
+    /** Default library for icons */
+    iconLibrary: IconLibrary;
+    /** Custom item renderer function */
+    itemRenderer: ((item: TransferItem) => string | HTMLElement) | null;
+    /** Property to group items by (e.g., 'category') */
+    groupBy: string;
+    /** Enable glassmorphism variant */
+    variant: GlassVariant;
+    /** Layout orientation */
+    layout: Orientation;
+    /** Enable panel resizing (only for horizontal layout) */
+    resizable: boolean;
+    /** Custom filter option function */
+    filterOption: ((inputValue: string, item: TransferItem) => boolean) | null;
+    /** Locale object for internationalization */
+    locale: {
+        itemUnit?: string;
+        itemsUnit?: string;
+        notFoundContent?: string;
+        searchPlaceholder?: string;
+        titles?: string[];
+    };
+    /** State */
+    sourceSearch: string;
+    targetSearch: string;
+    sourceSelected: Set<string | number>;
+    targetSelected: Set<string | number>;
+    lastSelected: {
+        key: string | number;
+        side: SourceTarget;
+    } | null;
+    draggingItem: {
+        key: string | number;
+        side: SourceTarget;
+    } | null;
+    newlyMovedKeys: Set<string | number>;
+    sourcePage: number;
+    targetPage: number;
+    badgeAnimating: {
+        source: boolean;
+        target: boolean;
+    };
+    sourceSort: SortOrder;
+    targetSort: SortOrder;
+    dividerPosition: number;
+    contextMenu: {
+        visible: boolean;
+        x: number;
+        y: number;
+        item: TransferItem | null;
+        side: SourceTarget | null;
+    };
+    /** Events */
+    transferChange: EventEmitter<{
+        source: TransferItem[];
+        target: TransferItem[];
+    }>;
+    selectionChanged: EventEmitter<{
+        sourceSelected: any[];
+        targetSelected: any[];
+    }>;
+    private getSourceItems;
+    private getTargetItems;
+    private getTitles;
+    private filterItems;
+    private handleItemClick;
+    private handleKeyDown;
+    private moveToTarget;
+    private moveToSource;
+    private moveAllToTarget;
+    private moveAllToSource;
+    private reorder;
+    private bulkAction;
+    private highlightSearchText;
+    private emitChange;
+    private emitSelectionChange;
+    private toggleSelectAll;
+    private handleDragStart;
+    private handleDragOver;
+    private handleDrop;
+    private toggleSort;
+    private sortItems;
+    private handleDividerMouseDown;
+    private handleContextMenu;
+    private closeContextMenu;
+    private el;
+    private getSelectionSummary;
+    render(): any;
+    private renderList;
+    private renderListView;
+    private renderItem;
+    private renderSkeleton;
+    private renderTableView;
+    private renderTreeView;
+}

package/dist/types/components/transfer-list/types.d.ts

@@ -0,0 +1,13 @@
+import { IconItem, LabeledItem } from '../../types/common.type';
+export { TransferMode, GlassVariant } from '../../types/common.type';
+/** Full-featured item for the transfer-list component (supports tree mode, custom props) */
+export interface TransferItem extends IconItem {
+    key: string | number;
+    description?: string;
+    children?: TransferItem[];
+    [key: string]: any;
+}
+/** Simplified item alias used in legacy code (id required) */
+export interface TransferListItem extends LabeledItem {
+    id: string;
+}

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

@@ -0,0 +1,180 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { TreeNode, TreeDropEvent, TreeNodePath, TreeDiffResult, TreeState, FlatNode } from './types';
+import { Orientation } from '../../types/common.type';
+export declare class Tree {
+    el: HTMLElement;
+    nodes: TreeNode[] | string;
+    orientation: Orientation;
+    showLines: boolean;
+    showIcons: boolean;
+    expandable: boolean;
+    selectable: boolean;
+    multiSelect: boolean;
+    checkboxes: boolean;
+    checkboxSync: boolean;
+    enableDrag: boolean;
+    searchable: boolean;
+    animated: boolean;
+    indent: number;
+    nodeHeight: number;
+    expandAll: boolean;
+    collapseAll: boolean;
+    layout: 'tree' | 'org-chart';
+    variant: 'default' | 'bordered' | 'rounded' | 'minimal' | 'glass' | 'compact' | 'directory' | 'cards' | 'git-graph';
+    size: 'sm' | 'md' | 'lg';
+    theme: 'light' | 'dark';
+    showGlow: boolean;
+    connectorWidth: number;
+    connectorColor: string;
+    connectorOpacity: number;
+    connectorShape: 'rounded' | 'square';
+    iconLibrary: string;
+    inlineEdit: boolean;
+    contextMenuEnabled: boolean;
+    undoRedoEnabled: boolean;
+    lazyLoad: boolean;
+    virtualScroll: boolean;
+    virtualScrollHeight: number;
+    showNodeActions: boolean;
+    showAvatars: boolean;
+    expandIconType: 'chevron' | 'plus-minus' | 'arrow' | 'caret' | 'custom';
+    expandedIcon: string;
+    collapsedIcon: string;
+    expandIconSize: string;
+    expandIconColor: string;
+    internalNodes: TreeNode[];
+    selectedNodes: (string | number)[];
+    searchTerm: string;
+    draggedNode: TreeNode | null;
+    focusedNodeId: string | number | null;
+    editingNodeId: string | number | null;
+    editingValue: string;
+    contextMenuVisible: boolean;
+    contextMenuNode: TreeNode | null;
+    contextMenuX: number;
+    contextMenuY: number;
+    undoStack: string[];
+    redoStack: string[];
+    dragOverNodeId: string | number | null;
+    dragPosition: 'before' | 'inside' | 'after';
+    private _selectionPathIds;
+    nodeClick: EventEmitter<{
+        node: TreeNode;
+        path: (string | number)[];
+    }>;
+    nodeExpand: EventEmitter<{
+        node: TreeNode;
+        expanded: boolean;
+    }>;
+    nodeSelect: EventEmitter<{
+        node: TreeNode;
+        selected: boolean;
+    }>;
+    nodeCheck: EventEmitter<{
+        node: TreeNode;
+        checked: boolean;
+        indeterminate: boolean;
+    }>;
+    nodeDragStart: EventEmitter<TreeNode>;
+    nodeDrop: EventEmitter<TreeDropEvent>;
+    treeChange: EventEmitter<{
+        nodes: TreeNode[];
+        selectedNodes: (string | number)[];
+    }>;
+    nodeAction: EventEmitter<{
+        node: TreeNode;
+        action: string;
+    }>;
+    nodeEdit: EventEmitter<{
+        node: TreeNode;
+        newLabel: string;
+        oldLabel: string;
+    }>;
+    nodeContextMenu: EventEmitter<{
+        node: TreeNode;
+        x: number;
+        y: number;
+    }>;
+    nodeLazyLoad: EventEmitter<{
+        node: TreeNode;
+    }>;
+    nodeAdd: EventEmitter<{
+        parentId: string | number | null;
+        node: TreeNode;
+    }>;
+    nodeRemove: EventEmitter<{
+        node: TreeNode;
+    }>;
+    nodeMove: EventEmitter<{
+        nodeId: string | number;
+        targetId: string | number;
+        position: 'before' | 'inside' | 'after';
+    }>;
+    componentWillLoad(): void;
+    disconnectedCallback(): void;
+    parseNodes(): void;
+    expandAllNodes(): Promise<void>;
+    collapseAllNodes(): Promise<void>;
+    selectNode(id: string | number): Promise<void>;
+    getNodePath(id: string | number): Promise<(string | number)[]>;
+    getBreadcrumb(id: string | number): Promise<TreeNodePath[]>;
+    updateNode(id: string | number, data: Partial<TreeNode>): Promise<void>;
+    scrollToNode(id: string | number): Promise<void>;
+    expandByPath(path: (string | number)[]): Promise<void>;
+    selectByPath(path: (string | number)[]): Promise<void>;
+    getSelectedNodes(): Promise<TreeNode[]>;
+    dfsTraversal(startId?: string | number, order?: 'pre' | 'post'): Promise<TreeNode[]>;
+    bfsTraversal(startId?: string | number): Promise<TreeNode[]>;
+    flattenTree(nodes?: TreeNode[]): Promise<FlatNode[]>;
+    addNode(parentId: string | number | null, node: TreeNode): Promise<void>;
+    removeNode(id: string | number): Promise<void>;
+    moveNode(nodeId: string | number, targetId: string | number, position: 'before' | 'inside' | 'after'): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    diffTrees(oldNodes: TreeNode[], newNodes: TreeNode[]): Promise<TreeDiffResult>;
+    getState(): Promise<TreeState>;
+    restoreState(state: TreeState): Promise<void>;
+    private _saveUndo;
+    private _expandAllRecursive;
+    private _collapseAllRecursive;
+    private _findNode;
+    private _findPath;
+    private _expandPath;
+    private _selectById;
+    private _updateData;
+    private _addToParent;
+    private _removeNode;
+    private _moveNode;
+    private _insertRelative;
+    private _dfs;
+    private _dfsPost;
+    private _bfs;
+    private _syncChildren;
+    private _syncParent;
+    private _applyCheckbox;
+    private _getSelectionPathIds;
+    private _getVisibleNodes;
+    private _findParent;
+    private _selectRange;
+    private _applySelection;
+    private _toggleNode;
+    private handleNodeClick;
+    private handleCheckboxChange;
+    private handleDragStart;
+    private handleDragOver;
+    private handleDragLeave;
+    private handleDrop;
+    private handleSearchInput;
+    private handleDocumentClick;
+    private handleContextMenu;
+    private startEditing;
+    private cancelEditing;
+    private commitEditing;
+    private handleKeyDown;
+    private filterNodes;
+    private renderLabel;
+    private _renderExpandIcon;
+    private renderNode;
+    private renderContextMenu;
+    render(): any;
+}

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

@@ -0,0 +1,76 @@
+import { IconItem, StatusColor, WithChildren, WithMetadata } from '../../types/common.type';
+export type TreeNodePosition = 'before' | 'inside' | 'after';
+export interface TreeNode extends IconItem, WithMetadata, WithChildren<TreeNode> {
+    id: string | number;
+    label?: string;
+    key?: string | number;
+    tag?: string;
+    badge?: string;
+    counter?: number;
+    color?: StatusColor;
+    expanded?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    locked?: boolean;
+    lockTooltip?: string;
+    iconDate?: IconItem;
+    avatar?: string;
+    avatarInitials?: string;
+    avatars?: {
+        src?: string;
+        label?: string;
+        initials?: string;
+        color?: string;
+    }[];
+    /** false = branch that has no children yet (lazy-loadable). true = leaf node. undefined = auto-detect. */
+    isLeaf?: boolean;
+    className?: string;
+    customContent?: string;
+    loading?: boolean;
+    indeterminate?: boolean;
+    actions?: TreeAction[];
+    connectorColor?: string;
+    description?: string;
+    href?: string;
+    level?: number;
+    path?: (string | number)[];
+    disabled?: boolean;
+}
+export interface TreeAction extends IconItem {
+    icon: string;
+    tooltip?: string;
+    color?: string;
+    library?: string;
+    variant?: string;
+}
+export interface TreeDropEvent {
+    draggedNode: TreeNode;
+    targetNode: TreeNode | null;
+    position: TreeNodePosition;
+}
+export interface TreeNodePath {
+    id: string | number;
+    label: string;
+}
+export interface TreeDiffResult {
+    added: TreeNode[];
+    removed: TreeNode[];
+    modified: {
+        id: string | number;
+        oldNode: TreeNode;
+        newNode: TreeNode;
+    }[];
+}
+export interface TreeState {
+    nodes: TreeNode[];
+    selectedNodes: (string | number)[];
+    expandedNodes: (string | number)[];
+}
+export type TreeTraversalOrder = 'dfs-pre' | 'dfs-post' | 'bfs';
+export interface FlatNode extends Omit<TreeNode, 'children'> {
+    parentId: string | number | null;
+    depth: number;
+    index: number;
+    path: (string | number)[];
+    hasChildren: boolean;
+}