orizon 0.1.0

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

@@ -0,0 +1,3 @@
+declare const Select: import('react').ForwardRefExoticComponent<import('./types').SelectProps & import('react').RefAttributes<HTMLButtonElement>>;
+export { Select };
+export type { SelectProps, SelectOptionType, LabeledValue, FieldNames, } from './types';

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

@@ -0,0 +1,65 @@
+import { ReactNode } from 'react';
+import { ComponentSize } from '../../hooks/useComponentSize';
+export interface SelectOptionType {
+    label: ReactNode;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface LabeledValue {
+    label: ReactNode;
+    value: string | number;
+}
+export interface FieldNames {
+    label?: string;
+    value?: string;
+}
+export interface SelectProps {
+    /** Array of select options */
+    options?: SelectOptionType[];
+    /** Current selected value (single mode) */
+    value?: string | number | (string | number)[] | LabeledValue | LabeledValue[];
+    /** Default selected value */
+    defaultValue?: string | number | (string | number)[] | LabeledValue | LabeledValue[];
+    /** Callback when value changes */
+    onChange?: (value: any, option: SelectOptionType | SelectOptionType[]) => void;
+    /** Mode of select: multiple or tags. Undefined means single select. */
+    mode?: "multiple" | "tags";
+    /** Size of select */
+    size?: ComponentSize;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the select is disabled */
+    disabled?: boolean;
+    /** Whether the select is loading */
+    loading?: boolean;
+    /** Show clear button */
+    allowClear?: boolean;
+    /** Validation status */
+    status?: "error" | "warning";
+    /** Visual variant */
+    variant?: "outlined" | "borderless" | "filled" | "underlined";
+    /** Enable search/filter */
+    showSearch?: boolean;
+    /** Callback when search input changes */
+    onSearch?: (value: string) => void;
+    /** Custom filter function. Return true to include option. */
+    filterOption?: boolean | ((inputValue: string, option: SelectOptionType) => boolean);
+    /** Whether to wrap value in { label, value } object */
+    labelInValue?: boolean;
+    /** Controlled open state */
+    open?: boolean;
+    /** Callback when dropdown open/close */
+    onOpenChange?: (open: boolean) => void;
+    /** Custom field names mapping */
+    fieldNames?: FieldNames;
+    /** Content to show when no options match */
+    notFoundContent?: ReactNode;
+    /** Whether popup width matches trigger width, or a fixed number */
+    popupMatchSelectWidth?: boolean | number;
+    /** Additional class name */
+    className?: string;
+    /** Additional style */
+    style?: React.CSSProperties;
+    /** ID attribute */
+    id?: string;
+}

package/dist/components/skeleton/Skeleton.d.ts

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

package/dist/components/skeleton/SkeletonElements.d.ts

@@ -0,0 +1,8 @@
+import { SkeletonAvatarProps, SkeletonButtonProps, SkeletonInputProps, SkeletonImageProps, SkeletonNodeProps } from './types';
+import * as React from "react";
+declare const SkeletonAvatar: React.ForwardRefExoticComponent<SkeletonAvatarProps & React.RefAttributes<HTMLDivElement>>;
+declare const SkeletonButton: React.ForwardRefExoticComponent<SkeletonButtonProps & React.RefAttributes<HTMLDivElement>>;
+declare const SkeletonInput: React.ForwardRefExoticComponent<SkeletonInputProps & React.RefAttributes<HTMLDivElement>>;
+declare const SkeletonImage: React.ForwardRefExoticComponent<SkeletonImageProps & React.RefAttributes<HTMLDivElement>>;
+declare const SkeletonNode: React.ForwardRefExoticComponent<SkeletonNodeProps & React.RefAttributes<HTMLDivElement>>;
+export { SkeletonAvatar, SkeletonButton, SkeletonInput, SkeletonImage, SkeletonNode, };

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

@@ -0,0 +1,12 @@
+import { InternalSkeleton } from './Skeleton';
+import { SkeletonAvatar, SkeletonButton, SkeletonInput, SkeletonImage, SkeletonNode } from './SkeletonElements';
+type SkeletonComponent = typeof InternalSkeleton & {
+    Avatar: typeof SkeletonAvatar;
+    Button: typeof SkeletonButton;
+    Input: typeof SkeletonInput;
+    Image: typeof SkeletonImage;
+    Node: typeof SkeletonNode;
+};
+declare const Skeleton: SkeletonComponent;
+export { Skeleton };
+export type { SkeletonProps, SkeletonAvatarProps, SkeletonButtonProps, SkeletonInputProps, SkeletonImageProps, SkeletonNodeProps, SkeletonAvatarConfig, SkeletonTitleConfig, SkeletonParagraphConfig, SkeletonAvatarShape, SkeletonAvatarSize, SkeletonButtonSize, SkeletonButtonShape, SkeletonInputSize, } from './types';

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

@@ -0,0 +1,76 @@
+import { ReactNode, CSSProperties } from 'react';
+export type SkeletonAvatarShape = "circle" | "square";
+export type SkeletonAvatarSize = "small" | "default" | "large" | number;
+export type SkeletonButtonSize = "small" | "default" | "large";
+export type SkeletonButtonShape = "default" | "circle" | "round";
+export type SkeletonInputSize = "small" | "default" | "large";
+export interface SkeletonAvatarConfig {
+    /** Avatar shape */
+    shape?: SkeletonAvatarShape;
+    /** Avatar size */
+    size?: SkeletonAvatarSize;
+}
+export interface SkeletonTitleConfig {
+    /** Width of the title */
+    width?: string | number;
+}
+export interface SkeletonParagraphConfig {
+    /** Number of rows */
+    rows?: number;
+    /** Width of each row (can be array for each row) */
+    width?: string | number | (string | number)[];
+}
+export interface SkeletonProps {
+    /** Whether to animate the skeleton */
+    active?: boolean;
+    /** Whether to show skeleton (true) or children (false) */
+    loading?: boolean;
+    /** Avatar configuration */
+    avatar?: boolean | SkeletonAvatarConfig;
+    /** Title configuration */
+    title?: boolean | SkeletonTitleConfig;
+    /** Paragraph configuration */
+    paragraph?: boolean | SkeletonParagraphConfig;
+    /** Use rounded borders */
+    round?: boolean;
+    /** Children shown when loading is false */
+    children?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+}
+export interface SkeletonElementProps {
+    /** Whether to animate */
+    active?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+}
+export interface SkeletonAvatarProps extends SkeletonElementProps {
+    /** Shape of avatar */
+    shape?: SkeletonAvatarShape;
+    /** Size of avatar */
+    size?: SkeletonAvatarSize;
+}
+export interface SkeletonButtonProps extends SkeletonElementProps {
+    /** Size of button */
+    size?: SkeletonButtonSize;
+    /** Shape of button */
+    shape?: SkeletonButtonShape;
+    /** Block mode */
+    block?: boolean;
+}
+export interface SkeletonInputProps extends SkeletonElementProps {
+    /** Size of input */
+    size?: SkeletonInputSize;
+    /** Block mode */
+    block?: boolean;
+}
+export interface SkeletonImageProps extends SkeletonElementProps {
+}
+export interface SkeletonNodeProps extends SkeletonElementProps {
+    /** Children content */
+    children?: ReactNode;
+}

package/dist/components/slider/Slider.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Slider: import('react').ForwardRefExoticComponent<import('./types').SliderProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Slider };
+export type { SliderProps, SliderMarks, SliderTooltipConfig, } from './types';

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

