@central-design-system/components 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/components/CdsTable/context/index.d.ts

@@ -0,0 +1,8 @@
+export * from './table';
+export * from './body';
+export * from './resize';
+export * from './slots';
+export * from './sticky';
+export * from './hover';
+export * from './expandedRow';
+export * from './summary';

package/dist/components/CdsTable/context/resize.d.ts

@@ -0,0 +1,9 @@
+import type { NTable } from '../interface';
+import type { InjectionKey } from 'vue';
+interface IResizeContextProps {
+    onColumnResize: (columnKey: NTable.TKey, width: number) => void;
+}
+export declare const ResizeContextKey: InjectionKey<IResizeContextProps>;
+export declare const useProvideResize: (props: IResizeContextProps) => void;
+export declare const useInjectResize: () => IResizeContextProps;
+export {};

package/dist/components/CdsTable/context/slots.d.ts

@@ -0,0 +1,17 @@
+import type { ComputedRef } from 'vue';
+export interface IContextSlots {
+    emptyText?: (...args: any[]) => any;
+    expandIcon?: (...args: any[]) => any;
+    header?: (...args: any[]) => any;
+    footer?: (...args: any[]) => any;
+    summary?: (...args: any[]) => any;
+    bodyCell?: (...args: any[]) => any;
+    headerCell?: (...args: any[]) => any;
+    customFilterIcon?: (...args: any[]) => any;
+    customFilterDropdown?: (...args: any[]) => any;
+    [key: string]: ((...args: any[]) => any) | undefined;
+}
+declare type TSlotsContextProps = ComputedRef<IContextSlots>;
+export declare const useProvideSlots: (props: TSlotsContextProps) => void;
+export declare const useInjectSlots: () => TSlotsContextProps;
+export {};

package/dist/components/CdsTable/context/sticky.d.ts

@@ -0,0 +1,2 @@
+export declare const useProvideSticky: () => void;
+export declare const useInjectSticky: () => import("vue").Ref<boolean>;

package/dist/components/CdsTable/context/summary.d.ts

@@ -0,0 +1,14 @@
+import type { InjectionKey } from 'vue';
+import type { NTable } from '../interface';
+export declare type TSummaryFlattenColumns<RecordType> = readonly (NTable.NColumn.IColumn<RecordType> & {
+    scrollbar?: boolean;
+})[];
+interface ISummaryContextProps {
+    stickyOffsets?: NTable.NSticky.IStickyOffsets;
+    scrollColumnIndex?: number | null;
+    flattenColumns?: TSummaryFlattenColumns<any>;
+}
+export declare const SummaryContextKey: InjectionKey<ISummaryContextProps>;
+export declare const useProvideSummary: (props: ISummaryContextProps) => void;
+export declare const useInjectSummary: () => ISummaryContextProps;
+export {};

package/dist/components/CdsTable/context/table.d.ts

@@ -0,0 +1,20 @@
+import type { InjectionKey } from 'vue';
+import type { NTable } from '../interface';
+import type { IFixedInfo } from '../utils';
+export interface ITableContextProps {
+    getComponent: NTable.NCustomize.TGetComponent;
+    scrollbarSize: number;
+    fixedInfoList: readonly IFixedInfo[];
+    isSticky: boolean;
+    summaryCollect: (uniKey: string, fixed: boolean | string) => void;
+    transformCellText?: NTable.NCell.TTransformCellText<unknown>;
+}
+export declare const TableContextKey: InjectionKey<ITableContextProps>;
+export declare const useProvideTable: (props: ITableContextProps) => void;
+export declare const useInjectTable: () => ITableContextProps;
+declare type TContextProps = {
+    onResizeColumn: (width: number, column: NTable.NColumn.IColumn) => void;
+};
+export declare const useProvideTableContext: (props: TContextProps) => void;
+export declare const useInjectTableContext: () => TContextProps;
+export {};

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

@@ -0,0 +1,6 @@
+export * from './interface';
+export * from './composable/table';
+export * from './composable/selection';
+export { default as CdsTableColumn } from './CdsTableColumn.vue';
+export { default as CdsTableColumnGroup } from './CdsTableColumnGroup.vue';
+export { default as CdsTable } from './CdsTable.vue';

package/dist/components/CdsTable/interface.d.ts

