yuyeon 0.0.9 → 0.0.10

package/types/components/table/composibles/selection.d.ts

@@ -0,0 +1,67 @@
+import { InjectionKey, PropType, Ref } from 'vue';
+import { DataTableProvideSelectionData } from '../types';
+import { DataTableItemsProps } from './items';
+export interface SelectableItem {
+    value: any;
+    selectable: boolean;
+}
+export interface DataTableSelectStrategy {
+    showSelectAll: boolean;
+    allSelected: (data: {
+        allItems: SelectableItem[];
+        pageItems: SelectableItem[];
+    }) => SelectableItem[];
+    select: (data: {
+        items: SelectableItem[];
+        value: boolean;
+        selected: Set<unknown>;
+    }) => Set<unknown>;
+    selectAll: (data: {
+        value: boolean;
+        allItems: SelectableItem[];
+        pageItems: SelectableItem[];
+        selected: Set<unknown>;
+    }) => Set<unknown>;
+}
+export declare const pressDataTableSelectionProps: <Defaults extends {
+    enableSelect?: unknown;
+    selectStrategy?: unknown;
+    modelValue?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    enableSelect: unknown extends Defaults["enableSelect"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults ? "enableSelect" : "enableSelect" | Defaults>;
+        default: unknown extends Defaults["enableSelect"] ? boolean : boolean | Defaults["enableSelect"];
+    };
+    selectStrategy: unknown extends Defaults["selectStrategy"] ? {
+        type: PropType<"single" | "page" | "all">;
+        default: string;
+    } : Omit<{
+        type: PropType<"single" | "page" | "all">;
+        default: string;
+    }, "default" | "type"> & {
+        type: PropType<unknown extends Defaults["selectStrategy"] ? "single" | "page" | "all" : NonNullable<"single" | "page" | "all"> | Defaults["selectStrategy"]>;
+        default: unknown extends Defaults["selectStrategy"] ? "single" | "page" | "all" : NonNullable<"single" | "page" | "all"> | Defaults["selectStrategy"];
+    };
+    modelValue: unknown extends Defaults["modelValue"] ? {
+        type: PropType<readonly any[]>;
+        default: () => never[];
+    } : Omit<{
+        type: PropType<readonly any[]>;
+        default: () => never[];
+    }, "default" | "type"> & {
+        type: PropType<unknown extends Defaults["modelValue"] ? readonly any[] : readonly any[] | Defaults["modelValue"]>;
+        default: unknown extends Defaults["modelValue"] ? readonly any[] : readonly any[] | Defaults["modelValue"];
+    };
+};
+type DataTableSelectionProps = Pick<DataTableItemsProps, 'itemKey'> & {
+    modelValue: readonly any[];
+    selectStrategy: 'single' | 'page' | 'all';
+    'onUpdate:modelValue': ((value: any[]) => void) | undefined;
+};
+export declare const Y_DATA_TABLE_SELECTION_KEY: InjectionKey<ReturnType<typeof provideSelection>>;
+export declare function provideSelection(props: DataTableSelectionProps, { allItems, pageItems, }: {
+    allItems: Ref<SelectableItem[]>;
+    pageItems: Ref<SelectableItem[]>;
+}): DataTableProvideSelectionData;
+export declare function useSelection(): DataTableProvideSelectionData;
+export {};

package/types/components/table/composibles/sorting.d.ts

@@ -0,0 +1,41 @@
+import type { PropType, Ref } from 'vue';
+import type { DataTableProvideSortingData, InternalDataTableHeader, SortOption } from '../types';
+export declare const pressDataTableSortProps: <Defaults extends {
+    sortBy?: unknown;
+    multiSort?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    sortBy: unknown extends Defaults["sortBy"] ? {
+        type: PropType<readonly SortOption[]>;
+        default: () => never[];
+    } : Omit<{
+        type: PropType<readonly SortOption[]>;
+        default: () => never[];
+    }, "default" | "type"> & {
+        type: PropType<unknown extends Defaults["sortBy"] ? readonly SortOption[] : readonly SortOption[] | Defaults["sortBy"]>;
+        default: unknown extends Defaults["sortBy"] ? readonly SortOption[] : readonly SortOption[] | Defaults["sortBy"];
+    };
+    multiSort: unknown extends Defaults["multiSort"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults ? "multiSort" : "multiSort" | Defaults>;
+        default: unknown extends Defaults["multiSort"] ? boolean : boolean | Defaults["multiSort"];
+    };
+};
+type SortProps = {
+    sortBy: readonly SortOption[];
+    'onUpdate:sortBy': ((value: any) => void) | undefined;
+    multiSort: boolean;
+};
+export declare function createSorting(props: SortProps): {
+    sortBy: import("vue").WritableComputedRef<any>;
+    multiSort: Ref<boolean>;
+};
+export declare function provideSorting(options: {
+    sortBy: Ref<readonly SortOption[]>;
+    page?: Ref<number>;
+    multiSort?: Ref<boolean>;
+}): DataTableProvideSortingData;
+export declare function useSorting(): {
+    sortBy: Ref<readonly SortOption[]>;
+    toggleSort: (col: InternalDataTableHeader) => void;
+    isSorted: (col: InternalDataTableHeader) => boolean;
+};
+export {};

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

