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

package/dist/treeUtil-IUdRJ6Ws.js

@@ -0,0 +1,277 @@
+import { A as e, S as t, d as n, g as r, m as i, s as a, v as o, x as s, y as c } from "./foundation-Cawx37mp.js";
+import { t as l } from "./env-BeIzjQx7.js";
+`${l}`, `${l}`;
+var u = {
+	EXPAND_ACTION: [
+		!1,
+		"click",
+		"doubleClick"
+	],
+	JSON_KEY_SPLIT: "_SEMI_TREE_SPLIT_"
+}, d = .45;
+function f(e, t) {
+	return `${e}-${t}`;
+}
+function p(e) {
+	return !(0, i.default)(e) && !(0, o.default)(e);
+}
+function m(e, n, r, i = !1) {
+	let c = [], l = !!i, u = (0, a.default)(r, "key", "key"), d = (0, a.default)(r, "children", "children");
+	if ((0, o.default)(e)) return [];
+	function p(e, a = null) {
+		return e.map((m, h) => {
+			let g = f(a ? a.pos : "0", h), _ = m[u], v = {};
+			r && Object.entries((0, s.default)(r, "children")).forEach(([e, t]) => {
+				let n = m[t];
+				!(0, o.default)(n) && (v[e] = n);
+			});
+			let y = {
+				...(0, t.default)(m, [
+					"key",
+					"label",
+					"value",
+					"icon",
+					"disabled",
+					"isLeaf"
+				]),
+				...v,
+				parent: a,
+				pos: g,
+				children: null,
+				data: m,
+				_innerDataTag: !0,
+				isEnd: [...a ? a.isEnd : [], h === e.length - 1]
+			}, b = typeof i == "boolean";
+			return (!l || !b && i.has(_)) && c.push(y), y.children = n.has(_) && (!l || !b && i.has(_)) ? p(m[d] || [], y) : [], y;
+		});
+	}
+	return p(e), c;
+}
+function h(e) {
+	let t = [], n = (e, t, i, a) => {
+		let o = [...i, e], s = {
+			key: o.join(u.JSON_KEY_SPLIT),
+			label: e,
+			value: t
+		};
+		if ((0, r.default)(t)) {
+			let e = [];
+			Object.entries(t).forEach((t) => {
+				n(t[0], t[1], o, e);
+			}), s.children = e;
+		}
+		a.push(s);
+	};
+	return Object.entries(e).forEach((e) => n(e[0], e[1], [], t)), t;
+}
+function g(e, t, n) {
+	let r = (0, a.default)(n, "key", "key"), i = (0, a.default)(n, "children", "children"), o = (n, s, c) => {
+		let l = n ? n[i] : e, u = n ? f(c.pos, s) : "0";
+		if (n) {
+			let e = (0, a.default)(n, r, null);
+			t({
+				data: { ...n },
+				ind: s,
+				pos: u,
+				key: e === null ? u : e,
+				parentPos: c.node ? c.pos : null,
+				level: Number(c.level) + 1
+			});
+		}
+		l && l.forEach((e, t) => {
+			o(e, t, {
+				node: n,
+				pos: u,
+				level: c ? Number(c.level) + 1 : -1
+			});
+		});
+	};
+	o(null);
+}
+function _(e, t) {
+	let n = {}, r = {}, i = {}, o = {
+		posEntities: n,
+		keyEntities: r,
+		valueEntities: i
+	}, s = (0, a.default)(t, "value", "value");
+	return g(e, (e) => {
+		let { pos: t, key: o, parentPos: c } = e, l = { ...e }, u = (0, a.default)(l, `data.${s}`, null);
+		u !== null && (i[u] = o), n[t] = l, r[o] = l, l.parent = n[c], l.parent && (l.parent.children = l.parent.children || [], l.parent.children.push(l));
+	}, t), o;
+}
+function v(e, t, r = !1) {
+	if (!p(e)) return [];
+	if (!r && Array.isArray(e) ? e = e.length ? [e[0]] : [] : Array.isArray(e) || (e = [e]), (0, n.default)(t)) return e;
+	let i = [];
+	return e.forEach((e) => {
+		e in t ? i.push(t[e]) : e && i.push(e);
+	}), i;
+}
+function y(e, t, n = !0) {
+	let r = [], i = (e) => {
+		if (!e) return;
+		let { children: n } = e;
+		p(n) && n.forEach((e) => {
+			r.push(e.key), i(t[e.key]);
+		});
+	};
+	return e.forEach((e) => {
+		n && r.push(e), i(t[e]);
+	}), r;
+}
+function b(e, t, n = []) {
+	let r = [];
+	return e && e.forEach((e) => {
+		let i = t[e];
+		i && i.children && i.children.forEach((e) => {
+			(!n.length || !n.includes(e.key)) && r.push(e.key);
+		});
+	}), r;
+}
+function x(t, n, r = !0) {
+	let i = [];
+	return t.forEach((e) => {
+		n[e] && n[e].parent && i.push(n[e].parent.key);
+	}), b((0, e.default)(i), n, r ? [] : t);
+}
+function S(e, t, n = !0) {
+	let r = [], i = (e) => {
+		e.parent && (r.push(e.parent.key), i(e.parent));
+	};
+	return e.forEach((e) => {
+		t[e] && i(t[e]), n && r.push(e);
+	}), r;
+}
+function C(e, t) {
+	let n = {};
+	return e.forEach((e) => {
+		if (!t[e]) return;
+		let { level: r } = t[e];
+		n[r] ? n[r].push(e) : n[r] = [e];
+	}), n;
+}
+function w(e, t) {
+	let r = Array.isArray(e) ? e : [e], i = y(r, t, !0), a = /* @__PURE__ */ new Set([...i]), o = /* @__PURE__ */ new Set([]), s = [], l = C(r, t), u = (e) => {
+		let { key: n, parent: r, level: i } = e;
+		if (!r || s.includes(n)) return;
+		let c = x([n], t);
+		if (s = [...s, ...c], c.every((e) => a.has(e))) a.add(r.key), i - 1 in l && i ? l[i - 1].push(r.key) : l[i - 1] = [r.key];
+		else {
+			let e = S([n], t, !1);
+			o = /* @__PURE__ */ new Set([...o, ...e]);
+		}
+	};
+	for (; !(0, n.default)(l);) {
+		let e = (0, c.default)(Object.keys(l).map((e) => Number(e)));
+		l[e].forEach((e) => u(t[e])), delete l[e];
+	}
+	return {
+		checkedKeys: a,
+		halfCheckedKeys: o
+	};
+}
+function T(e = [], t, n = !0) {
+	if (Array.isArray(e) || (e = [e]), n) {
+		let n = S(e, t, !0);
+		return new Set(n);
+	}
+	return new Set(e);
+}
+function E(e, t, n, r) {
+	let i = v(e, r, n);
+	return new Set(S(i, t, !1));
+}
+function D(e, t, n, r) {
+	if (!n) return !0;
+	let i = n, a = t;
+	return typeof n == "boolean" && (i = (e, t) => {
+		let n = e.toLowerCase();
+		return t?.toString().toLowerCase().includes(n);
+	}), r && (a = t[r]), i(e, a, t);
+}
+function O(e) {
+	return Array.isArray(e) ? e : [e];
+}
+function k(e, t, n = !1, r) {
+	let i = [], a = new Set(e);
+	return n ? e.forEach((e) => {
+		t[e] && !p(t[e].children) && i.push(e), !t[e] && r && i.push(e);
+	}) : e.forEach((e) => {
+		if (!t[e]) {
+			r && i.push(e);
+			return;
+		}
+		let { parent: n } = t[e];
+		n && a.has(n.key) || i.push(e);
+	}), i;
+}
+function A(e, t, n) {
+	let r = [], i = (e) => {
+		n[e].children && n[e].children.forEach((e) => {
+			let { key: n } = e;
+			r.push(n), t.has(n) && i(n);
+		});
+	};
+	return i(e), r;
+}
+function j(e, t, n, r) {
+	let i = y([e], t, !0), a = t[e];
+	n = /* @__PURE__ */ new Set([...n, e]);
+	let o = (e) => {
+		if (!e.parent) return;
+		let { key: i } = e;
+		if (x([i], t).every((e) => n.has(e))) {
+			let t = e.parent;
+			n.add(t.key), o(t);
+		} else {
+			let e = S([i], t, !1);
+			r = /* @__PURE__ */ new Set([...r, ...e]);
+		}
+	};
+	return o(a), {
+		checkedKeys: /* @__PURE__ */ new Set([...n, ...i]),
+		halfCheckedKeys: r
+	};
+}
+function M(e, t, n, r) {
+	let i = y([e], t, !0), a = t[e];
+	i.forEach((e) => {
+		n.has(e) && n.delete(e), r.has(e) && r.delete(e);
+	});
+	let o = (e) => {
+		let i = e.parent;
+		if (!i || !n.has(i.key) && !r.has(i.key)) return;
+		let { key: a } = e, s = x([a], t).some((e) => n.has(e) || r.has(e)), c = S([a], t, !1);
+		s ? c.forEach((e) => {
+			n.has(e) && (n.delete(e), r.add(e));
+		}) : (n.has(i.key) && n.delete(i.key), r.has(i.key) && r.delete(i.key), o(i));
+	};
+	return a && o(a), {
+		checkedKeys: n,
+		halfCheckedKeys: r
+	};
+}
+function N(e, t) {
+	let n = (0, a.default)(t, "value", "value"), r = (0, a.default)(t, "key", "key");
+	return Array.isArray(e) ? e.map((e) => (0, a.default)(e, n, e[r])) : (0, a.default)(e, n, e[r]);
+}
+function P(e, t, n) {
+	return t && p(e) ? N(e, n) : e;
+}
+function F(e, t) {
+	let n = (0, a.default)(t, "disabled", "disabled"), { checkedKeys: r } = w(Object.keys(e).filter((t) => e[t].data[n]), e);
+	return r;
+}
+function I(e, t) {
+	let { clientY: n } = e, { top: r, bottom: i, height: a } = t.nodeInstance.getBoundingClientRect();
+	return n <= r + a * d ? -1 : +(n >= i - a * d);
+}
+function L(e, t) {
+	return y([e], t, !0);
+}
+function R(e, t) {
+	let n = e.split("-");
+	return t + Number(n[n.length - 1]);
+}
+//#endregion
+export { u as S, A as _, R as a, P as b, E as c, D as d, S as f, L as g, m as h, F as i, _ as l, v as m, j as n, I as o, y as p, M as r, T as s, w as t, h as u, N as v, O as x, k as y };