@@ -0,0 +1,323 @@
+import { INTERNAL_SELECTION_ITEM } from './composable';
+import { CdsTooltip } from '../CdsTooltip';
+import { CdsCheckbox } from '../CdsCheckbox';
+import { CdsPagination } from '../CdsPagination';
+import type { CSSProperties, Ref, TdHTMLAttributes, VNode } from 'vue';
+import type { ComponentProps } from '../../utils';
+import type { TBreakpoint, TBreakpointUpDown } from '../../composable';
+declare type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+export declare type VueNode = VNodeChildAtom | VNodeChildAtom[] | JSX.Element;
+export declare namespace NTable {
+    type TDefaultRecord = any;
+    type TKey = string | number;
+    type TLayout = 'auto' | 'fixed';
+    type TFixed = boolean | 'left' | 'right' | null;
+    type TAlign = 'left' | 'center' | 'right';
+    type TAction = 'filter' | 'sort' | 'paginate';
+    type TSortOrder = 'descend' | 'ascend' | string;
+    type TScroll = {
+        x?: number | true | string;
+        y?: number | string;
+    };
+    type TDataIndex = string | number | readonly (string | number)[];
+    type TCompareFn<RecordType> = (a: RecordType, b: RecordType, sortOrder?: TSortOrder) => number;
+    type TFilterKey = TKey[] | null;
+    type TFilterValue = (TKey | boolean)[];
+    type TFilterMode = 'menu' | 'tree';
+    type TFilterSearch = boolean | ((input: string, record: {}) => boolean);
+    type TTriggerEventHandler<RecordType> = (record: RecordType, event: MouseEvent) => void;
+    interface ICurrentData<RecordType = TDefaultRecord> {
+        currentData: RecordType[];
+        action: TAction;
+    }
+    interface ISorterResult<RecordType = TDefaultRecord> {
+        column?: NColumn.IColumn<RecordType>;
+        order?: TSortOrder;
+        field?: TKey | readonly TKey[];
+        columnKey?: TKey;
+    }
+    interface IFilterState<RecordType = TDefaultRecord> {
+        column: NColumn.IColumn<RecordType>;
+        key: TKey;
+        filteredKeys?: TFilterKey;
+        forceFiltered?: boolean;
+    }
+    interface ISortState<RecordType = TDefaultRecord> {
+        column: NColumn.IColumn<RecordType>;
+        key: TKey;
+        sortOrder: TSortOrder;
+        multiplePriority: number | false;
+    }
+    interface IChangeEventInfo<RecordType = TDefaultRecord> {
+        pagination: {
+            modelValue?: number;
+            length?: number;
+            total?: number;
+        };
+        filters: Record<string, TFilterValue | null>;
+        sorter: ISorterResult<RecordType> | ISorterResult<RecordType>[];
+        filterStates: IFilterState<RecordType>[];
+        sorterStates: ISortState<RecordType>[];
+        resetPagination: Function;
+    }
+    interface ILocale {
+        filterTitle?: string;
+        filterConfirm?: any;
+        filterReset?: any;
+        filterEmptyText?: any;
+        filterCheckAll?: any;
+        filterSearchPlaceholder?: any;
+        emptyText?: any | (() => any);
+        selectAll?: any;
+        selectNone?: any;
+        selectInvert?: any;
+        selectionAll?: any;
+        sortTitle?: string;
+        expand?: string;
+        collapse?: string;
+        triggerDesc?: string;
+        triggerAsc?: string;
+        cancelSort?: string;
+    }
+    namespace NColumn {
+        type TTitle<RecordType> = VueNode | ((props: ITitleProps<RecordType>) => VueNode);
+        type TTransformColumns<RecordType> = (columns: TColumns<RecordType>) => TColumns<RecordType>;
+        type TColumns<RecordType = TDefaultRecord> = (IColumn<RecordType> | IColumnGroup<RecordType>)[];
+        interface ITitleProps<RecordItem> {
+            sortColumns?: {
+                column: IColumn<RecordItem>;
+                order: TSortOrder;
+            }[];
+            filters?: Record<string, string[]>;
+        }
+        interface IFilterItem {
+            text: VueNode;
+            value: string | number | boolean;
+            children?: IFilterItem[];
+        }
+        interface IFilterConfirmProps {
+            closeDropdown: boolean;
+        }
+        interface IFilterDropdownProps<RecordType> {
+            prefixCls: string;
+            setSelectedKeys: (selectedKeys: TKey[]) => void;
+            selectedKeys: TKey[];
+            confirm: (param?: IFilterConfirmProps) => void;
+            clearFilters: () => void;
+            filters?: IFilterItem[];
+            visible?: boolean;
+            column?: IColumn<RecordType>;
+        }
+        interface IColumn<RecordType = TDefaultRecord> {
+            title?: TTitle<RecordType>;
+            key?: TKey;
+            class?: string;
+            className?: string;
+            ellipsis?: NCell.TCellEllipsis;
+            align?: TAlign;
+            fixed?: TFixed;
+            colSpan?: number;
+            rowSpan?: number;
+            width?: number | string;
+            minWidth?: number;
+            maxWidth?: number;
+            resizable?: boolean;
+            dataIndex?: TDataIndex;
+            filtered?: boolean;
+            filters?: IFilterItem[];
+            filterDropdown?: VueNode | ((props: IFilterDropdownProps<RecordType>) => VueNode);
+            filterMultiple?: boolean;
+            filteredValue?: TFilterValue | null;
+            defaultFilteredValue?: TFilterValue | null;
+            filterIcon?: VueNode | ((opt: {
+                filtered: boolean;
+                column: IColumn;
+            }) => VueNode);
+            filterMode?: TFilterMode;
+            filterSearch?: TFilterSearch;
+            filterDropdownVisible?: boolean;
+            customFilterDropdown?: boolean;
+            onFilter?: (value: string | number | boolean, record: RecordType) => boolean;
+            onFilterDropdownVisibleChange?: (visible: boolean) => void;
+            sorter?: boolean | TCompareFn<RecordType> | {
+                compare?: TCompareFn<RecordType>;
+                multiple: number;
+            };
+            sortOrder?: TSortOrder;
+            defaultSortOrder?: TSortOrder;
+            sortDirections?: TSortOrder[];
+            showSorterTooltip?: boolean | ComponentProps<typeof CdsTooltip>;
+            responsive?: TBreakpoint[] | TBreakpointUpDown[];
+            onCellClick?: (record: RecordType, event: MouseEvent) => void;
+            customCell?: NCustomize.TGetComponentProps<RecordType>;
+            customHeaderCell?: NCustomize.TGetComponentProps<TColumns<RecordType>[number]>;
+            customRender?: (opt: {
+                value: any;
+                text: any;
+                record: RecordType;
+                index?: number;
+                renderIndex?: number;
+                column: IColumn<RecordType>;
+            }) => any | NCell.IRenderedCell<RecordType>;
+            /**
+             * @private Internal usage.
+             *
+             * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+             */
+            __originColumn__?: any;
+        }
+        interface IColumnGroup<RecordType = TDefaultRecord> extends Omit<IColumn<RecordType>, 'dataIndex'> {
+            children: TColumns<RecordType>;
+        }
+    }
+    namespace NRow {
+        type TGetRowKey<RecordType> = (record: RecordType, index?: number) => TKey;
+        type TClassName<RecordType> = (record: RecordType, index: number, indent: number) => string;
+        type TSelection = 'checkbox' | 'radio';
+        type TSelectionItemSelectFn = (currentRowKeys: TKey[]) => void;
+        type TSelectionSelectFn<RecordType> = (record: RecordType, selected: boolean, selectedRows: RecordType[], nativeEvent: Event) => void;
+        interface ISelectionItem {
+            key: string;
+            text: VueNode;
+            onSelect?: TSelectionItemSelectFn;
+        }
+        interface IRowSelection<RecordType = TDefaultRecord> {
+            preserveSelectedRowKeys?: boolean;
+            type?: TSelection;
+            selectedRowKeys?: TKey[];
+            defaultSelectedRowKeys?: TKey[];
+            selections?: INTERNAL_SELECTION_ITEM[] | boolean;
+            hideSelectAll?: boolean;
+            fixed?: TFixed;
+            columnWidth?: string | number;
+            columnTitle?: string | VueNode;
+            checkStrictly?: boolean;
+            onChange?: (selectedRowKeys: TKey[], selectedRows: RecordType[]) => void;
+            onSelect?: TSelectionSelectFn<RecordType>;
+            onSelectMultiple?: (selected: boolean, selectedRows: RecordType[], changeRows: RecordType[]) => void;
+            onSelectNone?: () => void;
+            getCheckboxProps?: (record: RecordType) => Partial<Omit<ComponentProps<typeof CdsCheckbox>, 'modelValue'>>;
+            renderCell?: (value: boolean, record: RecordType, index: number | undefined, originalNode: VueNode) => VueNode | NCell.IRenderedCell<RecordType>;
+        }
+    }
+    namespace NCell {
+        type TCellEllipsis = {
+            showTitle?: boolean;
+        } | boolean | undefined;
+        type TTransformCellText<RecordType> = (opt: {
+            text: any;
+            column: NColumn.IColumn<RecordType>;
+            record: any;
+            index?: number;
+        }) => any;
+        interface ICell<RecordType = TDefaultRecord> {
+            key?: TKey;
+            class?: string;
+            style?: CSSProperties;
+            column: NColumn.TColumns<RecordType>[number];
+            colSpan?: number;
+            rowSpan?: number;
+            hasSubColumns?: boolean;
+            colStart?: number;
+            colEnd?: number;
+        }
+        interface IRenderedCell<RecordType> {
+            props?: ICell<RecordType>;
+            children?: any;
+        }
+    }
+    namespace NExpand {
+        type TExpandableType = false | 'row' | 'nest';
+        type TRenderExpandIcon<RecordType> = (props: IRenderExpandIconProps<RecordType>) => any;
+        type TExpandedRowRender<RecordType> = (opt: {
+            record: RecordType;
+            index: number;
+            indent: number;
+            expanded: boolean;
+        }) => any;
+        interface IRenderExpandIconProps<RecordType> {
+            expanded: boolean;
+            record: RecordType;
+            expandable: boolean;
+            onExpand: TTriggerEventHandler<RecordType>;
+        }
+        interface IExpandable<RecordType = TDefaultRecord> {
+            expandedRowKeys?: readonly TKey[];
+            defaultExpandedRowKeys?: readonly TKey[];
+            defaultExpandAllRows?: boolean;
+            expandedRowByClick?: boolean;
+            expandIconColumnIndex?: number;
+            columnWidth?: string | number;
+            showExpandColumn?: boolean;
+            childrenColumnName?: string;
+            fixed?: TFixed;
+            indentSize?: number;
+            expandedRowRender?: TExpandedRowRender<RecordType>;
+            expandIcon?: TRenderExpandIcon<RecordType>;
+            expandedRowClassName?: NRow.TClassName<RecordType>;
+            rowExpandable?: (record: RecordType) => boolean;
+            onExpand?: (expanded: boolean, record: RecordType) => void;
+            onExpandedRowsChange?: (expandedKeys: readonly TKey[]) => void;
+        }
+    }
+    namespace NRender {
+        type TPanelRender<RecordType> = (data: readonly RecordType[]) => any;
+    }
+    namespace NPagination {
+        type TPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';
+        interface IProps extends ComponentProps<typeof CdsPagination> {
+            total?: number;
+            position?: TPosition[];
+            class?: string;
+            style?: CSSProperties;
+        }
+    }
+    namespace NSticky {
+        interface ISticky {
+            offsetHeader?: number;
+            offsetSummary?: number;
+            offsetScroll?: number;
+            getContainer?: () => Window | HTMLElement;
+        }
+        interface IStickyOffsets {
+            left: readonly number[];
+            right: readonly number[];
+            isSticky?: boolean;
+        }
+    }
+    namespace NCustomize {
+        type TCustomizeComponent = any;
+        type TAdditionalProps = TdHTMLAttributes & {
+            colSpan?: number;
+            rowSpan?: number;
+        };
+        type TGetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
+        type TGetComponentProps<DataType> = (data: DataType, index?: number, column?: NColumn.IColumn) => TAdditionalProps | undefined;
+        type TComponent = any;
+        type TGetComponent = (path: readonly string[], defaultComponent?: TComponent) => TComponent;
+        type TScrollBody<RecordType> = (data: readonly RecordType[], info: {
+            scrollbarSize: number;
+            ref: Ref<{
+                scrollLeft: number;
+            }>;
+            onScroll: (info: {
+                currentTarget?: HTMLElement;
+                scrollLeft?: number;
+            }) => void;
+        }) => any;
+        interface TableComponents<RecordType> {
+            table?: TComponent;
+            header?: {
+                wrapper?: TComponent;
+                row?: TComponent;
+                cell?: TComponent;
+            };
+            body?: TScrollBody<RecordType> | {
+                wrapper?: TComponent;
+                row?: TComponent;
+                cell?: TComponent;
+            };
+        }
+    }
+}
+export {};