@@ -0,0 +1,77 @@
+import { ComputedRef, Ref, UnwrapRef } from "vue";
+import { SelectableItem } from '../composibles/selection';
+export type DataTableCompareFn<T = any> = (a: T, b: T) => number;
+export type DataTableHeader = {
+    key: string;
+    text: string;
+    value?: any;
+    colspan?: number;
+    rowspan?: number;
+    fixed?: boolean;
+    align?: 'start' | 'end' | 'center';
+    width?: number | string;
+    minWidth?: string;
+    maxWidth?: string;
+    sortable?: boolean;
+    sort?: DataTableCompareFn;
+    mustSort?: boolean;
+};
+export type InternalDataTableHeader = DataTableHeader & {
+    sortable: boolean;
+    fixedOffset?: number;
+    lastFixed?: boolean;
+};
+export interface DataTableItem<T = any> extends SelectableItem {
+    index: number;
+    columns: Record<string, any>;
+    raw: T;
+}
+export type SortOption = {
+    key: string;
+    order?: boolean | 'asc' | 'desc';
+};
+export type DataTableProvideSortingData = {
+    sortBy: Ref<readonly SortOption[]>;
+    toggleSort: (column: InternalDataTableHeader) => void;
+    isSorted: (column: InternalDataTableHeader) => boolean;
+};
+export interface DataTableProvidePaginationData {
+    page: Ref<number>;
+    pageSize: Ref<number>;
+    startIndex: ComputedRef<number>;
+    endIndex: ComputedRef<number>;
+    pageLength: ComputedRef<number>;
+    total: Ref<number>;
+    nextPage: () => void;
+    prevPage: () => void;
+    setPage: (value: number) => void;
+    setPageSize: (value: number) => void;
+}
+export interface DataTableProvideSelectionData {
+    toggleSelect: (item: SelectableItem) => void;
+    select: (items: SelectableItem[], value: boolean) => void;
+    selectAll: (value: boolean) => void;
+    isSelected: (items: (SelectableItem | SelectableItem[])) => any;
+    isSomeSelected: (items: (SelectableItem | SelectableItem[])) => any;
+    someSelected: ComputedRef<boolean>;
+    allSelected: ComputedRef<any>;
+    showSelectAll: boolean;
+    selectables: ComputedRef<SelectableItem[]>;
+}
+export type YDataTableSlotProps = {
+    page: number;
+    pageSize: number;
+    pageLength: number;
+    setPageSize: DataTableProvidePaginationData['setPageSize'];
+    sortBy: UnwrapRef<DataTableProvideSortingData['sortBy']>;
+    toggleSort: DataTableProvideSortingData['toggleSort'];
+    someSelected: boolean;
+    allSelected: boolean;
+    isSelected: DataTableProvideSelectionData['isSelected'];
+    select: DataTableProvideSelectionData['select'];
+    selectAll: DataTableProvideSelectionData['selectAll'];
+    toggleSelect: DataTableProvideSelectionData['toggleSelect'];
+    items: readonly DataTableItem[];
+    columns: InternalDataTableHeader[];
+    headers: InternalDataTableHeader[][];
+};

package/types/components/tree-view/YTreeView.d.ts

@@ -1,5 +1,5 @@
 import { PropType, Ref } from 'vue';
