orizon 0.1.0

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

@@ -0,0 +1,162 @@
+import { ReactNode, Key, CSSProperties } from 'react';
+export type SortOrder = "ascend" | "descend" | null;
+export type FixedType = "left" | "right" | boolean;
+export type AlignType = "left" | "center" | "right";
+export interface FilterItem {
+    text: ReactNode;
+    value: string | number | boolean;
+    children?: FilterItem[];
+}
+export interface ColumnType<T = unknown> {
+    /** Column title */
+    title?: ReactNode;
+    /** Data index for accessing nested data */
+    dataIndex?: string | string[];
+    /** Unique key for this column */
+    key?: Key;
+    /** Column width */
+    width?: number | string;
+    /** Min width */
+    minWidth?: number;
+    /** Custom render function */
+    render?: (value: unknown, record: T, index: number) => ReactNode;
+    /** Sorter function or true for default */
+    sorter?: boolean | ((a: T, b: T) => number);
+    /** Default sort order */
+    defaultSortOrder?: SortOrder;
+    /** Sort directions */
+    sortDirections?: SortOrder[];
+    /** Filter items */
+    filters?: FilterItem[];
+    /** Filter function */
+    onFilter?: (value: string | number | boolean, record: T) => boolean;
+    /** Fixed column */
+    fixed?: FixedType;
+    /** Text alignment */
+    align?: AlignType;
+    /** Show ellipsis for overflowing text */
+    ellipsis?: boolean | {
+        showTitle?: boolean;
+    };
+    /** Column className */
+    className?: string;
+    /** Whether column is hidden */
+    hidden?: boolean;
+    /** onCell callback */
+    onCell?: (record: T, index: number) => React.HTMLAttributes<HTMLTableCellElement>;
+    /** onHeaderCell callback */
+    onHeaderCell?: () => React.HTMLAttributes<HTMLTableCellElement>;
+    /** Child columns for grouped headers */
+    children?: ColumnType<T>[];
+}
+export interface PaginationConfig {
+    current?: number;
+    pageSize?: number;
+    total?: number;
+    defaultCurrent?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: number[];
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    showTotal?: (total: number, range: [number, number]) => ReactNode;
+    onChange?: (page: number, pageSize: number) => void;
+    onShowSizeChange?: (current: number, size: number) => void;
+    position?: ("topLeft" | "topRight" | "bottomLeft" | "bottomRight")[];
+    simple?: boolean;
+    size?: "default" | "small";
+}
+export type RowSelectionType = "checkbox" | "radio";
+export interface RowSelection<T = unknown> {
+    type?: RowSelectionType;
+    selectedRowKeys?: Key[];
+    onChange?: (selectedRowKeys: Key[], selectedRows: T[]) => void;
+    onSelect?: (record: T, selected: boolean, selectedRows: T[]) => void;
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    getCheckboxProps?: (record: T) => Partial<{
+        disabled: boolean;
+        name: string;
+    }>;
+    columnWidth?: number | string;
+    columnTitle?: ReactNode;
+    fixed?: FixedType;
+    hideSelectAll?: boolean;
+}
+export interface ExpandableConfig<T = unknown> {
+    expandedRowRender?: (record: T, index: number, indent: number, expanded: boolean) => ReactNode;
+    expandedRowKeys?: Key[];
+    defaultExpandedRowKeys?: Key[];
+    onExpand?: (expanded: boolean, record: T) => void;
+    onExpandedRowsChange?: (expandedKeys: Key[]) => void;
+    expandIcon?: (props: {
+        expanded: boolean;
+        onExpand: () => void;
+        record: T;
+    }) => ReactNode;
+    expandRowByClick?: boolean;
+    indentSize?: number;
+    columnWidth?: number | string;
+    fixed?: FixedType;
+    showExpandColumn?: boolean;
+    rowExpandable?: (record: T) => boolean;
+}
+export interface ScrollConfig {
+    x?: number | string | true;
+    y?: number | string;
+    scrollToFirstRowOnChange?: boolean;
+}
+export type TableSize = "large" | "middle" | "small";
+export interface SorterResult<T = unknown> {
+    column?: ColumnType<T>;
+    order?: SortOrder;
+    field?: string | string[];
+    columnKey?: Key;
+}
+export interface TableProps<T = unknown> {
+    /** Column definitions */
+    columns?: ColumnType<T>[];
+    /** Data source */
+    dataSource?: T[];
+    /** Row key */
+    rowKey?: string | ((record: T) => Key);
+    /** Loading state */
+    loading?: boolean | {
+        spinning?: boolean;
+        tip?: ReactNode;
+    };
+    /** Table size */
+    size?: TableSize;
+    /** Pagination config or false to disable */
+    pagination?: PaginationConfig | false;
+    /** Row selection config */
+    rowSelection?: RowSelection<T>;
+    /** Scroll config */
+    scroll?: ScrollConfig;
+    /** Whether to show bordered */
+    bordered?: boolean;
+    /** Callback for sort, filter, pagination changes */
+    onChange?: (pagination: PaginationConfig, filters: Record<string, (string | number | boolean)[] | null>, sorter: SorterResult<T> | SorterResult<T>[]) => void;
+    /** Allowed sort directions */
+    sortDirections?: SortOrder[];
+    /** Expandable config */
+    expandable?: ExpandableConfig<T>;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Table title */
+    title?: (currentPageData: T[]) => ReactNode;
+    /** Table footer */
+    footer?: (currentPageData: T[]) => ReactNode;
+    /** Row className */
+    rowClassName?: string | ((record: T, index: number) => string);
+    /** onRow callback */
+    onRow?: (record: T, index: number) => React.HTMLAttributes<HTMLTableRowElement>;
+    /** Show table header */
+    showHeader?: boolean;
+    /** Empty text */
+    locale?: {
+        emptyText?: ReactNode;
+    };
+    /** Sticky header */
+    sticky?: boolean;
+}