package/dist/typography/Numeral.vue.d.ts

@@ -0,0 +1,32 @@
+import { NumeralProps, TypographyContentSlots } from './types';
+type __VLS_Slots = TypographyContentSlots;
+declare const __VLS_base: import('vue').DefineComponent<NumeralProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    copy: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    expand: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<NumeralProps> & Readonly<{
+    onCopy?: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    onExpand?: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}>, {
+    component: import('./types').TypographyComponent;
+    copyable: boolean | import('./types').TypographyCopyableConfig;
+    delete: boolean;
+    disabled: boolean;
+    link: import('./types').TypographyLink;
+    mark: boolean;
+    size: import('./types').TypographySize;
+    strong: boolean;
+    type: import('./types').TypographyType;
+    underline: boolean;
+    code: boolean;
+    rule: import('./types').TypographyNumeralRule;
+    precision: number;
+    truncate: import('./types').TypographyTruncate;
+}, {}, {}, {}, 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/typography/Paragraph.vue.d.ts

@@ -0,0 +1,30 @@
+import { ParagraphProps, TypographyActionSlots } from './types';
+type __VLS_Slots = TypographyActionSlots;
+declare const __VLS_base: import('vue').DefineComponent<ParagraphProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    copy: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    expand: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<ParagraphProps> & Readonly<{
+    onCopy?: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    onExpand?: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}>, {
+    spacing: import('./types').TypographySpacing;
+    component: import('./types').TypographyComponent;
+    copyable: boolean | import('./types').TypographyCopyableConfig;
+    delete: boolean;
+    disabled: boolean;
+    ellipsis: boolean | import('./types').TypographyEllipsis;
+    link: import('./types').TypographyLink;
+    mark: boolean;
+    size: import('./types').TypographySize;
+    strong: boolean;
+    type: import('./types').TypographyType;
+    underline: boolean;
+}, {}, {}, {}, 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/typography/Text.vue.d.ts

