lkt-table 1.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (16) hide show
  1. package/README.md +219 -0
  2. package/dist/lkt-table.es.js +373 -0
  3. package/dist/lkt-table.umd.js +1 -0
  4. package/dist/types/components/LktHiddenRow.vue.d.ts +209 -0
  5. package/dist/types/components/LktTableRow.vue.d.ts +194 -0
  6. package/dist/types/functions/table-functions.d.ts +52 -0
  7. package/dist/types/index.d.ts +6 -0
  8. package/dist/types/instances/LktTableColumn.d.ts +16 -0
  9. package/dist/types/interfaces/TableColumn.d.ts +9 -0
  10. package/dist/types/lib-components/LktTable.vue.d.ts +214 -0
  11. package/lkt-table.css +114 -0
  12. package/package.json +71 -0
  13. package/src/components/LktHiddenRow.vue +59 -0
  14. package/src/components/LktTableRow.vue +60 -0
  15. package/src/index.ts +13 -0
  16. package/src/lib-components/LktTable.vue +260 -0
package/dist/types/components/LktHiddenRow.vue.d.ts ADDED
@@ -0,0 +1,209 @@
1
+ import { LktTableColumn } from "../instances/LktTableColumn";
2
+ import { PropType } from "vue/dist/vue";
3
+ declare const _default: {
4
+ new (...args: any[]): import("@vue/runtime-core").CreateComponentPublicInstance<Readonly<import("@vue/runtime-core").ExtractPropTypes<{
5
+ isDraggable: {
6
+ type: BooleanConstructor;
7
+ default: boolean;
8
+ };
9
+ sortable: {
10
+ type: BooleanConstructor;
11
+ default: boolean;
12
+ };
13
+ i: {
14
+ type: NumberConstructor[];
15
+ default: number;
16
+ };
17
+ hiddenColumnsColSpan: {
18
+ type: NumberConstructor;
19
+ default: number;
20
+ };
21
+ visibleColumns: {
22
+ type: PropType<LktTableColumn[]>;
23
+ default: () => LktTableColumn[];
24
+ };
25
+ hiddenColumns: {
26
+ type: PropType<LktTableColumn[]>;
27
+ default: () => LktTableColumn[];
28
+ };
29
+ emptyColumns: {
30
+ type: PropType<string[]>;
31
+ default: () => string[];
32
+ };
33
+ hiddenIsVisible: {
34
+ type: BooleanConstructor;
35
+ default: boolean;
36
+ };
37
+ item: {
38
+ type: PropType<any>;
39
+ default: () => {};
40
+ };
41
+ }>> & {
42
+ onClick?: ((...args: any[]) => any) | undefined;
43
+ }, {}, unknown, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, "click"[], import("@vue/runtime-core").VNodeProps & import("@vue/runtime-core").AllowedComponentProps & import("@vue/runtime-core").ComponentCustomProps & Readonly<import("@vue/runtime-core").ExtractPropTypes<{
44
+ isDraggable: {
45
+ type: BooleanConstructor;
46
+ default: boolean;
47
+ };
48
+ sortable: {
49
+ type: BooleanConstructor;
50
+ default: boolean;
51
+ };
52
+ i: {
53
+ type: NumberConstructor[];
54
+ default: number;
55
+ };
56
+ hiddenColumnsColSpan: {
57
+ type: NumberConstructor;
58
+ default: number;
59
+ };
60
+ visibleColumns: {
61
+ type: PropType<LktTableColumn[]>;
62
+ default: () => LktTableColumn[];
63
+ };
64
+ hiddenColumns: {
65
+ type: PropType<LktTableColumn[]>;
66
+ default: () => LktTableColumn[];
67
+ };
68
+ emptyColumns: {
69
+ type: PropType<string[]>;
70
+ default: () => string[];
71
+ };
72
+ hiddenIsVisible: {
73
+ type: BooleanConstructor;
74
+ default: boolean;
75
+ };
76
+ item: {
77
+ type: PropType<any>;
78
+ default: () => {};
79
+ };
80
+ }>> & {
81
+ onClick?: ((...args: any[]) => any) | undefined;
82
+ }, {
83
+ item: any;
84
+ i: number;
85
+ isDraggable: boolean;
86
+ sortable: boolean;
87
+ hiddenColumnsColSpan: number;
88
+ visibleColumns: LktTableColumn[];
89
+ hiddenColumns: LktTableColumn[];
90
+ emptyColumns: string[];
91
+ hiddenIsVisible: boolean;
92
+ }, true, {}, {}, {
93
+ P: {};
94
+ B: {};
95
+ D: {};
96
+ C: {};
97
+ M: {};
98
+ Defaults: {};
99
+ }, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
100
+ isDraggable: {
101
+ type: BooleanConstructor;
102
+ default: boolean;
103
+ };
104
+ sortable: {
105
+ type: BooleanConstructor;
106
+ default: boolean;
107
+ };
108
+ i: {
109
+ type: NumberConstructor[];
110
+ default: number;
111
+ };
112
+ hiddenColumnsColSpan: {
113
+ type: NumberConstructor;
114
+ default: number;
115
+ };
116
+ visibleColumns: {
117
+ type: PropType<LktTableColumn[]>;
118
+ default: () => LktTableColumn[];
119
+ };
120
+ hiddenColumns: {
121
+ type: PropType<LktTableColumn[]>;
122
+ default: () => LktTableColumn[];
123
+ };
124
+ emptyColumns: {
125
+ type: PropType<string[]>;
126
+ default: () => string[];
127
+ };
128
+ hiddenIsVisible: {
129
+ type: BooleanConstructor;
130
+ default: boolean;
131
+ };
132
+ item: {
133
+ type: PropType<any>;
134
+ default: () => {};
135
+ };
136
+ }>> & {
137
+ onClick?: ((...args: any[]) => any) | undefined;
138
+ }, {}, {}, {}, {}, {
139
+ item: any;
140
+ i: number;
141
+ isDraggable: boolean;
142
+ sortable: boolean;
143
+ hiddenColumnsColSpan: number;
144
+ visibleColumns: LktTableColumn[];
145
+ hiddenColumns: LktTableColumn[];
146
+ emptyColumns: string[];
147
+ hiddenIsVisible: boolean;
148
+ }>;
149
+ __isFragment?: undefined;
150
+ __isTeleport?: undefined;
151
+ __isSuspense?: undefined;
152
+ } & import("@vue/runtime-core").ComponentOptionsBase<Readonly<import("@vue/runtime-core").ExtractPropTypes<{
153
+ isDraggable: {
154
+ type: BooleanConstructor;
155
+ default: boolean;
156
+ };
157
+ sortable: {
158
+ type: BooleanConstructor;
159
+ default: boolean;
160
+ };
161
+ i: {
162
+ type: NumberConstructor[];
163
+ default: number;
164
+ };
165
+ hiddenColumnsColSpan: {
166
+ type: NumberConstructor;
167
+ default: number;
168
+ };
169
+ visibleColumns: {
170
+ type: PropType<LktTableColumn[]>;
171
+ default: () => LktTableColumn[];
172
+ };
173
+ hiddenColumns: {
174
+ type: PropType<LktTableColumn[]>;
175
+ default: () => LktTableColumn[];
176
+ };
177
+ emptyColumns: {
178
+ type: PropType<string[]>;
179
+ default: () => string[];
180
+ };
181
+ hiddenIsVisible: {
182
+ type: BooleanConstructor;
183
+ default: boolean;
184
+ };
185
+ item: {
186
+ type: PropType<any>;
187
+ default: () => {};
188
+ };
189
+ }>> & {
190
+ onClick?: ((...args: any[]) => any) | undefined;
191
+ }, {}, unknown, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, "click"[], "click", {
192
+ item: any;
193
+ i: number;
194
+ isDraggable: boolean;
195
+ sortable: boolean;
196
+ hiddenColumnsColSpan: number;
197
+ visibleColumns: LktTableColumn[];
198
+ hiddenColumns: LktTableColumn[];
199
+ emptyColumns: string[];
200
+ hiddenIsVisible: boolean;
201
+ }, {}, string, {}> & import("@vue/runtime-core").VNodeProps & import("@vue/runtime-core").AllowedComponentProps & import("@vue/runtime-core").ComponentCustomProps & (new () => {
202
+ $slots: Record<string, {
203
+ value: any;
204
+ item: any;
205
+ column: LktTableColumn;
206
+ i: number;
207
+ }>;
208
+ });
209
+ export default _default;
package/dist/types/components/LktTableRow.vue.d.ts ADDED
@@ -0,0 +1,194 @@
1
+ import { LktTableColumn } from "../instances/LktTableColumn";
2
+ import { PropType } from "vue/dist/vue";
3
+ declare const _default: {
4
+ new (...args: any[]): import("@vue/runtime-core").CreateComponentPublicInstance<Readonly<import("@vue/runtime-core").ExtractPropTypes<{
5
+ isDraggable: {
6
+ type: BooleanConstructor;
7
+ default: boolean;
8
+ };
9
+ sortable: {
10
+ type: BooleanConstructor;
11
+ default: boolean;
12
+ };
13
+ i: {
14
+ type: NumberConstructor[];
15
+ default: number;
16
+ };
17
+ displayHiddenColumnsIndicator: {
18
+ type: BooleanConstructor;
19
+ default: boolean;
20
+ };
21
+ visibleColumns: {
22
+ type: PropType<LktTableColumn[]>;
23
+ default: () => LktTableColumn[];
24
+ };
25
+ emptyColumns: {
26
+ type: PropType<string[]>;
27
+ default: () => string[];
28
+ };
29
+ hiddenIsVisible: {
30
+ type: BooleanConstructor;
31
+ default: boolean;
32
+ };
33
+ item: {
34
+ type: PropType<any>;
35
+ default: () => {};
36
+ };
37
+ }>> & {
38
+ onClick?: ((...args: any[]) => any) | undefined;
39
+ onShow?: ((...args: any[]) => any) | undefined;
40
+ }, {}, unknown, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("show" | "click")[], import("@vue/runtime-core").VNodeProps & import("@vue/runtime-core").AllowedComponentProps & import("@vue/runtime-core").ComponentCustomProps & Readonly<import("@vue/runtime-core").ExtractPropTypes<{
41
+ isDraggable: {
42
+ type: BooleanConstructor;
43
+ default: boolean;
44
+ };
45
+ sortable: {
46
+ type: BooleanConstructor;
47
+ default: boolean;
48
+ };
49
+ i: {
50
+ type: NumberConstructor[];
51
+ default: number;
52
+ };
53
+ displayHiddenColumnsIndicator: {
54
+ type: BooleanConstructor;
55
+ default: boolean;
56
+ };
57
+ visibleColumns: {
58
+ type: PropType<LktTableColumn[]>;
59
+ default: () => LktTableColumn[];
60
+ };
61
+ emptyColumns: {
62
+ type: PropType<string[]>;
63
+ default: () => string[];
64
+ };
65
+ hiddenIsVisible: {
66
+ type: BooleanConstructor;
67
+ default: boolean;
68
+ };
69
+ item: {
70
+ type: PropType<any>;
71
+ default: () => {};
72
+ };
73
+ }>> & {
74
+ onClick?: ((...args: any[]) => any) | undefined;
75
+ onShow?: ((...args: any[]) => any) | undefined;
76
+ }, {
77
+ item: any;
78
+ i: number;
79
+ isDraggable: boolean;
80
+ sortable: boolean;
81
+ visibleColumns: LktTableColumn[];
82
+ emptyColumns: string[];
83
+ hiddenIsVisible: boolean;
84
+ displayHiddenColumnsIndicator: boolean;
85
+ }, true, {}, {}, {
86
+ P: {};
87
+ B: {};
88
+ D: {};
89
+ C: {};
90
+ M: {};
91
+ Defaults: {};
92
+ }, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
93
+ isDraggable: {
94
+ type: BooleanConstructor;
95
+ default: boolean;
96
+ };
97
+ sortable: {
98
+ type: BooleanConstructor;
99
+ default: boolean;
100
+ };
101
+ i: {
102
+ type: NumberConstructor[];
103
+ default: number;
104
+ };
105
+ displayHiddenColumnsIndicator: {
106
+ type: BooleanConstructor;
107
+ default: boolean;
108
+ };
109
+ visibleColumns: {
110
+ type: PropType<LktTableColumn[]>;
111
+ default: () => LktTableColumn[];
112
+ };
113
+ emptyColumns: {
114
+ type: PropType<string[]>;
115
+ default: () => string[];
116
+ };
117
+ hiddenIsVisible: {
118
+ type: BooleanConstructor;
119
+ default: boolean;
120
+ };
121
+ item: {
122
+ type: PropType<any>;
123
+ default: () => {};
124
+ };
125
+ }>> & {
126
+ onClick?: ((...args: any[]) => any) | undefined;
127
+ onShow?: ((...args: any[]) => any) | undefined;
128
+ }, {}, {}, {}, {}, {
129
+ item: any;
130
+ i: number;
131
+ isDraggable: boolean;
132
+ sortable: boolean;
133
+ visibleColumns: LktTableColumn[];
134
+ emptyColumns: string[];
135
+ hiddenIsVisible: boolean;
136
+ displayHiddenColumnsIndicator: boolean;
137
+ }>;
138
+ __isFragment?: undefined;
139
+ __isTeleport?: undefined;
140
+ __isSuspense?: undefined;
141
+ } & import("@vue/runtime-core").ComponentOptionsBase<Readonly<import("@vue/runtime-core").ExtractPropTypes<{
142
+ isDraggable: {
143
+ type: BooleanConstructor;
144
+ default: boolean;
145
+ };
146
+ sortable: {
147
+ type: BooleanConstructor;
148
+ default: boolean;
149
+ };
150
+ i: {
151
+ type: NumberConstructor[];
152
+ default: number;
153
+ };
154
+ displayHiddenColumnsIndicator: {
155
+ type: BooleanConstructor;
156
+ default: boolean;
157
+ };
158
+ visibleColumns: {
159
+ type: PropType<LktTableColumn[]>;
160
+ default: () => LktTableColumn[];
161
+ };
162
+ emptyColumns: {
163
+ type: PropType<string[]>;
164
+ default: () => string[];
165
+ };
166
+ hiddenIsVisible: {
167
+ type: BooleanConstructor;
168
+ default: boolean;
169
+ };
170
+ item: {
171
+ type: PropType<any>;
172
+ default: () => {};
173
+ };
174
+ }>> & {
175
+ onClick?: ((...args: any[]) => any) | undefined;
176
+ onShow?: ((...args: any[]) => any) | undefined;
177
+ }, {}, unknown, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("show" | "click")[], "show" | "click", {
178
+ item: any;
179
+ i: number;
180
+ isDraggable: boolean;
181
+ sortable: boolean;
182
+ visibleColumns: LktTableColumn[];
183
+ emptyColumns: string[];
184
+ hiddenIsVisible: boolean;
185
+ displayHiddenColumnsIndicator: boolean;
186
+ }, {}, string, {}> & import("@vue/runtime-core").VNodeProps & import("@vue/runtime-core").AllowedComponentProps & import("@vue/runtime-core").ComponentCustomProps & (new () => {
187
+ $slots: Record<string, {
188
+ value: any;
189
+ item: any;
190
+ column: LktTableColumn;
191
+ i: number;
192
+ }>;
193
+ });
194
+ export default _default;
package/dist/types/functions/table-functions.d.ts ADDED
@@ -0,0 +1,52 @@
1
+ import { LktTableColumn } from "../instances/LktTableColumn";
2
+ import { LktObject } from "lkt-ts-interfaces";
3
+ /**
4
+ *
5
+ * @param key
6
+ * @param label
7
+ * @param sortable
8
+ * @returns {LktTableColumn}
9
+ */
10
+ export declare const createColumn: (key: string, label: string, sortable?: boolean) => LktTableColumn;
11
+ export declare const createHiddenColumn: (key: string, label: string, sortable?: boolean) => LktTableColumn;
12
+ /**
13
+ *
14
+ * @param a
15
+ * @param b
16
+ * @param c
17
+ * @param sortDirection
18
+ * @returns {number}
19
+ */
20
+ export declare const defaultTableSorter: (a: any, b: any, c: LktTableColumn, sortDirection: string) => number;
21
+ /**
22
+ *
23
+ * @param column
24
+ * @param item
25
+ * @param i
26
+ * @returns {*}
27
+ */
28
+ export declare const getColumnDisplayContent: (column: LktTableColumn, item: any, i: number) => any;
29
+ /**
30
+ *
31
+ * @param column
32
+ * @param amountOfColumns
33
+ * @param items
34
+ */
35
+ export declare const getVerticalColSpan: (column: LktTableColumn, amountOfColumns: number, items: Array<LktObject>) => number;
36
+ /**
37
+ *
38
+ * @param column
39
+ * @param item
40
+ * @returns {boolean|*}
41
+ */
42
+ export declare const getHorizontalColSpan: (column: LktTableColumn, item: LktObject) => any;
43
+ /**
44
+ *
45
+ * @param column
46
+ * @param emptyColumns
47
+ * @param item
48
+ * @returns {boolean}
49
+ */
50
+ export declare const canRenderColumn: (column: LktTableColumn, emptyColumns: string[], item: LktObject) => boolean;
51
+ export declare const getDefaultSortColumn: (columns?: LktTableColumn[]) => string;
52
+ export declare const getColumnByKey: (columns: LktTableColumn[], key: string) => LktTableColumn | null;
package/dist/types/index.d.ts ADDED
@@ -0,0 +1,6 @@
1
+ import { App } from "vue";
2
+ export { createColumn, createHiddenColumn } from "./functions/table-functions";
3
+ declare const LktTable: {
4
+ install: (app: App) => void;
5
+ };
6
+ export default LktTable;
package/dist/types/instances/LktTableColumn.d.ts ADDED
@@ -0,0 +1,16 @@
1
+ import { TableColumn } from "../interfaces/TableColumn";
2
+ export declare class LktTableColumn implements TableColumn {
3
+ key: string;
4
+ label: string;
5
+ sortable: boolean;
6
+ hidden: boolean;
7
+ formatter?: Function;
8
+ checkEmpty?: Function;
9
+ colspan?: Function | boolean | number;
10
+ constructor(key?: string, label?: string);
11
+ setIsSortable(status?: boolean): this;
12
+ setIsHidden(status?: boolean): this;
13
+ setFormatter(formatter?: any): this;
14
+ setEmptyChecker(checker?: any): this;
15
+ setColSpan(checker?: any): this;
16
+ }
package/dist/types/interfaces/TableColumn.d.ts ADDED
@@ -0,0 +1,9 @@
1
+ export interface TableColumn {
2
+ key: string;
3
+ label: string;
4
+ sortable: boolean;
5
+ hidden?: boolean;
6
+ formatter?: Function;
7
+ checkEmpty?: Function;
8
+ colspan?: Function | boolean | number;
9
+ }
package/dist/types/lib-components/LktTable.vue.d.ts ADDED
@@ -0,0 +1,214 @@
1
+ import { PropType } from "vue";
2
+ import { LktTableColumn } from "../instances/LktTableColumn";
3
+ import { LktObject } from "lkt-ts-interfaces";
4
+ declare const _default: {
5
+ new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
6
+ modelValue: {
7
+ type: PropType<LktObject[]>;
8
+ default: () => any[];
9
+ };
10
+ columns: {
11
+ type: PropType<LktTableColumn[]>;
12
+ default: () => LktTableColumn[];
13
+ };
14
+ sorter: {
15
+ type: FunctionConstructor;
16
+ default: (a: any, b: any, c: LktTableColumn, sortDirection: string) => number;
17
+ };
18
+ sortable: {
19
+ type: BooleanConstructor;
20
+ default: boolean;
21
+ };
22
+ hideEmptyColumns: {
23
+ type: BooleanConstructor;
24
+ default: boolean;
25
+ };
26
+ draggableChecker: {
27
+ type: FunctionConstructor;
28
+ default: (item: any) => true;
29
+ };
30
+ checkValidDrag: {
31
+ type: FunctionConstructor;
32
+ default: (evt: any) => true;
33
+ };
34
+ draggableItemKey: {
35
+ type: StringConstructor;
36
+ default: string;
37
+ };
38
+ }>> & {
39
+ onClick?: ((...args: any[]) => any) | undefined;
40
+ onSort?: ((...args: any[]) => any) | undefined;
41
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
42
+ }, {
43
+ getItemByEvent: (e: any) => LktObject | undefined;
44
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("sort" | "click" | "update:modelValue")[], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
45
+ modelValue: {
46
+ type: PropType<LktObject[]>;
47
+ default: () => any[];
48
+ };
49
+ columns: {
50
+ type: PropType<LktTableColumn[]>;
51
+ default: () => LktTableColumn[];
52
+ };
53
+ sorter: {
54
+ type: FunctionConstructor;
55
+ default: (a: any, b: any, c: LktTableColumn, sortDirection: string) => number;
56
+ };
57
+ sortable: {
58
+ type: BooleanConstructor;
59
+ default: boolean;
60
+ };
61
+ hideEmptyColumns: {
62
+ type: BooleanConstructor;
63
+ default: boolean;
64
+ };
65
+ draggableChecker: {
66
+ type: FunctionConstructor;
67
+ default: (item: any) => true;
68
+ };
69
+ checkValidDrag: {
70
+ type: FunctionConstructor;
71
+ default: (evt: any) => true;
72
+ };
73
+ draggableItemKey: {
74
+ type: StringConstructor;
75
+ default: string;
76
+ };
77
+ }>> & {
78
+ onClick?: ((...args: any[]) => any) | undefined;
79
+ onSort?: ((...args: any[]) => any) | undefined;
80
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
81
+ }, {
82
+ columns: LktTableColumn[];
83
+ sortable: boolean;
84
+ modelValue: LktObject[];
85
+ sorter: Function;
86
+ hideEmptyColumns: boolean;
87
+ draggableChecker: Function;
88
+ checkValidDrag: Function;
89
+ draggableItemKey: string;
90
+ }, true, {}, {}, {
91
+ P: {};
92
+ B: {};
93
+ D: {};
94
+ C: {};
95
+ M: {};
96
+ Defaults: {};
97
+ }, Readonly<import("vue").ExtractPropTypes<{
98
+ modelValue: {
99
+ type: PropType<LktObject[]>;
100
+ default: () => any[];
101
+ };
102
+ columns: {
103
+ type: PropType<LktTableColumn[]>;
104
+ default: () => LktTableColumn[];
105
+ };
106
+ sorter: {
107
+ type: FunctionConstructor;
108
+ default: (a: any, b: any, c: LktTableColumn, sortDirection: string) => number;
109
+ };
110
+ sortable: {
111
+ type: BooleanConstructor;
112
+ default: boolean;
113
+ };
114
+ hideEmptyColumns: {
115
+ type: BooleanConstructor;
116
+ default: boolean;
117
+ };
118
+ draggableChecker: {
119
+ type: FunctionConstructor;
120
+ default: (item: any) => true;
121
+ };
122
+ checkValidDrag: {
123
+ type: FunctionConstructor;
124
+ default: (evt: any) => true;
125
+ };
126
+ draggableItemKey: {
127
+ type: StringConstructor;
128
+ default: string;
129
+ };
130
+ }>> & {
131
+ onClick?: ((...args: any[]) => any) | undefined;
132
+ onSort?: ((...args: any[]) => any) | undefined;
133
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
134
+ }, {
135
+ getItemByEvent: (e: any) => LktObject | undefined;
136
+ }, {}, {}, {}, {
137
+ columns: LktTableColumn[];
138
+ sortable: boolean;
139
+ modelValue: LktObject[];
140
+ sorter: Function;
141
+ hideEmptyColumns: boolean;
142
+ draggableChecker: Function;
143
+ checkValidDrag: Function;
144
+ draggableItemKey: string;
145
+ }>;
146
+ __isFragment?: undefined;
147
+ __isTeleport?: undefined;
148
+ __isSuspense?: undefined;
149
+ } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
150
+ modelValue: {
151
+ type: PropType<LktObject[]>;
152
+ default: () => any[];
153
+ };
154
+ columns: {
155
+ type: PropType<LktTableColumn[]>;
156
+ default: () => LktTableColumn[];
157
+ };
158
+ sorter: {
159
+ type: FunctionConstructor;
160
+ default: (a: any, b: any, c: LktTableColumn, sortDirection: string) => number;
161
+ };
162
+ sortable: {
163
+ type: BooleanConstructor;
164
+ default: boolean;
165
+ };
166
+ hideEmptyColumns: {
167
+ type: BooleanConstructor;
168
+ default: boolean;
169
+ };
170
+ draggableChecker: {
171
+ type: FunctionConstructor;
172
+ default: (item: any) => true;
173
+ };
174
+ checkValidDrag: {
175
+ type: FunctionConstructor;
176
+ default: (evt: any) => true;
177
+ };
178
+ draggableItemKey: {
179
+ type: StringConstructor;
180
+ default: string;
181
+ };
182
+ }>> & {
183
+ onClick?: ((...args: any[]) => any) | undefined;
184
+ onSort?: ((...args: any[]) => any) | undefined;
185
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
186
+ }, {
187
+ getItemByEvent: (e: any) => LktObject | undefined;
188
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("sort" | "click" | "update:modelValue")[], "sort" | "click" | "update:modelValue", {
189
+ columns: LktTableColumn[];
190
+ sortable: boolean;
191
+ modelValue: LktObject[];
192
+ sorter: Function;
193
+ hideEmptyColumns: boolean;
194
+ draggableChecker: Function;
195
+ checkValidDrag: Function;
196
+ draggableItemKey: string;
197
+ }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
198
+ $slots: Record<any, {
199
+ item: any;
200
+ value: any;
201
+ column: any;
202
+ }> & Record<any, {
203
+ item: any;
204
+ value: any;
205
+ column: any;
206
+ }> & Record<any, {
207
+ item: any;
208
+ value: any;
209
+ column: any;
210
+ }> & {
211
+ 'no-items': (_: {}) => any;
212
+ };
213
+ });
214
+ export default _default;