package/dist/components/CdsTable/utils/column.d.ts

@@ -0,0 +1,7 @@
+import type { NTable } from '../interface';
+export declare function convertChildrenToColumn<RecordType>(elements?: any[]): NTable.NColumn.TColumns<RecordType>;
+export declare function getColumnKey<RecordType>(column: NTable.NColumn.IColumn<RecordType>, defaultKey: string): NTable.TKey;
+export declare function getColumnPos(index: number, pos?: string): string;
+export declare function renderColumnTitle<RecordType>(title: NTable.NColumn.TTitle<RecordType>, props: NTable.NColumn.ITitleProps<RecordType>): import("../interface").VueNode;
+export declare function flattenChildren(children?: any[], filterEmpty?: boolean): any[];
+export declare function isEmptyElement(c: Record<string, any>): boolean;

package/dist/components/CdsTable/utils/expand.d.ts

@@ -0,0 +1,2 @@
+import type { NTable } from '../interface';
+export declare function findAllChildrenKeys<RecordType>(data: readonly RecordType[], getRowKey: NTable.NRow.TGetRowKey<RecordType>, childrenColumnName: string): NTable.TKey[];

package/dist/components/CdsTable/utils/fixed.d.ts

@@ -0,0 +1,13 @@
+import { NTable } from '../interface';
+export interface IFixedInfo {
+    fixLeft?: number | false;
+    fixRight?: number | false;
+    lastFixLeft: boolean;
+    firstFixRight: boolean;
+    lastFixRight: boolean;
+    firstFixLeft: boolean;
+    isSticky: boolean | undefined;
+}
+export declare function getCellFixedInfo(colStart: number, colEnd: number, columns: readonly {
+    fixed?: NTable.TFixed;
+}[], stickyOffsets: NTable.NSticky.IStickyOffsets): IFixedInfo;