@@ -0,0 +1,30 @@
+import { TextProps, TypographyContentSlots } from './types';
+type __VLS_Slots = TypographyContentSlots;
+declare const __VLS_base: import('vue').DefineComponent<TextProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    copy: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    expand: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<TextProps> & Readonly<{
+    onCopy?: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    onExpand?: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}>, {
+    component: import('./types').TypographyComponent;
+    copyable: boolean | import('./types').TypographyCopyableConfig;
+    delete: boolean;
+    disabled: boolean;
+    ellipsis: boolean | import('./types').TypographyEllipsis;
+    link: import('./types').TypographyLink;
+    mark: boolean;
+    size: import('./types').TypographySize;
+    strong: boolean;
+    type: import('./types').TypographyType;
+    underline: boolean;
+    code: boolean;
+}, {}, {}, {}, 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/typography/Title.vue.d.ts

@@ -0,0 +1,28 @@
+import { TitleProps, TypographyActionSlots } from './types';
+type __VLS_Slots = TypographyActionSlots;
+declare const __VLS_base: import('vue').DefineComponent<TitleProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    copy: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    expand: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<TitleProps> & Readonly<{
+    onCopy?: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    onExpand?: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}>, {
+    copyable: boolean | import('./types').TypographyCopyableConfig;
+    delete: boolean;
+    disabled: boolean;
+    ellipsis: boolean | import('./types').TypographyEllipsis;
+    link: import('./types').TypographyLink;
+    mark: boolean;
+    strong: boolean;
+    type: import('./types').TypographyType;
+    underline: boolean;
+    heading: import('./types').TypographyHeading;
+}, {}, {}, {}, 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/typography/Typography.vue.d.ts

