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

package/dist/spin/types.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const SPIN_SIZES: readonly ["small", "middle", "large"];
+export type SpinSize = (typeof SPIN_SIZES)[number];
+export interface SpinProps {
+    childStyle?: StyleValue;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    delay?: number;
+    indicator?: VNodeChild;
+    size?: SpinSize;
+    spinning?: boolean;
+    style?: StyleValue;
+    tip?: VNodeChild;
+    wrapperClassName?: string;
+}
+export interface SpinSlots {
+    default?: () => VNodeChild;
+    indicator?: () => VNodeChild;
+    tip?: () => VNodeChild;
+}

package/dist/spin-D-1P0WMW.js

@@ -0,0 +1,9 @@
+import { t as e } from "./Spin-CuFLkqev.js";
+//#region src/spin/types.ts
+var t = [
+	"small",
+	"middle",
+	"large"
+], n = e;
+//#endregion
+export { t as n, n as t };

package/dist/src-DNBBthjO.js

@@ -0,0 +1,490 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, c = (n, r, o) => (o = n == null ? {} : e(i(n)), s(r || !n || !n.__esModule || !a.call(n, "default") ? t(o, "default", {
+	value: n,
+	enumerable: !0
+}) : o, n)), l = /* @__PURE__ */ c((/* @__PURE__ */ o(((e, t) => {
+	var n = 11, r = 1 / (n - 1), i = typeof Float32Array == "function";
+	function a(e, t) {
+		return 1 - 3 * t + 3 * e;
+	}
+	function o(e, t) {
+		return 3 * t - 6 * e;
+	}
+	function s(e) {
+		return 3 * e;
+	}
+	function c(e, t, n) {
+		return ((a(t, n) * e + o(t, n)) * e + s(t)) * e;
+	}
+	function l(e, t, n) {
+		return 3 * a(t, n) * e * e + 2 * o(t, n) * e + s(t);
+	}
+	function u(e, t, n, r, i) {
+		var a, o, s = 0;
+		do
+			o = t + (n - t) / 2, a = c(o, r, i) - e, a > 0 ? n = o : t = o;
+		while (Math.abs(a) > 1e-7 && ++s < 10);
+		return o;
+	}
+	function d(e, t, n, r) {
+		for (var i = 0; i < 4; ++i) {
+			var a = l(t, n, r);
+			if (a === 0) return t;
+			var o = c(t, n, r) - e;
+			t -= o / a;
+		}
+		return t;
+	}
+	function f(e) {
+		return e;
+	}
+	t.exports = function(e, t, a, o) {
+		if (!(0 <= e && e <= 1 && 0 <= a && a <= 1)) throw Error("bezier x values must be in [0, 1] range");
+		if (e === t && a === o) return f;
+		for (var s = i ? new Float32Array(n) : Array(n), p = 0; p < n; ++p) s[p] = c(p * r, e, a);
+		function m(t) {
+			for (var i = 0, o = 1, c = n - 1; o !== c && s[o] <= t; ++o) i += r;
+			--o;
+			var f = (t - s[o]) / (s[o + 1] - s[o]), p = i + f * r, m = l(p, e, a);
+			return m >= .001 ? d(t, p, e, a) : m === 0 ? p : u(t, i, i + r, e, a);
+		}
+		return function(e) {
+			return e === 0 ? 0 : e === 1 ? 1 : c(m(e), t, o);
+		};
+	};
+})))());
+function u(e, t, n) {
+	return Math.min(Math.max(e, t), n);
+}
+function d(e) {
+	let t = /\(([^)]+)\)/.exec(e);
+	return t ? t[1].split(",").map((e) => parseFloat(e)) : [];
+}
+function f(e = 1, t = .5) {
+	let n = u(e, 1, 10), r = u(t, .1, 2);
+	return (e) => e === 0 || e === 1 ? e : -n * 2 ** (10 * (e - 1)) * Math.sin((e - 1 - r / (Math.PI * 2) * Math.asin(1 / n)) * (Math.PI * 2) / r);
+}
+var p = (() => {
+	let e = [
+		"Quad",
+		"Cubic",
+		"Quart",
+		"Quint",
+		"Sine",
+		"Expo",
+		"Circ",
+		"Back",
+		"Elastic"
+	], t = {
+		In: [
+			[
+				.55,
+				.085,
+				.68,
+				.53
+			],
+			[
+				.55,
+				.055,
+				.675,
+				.19
+			],
+			[
+				.895,
+				.03,
+				.685,
+				.22
+			],
+			[
+				.755,
+				.05,
+				.855,
+				.06
+			],
+			[
+				.47,
+				0,
+				.745,
+				.715
+			],
+			[
+				.95,
+				.05,
+				.795,
+				.035
+			],
+			[
+				.6,
+				.04,
+				.98,
+				.335
+			],
+			[
+				.6,
+				-.28,
+				.735,
+				.045
+			],
+			f
+		],
+		Out: [
+			[
+				.25,
+				.46,
+				.45,
+				.94
+			],
+			[
+				.215,
+				.61,
+				.355,
+				1
+			],
+			[
+				.165,
+				.84,
+				.44,
+				1
+			],
+			[
+				.23,
+				1,
+				.32,
+				1
+			],
+			[
+				.39,
+				.575,
+				.565,
+				1
+			],
+			[
+				.19,
+				1,
+				.22,
+				1
+			],
+			[
+				.075,
+				.82,
+				.165,
+				1
+			],
+			[
+				.175,
+				.885,
+				.32,
+				1.275
+			],
+			(e, t) => (n) => 1 - f(e, t)(1 - n)
+		],
+		InOut: [
+			[
+				.455,
+				.03,
+				.515,
+				.955
+			],
+			[
+				.645,
+				.045,
+				.355,
+				1
+			],
+			[
+				.77,
+				0,
+				.175,
+				1
+			],
+			[
+				.86,
+				0,
+				.07,
+				1
+			],
+			[
+				.445,
+				.05,
+				.55,
+				.95
+			],
+			[
+				1,
+				0,
+				0,
+				1
+			],
+			[
+				.785,
+				.135,
+				.15,
+				.86
+			],
+			[
+				.68,
+				-.55,
+				.265,
+				1.55
+			],
+			(e, t) => (n) => n < .5 ? f(e, t)(n * 2) / 2 : 1 - f(e, t)(n * -2 + 2) / 2
+		]
+	}, n = { linear: [
+		.25,
+		.25,
+		.75,
+		.75
+	] };
+	for (let r of Object.keys(t)) t[r].forEach((t, i) => {
+		n["ease" + r + e[i]] = t;
+	});
+	return n;
+})();
+function m(e) {
+	if (typeof e == "function") return e;
+	e = !e || typeof e != "string" ? "linear" : e.trim();
+	let t = e.split("(")[0], n = d(e), r;
+	return t === "cubic-bezier" || t === "cubicBezier" ? (0, l.default)(...n.length ? n : p.linear) : ((!t || typeof t != "string" || typeof t == "string" && p[t] == null) && (t = "linear"), r = p[t], typeof r == "function" ? r(...n) : n.length ? (0, l.default)(...n) : (0, l.default)(...r));
+}
+//#endregion
+//#region bundled-foundation
+var h = class {
+	constructor() {
+		this._eventMap = /* @__PURE__ */ new Map();
+	}
+	on(e, t) {
+		return e && typeof t == "function" && (this._eventMap.has(e) || this._eventMap.set(e, []), this._eventMap.get(e).push(t)), this;
+	}
+	once(e, t) {
+		if (e && typeof t == "function") {
+			let n = (...r) => {
+				t(...r), this.off(e, n);
+			};
+			this.on(e, n);
+		}
+	}
+	off(e, t) {
+		if (e) {
+			if (typeof t == "function") {
+				let n = this._eventMap.get(e);
+				if (Array.isArray(n) && n.length) {
+					let e = -1;
+					for (; (e = n.findIndex((e) => e === t)) > -1;) n.splice(e, 1);
+				}
+			} else t ?? this._eventMap.delete(e);
+		}
+		return this;
+	}
+	emit(e, ...t) {
+		return this._eventMap.has(e) ? (this._eventMap.get(e).forEach((e) => e(...t)), !0) : !1;
+	}
+};
+//#endregion
+//#region bundled-foundation
+function g(e) {
+	return !!(e && typeof e == "object" && (e.duration > 0 || typeof e.easing == "string" || typeof e.easing == "function"));
+}
+//#endregion
+//#region bundled-foundation
+function _(e, t, n, r, i) {
+	for (let a of Object.keys(t)) {
+		let o = t[a], s = typeof o == "number" ? o : o.val;
+		if (!(typeof o == "object" && o.done)) {
+			if (g(o) && r && i && o.duration) {
+				if (o.duration + r <= i || s !== e[a]) return !1;
+			} else if (typeof n[a] == "number" && n[a] !== 0) return !1;
+			if (e[a] !== s) return !1;
+		}
+	}
+	return !0;
+}
+//#endregion
+//#region bundled-foundation
+function v(e) {
+	let t = {};
+	for (let n in e) Object.prototype.hasOwnProperty.call(e, n) && (t[n] = typeof e[n] == "number" ? e[n] : e[n].val);
+	return t;
+}
+//#endregion
+//#region bundled-foundation
+var y = [0, 0];
+function b(e, t, n, r, i, a, o) {
+	let s = n + (-i * (t - r) + -a * n) * e, c = t + s * e;
+	return Math.abs(s) < o && Math.abs(c - r) < o ? (y[0] = r, y[1] = 0, y) : (y[0] = c, y[1] = s, y);
+}
+//#endregion
+//#region bundled-foundation
+function x(e) {
+	let t = {}, n = e && Object.keys(e) || [];
+	for (let e of n) t[e] = 0;
+	return t;
+}
+//#endregion
+//#region bundled-foundation
+var S = {
+	...{
+		default: {
+			tension: 170,
+			friction: 26
+		},
+		gentle: {
+			tension: 120,
+			friction: 14
+		},
+		wobbly: {
+			tension: 180,
+			friction: 12
+		},
+		stiff: {
+			tension: 210,
+			friction: 20
+		},
+		slow: {
+			tension: 280,
+			friction: 60
+		},
+		molasses: {
+			tension: 280,
+			friction: 120
+		}
+	}.default,
+	precision: .01
+};
+function C(e, t = {}) {
+	if (g(t)) {
+		let e = m(t.easing), n = typeof t.duration == "number" && t.duration > 0 ? t.duration : 1e3;
+		t = {
+			...t,
+			easing: e,
+			duration: n
+		};
+	}
+	let n = {
+		...S,
+		...t,
+		done: !1
+	};
+	if (e && typeof e == "object" && "val" in e) {
+		if (g(e)) {
+			let n = m(e.easing), r = typeof e.duration == "number" && e.duration > 0 ? e.duration : parseInt(t.duration) || 1e3;
+			e = {
+				...e,
+				easing: n,
+				duration: r
+			};
+		}
+		n = {
+			...n,
+			...e
+		};
+	} else n = {
+		...n,
+		val: e
+	};
+	return n;
+}
+//#endregion
+//#region bundled-foundation
+var w = () => Date.now(), T = 1e3 / 60, E = class extends h {
+	constructor(e = {}, t = {}) {
+		super(), this._props = { ...e }, this._config = { ...t }, this.initStates();
+	}
+	_wrapConfig(e, t) {
+		t = t && typeof t == "object" ? t : this._config;
+		let n = {};
+		for (let r of Object.keys(e)) n[r] = C(e[r], t);
+		return n;
+	}
+	initStates(e, t) {
+		e = e && typeof e == "object" ? e : this._props, t = t && typeof t == "object" ? t : this._config;
+		let { from: n, to: r } = e;
+		if (this._from = {}, n && typeof n) for (let e of Object.keys(n)) this._from[e] = typeof n[e] == "object" && n[e].val ? n[e].val : n[e];
+		this._to = this._wrapConfig(r, t), this._delay = parseInt(t.delay) || 0;
+		let i = this._from && v(this._from) || v(this._to), a = x(i);
+		this._currentStyle = { ...i }, this._currentVelocity = { ...a }, this._lastIdealStyle = { ...i }, this._lastIdealVelocity = { ...a }, this.resetPlayStates(), this._frameCount = 0, this._prevTime = 0;
+	}
+	animate() {
+		this._timer ??= requestAnimationFrame((e) => {
+			let t = w();
+			if (_(this._currentStyle, this._to, this._currentVelocity, this._startedTime || t, t) || this._ended || this._stopped) {
+				this._wasAnimating && !this._ended && !this._stopped && (this._timer = setTimeout(() => {
+					clearTimeout(this._timer), this._timer = null, this._ended = !0, this.emit("rest", this.getCurrentStates());
+				}, T)), this.resetPlayStates();
+				return;
+			}
+			this._started || (this._started = !0, this.emit("start", this.getCurrentStates())), this._stopped = !1, this._paused = !1, this._wasAnimating = !0, this._startedTime === 0 && (this._startedTime = t);
+			let n = t, r = n - this._prevTime;
+			this._prevTime = n, n - this._startedTime < this._delay && (this._timer = null, this.animate());
+			let i = {}, a = {}, o = {}, s = {}, c = this._to && Object.keys(this._to) || [];
+			for (let e of c) {
+				let t = this._to[e];
+				this._accumulatedTime[e] = typeof this._accumulatedTime[e] == "number" ? this._accumulatedTime[e] + r : r;
+				let c = this._from[e] != null && typeof this._from[e] == "object" ? this._from[e].val : this._from[e], l = t.val;
+				if (typeof t == "number") o[e] = t, s[e] = 0, i[e] = t, a[e] = 0;
+				else {
+					let r = this._lastIdealStyle[e], u = this._lastIdealVelocity[e];
+					if (g(this._config) || g(t)) {
+						let { easing: a, duration: s } = t;
+						r = c + a((n - this._startedTime) / s) * (l - c), n >= this._startedTime + s && (r = l, t.done = !0), i[e] = r, o[e] = r;
+					} else if (l != null && l === this._currentStyle[e]) o[e] = l, s[e] = 0, i[e] = l, a[e] = 0;
+					else {
+						let n = (this._accumulatedTime[e] - Math.floor(this._accumulatedTime[e] / T) * T) / T, c = Math.floor(this._accumulatedTime[e] / T);
+						for (let e = 0; e < c; e++) [r, u] = b(T / 1e3, r, u, t.val, t.tension, t.friction, t.precision);
+						let [l, d] = b(T / 1e3, r, u, t.val, t.tension, t.friction, t.precision);
+						o[e] = r + (l - r) * n, s[e] = u + (d - u) * n, i[e] = r, a[e] = u, this._accumulatedTime[e] -= c * T;
+					}
+				}
+			}
+			this._timer = null, this._currentStyle = { ...o }, this._currentVelocity = { ...s }, this._lastIdealStyle = { ...i }, this._lastIdealVelocity = { ...a }, this._destroyed || (this.emit("frame", this.getCurrentStates()), this.animate());
+		});
+	}
+	start() {
+		this._prevTime = w(), this._startedTime = w(), this.animate();
+	}
+	end() {
+		this._ended || (this._ended = !0, this._currentStyle = this.getFinalStates(), this.emit("frame", this.getFinalStates()), this.emit("rest", this.getFinalStates())), this.destroy();
+	}
+	pause() {
+		this._paused || (this._pausedTime = w(), this._paused = !0, this.emit("pause", this.getCurrentStates()), this.destroy(), this._destroyed = !1);
+	}
+	resume() {
+		if (this._started && this._paused) {
+			let e = w() - this._pausedTime;
+			this._paused = !1, this._startedTime += e, this._prevTime += e, this._pausedTime = 0, this.emit("resume", this.getCurrentStates()), this.animate();
+		}
+	}
+	stop() {
+		this.destroy(), this._stopped || (this._stopped = !0, this.emit("stop", this.getInitialStates()), this.initStates());
+	}
+	destroy() {
+		cancelAnimationFrame(this._timer), clearTimeout(this._timer), this._timer = null, this._destroyed = !0;
+	}
+	resetPlayStates() {
+		this._started = !1, this._stopped = !1, this._ended = !1, this._paused = !1, this._destroyed = !1, this._timer = null, this._wasAnimating = !1, this._accumulatedTime = {}, this._startedTime = 0, this._pausedTime = 0;
+	}
+	reset() {
+		this.destroy(), this.initStates();
+	}
+	reverse() {
+		this.destroy();
+		let e = { ...this._props }, [t, n] = [e.to, e.from];
+		e.from = t, e.to = n, this._props = { ...e }, this.initStates();
+	}
+	getCurrentStates() {
+		return { ...this._currentStyle };
+	}
+	getInitialStates() {
+		return { ...v(this._props.from) };
+	}
+	getFinalStates() {
+		return { ...v(this._props.to) };
+	}
+};
+//#endregion
+export { o as n, c as r, E as t };