package/dist/components/tabs/Tabs.d.ts

@@ -0,0 +1,4 @@
+import { TabsProps } from './types';
+import * as React from "react";
+declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
+export { Tabs };

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

@@ -0,0 +1,2 @@
+export { Tabs } from './Tabs';
+export type { TabsProps, TabItem, TabsType, TabsSize, TabsPosition } from './types';

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

@@ -0,0 +1,51 @@
+import { ReactNode, CSSProperties } from 'react';
+export type TabsType = "line" | "card" | "editable-card";
+export type TabsSize = "small" | "middle" | "large";
+export type TabsPosition = "top" | "bottom" | "left" | "right";
+export interface TabItem {
+    /** Unique key for the tab */
+    key: string;
+    /** Label displayed in the tab trigger */
+    label: ReactNode;
+    /** Content rendered when this tab is active */
+    children?: ReactNode;
+    /** Whether the tab is disabled */
+    disabled?: boolean;
+    /** Whether the tab can be closed (only for editable-card) */
+    closable?: boolean;
+    /** Custom icon in the tab trigger */
+    icon?: ReactNode;
+    /** Force render the tab panel even when not active */
+    forceRender?: boolean;
+}
+export interface TabsProps {
+    /** Controlled active tab key */
+    activeKey?: string;
+    /** Default active tab key (uncontrolled) */
+    defaultActiveKey?: string;
+    /** Tab items */
+    items?: TabItem[];
+    /** Tab display type */
+    type?: TabsType;
+    /** Tab size */
+    size?: TabsSize;
+    /** Tab bar position */
+    tabPosition?: TabsPosition;
+    /** Callback when active tab changes */
+    onChange?: (activeKey: string) => void;
+    /** Callback for add/remove operations (editable-card only) */
+    onEdit?: (targetKey: string | React.MouseEvent | React.KeyboardEvent, action: "add" | "remove") => void;
+    /** Extra content on the tab bar */
+    tabBarExtraContent?: ReactNode | {
+        left?: ReactNode;
+        right?: ReactNode;
+    };
+    /** Whether tabs are centered */
+    centered?: boolean;
+    /** Whether to destroy hidden tab panes */
+    destroyInactiveTabPane?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Style for the component */
+    style?: CSSProperties;
+}

package/dist/components/tag/Tag.d.ts

@@ -0,0 +1,5 @@
+import { TagProps, CheckableTagProps } from './types';
+import * as React from "react";
+declare const InternalTag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLSpanElement>>;
+declare const CheckableTag: React.FC<CheckableTagProps>;
+export { InternalTag, CheckableTag };

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