@@ -0,0 +1,13 @@
+import { TypographyProps, TypographySlots } from './types';
+type __VLS_Slots = TypographySlots;
+declare const __VLS_base: import('vue').DefineComponent<TypographyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TypographyProps> & Readonly<{}>, {
+    component: import('./types').TypographyComponent;
+}, {}, {}, {}, 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/typography/TypographyBase.vue.d.ts

@@ -0,0 +1,40 @@
+import { VNodeChild } from 'vue';
+import { TypographyBaseProps, TypographyContentSlots, TypographyCopyableConfig, TypographyEllipsis, TypographyHeading, TypographySize } from './types';
+type __VLS_Props = TypographyBaseProps & {
+    code?: boolean;
+    headingTag?: `h${TypographyHeading}`;
+    heading?: TypographyHeading;
+    paragraph?: boolean;
+    content?: VNodeChild[];
+};
+type __VLS_Slots = TypographyContentSlots;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    copy: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    expand: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCopy?: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+    onExpand?: (expanded: boolean, event: MouseEvent | KeyboardEvent) => any;
+}>, {
+    spacing: import('./types').TypographySpacing;
+    component: import('./types').TypographyComponent;
+    copyable: boolean | TypographyCopyableConfig;
+    delete: boolean;
+    disabled: boolean;
+    ellipsis: boolean | TypographyEllipsis;
+    link: import('./types').TypographyLink;
+    mark: boolean;
+    size: TypographySize;
+    strong: boolean;
+    type: import('./types').TypographyType;
+    underline: boolean;
+    code: boolean;
+    paragraph: boolean;
+}, {}, {}, {}, 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/typography/TypographyCopyable.vue.d.ts

@@ -0,0 +1,29 @@
+import { TypographyCopyableConfig } from './types';
+type __VLS_Props = {
+    config: TypographyCopyableConfig;
+    content: string;
+};
+type __VLS_Slots = {
+    icon?: (props: {
+        copied: boolean;
+        copy: (event: MouseEvent | KeyboardEvent) => void;
+    }) => unknown;
+    copied?: () => unknown;
+};
+declare function copy(event: MouseEvent | KeyboardEvent): void;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    copy: typeof copy;
+    copied: import('vue').ShallowRef<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    copy: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCopy?: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => 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/typography/TypographyDecorations.d.ts

