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

package/dist/components/CdsTable/composable/columns.d.ts

@@ -0,0 +1,28 @@
+import type { Ref, ComputedRef } from 'vue';
+import type { IContextSlots } from '../context';
+import type { NTable } from '../interface';
+export interface IUseColumns<RecordType> {
+    filledColumns: NTable.NColumn.TTransformColumns<RecordType>;
+}
+export declare function useColumns<RecordType>(contextSlots: Ref<IContextSlots>): IUseColumns<RecordType>;
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+export declare function useParseColumns<RecordType>({ columns: baseColumns, expandable, expandedKeys, getRowKey, onTriggerExpand, expandIcon, rowExpandable, expandIconColumnIndex, expandRowByClick, expandColumnWidth, expandFixed }: {
+    columns: Ref<NTable.NColumn.TColumns<RecordType>>;
+    expandable: Ref<boolean>;
+    expandedKeys: Ref<Set<NTable.TKey>>;
+    getRowKey: Ref<NTable.NRow.TGetRowKey<RecordType>>;
+    onTriggerExpand: NTable.TTriggerEventHandler<RecordType>;
+    expandIcon: Ref<NTable.NExpand.TRenderExpandIcon<RecordType>>;
+    rowExpandable: Ref<((record: RecordType) => boolean) | undefined>;
+    expandIconColumnIndex?: Ref<number>;
+    expandRowByClick: Ref<boolean | undefined>;
+    expandColumnWidth: Ref<number | string | undefined>;
+    expandFixed: Ref<NTable.TFixed | undefined>;
+}, transformColumns: Ref<(columns: NTable.NColumn.TColumns<RecordType>) => NTable.NColumn.TColumns<RecordType>>): {
+    columns: ComputedRef<NTable.NColumn.TColumns<RecordType>>;
+    flattenColumns: ComputedRef<readonly NTable.NColumn.IColumn<RecordType>[]>;
+};
+export declare function useTitleColumns<RecordType>(columnTitleProps: Ref<NTable.NColumn.ITitleProps<RecordType>>): IUseColumns<RecordType>;
+export declare function useColumnWidth(colWidthsRef: Ref<readonly (string | number | undefined)[]>, columnCountRef: Ref<number>): ComputedRef<string[] | number[] | null>;

package/dist/components/CdsTable/composable/filter.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from 'vue';
+import type { NTable } from '../interface';
+export interface IFilterOptions<RecordType> {
+    mergedColumns: Ref<NTable.NColumn.TColumns<RecordType>>;
+    tableLocale: Ref<NTable.ILocale>;
+    getPopupContainer?: Ref<NTable.NCustomize.TGetPopupContainer>;
+    onFilterChange: (filters: Record<string, NTable.TFilterValue | null>, filterStates: NTable.IFilterState<RecordType>[]) => void;
+}
+export interface IUseFilter<RecordType> {
+    transformColumns: NTable.NColumn.TTransformColumns<RecordType>;
+    mergedFilterStates: Ref<NTable.IFilterState<RecordType>[]>;
+    filters: Ref<Record<string, NTable.TFilterValue | null>>;
+}
+export declare function useFilter<RecordType>({ mergedColumns, tableLocale, getPopupContainer, onFilterChange }: IFilterOptions<RecordType>): IUseFilter<RecordType>;
+export declare function flattenKeys(filters?: NTable.NColumn.IFilterItem[]): NTable.TFilterValue;
+export declare function getFilterData<RecordType>(data: RecordType[], filterStates: NTable.IFilterState<RecordType>[]): RecordType[];

package/dist/components/CdsTable/composable/flat.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from 'vue';
+import type { NTable } from '../interface';
+declare type TRecord<T> = {
+    record: T;
+    indent: number;
+    index: number;
+};
+/**
+ * flat tree data on expanded state
+ * @param dataRef
+ * @param childrenColumnNameRef
+ * @param expandedKeysRef
+ * @param getRowKey
+ * @returns flattened data
+ */
+export declare function useFlattenRecords<T = unknown>(dataRef: Ref<T[]>, childrenColumnNameRef: Ref<string>, expandedKeysRef: Ref<Set<NTable.TKey>>, getRowKey: Ref<NTable.NRow.TGetRowKey<T>>): Ref<TRecord<T>[]>;
+export {};

package/dist/components/CdsTable/composable/frame.d.ts

@@ -0,0 +1,6 @@
+import type { Ref, UnwrapRef } from 'vue';
+declare type StateUpdater<State> = (prev: State) => State;
+export declare function useLayoutState<State>(defaultState: State): [Ref<State>, (updater: StateUpdater<State>) => void];
+/** Lock frame, when frame pass reset the lock. */
+export declare function useTimeoutLock<State>(defaultState?: State): [(state: UnwrapRef<State>) => void, () => UnwrapRef<State> | null];
+export {};

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

@@ -0,0 +1,10 @@
+export * from './table';
+export * from './columns';
+export * from './selection';
+export * from './filter';
+export * from './sorter';
+export * from './pagination';
+export * from './scroll';
+export * from './sticky';
+export * from './frame';
+export * from './flat';

package/dist/components/CdsTable/composable/pagination.d.ts