@@ -0,0 +1,29 @@
+import { CSSProperties, ReactNode } from 'react';
+export type SliderMarks = Record<number, ReactNode | {
+    label: ReactNode;
+    style?: CSSProperties;
+}>;
+export interface SliderTooltipConfig {
+    open?: boolean;
+    placement?: "top" | "bottom" | "left" | "right";
+    formatter?: ((value?: number) => ReactNode) | null;
+}
+export interface SliderProps {
+    value?: number | [number, number];
+    defaultValue?: number | [number, number];
+    onChange?: (value: number | [number, number]) => void;
+    onChangeComplete?: (value: number | [number, number]) => void;
+    min?: number;
+    max?: number;
+    step?: number | null;
+    range?: boolean;
+    marks?: SliderMarks;
+    dots?: boolean;
+    disabled?: boolean;
+    vertical?: boolean;
+    tooltip?: SliderTooltipConfig;
+    included?: boolean;
+    reverse?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/space/Compact.d.ts

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

package/dist/components/space/Space.d.ts

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

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

@@ -0,0 +1,8 @@
+import { InternalSpace } from './Space';
+import { SpaceCompact } from './Compact';
+type SpaceComponent = typeof InternalSpace & {
+    Compact: typeof SpaceCompact;
+};
+declare const Space: SpaceComponent;
+export { Space };
+export type { SpaceProps, SpaceCompactProps, SpaceSize, SpaceDirection, SpaceAlign } from './types';

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

@@ -0,0 +1,30 @@
+import { ReactNode, HTMLAttributes } from 'react';
+export type SpaceSize = "small" | "middle" | "large" | number;
+export type SpaceDirection = "horizontal" | "vertical";
+export type SpaceAlign = "start" | "end" | "center" | "baseline";
+export interface SpaceProps extends Omit<HTMLAttributes<HTMLDivElement>, "dir"> {
+    /** Alignment of children */
+    align?: SpaceAlign;
+    /** Spacing size between children */
+    size?: SpaceSize | [SpaceSize, SpaceSize];
+    /** Direction of the space layout */
+    direction?: SpaceDirection;
+    /** Whether to wrap children */
+    wrap?: boolean;
+    /** Separator node between children */
+    split?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}
+export interface SpaceCompactProps extends HTMLAttributes<HTMLDivElement> {
+    /** Direction of compact layout */
+    direction?: SpaceDirection;
+    /** Size override for children */
+    size?: "small" | "middle" | "large";
+    /** Whether to display as block */
+    block?: boolean;
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}

package/dist/components/spin/Spin.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Spin: import('react').ForwardRefExoticComponent<import('./types').SpinProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Spin };
+export type { SpinProps, SpinSize } from './types';

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

