@aifuxi/semi-ui-vue 0.1.0-alpha.0

package/dist/overflow-list/OverflowList.vue.d.ts

@@ -0,0 +1,131 @@
+import { PropType, StyleValue } from 'vue';
+import { OverflowItem, OverflowListCollapseFrom, OverflowListKey, OverflowListProps, OverflowListRenderDirection, OverflowListRenderMode, OverflowListSlots } from './types';
+type __VLS_Slots = OverflowListSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<readonly OverflowItem[]>;
+        default: undefined;
+    };
+    collapseFrom: {
+        type: PropType<OverflowListCollapseFrom>;
+        default: undefined;
+    };
+    minVisibleItems: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    renderMode: {
+        type: PropType<OverflowListRenderMode>;
+        default: undefined;
+    };
+    threshold: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    class: {
+        type: PropType<OverflowListProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<OverflowListProps["style"]>;
+        default: undefined;
+    };
+    wrapperClassName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    wrapperStyle: {
+        type: PropType<OverflowListProps["wrapperStyle"]>;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<OverflowListProps["itemKey"]>;
+        default: undefined;
+    };
+    overflowRenderDirection: {
+        type: PropType<OverflowListRenderDirection>;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    intersect: (entries: Record<string, IntersectionObserverEntry>) => any;
+    overflow: (items: OverflowItem[]) => any;
+    visibleStateChange: (visibleState: Map<string, boolean>) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<readonly OverflowItem[]>;
+        default: undefined;
+    };
+    collapseFrom: {
+        type: PropType<OverflowListCollapseFrom>;
+        default: undefined;
+    };
+    minVisibleItems: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    renderMode: {
+        type: PropType<OverflowListRenderMode>;
+        default: undefined;
+    };
+    threshold: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    class: {
+        type: PropType<OverflowListProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<OverflowListProps["style"]>;
+        default: undefined;
+    };
+    wrapperClassName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    wrapperStyle: {
+        type: PropType<OverflowListProps["wrapperStyle"]>;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<OverflowListProps["itemKey"]>;
+        default: undefined;
+    };
+    overflowRenderDirection: {
+        type: PropType<OverflowListRenderDirection>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onIntersect?: (entries: Record<string, IntersectionObserverEntry>) => any;
+    onOverflow?: (items: OverflowItem[]) => any;
+    onVisibleStateChange?: (visibleState: Map<string, boolean>) => any;
+}>, {
+    className: string;
+    style: StyleValue;
+    class: undefined;
+    wrapperStyle: StyleValue;
+    wrapperClassName: string;
+    itemKey: OverflowListKey | ((item: OverflowItem) => OverflowListKey) | undefined;
+    items: readonly OverflowItem[];
+    collapseFrom: OverflowListCollapseFrom;
+    minVisibleItems: number;
+    renderMode: OverflowListRenderMode;
+    threshold: number;
+    overflowRenderDirection: OverflowListRenderDirection;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/overflow-list/OverflowListNodeRenderer.d.ts

@@ -0,0 +1,35 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    scrollKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    setElement: {
+        type: PropType<(element: unknown) => void>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    scrollKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    setElement: {
+        type: PropType<(element: unknown) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+    setElement: (element: unknown) => void;
+    scrollKey: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/overflow-list/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineComponent } from 'vue';
+import { OverflowListProps } from './types';
+export declare const OverflowList: DefineComponent<OverflowListProps>;
+export default OverflowList;
+export type { OverflowItem, OverflowListCollapseFrom, OverflowListEmits, OverflowListKey, OverflowListProps, OverflowListRenderDirection, OverflowListRenderMode, OverflowListSlots, } from './types';

package/dist/overflow-list/index.js

@@ -0,0 +1,2 @@
+import { t as e } from "../overflow-list-Df6ixrtB.js";
+export { e as OverflowList, e as default };

package/dist/overflow-list/types.d.ts

@@ -0,0 +1,35 @@
+import { StyleValue, VNodeChild } from 'vue';
+export type OverflowListKey = string | number;
+export type OverflowListCollapseFrom = 'start' | 'end';
+export type OverflowListRenderMode = 'collapse' | 'scroll';
+export type OverflowListRenderDirection = 'both' | 'start' | 'end';
+export type OverflowItem = Record<string, unknown>;
+export interface OverflowListProps<Item extends OverflowItem = OverflowItem> {
+    items?: readonly Item[];
+    collapseFrom?: OverflowListCollapseFrom;
+    minVisibleItems?: number;
+    renderMode?: OverflowListRenderMode;
+    threshold?: number;
+    class?: unknown;
+    className?: string;
+    style?: StyleValue;
+    wrapperClassName?: string;
+    wrapperStyle?: StyleValue;
+    itemKey?: OverflowListKey | ((item: Item) => OverflowListKey);
+    overflowRenderDirection?: OverflowListRenderDirection;
+}
+export interface OverflowListSlots<Item extends OverflowItem = OverflowItem> {
+    visibleItem?: (scope: {
+        item: Item;
+        index: number;
+    }) => VNodeChild;
+    overflow?: (scope: {
+        items: readonly Item[];
+        position: OverflowListCollapseFrom;
+    }) => VNodeChild;
+}
+export interface OverflowListEmits<Item extends OverflowItem = OverflowItem> {
+    overflow: [items: Item[]];
+    intersect: [entries: Record<string, IntersectionObserverEntry>];
+    visibleStateChange: [visibleState: Map<string, boolean>];
+}

package/dist/overflow-list-Df6ixrtB.js

@@ -0,0 +1,413 @@
+import "./src-DNBBthjO.js";
+import { s as e, t } from "./foundation-Cawx37mp.js";
+import { t as n } from "./env-BeIzjQx7.js";
+import { n as r } from "./config-provider-VMfNNSF1.js";
+import { Fragment as i, cloneVNode as a, computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, createVNode as ee, defineComponent as d, getCurrentInstance as te, h as f, isVNode as p, markRaw as ne, nextTick as m, normalizeClass as h, normalizeStyle as g, onBeforeUnmount as _, onMounted as re, onUpdated as v, openBlock as y, renderList as ie, renderSlot as b, shallowReactive as ae, shallowRef as x, unref as S, useAttrs as oe, useSlots as se, watch as C } from "vue";
+n + "";
+var w = {
+	COLLAPSE: "collapse",
+	SCROLL: "scroll"
+}, T = {
+	START: "start",
+	END: "end"
+}, E = {
+	BOUNDARY_SET: Object.values(T),
+	POSITION_SET: ["vertical", "horizontal"],
+	MODE_SET: Object.values(w),
+	MODE_MAP: w,
+	BOUNDARY_MAP: T,
+	OVERFLOW_DIR: {
+		NONE: 0,
+		GROW: 1,
+		SHRINK: 2
+	}
+};
+//#endregion
+//#region ../foundation-integration/src/fast-copy.js
+function D(e) {
+	return Array.isArray(e) ? [...e] : e instanceof Map ? new Map(e) : e instanceof Set ? new Set(e) : e && typeof e == "object" ? { ...e } : e;
+}
+//#endregion
+//#region bundled-foundation
+var O = E.BOUNDARY_MAP;
+E.OVERFLOW_DIR;
+var ce = class extends t {
+	constructor(e) {
+		super({ ...e }), this.previousY = void 0, this.isScrollMode = () => {
+			let { renderMode: e } = this.getProps();
+			return e === "scroll";
+		}, this.getReversedItems = () => {
+			let { items: e } = this.getProps();
+			return D(e).reverse();
+		};
+	}
+	getOverflowItem() {
+		let { items: e } = this.getProps(), { visibleState: t, overflow: n, scrollOverflow: r } = this.getStates();
+		if (!this.isScrollMode()) return n;
+		if (!t || t.size === 0) return Array.isArray(r) && r.length === 2 ? r : [[], []];
+		let i = e.map(({ key: e }) => !!t.get(e)), a = i.indexOf(!0), o = i.lastIndexOf(!0);
+		if (a < 0 || o < 0) return Array.isArray(r) && r.length === 2 ? r : [[], []];
+		let s = [];
+		return s[0] = a >= 0 ? e.slice(0, a) : [], s[1] = o >= 0 ? e.slice(o + 1, e.length) : e.slice(), s;
+	}
+	_syncScrollOverflowCache(e) {
+		if (!this.isScrollMode()) return;
+		let { items: t } = this.getProps(), n = t.map(({ key: t }) => !!e.get(t)), r = n.indexOf(!0), i = n.lastIndexOf(!0);
+		if (r < 0 || i < 0) {
+			this._adapter.updateStates({ isScrollOverflowCalculating: !0 });
+			return;
+		}
+		let a = [];
+		a[0] = r >= 0 ? t.slice(0, r) : [], a[1] = i >= 0 ? t.slice(i + 1, t.length) : t.slice(), this._adapter.updateStates({
+			scrollOverflow: a,
+			isScrollOverflowCalculating: !1
+		});
+	}
+	handleIntersect(t) {
+		let n = D(this.getState("visibleState")), r = {};
+		t.forEach((t) => {
+			let i = (0, e.default)(t, "target.dataset.scrollkey"), a = t.isIntersecting;
+			r[i] = t, n.set(i, a);
+		});
+		let i = !1;
+		for (let e of n.values()) if (e) {
+			i = !0;
+			break;
+		}
+		let a = i, [o] = t, s = o.boundingClientRect.y;
+		if (!a && this.previousY !== void 0 && s !== this.previousY) {
+			this.previousY = s;
+			return;
+		}
+		this.previousY = s, this._adapter.updateVisibleState(n), this._syncScrollOverflowCache(n), this._adapter.notifyIntersect(r);
+	}
+	handleCollapseOverflow() {
+		let { minVisibleItems: e, collapseFrom: t } = this.getProps(), { overflowWidth: n, containerWidth: r, pivot: i, overflowStatus: a } = this.getStates(), { items: o, onOverflow: s } = this.getProps(), c = n, l = 0, u = !1;
+		for (let e of this._adapter.getItemSizeMap().values()) {
+			if (c += e, c > r) {
+				u = !0;
+				break;
+			}
+			if (l === o.length - 1) {
+				this._adapter.updateStates({
+					overflowStatus: "normal",
+					pivot: o.length - 1,
+					visible: o,
+					overflow: []
+				});
+				break;
+			}
+			l++;
+		}
+		if (u) {
+			let n = Math.max(e, l), r = t === O.START, a = r ? this.getReversedItems().slice(0, n).reverse() : o.slice(0, n), c = r ? this.getReversedItems().slice(n).reverse() : o.slice(n);
+			this._adapter.updateStates({
+				overflowStatus: "overflowed",
+				pivot: n,
+				visible: a,
+				overflow: c
+			}), i !== n && s(c);
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/overflow-list/OverflowListNodeRenderer.ts
+function k(e, t = []) {
+	if (Array.isArray(e)) for (let n of e) k(n, t);
+	else e != null && e !== !1 && t.push(e);
+	return t;
+}
+var A = d({
+	name: "OverflowListNodeRenderer",
+	inheritAttrs: !1,
+	props: {
+		content: {
+			type: null,
+			default: void 0
+		},
+		scrollKey: {
+			type: String,
+			default: void 0
+		},
+		setElement: {
+			type: Function,
+			default: void 0
+		}
+	},
+	setup(e) {
+		let t = te(), n = null;
+		function r() {
+			let r = t?.subTree.el, i = r instanceof Element ? r : null;
+			i !== n && (n = i, e.setElement?.(i));
+		}
+		return re(r), v(r), _(() => e.setElement?.(null)), () => {
+			let t = k(e.content);
+			return e.scrollKey === void 0 || e.setElement === void 0 ? f(i, null, t) : t.length === 1 && p(t[0]) && t[0].type !== i ? a(t[0], { "data-scrollkey": e.scrollKey }) : f("span", {
+				class: "semi-overflow-list-scroll-item",
+				"data-scrollkey": e.scrollKey
+			}, t);
+		};
+	}
+}), j = /* @__PURE__ */ d({
+	name: "OverflowList",
+	inheritAttrs: !1,
+	__name: "OverflowList",
+	props: {
+		items: {
+			type: Array,
+			default: void 0
+		},
+		collapseFrom: {
+			type: String,
+			default: void 0
+		},
+		minVisibleItems: {
+			type: Number,
+			default: void 0
+		},
+		renderMode: {
+			type: String,
+			default: void 0
+		},
+		threshold: {
+			type: Number,
+			default: void 0
+		},
+		class: {
+			type: null,
+			default: void 0
+		},
+		className: {
+			type: String,
+			default: void 0
+		},
+		style: {
+			type: null,
+			default: void 0
+		},
+		wrapperClassName: {
+			type: String,
+			default: void 0
+		},
+		wrapperStyle: {
+			type: null,
+			default: void 0
+		},
+		itemKey: {
+			type: [
+				String,
+				Number,
+				Function
+			],
+			default: void 0
+		},
+		overflowRenderDirection: {
+			type: String,
+			default: void 0
+		}
+	},
+	emits: [
+		"overflow",
+		"intersect",
+		"visibleStateChange"
+	],
+	setup(e, { emit: t }) {
+		let n = e, a = t, d = oe(), f = se(), p = te();
+		function v(e) {
+			let t = p?.vnode.props, n = String(e).replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`);
+			return !!(t && (Object.prototype.hasOwnProperty.call(t, e) || Object.prototype.hasOwnProperty.call(t, n)));
+		}
+		function w(e, t) {
+			if (v(e) && n[e] !== void 0) return n[e];
+			let i = r.config.overrideDefaultProps?.OverflowList?.[e];
+			return i === void 0 ? t : i;
+		}
+		let T = o(() => w("items", [])), E = o(() => w("collapseFrom", "end")), D = o(() => w("minVisibleItems", 0)), O = o(() => w("renderMode", "collapse")), k = o(() => w("threshold", .75)), j = o(() => w("overflowRenderDirection", "both")), M = ae({
+			visibleState: /* @__PURE__ */ new Map(),
+			visible: [...T.value],
+			overflow: [],
+			containerWidth: 0,
+			overflowWidth: 0,
+			overflowStatus: "calculating",
+			pivot: -1,
+			scrollOverflow: [[], []],
+			isScrollOverflowCalculating: !0
+		}), N = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map();
+		function le() {
+			return {
+				items: T.value,
+				collapseFrom: E.value,
+				minVisibleItems: D.value,
+				renderMode: O.value,
+				threshold: k.value,
+				overflowRenderDirection: j.value,
+				onOverflow: (e) => a("overflow", [...e])
+			};
+		}
+		let F = ne(new ce({
+			getContext: () => void 0,
+			getContexts: () => void 0,
+			getProp: (e) => le()[e],
+			getProps: le,
+			getState: (e) => M[e],
+			getStates: () => M,
+			setState: (e, t) => {
+				Object.assign(M, e), t?.();
+			},
+			getCache: (e) => N.get(e),
+			getCaches: () => N,
+			setCache: (e, t) => (N.set(e, t), t),
+			stopPropagation: (e) => e?.stopPropagation?.(),
+			persistEvent: () => void 0,
+			updateStates: (e) => Object.assign(M, e),
+			updateVisibleState: (e) => {
+				M.visibleState = e, a("visibleStateChange", new Map(e));
+			},
+			notifyIntersect: (e) => a("intersect", e),
+			getItemSizeMap: () => P
+		})), I = x(), L = x(), R = x(), z = /* @__PURE__ */ new Map(), B = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Map(), H = /* @__PURE__ */ new Map(), U, W, G, K = !1, q = !1;
+		function J(e, t) {
+			if (typeof n.itemKey == "function") return n.itemKey(e);
+			let r = n.itemKey ?? "key", i = e[String(r)];
+			return typeof i == "string" || typeof i == "number" ? i : t;
+		}
+		function Y(e) {
+			return e instanceof HTMLElement ? e.clientWidth : 0;
+		}
+		function ue() {
+			if (q = !1, !(!K || O.value !== "collapse")) {
+				M.containerWidth = Y(I.value), M.overflowWidth = Y(L.value);
+				for (let [e, t] of z) P.set(e, Y(t));
+				P.size < M.visible.length || M.containerWidth <= 0 || F.handleCollapseOverflow();
+			}
+		}
+		function X() {
+			q || (q = !0, m(ue));
+		}
+		function de(e, t) {
+			let n = z.get(e);
+			t !== n && (n && W?.unobserve(n), t instanceof HTMLElement ? (z.set(e, t), W?.observe(t)) : z.delete(e), X());
+		}
+		function fe(e, t) {
+			let n = B.get(e);
+			t !== n && (n && G?.unobserve(n), t instanceof Element ? (B.set(e, t), G?.observe(t)) : B.delete(e));
+		}
+		function pe(e) {
+			let t = V.get(e);
+			return t || (t = (t) => de(e, t), V.set(e, t)), t;
+		}
+		function me(e) {
+			let t = H.get(e);
+			return t || (t = (t) => fe(e, t), H.set(e, t)), t;
+		}
+		function Z() {
+			G?.disconnect(), G = void 0, !(!K || O.value !== "scroll" || !R.value || typeof IntersectionObserver > "u") && (G = new IntersectionObserver((e) => F.handleIntersect(e), {
+				root: R.value,
+				threshold: k.value,
+				rootMargin: "0px"
+			}), B.forEach((e) => G?.observe(e)));
+		}
+		function he() {
+			let e = [...T.value];
+			P.clear(), z.clear(), M.visibleState = /* @__PURE__ */ new Map(), M.overflowStatus = "calculating", M.isScrollOverflowCalculating = !0, O.value, M.visible = e, M.overflow = [], m(() => {
+				Z(), X();
+			});
+		}
+		C(() => T.value.map((e, t) => J(e, t)), he, { deep: !0 }), C([O, k], he), C(() => n.style, () => {
+			M.overflowStatus = "calculating", X();
+		}, { deep: !0 });
+		let ge = o(() => F.getOverflowItem()), _e = o(() => ge.value), Q = o(() => ge.value), $ = o(() => f.overflow?.({
+			items: _e.value,
+			position: E.value
+		})), ve = o(() => {
+			let e = $.value;
+			return Array.isArray(e) ? e.some((e) => e != null && e !== !1) : e != null && e !== !1;
+		}), ye = o(() => [
+			"semi-overflow-list",
+			n.class,
+			n.className,
+			d.class
+		]), be = o(() => [
+			n.style,
+			d.style,
+			O.value === "collapse" ? {
+				maxWidth: "100%",
+				visibility: M.overflowStatus === "calculating" && M.pivot < 0 ? "hidden" : "visible"
+			} : void 0
+		]);
+		return re(() => {
+			K = !0, F.init(), typeof ResizeObserver < "u" && (U = new ResizeObserver(() => {
+				M.overflowStatus = "calculating", X();
+			}), W = new ResizeObserver(() => {
+				M.overflowStatus = "calculating", X();
+			}), I.value && U.observe(I.value), z.forEach((e) => W?.observe(e)), L.value && W.observe(L.value)), Z(), X();
+		}), C(L, (e, t) => {
+			t && W?.unobserve(t), e && W?.observe(e), X();
+		}), C(R, () => void m(Z)), _(() => {
+			K = !1, U?.disconnect(), W?.disconnect(), G?.disconnect(), F.destroy();
+		}), (t, n) => (y(), l("div", {
+			ref_key: "root",
+			ref: I,
+			class: h(ye.value),
+			style: g(be.value)
+		}, [O.value === "scroll" ? (y(), l(i, { key: 0 }, [
+			j.value === "both" || j.value === "start" ? (y(), l(i, { key: 0 }, [b(t.$slots, "overflow", {
+				items: Q.value[0],
+				position: "start"
+			}), j.value === "start" ? b(t.$slots, "overflow", {
+				items: Q.value[1],
+				position: "end"
+			}, void 0, void 0, 0) : c("", !0)], 64)) : c("", !0),
+			u("div", {
+				ref_key: "scroller",
+				ref: R,
+				class: h([e.wrapperClassName, "semi-overflow-list-scroll-wrapper"]),
+				style: g(e.wrapperStyle)
+			}, [(y(!0), l(i, null, ie(S(M).visible, (e, t) => (y(), s(S(A), {
+				key: J(e, t),
+				content: S(f).visibleItem?.({
+					item: e,
+					index: t
+				}),
+				"scroll-key": String(J(e, t)),
+				"set-element": me(String(J(e, t)))
+			}, null, 8, [
+				"content",
+				"scroll-key",
+				"set-element"
+			]))), 128))], 6),
+			j.value === "both" || j.value === "end" ? (y(), l(i, { key: 1 }, [j.value === "end" ? b(t.$slots, "overflow", {
+				items: Q.value[0],
+				position: "start"
+			}, void 0, void 0, 0) : c("", !0), b(t.$slots, "overflow", {
+				items: Q.value[1],
+				position: "end"
+			})], 64)) : c("", !0)
+		], 64)) : (y(), l(i, { key: 1 }, [
+			E.value === "start" && ve.value ? (y(), l("div", {
+				key: 0,
+				ref_key: "overflowElement",
+				ref: L,
+				class: "semi-overflow-list-overflow"
+			}, [ee(S(A), { content: $.value }, null, 8, ["content"])], 512)) : c("", !0),
+			(y(!0), l(i, null, ie(S(M).visible, (e, n) => (y(), l("div", {
+				key: J(e, n),
+				ref_for: !0,
+				ref: pe(J(e, n)),
+				class: "semi-overflow-list-item"
+			}, [b(t.$slots, "visibleItem", {
+				item: e,
+				index: n
+			})]))), 128)),
+			E.value === "end" && ve.value ? (y(), l("div", {
+				key: 1,
+				ref_key: "overflowElement",
+				ref: L,
+				class: "semi-overflow-list-overflow"
+			}, [ee(S(A), { content: $.value }, null, 8, ["content"])], 512)) : c("", !0)
+		], 64))], 6));
+	}
+});
+//#endregion
+export { j as t };

package/dist/pagination/Pagination.vue.d.ts

@@ -0,0 +1,25 @@
+import { PaginationProps, PaginationSlots } from './types';
+type __VLS_Slots = PaginationSlots;
+declare const __VLS_base: import('vue').DefineComponent<PaginationProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (currentPage: number, pageSize: number) => any;
+    "update:modelValue": (currentPage: number) => any;
+    pageChange: (currentPage: number) => any;
+    pageSizeChange: (pageSize: number) => any;
+    "update:currentPage": (currentPage: number) => any;
+    "update:pageSize": (pageSize: number) => any;
+}, string, import('vue').PublicProps, Readonly<PaginationProps> & Readonly<{
+    onChange?: (currentPage: number, pageSize: number) => any;
+    "onUpdate:modelValue"?: (currentPage: number) => any;
+    onPageChange?: (currentPage: number) => any;
+    onPageSizeChange?: (pageSize: number) => any;
+    "onUpdate:currentPage"?: (currentPage: number) => any;
+    "onUpdate:pageSize"?: (pageSize: number) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/pagination/PaginationNodeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/pagination/PaginationPopover.vue.d.ts

@@ -0,0 +1,25 @@
+import { TooltipPosition } from '../tooltip';
+type __VLS_Props = {
+    position?: TooltipPosition;
+    rePosKey?: number | undefined;
+    zIndex?: number;
+};
+declare var __VLS_8: {}, __VLS_11: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+} & {
+    content?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    position: TooltipPosition;
+    zIndex: number;
+    rePosKey: number | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};