@@ -0,0 +1,7 @@
+import { InternalTag, CheckableTag } from './Tag';
+type TagComponent = typeof InternalTag & {
+    CheckableTag: typeof CheckableTag;
+};
+declare const Tag: TagComponent;
+export { Tag };
+export type { TagProps, CheckableTagProps } from './types';

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

@@ -0,0 +1,32 @@
+import { ReactNode, CSSProperties, HTMLAttributes, MouseEvent } from 'react';
+export type PresetColor = "blue" | "purple" | "cyan" | "green" | "magenta" | "pink" | "red" | "orange" | "yellow" | "volcano" | "geekblue" | "lime" | "gold" | "success" | "processing" | "error" | "warning" | "default";
+export interface TagProps extends Omit<HTMLAttributes<HTMLSpanElement>, "color"> {
+    /** Preset or custom color */
+    color?: PresetColor | string;
+    /** Whether the tag is closable */
+    closable?: boolean;
+    /** Icon element */
+    icon?: ReactNode;
+    /** Whether to show border */
+    bordered?: boolean;
+    /** Callback when tag is closed */
+    onClose?: (e: MouseEvent<HTMLElement>) => void;
+    /** Custom close icon */
+    closeIcon?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export interface CheckableTagProps extends Omit<HTMLAttributes<HTMLSpanElement>, "onChange"> {
+    /** Whether the tag is checked */
+    checked: boolean;
+    /** Callback when checked state changes */
+    onChange?: (checked: boolean) => void;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}

package/dist/components/time-picker/TimePicker.d.ts

@@ -0,0 +1,5 @@
+import { TimePickerProps } from './types';
+import * as React from "react";
+declare function formatTime(date: Date, fmt: string, use12Hours: boolean): string;
+declare const InternalTimePicker: React.ForwardRefExoticComponent<TimePickerProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalTimePicker, formatTime };

package/dist/components/time-picker/TimeRangePicker.d.ts

@@ -0,0 +1,4 @@
+import { TimeRangePickerProps } from './types';
+import * as React from "react";
+declare const TimeRangePicker: React.ForwardRefExoticComponent<TimeRangePickerProps & React.RefAttributes<HTMLDivElement>>;
+export { TimeRangePicker };

package/dist/components/time-picker/index.d.ts

@@ -0,0 +1,8 @@
+import { InternalTimePicker } from './TimePicker';
+import { TimeRangePicker } from './TimeRangePicker';
+type TimePickerComponent = typeof InternalTimePicker & {
+    RangePicker: typeof TimeRangePicker;
+};
+declare const TimePicker: TimePickerComponent;
+export { TimePicker };
+export type { TimePickerProps, TimeRangePickerProps, TimePickerSize, TimePickerStatus, TimePickerVariant, } from './types';

package/dist/components/time-picker/types.d.ts

@@ -0,0 +1,48 @@
+import { CSSProperties, ReactNode } from 'react';
+export type TimePickerSize = "small" | "middle" | "large";
+export type TimePickerStatus = "error" | "warning";
+export type TimePickerVariant = "outlined" | "borderless" | "filled";
+export interface TimePickerProps {
+    value?: Date;
+    defaultValue?: Date;
+    onChange?: (time: Date | null, timeString: string) => void;
+    format?: string;
+    use12Hours?: boolean;
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    showNow?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    size?: TimePickerSize;
+    status?: TimePickerStatus;
+    variant?: TimePickerVariant;
+    allowClear?: boolean;
+    suffixIcon?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    hideDisabledOptions?: boolean;
+    disabledTime?: () => {
+        disabledHours?: () => number[];
+        disabledMinutes?: (selectedHour: number) => number[];
+        disabledSeconds?: (selectedHour: number, selectedMinute: number) => number[];
+    };
+}
+export interface TimeRangePickerProps {
+    value?: [Date | null, Date | null];
+    defaultValue?: [Date | null, Date | null];
+    onChange?: (times: [Date | null, Date | null], timeStrings: [string, string]) => void;
+    format?: string;
+    use12Hours?: boolean;
+    disabled?: boolean | [boolean, boolean];
+    placeholder?: [string, string];
+    size?: TimePickerSize;
+    status?: TimePickerStatus;
+    variant?: TimePickerVariant;
+    allowClear?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    order?: boolean;
+}

