yuyeon 0.3.4-beta.12 → 0.3.4-beta.13

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

@@ -0,0 +1,59 @@
+import { ComputedRef, Ref, UnwrapRef } from 'vue';
+import { SelectableItem } from '../composables/selection';
+import { DataTableCompareFn } from './common';
+import { DataTableHeader, InternalDataTableHeader } from './header';
+import { DataTableItem, ItemKeySlot } from './item';
+import { CellProps, RowProps } from './row';
+
+export type { ItemKeySlot, RowProps, CellProps, DataTableHeader, InternalDataTableHeader, DataTableItem, DataTableCompareFn, };
+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[][];
+    TableBodyRef: Ref<any>;
+};
+export type FixedPropType = 'lead' | 'trail' | 'lead-last' | 'trail-last';

package/types/src/components/table/types/item.d.ts

@@ -0,0 +1,23 @@
+import { provideSelection, SelectableItem } from '../composables/selection';
+import { InternalDataTableHeader } from './header';
+
+type ItemSlotBase<T> = {
+    index: number;
+    item: T;
+    internalItem: DataTableItem<T>;
+    selected: boolean;
+    isSelected: ReturnType<typeof provideSelection>['isSelected'];
+    toggleSelect: ReturnType<typeof provideSelection>['toggleSelect'];
+};
+export type ItemKeySlot<T> = ItemSlotBase<T> & {
+    value: any;
+    column: InternalDataTableHeader;
+};
+export interface DataTableItem<T = any> extends SelectableItem {
+    index: number;
+    columns: Record<string, any>;
+    raw: T;
+    rowRef?: any;
+    readonly _bindRowRef: (el: any | null) => void;
+}
+export {};

package/types/src/components/table/types/row.d.ts

@@ -0,0 +1,4 @@
+import { ItemKeySlot } from './item';
+
+export type RowProps<T> = Record<string, any> | ((data: Pick<ItemKeySlot<T>, 'index' | 'item' | 'internalItem'>) => Record<string, any>);
+export type CellProps<T = any> = Record<string, any> | ((data: Pick<ItemKeySlot<T>, 'index' | 'item' | 'internalItem' | 'value' | 'column' | 'selected'>) => Record<string, any>);

package/types/src/components/text-ellipsis/YTextEllipsis.d.ts

@@ -0,0 +1,11 @@
+
+export declare const YTextEllipsis: import('vue').DefineComponent<{
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+    position: {
+        type: StringConstructor;
+    };
+}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string>;
+export type YTextEllipsis = InstanceType<typeof YTextEllipsis>;

package/types/src/components/text-ellipsis/index.d.ts

@@ -0,0 +1 @@
+export * from './YTextEllipsis';

package/types/src/components/text-highlighter/YTextHighlighter.d.ts

@@ -0,0 +1,26 @@
+import { VNode } from 'vue';
+
+export declare const YTextHighlighter: import('vue').DefineComponent<{
+    text: {
+        type: StringConstructor;
+    };
+    keyword: {
+        type: StringConstructor;
+    };
+    color: {
+        type: StringConstructor;
+    };
+    sensitive: {
+        type: BooleanConstructor;
+    };
+}, {}, {}, {
+    splitText(): {
+        text: string;
+        isKeyword: boolean;
+    }[];
+}, {
+    createItem(text: string): VNode;
+    createHighlightKeywordItem(text: string): VNode;
+    createSplitTexts(): VNode[];
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string>;
+export type YTextHighlighter = InstanceType<typeof YTextHighlighter>;

package/types/src/components/text-highlighter/index.d.ts

@@ -0,0 +1 @@
+export * from './YTextHighlighter';

package/types/src/components/text-interpolation/YTi.d.ts

@@ -0,0 +1,11 @@
+import { PropType } from 'vue';
+
+export declare const YTi: import('vue').DefineComponent<{
+    text: StringConstructor;
+    item: ObjectConstructor;
+    tag: {
+        type: PropType<keyof HTMLElementTagNameMap>;
+        default: string;
+    };
+}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string>;
+export type YTi = InstanceType<typeof YTi>;

package/types/src/components/text-interpolation/index.d.ts

@@ -0,0 +1 @@
+export * from './YTi';