@fangzhongya/fang-ui 0.1.86 → 0.1.90

package/dist/components/labels/src/index.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1,97 @@
+const require_index = require("../../../hooks/cssname/index.cjs");
+const require_index$1 = require("../../../hooks/props-default/index.cjs");
+const require_use = require("../../common/use.cjs");
+const require_index$2 = require("../../selects/index.cjs");
+const require_index$3 = require("../../checks/index.cjs");
+const require_data = require("./data.cjs");
+let vue = require("vue");
+//#region packages/components/packages/subset/labels/src/index.vue?vue&type=script&setup=true&lang.ts
+var wholeClass = "labels-li-whole";
+var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ (0, vue.defineComponent)({
+	__name: "index",
+	props: require_index$1.getProps(require_data.dataProps),
+	emits: require_data.dataEmits,
+	setup(__props, { emit: __emit }) {
+		const cs = require_index.useCssName(require_data.name);
+		const prs = __props;
+		const props = require_index$1.usePropsDefault(require_data.name, prs, require_data.dataProps);
+		const emit = __emit;
+		const comps = (0, vue.computed)(() => {
+			if (props.select) return require_index$2.default;
+			else return require_index$3.default;
+		});
+		const listFuObj = require_data.dataHandle(props, emit);
+		const value = listFuObj.value;
+		const multiple = listFuObj.multiple;
+		function setPropsValue(obj, key, value, d) {
+			if (typeof key === "function") {
+				const k = key(obj) ?? d;
+				obj[k] = value;
+			} else if (typeof key == "string") obj[key] = value;
+			else obj[d] = value;
+		}
+		const wholeValue = props.whole;
+		const options = (0, vue.computed)(() => {
+			const opts = [...props.options];
+			if (props.isWhole) {
+				const obj = { class: wholeClass };
+				if (multiple.value) setPropsValue(obj, props.prop, wholeValue, "value");
+				else setPropsValue(obj, props.prop, props.whole, "value");
+				setPropsValue(obj, props.label, props.wholeName, "label");
+				opts.unshift(obj);
+			}
+			return opts;
+		});
+		const valueMultiple = (0, vue.computed)({
+			get() {
+				if (value.value !== void 0) if (value.value.length === props.options.filter((item) => {
+					if (item && typeof item === "object") return !item.disabled;
+					return true;
+				}).length) return [...value.value, wholeValue];
+				else return [...value.value];
+				else return [];
+			},
+			set(v) {
+				if (v.includes(wholeValue)) v = v.filter((item) => item !== wholeValue);
+				if (v.length !== (value.value?.length ?? 0)) value.value = [...v];
+			}
+		});
+		function onClickWholes(item, is) {
+			if (item?.class === wholeClass) if (valueMultiple.value.includes(wholeValue)) valueMultiple.value = [];
+			else {
+				const v = props.options;
+				props.options.filter((item) => {
+					if (item && typeof item === "object") return !item.disabled;
+					return true;
+				}).map((item) => {
+					return require_use.useVueValue(item, props.prop);
+				});
+				valueMultiple.value = [...v, wholeValue];
+			}
+			else if (!is) {
+				if (valueMultiple.value.includes(wholeValue)) valueMultiple.value = valueMultiple.value.filter((item) => item !== wholeValue);
+			}
+		}
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", { class: (0, vue.normalizeClass)([(0, vue.unref)(cs).z(), (0, vue.unref)(cs).is("compact", (0, vue.unref)(props).compact)]) }, [(0, vue.unref)(multiple) ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(comps.value), (0, vue.mergeProps)({ key: 0 }, (0, vue.unref)(props), {
+				class: [(0, vue.unref)(cs).z("whole")],
+				options: options.value,
+				modelValue: valueMultiple.value,
+				"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => valueMultiple.value = $event),
+				multiple: (0, vue.unref)(multiple),
+				onClickMultiple: onClickWholes
+			}), null, 16, [
+				"class",
+				"options",
+				"modelValue",
+				"multiple"
+			])) : ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(comps.value), (0, vue.mergeProps)({ key: 1 }, (0, vue.unref)(props), {
+				options: options.value,
+				modelValue: (0, vue.unref)(value),
+				"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => (0, vue.isRef)(value) ? value.value = $event : null)
+			}), null, 16, ["options", "modelValue"]))], 2);
+		};
+	}
+});
+//#endregion
+exports.default = index_vue_vue_type_script_setup_true_lang_default;