@@ -0,0 +1,28 @@
+import { ReactNode, CSSProperties } from 'react';
+export type SpinSize = "small" | "middle" | "large";
+export interface SpinProps {
+    /** Whether the spin is active */
+    spinning?: boolean;
+    /** Size of the spinner */
+    size?: SpinSize;
+    /** Delay before showing spinner (ms) */
+    delay?: number;
+    /** Custom spinner indicator */
+    indicator?: ReactNode;
+    /** Tip/description text below the spinner */
+    tip?: ReactNode;
+    /** Alias for tip */
+    description?: ReactNode;
+    /** Whether to show fullscreen overlay */
+    fullscreen?: boolean;
+    /** Progress percentage ("auto" for indeterminate, or number) */
+    percent?: "auto" | number;
+    /** Wrapper class name when wrapping children */
+    wrapperClassName?: string;
+    /** Children to wrap with spin overlay */
+    children?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+}

package/dist/components/splitter/Panel.d.ts

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

package/dist/components/splitter/Splitter.d.ts

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

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

@@ -0,0 +1,8 @@
+import { InternalSplitter } from './Splitter';
+import { Panel } from './Panel';
+type SplitterComponent = typeof InternalSplitter & {
+    Panel: typeof Panel;
+};
+declare const Splitter: SplitterComponent;
+export { Splitter };
+export type { SplitterProps, SplitterPanelProps, SplitterLayout, } from './types';

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