package/dist/components/timeline/Timeline.d.ts

@@ -0,0 +1,4 @@
+import { TimelineProps } from './types';
+import * as React from "react";
+declare const InternalTimeline: React.FC<TimelineProps>;
+export { InternalTimeline };

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

@@ -0,0 +1,3 @@
+declare const Timeline: import('react').FC<import('./types').TimelineProps>;
+export { Timeline };
+export type { TimelineProps, TimelineItem, TimelineMode, TimelineItemPosition } from './types';

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

@@ -0,0 +1,35 @@
+import { ReactNode, CSSProperties } from 'react';
+export type TimelineMode = "left" | "right" | "alternate";
+export type TimelineItemPosition = "left" | "right";
+export interface TimelineItem {
+    /** Content */
+    children: ReactNode;
+    /** Dot color (CSS color or preset) */
+    color?: string;
+    /** Custom dot element */
+    dot?: ReactNode;
+    /** Label displayed on opposite side */
+    label?: ReactNode;
+    /** Position override for alternate mode */
+    position?: TimelineItemPosition;
+    /** Class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}
+export interface TimelineProps {
+    /** Timeline items */
+    items?: TimelineItem[];
+    /** Mode of timeline */
+    mode?: TimelineMode;
+    /** Whether to show a pending indicator */
+    pending?: ReactNode;
+    /** Custom pending dot */
+    pendingDot?: ReactNode;
+    /** Whether to reverse the order */
+    reverse?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}

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

@@ -0,0 +1,4 @@
+import { TooltipProps } from './types';
+import * as React from "react";
+declare const InternalTooltip: React.FC<TooltipProps>;
+export { InternalTooltip };

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

@@ -0,0 +1,3 @@
+declare const Tooltip: import('react').FC<import('./types').TooltipProps>;
+export { Tooltip };
+export type { TooltipProps, TooltipPlacement, TooltipTrigger } from './types';

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

@@ -0,0 +1,33 @@
+import { ReactNode, CSSProperties } from 'react';
+export type TooltipPlacement = "top" | "topLeft" | "topRight" | "bottom" | "bottomLeft" | "bottomRight" | "left" | "leftTop" | "leftBottom" | "right" | "rightTop" | "rightBottom";
+export type TooltipTrigger = "hover" | "focus" | "click";
+export interface TooltipProps {
+    /** Tooltip content */
+    title?: ReactNode | (() => ReactNode);
+    /** Placement position */
+    placement?: TooltipPlacement;
+    /** Trigger mode */
+    trigger?: TooltipTrigger;
+    /** Controlled open state */
+    open?: boolean;
+    /** Default open state */
+    defaultOpen?: boolean;
+    /** Callback when open changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Custom background color */
+    color?: string;
+    /** Whether to show arrow */
+    arrow?: boolean;
+    /** Overlay class name */
+    overlayClassName?: string;
+    /** Overlay style */
+    overlayStyle?: CSSProperties;
+    /** Mouse enter delay in seconds */
+    mouseEnterDelay?: number;
+    /** Mouse leave delay in seconds */
+    mouseLeaveDelay?: number;
+    /** Destroy on hide */
+    destroyTooltipOnHide?: boolean;
+    /** Children trigger element */
+    children?: ReactNode;
+}

package/dist/components/tour/Tour.d.ts

@@ -0,0 +1,4 @@
+import { TourProps } from './types';
+import * as React from "react";
+declare const InternalTour: React.FC<TourProps>;
+export { InternalTour };

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

@@ -0,0 +1,3 @@
+declare const Tour: import('react').FC<import('./types').TourProps>;
+export { Tour };
+export type { TourProps, TourStepConfig, TourPlacement, TourType } from './types';

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