package/dist/components/labels/src/index.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,96 @@
+import { useCssName } from "../../../hooks/cssname/index.js";
+import { getProps, usePropsDefault } from "../../../hooks/props-default/index.js";
+import { useVueValue } from "../../common/use.js";
+import _default from "../../selects/index.js";
+import _default$1 from "../../checks/index.js";
+import { dataEmits, dataHandle, dataProps, name } from "./data.js";
+import { computed, createBlock, createElementBlock, defineComponent, isRef, mergeProps, normalizeClass, openBlock, resolveDynamicComponent, unref } from "vue";
+//#region packages/components/packages/subset/labels/src/index.vue?vue&type=script&setup=true&lang.ts
+var wholeClass = "labels-li-whole";
+var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "index",
+	props: getProps(dataProps),
+	emits: dataEmits,
+	setup(__props, { emit: __emit }) {
+		const cs = useCssName(name);
+		const props = usePropsDefault(name, __props, dataProps);
+		const emit = __emit;
+		const comps = computed(() => {
+			if (props.select) return _default;
+			else return _default$1;
+		});
+		const listFuObj = dataHandle(props, emit);
+		const value = listFuObj.value;
+		const multiple = listFuObj.multiple;
+		function setPropsValue(obj, key, value, d) {
+			if (typeof key === "function") {
+				const k = key(obj) ?? d;
+				obj[k] = value;
+			} else if (typeof key == "string") obj[key] = value;
+			else obj[d] = value;
+		}
+		const wholeValue = props.whole;
+		const options = computed(() => {
+			const opts = [...props.options];
+			if (props.isWhole) {
+				const obj = { class: wholeClass };
+				if (multiple.value) setPropsValue(obj, props.prop, wholeValue, "value");
+				else setPropsValue(obj, props.prop, props.whole, "value");
+				setPropsValue(obj, props.label, props.wholeName, "label");
+				opts.unshift(obj);
+			}
+			return opts;
+		});
+		const valueMultiple = computed({
+			get() {
+				if (value.value !== void 0) if (value.value.length === props.options.filter((item) => {
+					if (item && typeof item === "object") return !item.disabled;
+					return true;
+				}).length) return [...value.value, wholeValue];
+				else return [...value.value];
+				else return [];
+			},
+			set(v) {
+				if (v.includes(wholeValue)) v = v.filter((item) => item !== wholeValue);
+				if (v.length !== (value.value?.length ?? 0)) value.value = [...v];
+			}
+		});
+		function onClickWholes(item, is) {
+			if (item?.class === wholeClass) if (valueMultiple.value.includes(wholeValue)) valueMultiple.value = [];
+			else {
+				const v = props.options;
+				props.options.filter((item) => {
+					if (item && typeof item === "object") return !item.disabled;
+					return true;
+				}).map((item) => {
+					return useVueValue(item, props.prop);
+				});
+				valueMultiple.value = [...v, wholeValue];
+			}
+			else if (!is) {
+				if (valueMultiple.value.includes(wholeValue)) valueMultiple.value = valueMultiple.value.filter((item) => item !== wholeValue);
+			}
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass([unref(cs).z(), unref(cs).is("compact", unref(props).compact)]) }, [unref(multiple) ? (openBlock(), createBlock(resolveDynamicComponent(comps.value), mergeProps({ key: 0 }, unref(props), {
+				class: [unref(cs).z("whole")],
+				options: options.value,
+				modelValue: valueMultiple.value,
+				"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => valueMultiple.value = $event),
+				multiple: unref(multiple),
+				onClickMultiple: onClickWholes
+			}), null, 16, [
+				"class",
+				"options",
+				"modelValue",
+				"multiple"
+			])) : (openBlock(), createBlock(resolveDynamicComponent(comps.value), mergeProps({ key: 1 }, unref(props), {
+				options: options.value,
+				modelValue: unref(value),
+				"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(value) ? value.value = $event : null)
+			}), null, 16, ["options", "modelValue"]))], 2);
+		};
+	}
+});
+//#endregion
+export { index_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/list/index.cjs

@@ -1,9 +1,9 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
-require("./src/index.cjs");
-const withInstall = require("../../utils/vues/withInstall.cjs");
-const index_vue_vue_type_script_lang = require("./src/index2.cjs");
-const List = withInstall.withInstall(index_vue_vue_type_script_lang.default, "List");
+const require_index$1 = require("./src/index.cjs");
+//#region packages/components/packages/tableset/list/index.ts
+var _default = require_withInstall.withInstall(require_index$1.default, "List");
+var List = _default;
+//#endregion
 exports.List = List;
-exports.default = List;
+exports.default = _default;

package/dist/components/list/index.d.ts

@@ -1,5 +1,417 @@
-import { SFCWithInstall } from '../../utils/vues';
-import { DefineComponent } from 'vue';
-declare const List: SFCWithInstall<DefineComponent<{}, {}, any>>;
-export { List };
-export default List;
+import { SFCWithInstall } from '../../../utils/vues';
+import { DefineComponent, ExtractPropTypes, Component, VNode, RendererNode, RendererElement, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: SFCWithInstall<DefineComponent<ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    isCompons: {
+        type: BooleanConstructor;
+    };
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+    labelPosition: {
+        type: () => "left" | "top" | "right" | "center" | "auto";
+        default: string;
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    value: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    column: {
+        type: NumberConstructor;
+        default(): number;
+    };
+    colon: (StringConstructor | BooleanConstructor)[];
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    align: {
+        type: StringConstructor;
+    };
+    showOverflow: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    labelAlign: {
+        type: StringConstructor;
+    };
+    items: {
+        type: StringConstructor;
+    };
+    labelItems: {
+        type: StringConstructor;
+        default: string;
+    };
+    rowMaxHeight: {
+        type: StringConstructor;
+    };
+    lineClamp: {
+        type: NumberConstructor;
+    };
+    border: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    aliquots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    componSelected: BooleanConstructor;
+    emptyDisplay: {
+        type: StringConstructor;
+    };
+    isEmptyStr: {
+        type: BooleanConstructor;
+    };
+    interval: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalHorizon: {
+        type: StringConstructor;
+    };
+}>, {
+    renderValue: () => "" | VNode<RendererNode, RendererElement, {
+        [key: string]: any;
+    }>;
+    borderColor: ComputedRef<string>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, string[], string, PublicProps, Readonly< ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    isCompons: {
+        type: BooleanConstructor;
+    };
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+    labelPosition: {
+        type: () => "left" | "top" | "right" | "center" | "auto";
+        default: string;
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    value: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    column: {
+        type: NumberConstructor;
+        default(): number;
+    };
+    colon: (StringConstructor | BooleanConstructor)[];
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    align: {
+        type: StringConstructor;
+    };
+    showOverflow: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    labelAlign: {
+        type: StringConstructor;
+    };
+    items: {
+        type: StringConstructor;
+    };
+    labelItems: {
+        type: StringConstructor;
+        default: string;
+    };
+    rowMaxHeight: {
+        type: StringConstructor;
+    };
+    lineClamp: {
+        type: NumberConstructor;
+    };
+    border: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    aliquots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    componSelected: BooleanConstructor;
+    emptyDisplay: {
+        type: StringConstructor;
+    };
+    isEmptyStr: {
+        type: BooleanConstructor;
+    };
+    interval: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalHorizon: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}>, {
+    value: Record<string, any>;
+    options: Record<string, any>;
+    labelPosition: "top" | "left" | "right" | "center" | "auto";
+    compons: {
+        [key: string]: Component;
+    };
+    componSelected: boolean;
+    list: ListObj[];
+    isCompons: boolean;
+    column: number;
+    interval: string;
+    isEmptyStr: boolean;
+    labelItems: string;
+    aliquots: boolean;
+}, {}, {}, {}, never, ComponentProvideOptions, true, {}, any>>;
+export declare const List: SFCWithInstall<DefineComponent<ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    isCompons: {
+        type: BooleanConstructor;
+    };
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+    labelPosition: {
+        type: () => "left" | "top" | "right" | "center" | "auto";
+        default: string;
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    value: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    column: {
+        type: NumberConstructor;
+        default(): number;
+    };
+    colon: (StringConstructor | BooleanConstructor)[];
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    align: {
+        type: StringConstructor;
+    };
+    showOverflow: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    labelAlign: {
+        type: StringConstructor;
+    };
+    items: {
+        type: StringConstructor;
+    };
+    labelItems: {
+        type: StringConstructor;
+        default: string;
+    };
+    rowMaxHeight: {
+        type: StringConstructor;
+    };
+    lineClamp: {
+        type: NumberConstructor;
+    };
+    border: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    aliquots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    componSelected: BooleanConstructor;
+    emptyDisplay: {
+        type: StringConstructor;
+    };
+    isEmptyStr: {
+        type: BooleanConstructor;
+    };
+    interval: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalHorizon: {
+        type: StringConstructor;
+    };
+}>, {
+    renderValue: () => "" | VNode<RendererNode, RendererElement, {
+        [key: string]: any;
+    }>;
+    borderColor: ComputedRef<string>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, string[], string, PublicProps, Readonly< ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    isCompons: {
+        type: BooleanConstructor;
+    };
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+    labelPosition: {
+        type: () => "left" | "top" | "right" | "center" | "auto";
+        default: string;
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    value: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    column: {
+        type: NumberConstructor;
+        default(): number;
+    };
+    colon: (StringConstructor | BooleanConstructor)[];
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    align: {
+        type: StringConstructor;
+    };
+    showOverflow: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    labelAlign: {
+        type: StringConstructor;
+    };
+    items: {
+        type: StringConstructor;
+    };
+    labelItems: {
+        type: StringConstructor;
+        default: string;
+    };
+    rowMaxHeight: {
+        type: StringConstructor;
+    };
+    lineClamp: {
+        type: NumberConstructor;
+    };
+    border: {
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+    aliquots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    componSelected: BooleanConstructor;
+    emptyDisplay: {
+        type: StringConstructor;
+    };
+    isEmptyStr: {
+        type: BooleanConstructor;
+    };
+    interval: {
+        type: StringConstructor;
+        default: string;
+    };
+    intervalHorizon: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}>, {
+    value: Record<string, any>;
+    options: Record<string, any>;
+    labelPosition: "top" | "left" | "right" | "center" | "auto";
+    compons: {
+        [key: string]: Component;
+    };
+    componSelected: boolean;
+    list: ListObj[];
+    isCompons: boolean;
+    column: number;
+    interval: string;
+    isEmptyStr: boolean;
+    labelItems: string;
+    aliquots: boolean;
+}, {}, {}, {}, never, ComponentProvideOptions, true, {}, any>>;
+export default _default;

package/dist/components/list/index.js

@@ -1,9 +1,8 @@
-/* empty css                 */
-import "./src/index.js";
 import { withInstall } from "../../utils/vues/withInstall.js";
-import _sfc_main from "./src/index2.js";
-const List = withInstall(_sfc_main, "List");
-export {
-  List,
-  List as default
-};
+/* empty css                 */
+import src_default from "./src/index.js";
+//#region packages/components/packages/tableset/list/index.ts
+var _default = withInstall(src_default, "List");
+var List = _default;
+//#endregion
+export { List, _default as default };