@@ -0,0 +1,34 @@
+import { PropType } from 'vue';
+import { TypographyLink } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    mark: BooleanConstructor;
+    code: BooleanConstructor;
+    underline: BooleanConstructor;
+    strong: BooleanConstructor;
+    delete: BooleanConstructor;
+    disabled: BooleanConstructor;
+    link: {
+        type: PropType<TypographyLink>;
+        default: boolean;
+    };
+}>, () => import('vue').VNodeArrayChildren, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    mark: BooleanConstructor;
+    code: BooleanConstructor;
+    underline: BooleanConstructor;
+    strong: BooleanConstructor;
+    delete: BooleanConstructor;
+    disabled: BooleanConstructor;
+    link: {
+        type: PropType<TypographyLink>;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    delete: boolean;
+    disabled: boolean;
+    link: TypographyLink;
+    mark: boolean;
+    strong: boolean;
+    underline: boolean;
+    code: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/typography/TypographyNodeRenderer.d.ts

@@ -0,0 +1,17 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: null;
+    };
+}>, () => string | number | boolean | void | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | import('vue').VNodeArrayChildren | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/typography/index.d.ts

@@ -0,0 +1,17 @@
+import { default as TypographyBase } from './Typography.vue';
+import { default as Numeral } from './Numeral.vue';
+import { default as Paragraph } from './Paragraph.vue';
+import { default as Text } from './Text.vue';
+import { default as Title } from './Title.vue';
+export type TypographyCompoundComponent = typeof TypographyBase & {
+    Text: typeof Text;
+    Title: typeof Title;
+    Paragraph: typeof Paragraph;
+    Numeral: typeof Numeral;
+};
+export declare const Typography: TypographyCompoundComponent;
+export { Numeral, Paragraph, Text, Title };
+export { DEFAULT_TYPOGRAPHY_LOCALE, EN_US_TYPOGRAPHY_LOCALE, typographyLocaleKey, } from './typography-locale';
+export { TYPOGRAPHY_HEADINGS, TYPOGRAPHY_NUMERAL_RULES, TYPOGRAPHY_SIZES, TYPOGRAPHY_SPACINGS, TYPOGRAPHY_TRUNCATE_MODES, TYPOGRAPHY_TYPES, TYPOGRAPHY_WEIGHTS, } from './types';
+export type { NumeralProps, ParagraphProps, TextProps, TitleProps, TypographyBaseProps, TypographyComponent, TypographyContentSlots, TypographyCopyableConfig, TypographyEllipsis, TypographyEmits, TypographyHeading, TypographyLink, TypographyLocale, TypographyNumeralRule, TypographyProps, TypographyShowTooltip, TypographySize, TypographySlots, TypographySpacing, TypographyTooltipOptions, TypographyTruncate, TypographyType, TypographyWeight, } from './types';
+export default Typography;

package/dist/typography/index.js

@@ -0,0 +1,2 @@
+import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m } from "../typography-DF8KwKuL.js";
+export { u as DEFAULT_TYPOGRAPHY_LOCALE, s as EN_US_TYPOGRAPHY_LOCALE, r as Numeral, n as Paragraph, c as TYPOGRAPHY_HEADINGS, d as TYPOGRAPHY_NUMERAL_RULES, a as TYPOGRAPHY_SIZES, e as TYPOGRAPHY_SPACINGS, l as TYPOGRAPHY_TRUNCATE_MODES, f as TYPOGRAPHY_TYPES, t as TYPOGRAPHY_WEIGHTS, m as Text, o as Title, p as Typography, p as default, i as typographyLocaleKey };

package/dist/typography/types.d.ts