package/dist/components/CdsTable/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './value';
+export * from './column';
+export * from './expand';
+export * from './fixed';
+export * from './listener';

package/dist/components/CdsTable/utils/listener.d.ts

@@ -0,0 +1,5 @@
+declare let supportsPassive: boolean;
+declare function addEventListenerWrapper<K extends keyof WindowEventMap>(target: Element | Window | Document | null, eventType: K, listener: (event: Event | any) => void, option?: boolean | AddEventListenerOptions | undefined): {
+    remove: () => void;
+};
+export { addEventListenerWrapper, supportsPassive };

package/dist/components/CdsTable/utils/value.d.ts

@@ -0,0 +1,10 @@
+import type { NTable } from '../interface';
+export declare function mergeObject<ReturnObject extends object>(...objects: Partial<ReturnObject>[]): ReturnObject;
+export declare function getPathValue<ValueType, ObjectType extends object>(record: ObjectType, path?: NTable.TDataIndex): ValueType | null;
+interface TGetColumnKeyColumn {
+    key?: NTable.TKey;
+    dataIndex?: NTable.TDataIndex;
+}
+export declare function getColumnsKey(columns: readonly TGetColumnKeyColumn[]): NTable.TKey[];
+export declare function validateValue<T>(value: T): boolean;
+export {};