package/dist/steps/Step.vue.d.ts

@@ -0,0 +1,22 @@
+import { InternalStepProps, StepSlots, StepsStatus } from './types';
+type __VLS_Slots = StepSlots;
+declare const __VLS_base: import('vue').DefineComponent<InternalStepProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    keyDown: (event: KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<InternalStepProps> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+    onKeyDown?: (event: KeyboardEvent) => any;
+}>, {
+    size: import('./types').StepsSize | "";
+    done: boolean;
+    active: boolean;
+    status: StepsStatus;
+}, {}, {}, {}, 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/steps/Steps.vue.d.ts

@@ -0,0 +1,24 @@
+import { StepsProps, StepsSlots, StepsStatus, StepsType } from './types';
+type __VLS_Slots = StepsSlots;
+declare const __VLS_base: import('vue').DefineComponent<StepsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (current: number) => any;
+}, string, import('vue').PublicProps, Readonly<StepsProps> & Readonly<{
+    onChange?: (current: number) => any;
+}>, {
+    size: import('./types').StepsSize;
+    type: StepsType;
+    prefixCls: string;
+    initial: number;
+    direction: import('./types').StepsDirection;
+    status: StepsStatus;
+    current: number;
+    hasLine: 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/steps/StepsNodeRenderer.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: undefined;
+    };
+}>, () => string | number | boolean | void | import('vue').VNodeArrayChildren | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, 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/steps/index.d.ts