@@ -0,0 +1,25 @@
+import { CSSProperties, ReactNode } from 'react';
+export type SplitterLayout = "horizontal" | "vertical";
+export interface SplitterPanelProps {
+    defaultSize?: number | string;
+    min?: number | string;
+    max?: number | string;
+    collapsible?: boolean | {
+        start?: boolean;
+        end?: boolean;
+    };
+    resizable?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export interface SplitterProps {
+    layout?: SplitterLayout;
+    lazy?: boolean;
+    onResize?: (sizes: number[]) => void;
+    onResizeStart?: (sizes: number[]) => void;
+    onResizeEnd?: (sizes: number[]) => void;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/statistic/Statistic.d.ts

@@ -0,0 +1,5 @@
+import { StatisticProps, CountdownProps } from './types';
+import * as React from "react";
+declare const InternalStatistic: React.FC<StatisticProps>;
+declare const Countdown: React.FC<CountdownProps>;
+export { InternalStatistic, Countdown };

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

@@ -0,0 +1,7 @@
+import { InternalStatistic, Countdown } from './Statistic';
+type StatisticComponent = typeof InternalStatistic & {
+    Countdown: typeof Countdown;
+};
+declare const Statistic: StatisticComponent;
+export { Statistic };
+export type { StatisticProps, CountdownProps } from './types';

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

@@ -0,0 +1,37 @@
+import { ReactNode, CSSProperties } from 'react';
+export interface StatisticProps {
+    /** Title text */
+    title?: ReactNode;
+    /** Numeric or string value */
+    value?: number | string;
+    /** Decimal precision */
+    precision?: number;
+    /** Prefix element */
+    prefix?: ReactNode;
+    /** Suffix element */
+    suffix?: ReactNode;
+    /** Value text style */
+    valueStyle?: CSSProperties;
+    /** Custom value formatter */
+    formatter?: (value: number | string) => ReactNode;
+    /** Group separator for numbers */
+    groupSeparator?: string;
+    /** Loading skeleton */
+    loading?: boolean;
+    /** Decimal separator */
+    decimalSeparator?: string;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}
+export interface CountdownProps extends Omit<StatisticProps, "value"> {
+    /** Target timestamp (Date, number, or dayjs-like value) */
+    value: number | Date;
+    /** Display format string (e.g., "HH:mm:ss", "D days HH:mm:ss") */
+    format?: string;
+    /** Callback when countdown finishes */
+    onFinish?: () => void;
+    /** Callback on each tick */
+    onChange?: (value: number) => void;
+}

package/dist/components/steps/Steps.d.ts

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

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

@@ -0,0 +1,2 @@
+export { Steps } from './Steps';
+export type { StepsProps, StepItem, StepsDirection, StepsType, StepsSize, StepStatus } from './types';

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

@@ -0,0 +1,54 @@
+import { ReactNode, CSSProperties } from 'react';
+export type StepsDirection = "horizontal" | "vertical";
+export type StepsType = "default" | "navigation" | "dot" | "inline";
+export type StepsSize = "small" | "default";
+export type StepStatus = "wait" | "process" | "finish" | "error";
+export interface StepItem {
+    /** Title of the step */
+    title: ReactNode;
+    /** Description of the step */
+    description?: ReactNode;
+    /** Custom icon for the step */
+    icon?: ReactNode;
+    /** Status of the step (overrides computed status) */
+    status?: StepStatus;
+    /** Whether the step is disabled */
+    disabled?: boolean;
+    /** Subtitle (inline type only) */
+    subTitle?: ReactNode;
+}
+export interface StepsProps {
+    /** Current step index (zero-based) */
+    current?: number;
+    /** Step items */
+    items?: StepItem[];
+    /** Direction of the steps layout */
+    direction?: StepsDirection;
+    /** Type of steps display */
+    type?: StepsType;
+    /** Overall status of the current step */
+    status?: StepStatus;
+    /** Size */
+    size?: StepsSize;
+    /** Whether to make steps clickable */
+    onChange?: (current: number) => void;
+    /** Initial step (zero-based) */
+    initial?: number;
+    /** Enable label placement under the icon */
+    labelPlacement?: "horizontal" | "vertical";
+    /** Whether progress dot type should use a custom render */
+    progressDot?: boolean | ((dot: ReactNode, info: {
+        index: number;
+        status: StepStatus;
+        title: ReactNode;
+        description: ReactNode;
+    }) => ReactNode);
+    /** Percent of current step */
+    percent?: number;
+    /** Responsive support */
+    responsive?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}

package/dist/components/switch/Switch.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Switch: import('react').ForwardRefExoticComponent<import('./types').SwitchProps & import('react').RefAttributes<HTMLElement>>;
+export { Switch };
+export type { SwitchProps } from './types';

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

@@ -0,0 +1,25 @@
+import { ReactNode, MouseEventHandler } from 'react';
+export interface SwitchProps {
+    /** Whether the switch is checked (controlled) */
+    checked?: boolean;
+    /** Default checked state (uncontrolled) */
+    defaultChecked?: boolean;
+    /** Whether the switch is disabled */
+    disabled?: boolean;
+    /** Whether the switch is in loading state */
+    loading?: boolean;
+    /** Size of the switch */
+    size?: "middle" | "small";
+    /** Content shown when checked */
+    checkedChildren?: ReactNode;
+    /** Content shown when unchecked */
+    unCheckedChildren?: ReactNode;
+    /** Callback when state changes */
+    onChange?: (checked: boolean) => void;
+    /** Click handler */
+    onClick?: MouseEventHandler<HTMLElement>;
+    /** Additional class name */
+    className?: string;
+    /** ID attribute */
+    id?: string;
+}

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

@@ -0,0 +1,6 @@
+import { TableProps } from './types';
+declare function InternalTable<T extends Record<string, unknown> = Record<string, unknown>>(props: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace InternalTable {
+    var displayName: string;
+}
+export { InternalTable };

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

@@ -0,0 +1,4 @@
+import { InternalTable } from './Table';
+declare const Table: typeof InternalTable;
+export { Table };
+export type { TableProps, ColumnType, SortOrder, SorterResult, PaginationConfig, RowSelection, RowSelectionType, ExpandableConfig, ScrollConfig, TableSize, FilterItem, FixedType, AlignType, } from './types';