package/dist/components/CdsTag/CdsTag.vue.d.ts

@@ -9,7 +9,6 @@ declare const _sfc_main: import("vue").DefineComponent<{
         type: PropType<"yellow" | "light-blue" | "blue" | "deep-purple" | "purple" | "pink">;
         available: readonly ["yellow", "light-blue", "blue", "deep-purple", "purple", "pink"];
         default: undefined;
-        description: string;
         validator: (value: "yellow" | "light-blue" | "blue" | "deep-purple" | "purple" | "pink") => boolean;
     };
     href: {
@@ -47,7 +46,14 @@ declare const _sfc_main: import("vue").DefineComponent<{
     tag: string | import("vue").ComputedRef<string>;
     href: import("vue").ComputedRef<string | undefined>;
     to: import("vue").ComputedRef<import("vue-router").RouteLocationRaw | undefined>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "remove"[], "remove", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    /**
+     * Событие удаления
+     *
+     * @event remove
+     */
+    remove: (event: MouseEvent | KeyboardEvent) => true;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     text: {
         type: PropType<string>;
         default: undefined;
@@ -56,7 +62,6 @@ declare const _sfc_main: import("vue").DefineComponent<{
         type: PropType<"yellow" | "light-blue" | "blue" | "deep-purple" | "purple" | "pink">;
         available: readonly ["yellow", "light-blue", "blue", "deep-purple", "purple", "pink"];
         default: undefined;
-        description: string;
         validator: (value: "yellow" | "light-blue" | "blue" | "deep-purple" | "purple" | "pink") => boolean;
     };
     href: {
@@ -83,13 +88,13 @@ declare const _sfc_main: import("vue").DefineComponent<{
         description: string;
     };
 }>> & {
-    onRemove?: ((...args: any[]) => any) | undefined;
+    onRemove?: ((event: MouseEvent | KeyboardEvent) => any) | undefined;
 }, {
-    size: "xs" | "sm" | "md" | "lg" | "xl";
     text: string;
-    disabled: boolean;
     href: string;
     to: import("vue-router").RouteLocationRaw;
+    disabled: boolean;
+    size: "xs" | "sm" | "md" | "lg" | "xl";
     color: "yellow" | "light-blue" | "blue" | "deep-purple" | "purple" | "pink";
     removable: boolean;
 }>;

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

@@ -0,0 +1 @@
+export { default as CdsTag } from './CdsTag.vue';