@@ -0,0 +1,9 @@
+import { DefineComponent } from 'vue';
+import { StepProps, StepsProps } from './types';
+export type StepsCompoundComponent = DefineComponent<StepsProps> & {
+    Step: DefineComponent<StepProps>;
+};
+export declare const Step: DefineComponent<StepProps>;
+export declare const Steps: StepsCompoundComponent;
+export default Steps;
+export type { StepEmits, StepProps, StepSlots, StepsDirection, StepsEmits, StepsProps, StepsSize, StepsSlots, StepsStatus, StepsType, } from './types';

package/dist/steps/index.js

@@ -0,0 +1,2 @@
+import { n as e, t } from "../steps-6p04q-Lz.js";
+export { t as Step, e as Steps, e as default };

package/dist/steps/steps-context.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { StepsType } from './types';
+export interface StepsContext {
+    type: ComputedRef<StepsType>;
+}
+export declare const stepsContextKey: InjectionKey<StepsContext>;

package/dist/steps/types.d.ts

@@ -0,0 +1,54 @@
+import { CSSProperties, HTMLAttributes, VNodeChild } from 'vue';
+export type StepsType = 'fill' | 'basic' | 'nav';
+export type StepsDirection = 'horizontal' | 'vertical';
+export type StepsStatus = 'wait' | 'process' | 'finish' | 'error' | 'warning';
+export type StepsSize = 'default' | 'small';
+export interface StepsProps {
+    ariaLabel?: string;
+    class?: HTMLAttributes['class'];
+    className?: string;
+    current?: number;
+    direction?: StepsDirection;
+    hasLine?: boolean;
+    initial?: number;
+    prefixCls?: string;
+    size?: StepsSize;
+    status?: StepsStatus;
+    style?: CSSProperties;
+    type?: StepsType;
+}
+export interface StepsEmits {
+    change: [current: number];
+}
+export interface StepsSlots {
+    default?: () => VNodeChild;
+}
+export interface StepProps {
+    ariaLabel?: string;
+    class?: HTMLAttributes['class'];
+    className?: string;
+    description?: VNodeChild;
+    icon?: VNodeChild;
+    role?: HTMLAttributes['role'];
+    status?: StepsStatus;
+    style?: CSSProperties;
+    title?: VNodeChild;
+}
+export interface StepEmits {
+    click: [event: MouseEvent];
+    keyDown: [event: KeyboardEvent];
+}
+export interface StepSlots {
+    description?: () => VNodeChild;
+    icon?: () => VNodeChild;
+    title?: () => VNodeChild;
+}
+export interface InternalStepProps extends StepProps {
+    active?: boolean;
+    done?: boolean;
+    index?: number;
+    onStepChange?: () => void;
+    size?: StepsSize | '';
+    stepNumber?: string;
+    total?: number;
+}