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

package/dist/skeleton-p61lfhoz.js

@@ -0,0 +1,302 @@
+import { Fragment as e, computed as t, createElementBlock as n, createVNode as r, defineComponent as i, mergeProps as a, normalizeClass as o, normalizeStyle as s, openBlock as c, renderList as l, renderSlot as u, unref as d, useAttrs as f } from "vue";
+//#region src/skeleton/SkeletonNodeRenderer.ts
+var p = i({
+	name: "SkeletonNodeRenderer",
+	props: { content: {
+		type: null,
+		default: void 0
+	} },
+	setup(e) {
+		return () => e.content;
+	}
+}), m = /* @__PURE__ */ i({
+	name: "Skeleton",
+	inheritAttrs: !1,
+	__name: "Skeleton",
+	props: {
+		active: {
+			type: Boolean,
+			default: !1
+		},
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		loading: {
+			type: Boolean,
+			default: !0
+		},
+		placeholder: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array
+		] },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(e) {
+		let t = e, i = f();
+		return (e, o) => t.loading ? (c(), n("div", a({ key: 0 }, d(i), {
+			class: [
+				"semi-skeleton",
+				t.active && "semi-skeleton-active",
+				t.class,
+				t.className
+			],
+			style: t.style,
+			"x-semi-prop": "placeholder"
+		}), [u(e.$slots, "placeholder", {}, () => [r(d(p), { content: t.placeholder }, null, 8, ["content"])])], 16)) : u(e.$slots, "default", {}, void 0, void 0, 1);
+	}
+}), h = /* @__PURE__ */ i({
+	name: "SkeletonAvatar",
+	inheritAttrs: !1,
+	__name: "SkeletonAvatar",
+	props: {
+		shape: { default: "circle" },
+		size: { default: "medium" },
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		prefixCls: { default: "semi-skeleton" },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(e) {
+		let t = e, r = f();
+		return (e, i) => (c(), n("div", a(d(r), {
+			class: [
+				`${t.prefixCls}-avatar`,
+				`${t.prefixCls}-avatar-${t.size}`,
+				`${t.prefixCls}-avatar-${t.shape}`,
+				t.class,
+				t.className
+			],
+			style: t.style
+		}), null, 16));
+	}
+}), g = /* @__PURE__ */ i({
+	name: "SkeletonButton",
+	inheritAttrs: !1,
+	__name: "SkeletonButton",
+	props: {
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		prefixCls: { default: "semi-skeleton" },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(e) {
+		let t = e, r = f();
+		return (e, i) => (c(), n("div", a(d(r), {
+			class: [
+				`${t.prefixCls}-button`,
+				t.class,
+				t.className
+			],
+			style: t.style
+		}), null, 16));
+	}
+}), _ = /* @__PURE__ */ i({
+	name: "SkeletonImage",
+	inheritAttrs: !1,
+	__name: "SkeletonImage",
+	props: {
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		prefixCls: { default: "semi-skeleton" },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(e) {
+		let t = e, r = f();
+		return (e, i) => (c(), n("div", a(d(r), {
+			class: [
+				`${t.prefixCls}-image`,
+				t.class,
+				t.className
+			],
+			style: t.style
+		}), null, 16));
+	}
+}), v = /* @__PURE__ */ i({
+	name: "SkeletonParagraph",
+	inheritAttrs: !1,
+	__name: "SkeletonParagraph",
+	props: {
+		rows: { default: 4 },
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		prefixCls: { default: "semi-skeleton" },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(r) {
+		let i = r, a = t(() => [...Array(i.rows).keys()]);
+		return (t, r) => (c(), n("ul", {
+			class: o([
+				`${i.prefixCls}-paragraph`,
+				i.class,
+				i.className
+			]),
+			style: s(i.style)
+		}, [(c(!0), n(e, null, l(a.value, (e) => (c(), n("li", { key: e }))), 128))], 6));
+	}
+}), y = /* @__PURE__ */ i({
+	name: "SkeletonTitle",
+	inheritAttrs: !1,
+	__name: "SkeletonTitle",
+	props: {
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		prefixCls: { default: "semi-skeleton" },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(e) {
+		let t = e, r = f();
+		return (e, i) => (c(), n("div", a(d(r), {
+			class: [
+				`${t.prefixCls}-title`,
+				t.class,
+				t.className
+			],
+			style: t.style
+		}), null, 16));
+	}
+}), b = [
+	"extra-extra-small",
+	"extra-small",
+	"small",
+	"default",
+	"medium",
+	"large",
+	"extra-large"
+], x = ["circle", "square"], S = h, C = g, w = _, T = v, E = y, D = Object.assign(m, {
+	Avatar: S,
+	Button: C,
+	Image: w,
+	Paragraph: T,
+	Title: E
+});
+//#endregion
+export { T as a, b as c, w as i, S as n, E as o, C as r, x as s, D as t };

package/dist/slider/Slider.vue.d.ts

@@ -0,0 +1,32 @@
+import { VNodeChild } from 'vue';
+import { SliderProps, SliderValue } from './types';
+declare const __VLS_export: import('vue').DefineComponent<SliderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: SliderValue) => any;
+    "update:modelValue": (value: SliderValue) => any;
+    "update:value": (value: SliderValue) => any;
+    afterChange: (value: SliderValue) => any;
+    mouseUp: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<SliderProps> & Readonly<{
+    onChange?: (value: SliderValue) => any;
+    "onUpdate:modelValue"?: (value: SliderValue) => any;
+    "onUpdate:value"?: (value: SliderValue) => any;
+    onAfterChange?: (value: SliderValue) => any;
+    onMouseUp?: (event: MouseEvent) => any;
+}>, {
+    disabled: boolean;
+    vertical: boolean;
+    range: boolean;
+    max: number;
+    min: number;
+    step: number;
+    showArrow: boolean;
+    included: boolean;
+    showBoundary: boolean;
+    showMarkLabel: boolean;
+    tipFormatter: ((value: string | number | boolean | null) => VNodeChild) | null;
+    tooltipOnMark: boolean;
+    tooltipVisible: boolean | undefined;
+    verticalReverse: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/slider/SliderFragment.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/slider/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineComponent } from 'vue';
+import { SliderProps } from './types';
+export declare const Slider: DefineComponent<SliderProps>;
+export type { SliderEmits, SliderHandleDot, SliderMarks, SliderProps, SliderState, SliderValue, } from './types';
+export default Slider;

package/dist/slider/index.js

@@ -0,0 +1,5 @@
+import { t as e } from "../Slider-w9sbxzBw.js";
+//#region src/slider/index.ts
+var t = e;
+//#endregion
+export { t as Slider, t as default };

package/dist/slider/types.d.ts

@@ -0,0 +1,57 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export type SliderValue = number | number[];
+export interface SliderHandleDot {
+    color?: string;
+    size?: string;
+}
+export type SliderMarks = Record<number, string>;
+export interface SliderProps {
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaValueText?: string;
+    className?: HTMLAttributes['class'];
+    defaultValue?: SliderValue;
+    disabled?: boolean;
+    getAriaValueText?: (value: number, index?: number) => string;
+    handleDot?: SliderHandleDot | [SliderHandleDot?, SliderHandleDot?];
+    included?: boolean;
+    marks?: SliderMarks;
+    max?: number;
+    min?: number;
+    modelValue?: SliderValue | undefined;
+    railStyle?: StyleValue;
+    range?: boolean;
+    showArrow?: boolean;
+    showBoundary?: boolean;
+    showMarkLabel?: boolean;
+    step?: number;
+    style?: StyleValue;
+    tipFormatter?: ((value: string | number | boolean | null) => VNodeChild) | null;
+    tooltipOnMark?: boolean;
+    tooltipVisible?: boolean | undefined;
+    value?: SliderValue | undefined;
+    vertical?: boolean;
+    verticalReverse?: boolean;
+}
+export interface SliderEmits {
+    afterChange: [value: SliderValue];
+    change: [value: SliderValue];
+    mouseUp: [event: MouseEvent];
+    'update:modelValue': [value: SliderValue];
+    'update:value': [value: SliderValue];
+}
+export interface SliderState {
+    currentValue: SliderValue;
+    min: number;
+    max: number;
+    focusPos: 'min' | 'max' | '';
+    onChange: ((value: SliderValue) => void) | undefined;
+    disabled: boolean;
+    chooseMovePos: 'min' | 'max' | '';
+    isDrag: boolean;
+    clickValue: 0;
+    showBoundary: boolean;
+    isInRenderTree: boolean;
+    firstDotFocusVisible: boolean;
+    secondDotFocusVisible: boolean;
+}

package/dist/slider/use-slider-foundation.d.ts

@@ -0,0 +1,47 @@
+import { ComputedRef, Ref } from 'vue';
+import { ConfigContextValue } from '../config-provider';
+import { SliderEmits, SliderProps, SliderState, SliderValue } from './types';
+interface UseSliderFoundationOptions {
+    config: ComputedRef<ConfigContextValue>;
+    emit: <Event extends keyof SliderEmits>(event: Event, ...args: SliderEmits[Event]) => void;
+    maxHandle: Ref<HTMLSpanElement | null>;
+    minHandle: Ref<HTMLSpanElement | null>;
+    props: Readonly<SliderProps>;
+    slider: Ref<HTMLDivElement | null>;
+}
+interface SliderFoundationController {
+    checkAndUpdateIsInRenderTreeState(): boolean;
+    computeHandleVisibleVal(visible: boolean | undefined, formatter: ((value: unknown) => unknown) | null | undefined, range: boolean): {
+        tipVisible: {
+            min: boolean;
+            max: boolean;
+        };
+        tipChildren: {
+            min: unknown;
+            max: unknown;
+        };
+    };
+    getMinAndMaxPercent(value: SliderValue): {
+        min: number;
+        max: number;
+    };
+    handleKeyDown(event: KeyboardEvent, handler: 'min' | 'max'): void;
+    handleWrapClick(event: MouseEvent): void;
+    handleWrapperEnter(): void;
+    handleWrapperLeave(): void;
+    isMarkActive(mark: number): 'active' | 'unActive' | false;
+    onBlur(event: FocusEvent, handler: 'min' | 'max'): void;
+    onFocus(event: FocusEvent, handler: 'min' | 'max'): void;
+    onHandleDown(event: MouseEvent, handler: 'min' | 'max'): boolean;
+    onHandleEnter(position: 'min' | 'max'): void;
+    onHandleLeave(): void;
+    onHandleTouchStart(event: TouchEvent, handler: 'min' | 'max'): void;
+    onHandleUp(event: MouseEvent | TouchEvent | KeyboardEvent): boolean;
+}
+interface UseSliderFoundationBinding {
+    controlled: ComputedRef<boolean>;
+    foundation: SliderFoundationController;
+    state: SliderState;
+}
+export declare function useSliderFoundation(options: UseSliderFoundationOptions): UseSliderFoundationBinding;
+export {};

package/dist/space/Space.vue.d.ts

@@ -0,0 +1,16 @@
+import { SpaceProps, SpaceSlots } from './types';
+type __VLS_Slots = SpaceSlots;
+declare const __VLS_base: import('vue').DefineComponent<SpaceProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SpaceProps> & Readonly<{}>, {
+    spacing: import('./types').SpaceSpacingValue;
+    wrap: boolean;
+    vertical: boolean;
+    align: import('./types').SpaceAlign;
+}, {}, {}, {}, 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/space/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Space } from './Space.vue';
+export { SPACE_ALIGNS, SPACE_SPACING_PRESETS } from './types';
+export type { SpaceAlign, SpaceProps, SpaceSlots, SpaceSpacing, SpaceSpacingPreset, SpaceSpacingValue, } from './types';

package/dist/space/index.js

@@ -0,0 +1,2 @@
+import { n as e, r as t, t as n } from "../space-DVnFbkCz.js";
+export { n as SPACE_ALIGNS, e as SPACE_SPACING_PRESETS, t as Space };

package/dist/space/types.d.ts

@@ -0,0 +1,15 @@
+export declare const SPACE_ALIGNS: readonly ["start", "center", "end", "baseline"];
+export declare const SPACE_SPACING_PRESETS: readonly ["tight", "medium", "loose"];
+export type SpaceAlign = (typeof SPACE_ALIGNS)[number];
+export type SpaceSpacingPreset = (typeof SPACE_SPACING_PRESETS)[number];
+export type SpaceSpacing = SpaceSpacingPreset | number;
+export type SpaceSpacingValue = SpaceSpacing | readonly SpaceSpacing[];
+export interface SpaceProps {
+    align?: SpaceAlign;
+    spacing?: SpaceSpacingValue;
+    vertical?: boolean;
+    wrap?: boolean;
+}
+export interface SpaceSlots {
+    default?: () => unknown;
+}

package/dist/space-DVnFbkCz.js

@@ -0,0 +1,63 @@
+import { computed as e, createElementBlock as t, defineComponent as n, mergeProps as r, openBlock as i, renderSlot as a, useAttrs as o } from "vue";
+//#endregion
+//#region src/space/Space.vue
+var s = /* @__PURE__ */ n({
+	name: "Space",
+	inheritAttrs: !1,
+	__name: "Space",
+	props: {
+		align: { default: "center" },
+		spacing: { default: "tight" },
+		vertical: {
+			type: Boolean,
+			default: !1
+		},
+		wrap: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	setup(n) {
+		let s = n, c = o(), l = e(() => {
+			let e = Array.isArray(s.spacing) ? s.spacing[0] : s.spacing, t = Array.isArray(s.spacing) ? s.spacing[1] : s.spacing, n = [];
+			return typeof e == "string" && n.push(`semi-space-${e}-horizontal`), typeof t == "string" && n.push(`semi-space-${t}-vertical`), n;
+		}), u = e(() => [
+			"semi-space",
+			`semi-space-align-${s.align}`,
+			s.vertical ? "semi-space-vertical" : "semi-space-horizontal",
+			s.wrap && !s.vertical ? "semi-space-wrap" : null,
+			...l.value,
+			c.class
+		]), d = e(() => {
+			if (typeof s.spacing == "number") {
+				let e = `${s.spacing}px`;
+				return {
+					columnGap: e,
+					rowGap: e
+				};
+			}
+			if (!Array.isArray(s.spacing)) return {};
+			let [e, t] = s.spacing;
+			return {
+				...typeof e == "number" ? { columnGap: `${e}px` } : {},
+				...typeof t == "number" ? { rowGap: `${t}px` } : {}
+			};
+		}), f = e(() => Object.fromEntries(Object.entries(c).filter(([e]) => !["class", "style"].includes(e)))), p = e(() => [c.style, d.value]);
+		return (e, n) => (i(), t("div", r(f.value, {
+			class: u.value,
+			style: p.value,
+			"x-semi-prop": "children"
+		}), [a(e.$slots, "default")], 16));
+	}
+}), c = [
+	"start",
+	"center",
+	"end",
+	"baseline"
+], l = [
+	"tight",
+	"medium",
+	"loose"
+];
+//#endregion
+export { l as n, s as r, c as t };

package/dist/spin/Spin.vue.d.ts

@@ -0,0 +1,105 @@
+import { PropType, VNodeChild } from 'vue';
+import { SpinProps, SpinSize, SpinSlots } from './types';
+type __VLS_Slots = SpinSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    childStyle: {
+        type: PropType<SpinProps["childStyle"]>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<SpinProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<SpinProps["className"]>;
+        default: undefined;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    indicator: {
+        type: PropType<SpinProps["indicator"]>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<SpinSize>;
+        default: undefined;
+    };
+    spinning: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<SpinProps["style"]>;
+        default: undefined;
+    };
+    tip: {
+        type: PropType<SpinProps["tip"]>;
+        default: undefined;
+    };
+    wrapperClassName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    childStyle: {
+        type: PropType<SpinProps["childStyle"]>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<SpinProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<SpinProps["className"]>;
+        default: undefined;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    indicator: {
+        type: PropType<SpinProps["indicator"]>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<SpinSize>;
+        default: undefined;
+    };
+    spinning: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<SpinProps["style"]>;
+        default: undefined;
+    };
+    tip: {
+        type: PropType<SpinProps["tip"]>;
+        default: undefined;
+    };
+    wrapperClassName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    size: "small" | "middle" | "large";
+    class: import('vue').ClassValue;
+    wrapperClassName: string;
+    childStyle: import('vue').StyleValue;
+    delay: number;
+    indicator: VNodeChild;
+    spinning: boolean;
+    tip: VNodeChild;
+}, {}, {}, {}, 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/spin/SpinNodeRenderer.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/spin/index.d.ts

@@ -0,0 +1,6 @@
+import { DefineComponent } from 'vue';
+import { SpinProps } from './types';
+export declare const Spin: DefineComponent<SpinProps>;
+export { SPIN_SIZES } from './types';
+export type { SpinProps, SpinSize, SpinSlots } from './types';
+export default Spin;

package/dist/spin/index.js

@@ -0,0 +1,2 @@
+import { n as e, t } from "../spin-D-1P0WMW.js";
+export { e as SPIN_SIZES, t as Spin, t as default };