@@ -0,0 +1,63 @@
+import { ReactNode, CSSProperties, RefObject } from 'react';
+export type TourPlacement = "top" | "topLeft" | "topRight" | "bottom" | "bottomLeft" | "bottomRight" | "left" | "leftTop" | "leftBottom" | "right" | "rightTop" | "rightBottom" | "center";
+export type TourType = "default" | "primary";
+export interface TourStepConfig {
+    /** Target element ref or selector */
+    target?: RefObject<HTMLElement> | (() => HTMLElement | null) | null;
+    /** Step title */
+    title?: ReactNode;
+    /** Step description */
+    description?: ReactNode;
+    /** Cover image/content */
+    cover?: ReactNode;
+    /** Placement of the popover */
+    placement?: TourPlacement;
+    /** Whether to show mask */
+    mask?: boolean;
+    /** Custom mask style */
+    maskStyle?: CSSProperties;
+    /** Custom next button text */
+    nextButtonProps?: {
+        children?: ReactNode;
+        onClick?: () => void;
+    };
+    /** Custom prev button text */
+    prevButtonProps?: {
+        children?: ReactNode;
+        onClick?: () => void;
+    };
+    /** Step type */
+    type?: TourType;
+    /** Custom class name */
+    className?: string;
+    /** Custom style */
+    style?: CSSProperties;
+}
+export interface TourProps {
+    /** Tour step configurations */
+    steps: TourStepConfig[];
+    /** Controlled open state */
+    open?: boolean;
+    /** Current step (controlled) */
+    current?: number;
+    /** Callback when step changes */
+    onChange?: (current: number) => void;
+    /** Callback when tour is closed */
+    onClose?: () => void;
+    /** Callback when tour finishes */
+    onFinish?: () => void;
+    /** Tour type */
+    type?: TourType;
+    /** Whether to show mask overlay */
+    mask?: boolean;
+    /** Whether to show arrow */
+    arrow?: boolean;
+    /** Custom indicator render */
+    indicatorsRender?: (current: number, total: number) => ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Z-index */
+    zIndex?: number;
+}

package/dist/components/transfer/Transfer.d.ts

@@ -0,0 +1,4 @@
+import { TransferProps } from './types';
+import * as React from "react";
+declare const InternalTransfer: React.FC<TransferProps>;
+export { InternalTransfer };

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

@@ -0,0 +1,3 @@
+declare const Transfer: import('react').FC<import('./types').TransferProps>;
+export { Transfer };
+export type { TransferProps, TransferItem } from './types';

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

@@ -0,0 +1,40 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface TransferItem {
+    key: string;
+    title?: string;
+    description?: string;
+    disabled?: boolean;
+    [name: string]: unknown;
+}
+export interface TransferProps {
+    dataSource?: TransferItem[];
+    targetKeys?: string[];
+    selectedKeys?: string[];
+    onChange?: (targetKeys: string[], direction: "left" | "right", moveKeys: string[]) => void;
+    onSelectChange?: (sourceSelectedKeys: string[], targetSelectedKeys: string[]) => void;
+    onSearch?: (direction: "left" | "right", value: string) => void;
+    render?: (item: TransferItem) => ReactNode;
+    showSearch?: boolean;
+    titles?: [ReactNode, ReactNode];
+    operations?: [string, string];
+    disabled?: boolean;
+    listStyle?: CSSProperties | ((params: {
+        direction: "left" | "right";
+    }) => CSSProperties);
+    pagination?: boolean | {
+        pageSize?: number;
+    };
+    oneWay?: boolean;
+    selectAllLabels?: [
+        (info: {
+            selectedCount: number;
+            totalCount: number;
+        }) => ReactNode,
+        (info: {
+            selectedCount: number;
+            totalCount: number;
+        }) => ReactNode
+    ];
+    className?: string;
+    style?: CSSProperties;
+}

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

@@ -0,0 +1,5 @@
+import { TreeProps, DirectoryTreeProps } from './types';
+import * as React from "react";
+declare const InternalTree: React.FC<TreeProps>;
+declare const DirectoryTree: React.FC<DirectoryTreeProps>;
+export { InternalTree, DirectoryTree };

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

@@ -0,0 +1,7 @@
+import { InternalTree, DirectoryTree } from './Tree';
+type TreeComponent = typeof InternalTree & {
+    DirectoryTree: typeof DirectoryTree;
+};
+declare const Tree: TreeComponent;
+export { Tree };
+export type { TreeProps, DirectoryTreeProps, TreeDataNode } from './types';