@@ -0,0 +1,108 @@
+import { Component, CSSProperties, VNodeChild } from 'vue';
+export declare const TYPOGRAPHY_TYPES: readonly ["primary", "secondary", "danger", "warning", "success", "tertiary", "quaternary"];
+export declare const TYPOGRAPHY_SIZES: readonly ["normal", "small", "inherit"];
+export declare const TYPOGRAPHY_SPACINGS: readonly ["normal", "extended"];
+export declare const TYPOGRAPHY_HEADINGS: readonly [1, 2, 3, 4, 5, 6];
+export declare const TYPOGRAPHY_WEIGHTS: readonly ["light", "regular", "medium", "semibold", "bold", "default"];
+export declare const TYPOGRAPHY_NUMERAL_RULES: readonly ["text", "numbers", "bytes-decimal", "bytes-binary", "percentages", "exponential"];
+export declare const TYPOGRAPHY_TRUNCATE_MODES: readonly ["ceil", "floor", "round"];
+export type TypographyType = (typeof TYPOGRAPHY_TYPES)[number];
+export type TypographySize = (typeof TYPOGRAPHY_SIZES)[number];
+export type TypographySpacing = (typeof TYPOGRAPHY_SPACINGS)[number];
+export type TypographyHeading = (typeof TYPOGRAPHY_HEADINGS)[number];
+export type TypographyWeight = (typeof TYPOGRAPHY_WEIGHTS)[number] | number;
+export type TypographyNumeralRule = (typeof TYPOGRAPHY_NUMERAL_RULES)[number];
+export type TypographyTruncate = (typeof TYPOGRAPHY_TRUNCATE_MODES)[number];
+export type TypographyComponent = string | Component;
+export type TypographyLink = boolean | Record<string, unknown>;
+export interface TypographyLocale {
+    copy: string;
+    copied: string;
+    expand: string;
+    collapse: string;
+}
+export interface TypographyTooltipOptions {
+    className?: string;
+    style?: CSSProperties;
+    [key: string]: unknown;
+}
+export interface TypographyShowTooltip {
+    type?: 'tooltip' | 'popover' | (string & {});
+    opts?: TypographyTooltipOptions;
+}
+export interface TypographyEllipsis {
+    collapseText?: string;
+    collapsible?: boolean;
+    expandText?: string;
+    expandable?: boolean;
+    pos?: 'end' | 'middle';
+    rows?: number;
+    showTooltip?: boolean | TypographyShowTooltip;
+    suffix?: string;
+    onExpand?: (expanded: boolean, event: MouseEvent | KeyboardEvent) => void;
+}
+export interface TypographyCopyableConfig {
+    content?: string;
+    copyTip?: VNodeChild;
+    successTip?: VNodeChild;
+    icon?: VNodeChild | undefined;
+    duration?: number;
+    onCopy?: (event: MouseEvent | KeyboardEvent, content: string, result: boolean) => void;
+    render?: (copied: boolean, copy: (event: MouseEvent | KeyboardEvent) => void, config: TypographyCopyableConfig) => VNodeChild;
+}
+export interface TypographyBaseProps {
+    component?: TypographyComponent;
+    copyable?: boolean | TypographyCopyableConfig;
+    delete?: boolean;
+    disabled?: boolean;
+    ellipsis?: boolean | TypographyEllipsis;
+    icon?: VNodeChild;
+    link?: TypographyLink;
+    mark?: boolean;
+    size?: TypographySize;
+    spacing?: TypographySpacing;
+    strong?: boolean;
+    type?: TypographyType;
+    underline?: boolean;
+    weight?: TypographyWeight | undefined;
+}
+export interface TypographyProps {
+    component?: TypographyComponent;
+}
+export interface TypographySlots {
+    default?: () => unknown;
+}
+export interface TypographyActionSlots extends TypographySlots {
+    copyIcon?: (props: {
+        copied: boolean;
+        copy: (event: MouseEvent | KeyboardEvent) => void;
+    }) => unknown;
+    copied?: () => unknown;
+    tooltip?: (props: {
+        content: string;
+    }) => unknown;
+}
+export interface TypographyContentSlots extends TypographyActionSlots {
+    icon?: () => unknown;
+}
+export interface TextProps extends Omit<TypographyBaseProps, 'spacing' | 'weight'> {
+    code?: boolean;
+    weight?: number;
+}
+export interface TitleProps extends Omit<TypographyBaseProps, 'icon' | 'size' | 'spacing'> {
+    heading?: TypographyHeading;
+}
+export interface ParagraphProps extends Omit<TypographyBaseProps, 'icon' | 'weight'> {
+    spacing?: TypographySpacing;
+}
+export interface NumeralProps extends Omit<TypographyBaseProps, 'ellipsis' | 'spacing'> {
+    code?: boolean;
+    rule?: TypographyNumeralRule;
+    precision?: number;
+    truncate?: TypographyTruncate;
+    parser?: (value: string) => string;
+}
+export interface TypographyEmits {
+    copy: [event: MouseEvent | KeyboardEvent, content: string, result: boolean];
+    expand: [expanded: boolean, event: MouseEvent | KeyboardEvent];
+}

package/dist/typography/typography-locale.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey, MaybeRef } from 'vue';
+import { TypographyLocale } from './types';
+export declare const DEFAULT_TYPOGRAPHY_LOCALE: Readonly<TypographyLocale>;
+export declare const EN_US_TYPOGRAPHY_LOCALE: Readonly<TypographyLocale>;
+export declare const typographyLocaleKey: InjectionKey<MaybeRef<TypographyLocale>>;