@@ -0,0 +1,18 @@
+import { VNode } from 'vue';
+import type { Ref } from 'vue';
+import type { NTable } from '../interface';
+export declare const DEFAULT_PAGE_SIZE = 10;
+export interface IUsePagination {
+    mergedPagination: Ref<NTable.NPagination.IProps>;
+    resetPagination: (modelValue?: number, length?: number) => void;
+}
+export declare function usePagination(totalRef: Ref<number>, paginationRef: Ref<NTable.NPagination.IProps | false | undefined>, disabled: Ref<boolean>, onChange: (modelValue: number | undefined, length: number) => void): IUsePagination;
+export declare function getPaginationParam(pagination: NTable.NPagination.IProps | boolean | undefined, mergedPagination: NTable.NPagination.IProps): any;
+export declare function useRenderPagination(paginationProps: Ref<NTable.NPagination.IProps>, pagination?: false | NTable.NPagination.IProps): {
+    topPaginationNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | undefined;
+    bottomPaginationNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | undefined;
+};

package/dist/components/CdsTable/composable/selection.d.ts

@@ -0,0 +1,23 @@
+import type { Ref, ComputedRef } from 'vue';
+import type { NTable } from '../interface';
+export declare const SELECTION_COLUMN: {};
+export declare const SELECTION_ALL: "SELECT_ALL";
+export declare const SELECTION_INVERT: "SELECT_INVERT";
+export declare const SELECTION_NONE: "SELECT_NONE";
+export declare const EXPAND_COLUMN: {};
+export declare type INTERNAL_SELECTION_ITEM = NTable.NRow.ISelectionItem | typeof SELECTION_ALL | typeof SELECTION_INVERT | typeof SELECTION_NONE;
+export interface ISelectionOptions<RecordType> {
+    pageData: Ref<RecordType[]>;
+    data: Ref<RecordType[]>;
+    getRowKey: Ref<NTable.NRow.TGetRowKey<RecordType>>;
+    getRecordByKey: (key: NTable.TKey) => RecordType;
+    expandType: Ref<NTable.NExpand.TExpandableType>;
+    childrenColumnName: Ref<string>;
+    locale: Ref<NTable.ILocale>;
+    getPopupContainer?: ComputedRef<NTable.NCustomize.TGetPopupContainer | undefined>;
+}
+export interface IUseSelection<RecordType> {
+    transformColumns: NTable.NColumn.TTransformColumns<RecordType>;
+    selectedKeySet: Ref<Set<NTable.TKey>>;
+}
+export declare function useSelection<RecordType>(rowSelectionRef: Ref<NTable.NRow.IRowSelection<RecordType> | undefined>, configRef: ISelectionOptions<RecordType>): IUseSelection<RecordType>;

package/dist/components/CdsTable/composable/sorter.d.ts

@@ -0,0 +1,21 @@
+import { CdsTooltip } from '../../CdsTooltip';
+import type { Ref, ComputedRef } from 'vue';
+import type { NTable } from '../interface';
+import type { ComponentProps } from '../../../utils';
+export declare const ASCEND = "ascend";
+export declare const DESCEND = "descend";
+export interface ISorterOptions<RecordType> {
+    mergedColumns: ComputedRef<NTable.NColumn.TColumns<RecordType>>;
+    sortDirections: ComputedRef<NTable.TSortOrder[]>;
+    tableLocale?: Ref<NTable.ILocale>;
+    showSorterTooltip?: Ref<boolean | ComponentProps<typeof CdsTooltip>>;
+    onSorterChange: (sorterResult: NTable.ISorterResult<RecordType> | NTable.ISorterResult<RecordType>[], sortStates: NTable.ISortState<RecordType>[]) => void;
+}
+export interface IUseSorter<RecordType> {
+    transformColumns: NTable.NColumn.TTransformColumns<RecordType>;
+    mergedSorterStates: Ref<NTable.ISortState<RecordType>[]>;
+    columnTitleSorterProps: Ref<NTable.NColumn.ITitleProps<RecordType>>;
+    sorters: Ref<NTable.ISorterResult<RecordType> | NTable.ISorterResult<RecordType>[]>;
+}
+export declare function useSorter<RecordType>({ mergedColumns, sortDirections, tableLocale, showSorterTooltip, onSorterChange }: ISorterOptions<RecordType>): IUseSorter<RecordType>;
+export declare function getSortData<RecordType>(data: readonly RecordType[], sortStates: NTable.ISortState<RecordType>[], childrenColumnName: string): RecordType[];

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

@@ -0,0 +1,12 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { NTable } from '../interface';
+export interface IUseSticky {
+    isSticky: boolean;
+    offsetHeader: number;
+    offsetSummary: number;
+    offsetScroll: number;
+    stickyClassName: string;
+    container: Window | HTMLElement | null;
+}
+export declare function useSticky(stickyRef: Ref<boolean | NTable.NSticky.ISticky | undefined>): ComputedRef<IUseSticky>;
+export declare function useStickyOffsets(colWidthsRef: ComputedRef<(number | undefined)[]>, columnCountRef: Ref<number>): ComputedRef<NTable.NSticky.IStickyOffsets>;