@application-kit/ui 0.0.0-stage → 0.0.0

package/dist/components/table/DataTable.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,303 @@
+import { useUiDescribeRequestError, useUiMessages } from "../../plugin/ui-injection.js";
+import Message_default from "../message/Message.js";
+import "../../store/listing/cursor-listing.js";
+import { collectColumnFilters } from "./collect-column-filters.js";
+import { getFilters } from "./get-filters.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createSlots, createTextVNode, createVNode, defineComponent, mergeModels, mergeProps, onBeforeMount, onServerPrefetch, openBlock, ref, renderList, renderSlot, resolveDynamicComponent, toDisplayString, unref, useModel, watch, withCtx, withKeys } from "vue";
+import { DEFAULT_CREATED_AT_SORTING, FiltersMatchMode, SortOrder } from "@application-kit/typeorm/listing";
+import InputText from "openvue/inputtext";
+import DataTableColumn from "openvue/column";
+import DataTable from "openvue/datatable";
+//#region src/components/table/DataTable.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "data-table-frame" };
+var SORT_ASC_FLAG = 1;
+var SORT_NEUTRAL = 0;
+var DataTable_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "ListingDataTable",
+	__name: "DataTable",
+	props: /*@__PURE__*/ mergeModels({
+		columns: {
+			required: true,
+			type: Object
+		},
+		defaultSorting: {
+			default: void 0,
+			type: Array
+		},
+		extraFilters: {
+			default: void 0,
+			type: Array
+		},
+		filters: {
+			default: void 0,
+			type: Object
+		},
+		listingStore: {
+			required: true,
+			type: Object
+		},
+		multiSelectEnabled: {
+			default: false,
+			type: Boolean
+		},
+		rowsPerPage: {
+			default: 20,
+			type: Number
+		}
+	}, {
+		"selection": { default: () => [] },
+		"selectionModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels(["update:filters"], ["update:selection"]),
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const messages = useUiMessages();
+		const describeRequestError = useUiDescribeRequestError();
+		const toColumnFilters = (vendorFilters) => vendorFilters;
+		const internalFilters = ref(collectColumnFilters(props.columns));
+		watch(() => props.columns, () => {
+			if (props.filters === void 0) internalFilters.value = collectColumnFilters(props.columns);
+		});
+		const filtersBinding = computed({
+			get: () => props.filters ?? internalFilters.value,
+			set: (value) => {
+				if (props.filters !== void 0) {
+					emit("update:filters", value);
+					return;
+				}
+				internalFilters.value = value;
+			}
+		});
+		const listing = props.listingStore;
+		const defaultTableSorting = computed(() => props.defaultSorting ?? DEFAULT_CREATED_AT_SORTING);
+		const selectedRows = useModel(__props, "selection");
+		const selectedAll = ref(false);
+		const selectFilters = ref(/* @__PURE__ */ new Map());
+		const combinedFilters = (textFilters) => [
+			...textFilters,
+			...selectFilters.value.values(),
+			...props.extraFilters ?? []
+		];
+		const reloadWithFilters = async (textFilters) => {
+			listing.setFilters(combinedFilters(textFilters));
+			await listing.getRecords(listing.currentPage);
+		};
+		const rowsPerPageOptions = () => {
+			return [
+				20,
+				40,
+				100
+			];
+		};
+		const filterDisplay = computed(() => props.columns.some((column) => column.filter !== void 0) ? "row" : void 0);
+		const loading = computed(() => listing.loading);
+		const listingError = computed(() => listing.error);
+		const errorMessage = computed(() => describeRequestError(listing.error, messages.value.table.error));
+		const paginatorFirst = computed(() => listing.currentPage * listing.limit);
+		const totalRecords = computed(() => listing.totalRecords);
+		onServerPrefetch(async () => {
+			listing.setLimit(props.rowsPerPage);
+			await listing.getRecords(listing.currentPage);
+			listing.markServerRendered();
+		});
+		onBeforeMount(async () => {
+			listing.setLimit(props.rowsPerPage);
+			if (listing.records.length === 0) await listing.getRecords(listing.currentPage);
+		});
+		const onPage = async (event) => {
+			listing.setLimit(event.rows);
+			await listing.getRecords(event.page);
+		};
+		const toSortingFromMultiMeta = (multiSortMeta) => {
+			if (multiSortMeta === void 0 || multiSortMeta.length === SORT_NEUTRAL) return [];
+			return multiSortMeta.map((sortMeta) => ({
+				field: sortMeta.field,
+				order: sortMeta.order === SORT_ASC_FLAG ? SortOrder.ASC : SortOrder.DESC
+			}));
+		};
+		const NEUTRAL_SORT_ORDERS = /* @__PURE__ */ new Set([
+			null,
+			SORT_NEUTRAL,
+			void 0
+		]);
+		const isNeutralSortOrder = (order) => NEUTRAL_SORT_ORDERS.has(order);
+		const singleSortRow = (field, orderFlag) => ({
+			field,
+			order: orderFlag === SORT_ASC_FLAG ? SortOrder.ASC : SortOrder.DESC
+		});
+		const toSortingFromSingleSort = (event) => {
+			const field = typeof event.sortField === "string" ? event.sortField : "";
+			return field === "" || isNeutralSortOrder(event.sortOrder) ? [] : [singleSortRow(field, event.sortOrder)];
+		};
+		const onSort = async (event) => {
+			const fromMulti = toSortingFromMultiMeta(event.multiSortMeta);
+			let sorting = fromMulti.length > SORT_NEUTRAL ? fromMulti : toSortingFromSingleSort(event);
+			if (sorting.length === SORT_NEUTRAL) sorting = defaultTableSorting.value;
+			listing.setSorting(sorting);
+			listing.setLimit(event.rows);
+			await listing.getRecords(listing.currentPage);
+		};
+		const onFilter = async (event) => {
+			await reloadWithFilters(getFilters(toColumnFilters(event.filters)));
+		};
+		const onSelectFilters = async (field, selectedFilters) => {
+			if (selectedFilters.length === 0) selectFilters.value.delete(field);
+			else selectFilters.value.set(field, {
+				field,
+				matchMode: FiltersMatchMode.IN,
+				value: selectedFilters.map((value) => value.name).join(",")
+			});
+			await reloadWithFilters(getFilters(filtersBinding.value));
+		};
+		watch(() => props.extraFilters, async () => {
+			await reloadWithFilters(getFilters(filtersBinding.value));
+		});
+		const onSelectAllChange = (event) => {
+			if (event.checked) {
+				selectedAll.value = true;
+				selectedRows.value = listing.records;
+			} else {
+				selectedAll.value = false;
+				selectedRows.value = [];
+			}
+		};
+		const onRowSelect = () => {
+			selectedAll.value = selectedRows.value.length === totalRecords.value;
+		};
+		const onRowUnselect = () => {
+			selectedAll.value = false;
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [listingError.value !== null ? renderSlot(_ctx.$slots, "error", { error: listingError.value }, () => [createVNode(Message_default, {
+				class: "data-table-frame__error",
+				role: "alert",
+				severity: "danger"
+			}, {
+				default: withCtx(() => [createTextVNode(toDisplayString(errorMessage.value), 1)]),
+				_: 1
+			})], true, 0) : createCommentVNode("", true), createVNode(unref(DataTable), {
+				selection: selectedRows.value,
+				"onUpdate:selection": _cache[0] || (_cache[0] = ($event) => selectedRows.value = $event),
+				filters: filtersBinding.value,
+				"onUpdate:filters": _cache[1] || (_cache[1] = ($event) => filtersBinding.value = $event),
+				loading: loading.value,
+				first: paginatorFirst.value,
+				"rows-per-page-options": rowsPerPageOptions(),
+				rows: unref(listing).limit,
+				"select-all": selectedAll.value,
+				"total-records": totalRecords.value,
+				value: unref(listing).records,
+				pt: {
+					"column": {
+						"bodyCell": {
+							"class": "data-table__body-cell",
+							[_ctx.$options["__scopeId"]]: ""
+						},
+						"headerCell": {
+							"class": "data-table__header-cell",
+							[_ctx.$options["__scopeId"]]: ""
+						},
+						"filterRowItem": {
+							"class": "data-table__filter-row-item",
+							[_ctx.$options["__scopeId"]]: ""
+						}
+					},
+					"paginator": { "rowPerPageDropdown": {
+						"input": {
+							"class": "data-table__paginator-row-per-page-input",
+							[_ctx.$options["__scopeId"]]: ""
+						},
+						"item": {
+							"class": "data-table__paginator-row-per-page-item",
+							[_ctx.$options["__scopeId"]]: ""
+						}
+					} }
+				},
+				class: "data-table",
+				"current-page-report-template": "{first} to {last} of {totalRecords}",
+				"filter-display": filterDisplay.value,
+				"data-key": "id",
+				lazy: "",
+				paginator: "",
+				"paginator-template": "PrevPageLink CurrentPageReport NextPageLink RowsPerPageDropdown ",
+				"removable-sort": "",
+				"row-hover": "",
+				"show-gridlines": "",
+				size: "small",
+				"sort-mode": "single",
+				"striped-rows": "",
+				onFilter,
+				onPage,
+				onRowSelect,
+				onRowUnselect,
+				onSelectAllChange,
+				onSort
+			}, {
+				empty: withCtx(() => [listingError.value === null ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createTextVNode(toDisplayString(unref(messages).table.empty), 1)], 64)) : createCommentVNode("", true)]),
+				loading: withCtx(() => [createTextVNode(toDisplayString(unref(messages).table.loading), 1)]),
+				default: withCtx(() => [__props.multiSelectEnabled ? (openBlock(), createBlock(unref(DataTableColumn), {
+					key: 0,
+					"selection-mode": "multiple",
+					class: "table-column"
+				})) : createCommentVNode("", true), (openBlock(true), createElementBlock(Fragment, null, renderList(props.columns, (column, index) => {
+					return openBlock(), createBlock(unref(DataTableColumn), {
+						key: index,
+						field: column.field,
+						"filter-field": column.field,
+						"show-filter-menu": column.showFilterMenu === true,
+						header: column.header,
+						sortable: column.sortable,
+						class: "table-column",
+						"filter-header-class": "",
+						"filter-menu-class": "table-column"
+					}, createSlots({
+						body: withCtx((slotProps) => [(openBlock(), createBlock(resolveDynamicComponent(column.component), mergeProps({ ref_for: true }, { ...column.componentProps(slotProps.data) }), null, 16))]),
+						_: 2
+					}, [column.filter ? {
+						name: "filter",
+						fn: withCtx((slotProps) => [column.filter.metadata ? (openBlock(), createBlock(unref(InputText), {
+							key: 0,
+							modelValue: slotProps.filterModel.value,
+							"onUpdate:modelValue": ($event) => slotProps.filterModel.value = $event,
+							type: "text",
+							class: "p-column-filter",
+							placeholder: column.filter.filterPlaceholder ?? unref(messages).table.searchPlaceholder,
+							onKeydown: withKeys(($event) => slotProps.filterCallback(), ["enter"])
+						}, null, 8, [
+							"modelValue",
+							"onUpdate:modelValue",
+							"placeholder",
+							"onKeydown"
+						])) : column.filter.component ? (openBlock(), createBlock(resolveDynamicComponent(column.filter.component.component), mergeProps({
+							key: 1,
+							ref_for: true
+						}, { ...column.filter.component.filterComponentProps(slotProps) }, { "onUpdate:selectedValue": (selectedValues) => onSelectFilters(slotProps.field, selectedValues) }), null, 16, ["onUpdate:selectedValue"])) : createCommentVNode("", true)]),
+						key: "0"
+					} : void 0]), 1032, [
+						"field",
+						"filter-field",
+						"show-filter-menu",
+						"header",
+						"sortable"
+					]);
+				}), 128))]),
+				_: 1
+			}, 8, [
+				"selection",
+				"filters",
+				"loading",
+				"first",
+				"rows-per-page-options",
+				"rows",
+				"select-all",
+				"total-records",
+				"value",
+				"pt",
+				"filter-display"
+			])]);
+		};
+	}
+});
+//#endregion
+export { DataTable_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/table/InfiniteDataTable.js

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../../_virtual/_plugin-vue_export-helper.js";
+import InfiniteDataTable_vue_vue_type_script_setup_true_lang_default from "./InfiniteDataTable.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                  */
+//#region src/components/table/InfiniteDataTable.vue
+var InfiniteDataTable_default = /*#__PURE__*/ _plugin_vue_export_helper_default(InfiniteDataTable_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-2c01be04"]]);
+//#endregion
+export { InfiniteDataTable_default as default };

package/dist/components/table/InfiniteDataTable.vue.d.ts

@@ -0,0 +1,32 @@
+import type { Component, PropType } from 'vue';
+import { InfiniteListingStoreType } from '../../store/listing/infinite-listing-store';
+import { ColumnSchemaInterface } from './column-schema-interface';
+declare const __VLS_export: <T, S extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<import("vue").ExtractPublicPropTypes<{
+        columns: {
+            required: boolean;
+            type: PropType<ColumnSchemaInterface<T, Component>[]>;
+        };
+        listingStore: {
+            required: boolean;
+            type: PropType<InfiniteListingStoreType<T, S>>;
+        };
+    }>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        limit?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/table/InfiniteDataTable.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,88 @@
+import { useUiMessages } from "../../plugin/ui-injection.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeProps, onBeforeMount, onBeforeUnmount, onMounted, onServerPrefetch, openBlock, ref, renderList, renderSlot, resolveDynamicComponent, shallowRef, toDisplayString, unref, withCtx } from "vue";
+import DataTableColumn from "openvue/column";
+import DataTable from "openvue/datatable";
+//#region src/components/table/InfiniteDataTable.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 0,
+	class: "infinite-data-table__more",
+	role: "status"
+};
+var NO_RECORDS = 0;
+var InfiniteDataTable_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "InfiniteDataTable",
+	props: {
+		columns: {
+			required: true,
+			type: Object
+		},
+		listingStore: {
+			required: true,
+			type: Object
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const messages = useUiMessages();
+		const listing = props.listingStore;
+		const isInitialLoading = computed(() => listing.loading && listing.records.length === NO_RECORDS);
+		const isLoadingMore = computed(() => listing.loading && listing.records.length > NO_RECORDS);
+		const sentinel = ref(null);
+		const observer = shallowRef(null);
+		onServerPrefetch(async () => {
+			await listing.reload();
+		});
+		onBeforeMount(async () => {
+			if (listing.records.length === NO_RECORDS) await listing.reload();
+		});
+		onMounted(() => {
+			observer.value = new globalThis.IntersectionObserver((entries) => {
+				if (entries.some((entry) => entry.isIntersecting)) listing.loadMore();
+			}, { rootMargin: "200px" });
+			/* v8 ignore next */
+			if (sentinel.value !== null) observer.value.observe(sentinel.value);
+		});
+		onBeforeUnmount(() => {
+			observer.value?.disconnect();
+			observer.value = null;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [
+				createVNode(unref(DataTable), {
+					loading: isInitialLoading.value,
+					value: unref(listing).records,
+					class: "infinite-data-table",
+					lazy: "",
+					"show-gridlines": "",
+					size: "small",
+					"striped-rows": ""
+				}, {
+					empty: withCtx(() => [createTextVNode(toDisplayString(unref(messages).table.empty), 1)]),
+					loading: withCtx(() => [createTextVNode(toDisplayString(unref(messages).table.loading), 1)]),
+					default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(props.columns, (column, index) => {
+						return openBlock(), createBlock(unref(DataTableColumn), {
+							key: index,
+							field: column.field,
+							header: column.header,
+							class: "table-column"
+						}, {
+							body: withCtx((slotProps) => [(openBlock(), createBlock(resolveDynamicComponent(column.component), mergeProps({ ref_for: true }, { ...column.componentProps(slotProps.data) }), null, 16))]),
+							_: 2
+						}, 1032, ["field", "header"]);
+					}), 128))]),
+					_: 1
+				}, 8, ["loading", "value"]),
+				isLoadingMore.value ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(unref(messages).table.loadingMore), 1)) : createCommentVNode("", true),
+				createElementVNode("div", {
+					ref_key: "sentinel",
+					ref: sentinel,
+					class: "infinite-data-table__sentinel",
+					"aria-hidden": "true"
+				}, null, 512),
+				renderSlot(_ctx.$slots, "limit", {}, void 0, true)
+			], 64);
+		};
+	}
+});
+//#endregion
+export { InfiniteDataTable_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/table/SelectColumnFilter.js

@@ -0,0 +1,5 @@
+import SelectColumnFilter_vue_vue_type_script_setup_true_lang_default from "./SelectColumnFilter.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/table/SelectColumnFilter.vue
+var SelectColumnFilter_default = SelectColumnFilter_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { SelectColumnFilter_default as default };

package/dist/components/table/SelectColumnFilter.vue.d.ts

@@ -0,0 +1,29 @@
+import type { PropType } from 'vue';
+import type { SelectColumnFilterOptionInterface } from './select-column-filter-option.interface';
+declare const __VLS_export: import("*.vue").DefineComponent<import("vue").ExtractPropTypes<{
+    options: {
+        required: true;
+        type: PropType<SelectColumnFilterOptionInterface[]>;
+    };
+    placeholder: {
+        default: undefined;
+        type: StringConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:selected-value": (selected: SelectColumnFilterOptionInterface[]) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    options: {
+        required: true;
+        type: PropType<SelectColumnFilterOptionInterface[]>;
+    };
+    placeholder: {
+        default: undefined;
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    "onUpdate:selected-value"?: (selected: SelectColumnFilterOptionInterface[]) => any;
+}>, {
+    placeholder: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/table/SelectColumnFilter.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,58 @@
+import { useUiMessages } from "../../plugin/ui-injection.js";
+import MultiSelect_default from "../form/MultiSelect.js";
+import Tag_default from "../tag/Tag.js";
+import { createBlock, createElementBlock, defineComponent, openBlock, ref, toDisplayString, unref, withCtx } from "vue";
+//#region src/components/table/SelectColumnFilter.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 1,
+	class: "select-column-filter__option"
+};
+var SelectColumnFilter_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "SelectColumnFilter",
+	props: {
+		options: {
+			required: true,
+			type: Array
+		},
+		placeholder: {
+			default: void 0,
+			type: String
+		}
+	},
+	emits: ["update:selected-value"],
+	setup(__props, { emit: __emit }) {
+		const messages = useUiMessages();
+		const emit = __emit;
+		const selected = ref([]);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(MultiSelect_default, {
+				modelValue: selected.value,
+				"onUpdate:modelValue": [_cache[0] || (_cache[0] = ($event) => selected.value = $event), _cache[1] || (_cache[1] = ($event) => emit("update:selected-value", $event))],
+				options: __props.options,
+				placeholder: __props.placeholder ?? unref(messages).table.selectFilterPlaceholder,
+				class: "p-column-filter",
+				display: "chip",
+				"max-selected-labels": 2,
+				"option-label": "label"
+			}, {
+				option: withCtx(({ option }) => [option.severity !== void 0 ? (openBlock(), createBlock(Tag_default, {
+					key: 0,
+					icon: option.tagIcon,
+					severity: option.severity,
+					value: option.label
+				}, null, 8, [
+					"icon",
+					"severity",
+					"value"
+				])) : (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(option.label), 1))]),
+				_: 1
+			}, 8, [
+				"modelValue",
+				"options",
+				"placeholder"
+			]);
+		};
+	}
+});
+//#endregion
+export { SelectColumnFilter_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/table/StaticTable.js

@@ -0,0 +1,5 @@
+import StaticTable_vue_vue_type_script_setup_true_lang_default from "./StaticTable.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/table/StaticTable.vue
+var StaticTable_default = StaticTable_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { StaticTable_default as default };

package/dist/components/table/StaticTable.vue.d.ts

@@ -0,0 +1,39 @@
+import type { PropType, VNode } from 'vue';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<import("vue").ExtractPublicPropTypes<{
+        dataKey: {
+            default: undefined;
+            type: PropType<string | undefined>;
+        };
+        rows: {
+            required: boolean;
+            type: PropType<T[]>;
+        };
+        showGridlines: {
+            default: boolean;
+            type: BooleanConstructor;
+        };
+        stripedRows: {
+            default: boolean;
+            type: BooleanConstructor;
+        };
+    }>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => VNode[];
+        empty?: () => VNode[];
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/table/StaticTable.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,48 @@
+import { createBlock, createSlots, defineComponent, openBlock, renderSlot, unref, withCtx } from "vue";
+import DataTable from "openvue/datatable";
+//#region src/components/table/StaticTable.vue?vue&type=script&setup=true&lang.ts
+var StaticTable_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "StaticTable",
+	props: {
+		dataKey: {
+			default: void 0,
+			type: String
+		},
+		rows: {
+			required: true,
+			type: Array
+		},
+		showGridlines: {
+			default: false,
+			type: Boolean
+		},
+		stripedRows: {
+			default: false,
+			type: Boolean
+		}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(DataTable), {
+				"data-key": __props.dataKey,
+				"show-gridlines": __props.showGridlines,
+				"striped-rows": __props.stripedRows,
+				value: __props.rows
+			}, createSlots({
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 2
+			}, [_ctx.$slots.empty ? {
+				name: "empty",
+				fn: withCtx(() => [renderSlot(_ctx.$slots, "empty")]),
+				key: "0"
+			} : void 0]), 1032, [
+				"data-key",
+				"show-gridlines",
+				"striped-rows",
+				"value"
+			]);
+		};
+	}
+});
+//#endregion
+export { StaticTable_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/table/TextColumn.js

@@ -0,0 +1,5 @@
+import TextColumn_vue_vue_type_script_setup_true_lang_default from "./TextColumn.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/table/TextColumn.vue
+var TextColumn_default = TextColumn_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { TextColumn_default as default };

package/dist/components/table/TextColumn.vue.d.ts

@@ -0,0 +1,13 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        required: true;
+        type: StringConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        required: true;
+        type: StringConstructor;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/table/TextColumn.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,16 @@
+import { createElementBlock, defineComponent, openBlock, toDisplayString } from "vue";
+//#region src/components/table/TextColumn.vue?vue&type=script&setup=true&lang.ts
+var TextColumn_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "TextColumn",
+	props: { value: {
+		required: true,
+		type: String
+	} },
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", null, toDisplayString(__props.value), 1);
+		};
+	}
+});
+//#endregion
+export { TextColumn_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/table/collect-column-filters.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from 'vue';
+import type { ColumnFiltersInterface } from './column-filters-interface';
+import type { ColumnSchemaInterface } from './column-schema-interface';
+export declare const collectColumnFilters: <T>(columns: ColumnSchemaInterface<T, Component>[]) => ColumnFiltersInterface;