-import { NodeKey } from './types';
+import { CandidateKey } from '../../types';
 export declare const YTreeView: import("vue").DefineComponent<{
     itemKey: {
         type: PropType<string>;
@@ -26,11 +26,11 @@ export declare const YTreeView: import("vue").DefineComponent<{
         default: () => never[];
     };
     expanded: {
-        type: PropType<NodeKey[]>;
+        type: PropType<CandidateKey[]>;
         default: () => never[];
     };
     active: {
-        type: PropType<NodeKey[]>;
+        type: PropType<CandidateKey[]>;
         default: () => never[];
     };
     multipleActive: BooleanConstructor;
@@ -39,7 +39,7 @@ export declare const YTreeView: import("vue").DefineComponent<{
         default: string;
     };
     selected: {
-        type: PropType<NodeKey[]>;
+        type: PropType<CandidateKey[]>;
         default: () => never[];
     };
     selectStrategy: {
@@ -49,10 +49,10 @@ export declare const YTreeView: import("vue").DefineComponent<{
     returnItem: BooleanConstructor;
     defaultExpand: (BooleanConstructor | StringConstructor | NumberConstructor)[];
 }, {
-    nodes: Ref<Record<NodeKey, any>>;
-    expandedSet: Ref<Set<NodeKey>>;
-    selectedSet: Ref<Set<NodeKey>>;
-    activeSet: Ref<Set<NodeKey>>;
+    nodes: Ref<Record<CandidateKey, any>>;
+    expandedSet: Ref<Set<CandidateKey>>;
+    selectedSet: Ref<Set<CandidateKey>>;
+    activeSet: Ref<Set<CandidateKey>>;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:expanded" | "update:active" | "update:selected")[], "update:expanded" | "update:active" | "update:selected", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     itemKey: {
         type: PropType<string>;
@@ -79,11 +79,11 @@ export declare const YTreeView: import("vue").DefineComponent<{
         default: () => never[];
     };
     expanded: {
-        type: PropType<NodeKey[]>;
+        type: PropType<CandidateKey[]>;
         default: () => never[];
     };
     active: {
-        type: PropType<NodeKey[]>;
+        type: PropType<CandidateKey[]>;
         default: () => never[];
     };
     multipleActive: BooleanConstructor;
@@ -92,7 +92,7 @@ export declare const YTreeView: import("vue").DefineComponent<{
         default: string;
     };
     selected: {
-        type: PropType<NodeKey[]>;
+        type: PropType<CandidateKey[]>;
         default: () => never[];
     };
     selectStrategy: {
@@ -106,7 +106,7 @@ export declare const YTreeView: import("vue").DefineComponent<{
     "onUpdate:active"?: ((...args: any[]) => any) | undefined;
     "onUpdate:selected"?: ((...args: any[]) => any) | undefined;
 }, {
-    active: NodeKey[];
+    active: CandidateKey[];
     itemKey: string;
     textKey: string;
     childrenKey: string;
@@ -114,8 +114,8 @@ export declare const YTreeView: import("vue").DefineComponent<{
     enableActive: boolean;
     activeColor: string;
     enableSelect: boolean;
-    expanded: NodeKey[];
-    selected: NodeKey[];
+    expanded: CandidateKey[];
+    selected: CandidateKey[];
     items: any[];
     multipleActive: boolean;
     activeStrategy: "independent" | "cascade";

package/types/components/tree-view/types.d.ts

@@ -1,9 +1,9 @@
 import { ComponentPublicInstance } from 'vue';
-export type NodeKey = string | number;
+import { CandidateKey } from "../../types";
 export interface NodeState {
-    childKeys: NodeKey[];
+    childKeys: CandidateKey[];
     item: any;
-    parentKey: null | NodeKey;
+    parentKey: null | CandidateKey;
     vnode: null | ComponentPublicInstance;
     level: number;
     selected: false;

package/types/components/tree-view/util.d.ts

@@ -1,2 +1,2 @@
-import { NodeKey } from './types';
-export declare function getKeys(items: any[], itemKey: string, childrenKey: string): NodeKey[];
+import { CandidateKey } from "../../types";
+export declare function getKeys(items: any[], itemKey: string, childrenKey: string): CandidateKey[];

package/types/types/index.d.ts

@@ -0,0 +1 @@
+export type CandidateKey = string | number;

package/types/util/array.d.ts

@@ -1 +1,2 @@
 export declare function differenceBetween(inspect: any[], exclude: any[]): any[];
+export declare function wrapInArray(arrOrNot: any | any[]): any[];

package/types/util/common.d.ts

@@ -4,6 +4,8 @@ export declare function mergeDeep(source?: Record<string, any>, overwrite?: Reco
     [x: string]: any;
 };
 export declare function getObjectValueByPath(obj: any, path: string, fallback?: any): any;
+export type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
+export declare function getPropertyFromItem(item: any, property: SelectItemKey, fallback?: any): any;
 export declare function randomCharOne(str: string): string;
 export declare function clamp(value: number, min?: number, max?: number): number;
 export declare function getRangeArr(length: number, start?: number): number[];