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

package/dist/timeline/Timeline.vue.d.ts

@@ -0,0 +1,69 @@
+import { PropType } from 'vue';
+import { TimelineData, TimelineMode, TimelineProps, TimelineSlots } from './types';
+type __VLS_Slots = TimelineSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: PropType<TimelineProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<TimelineProps["className"]>;
+        default: undefined;
+    };
+    dataSource: {
+        type: PropType<readonly TimelineData[]>;
+        default: undefined;
+    };
+    mode: {
+        type: PropType<TimelineMode>;
+        default: string;
+    };
+    style: {
+        type: PropType<TimelineProps["style"]>;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: PropType<TimelineProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<TimelineProps["className"]>;
+        default: undefined;
+    };
+    dataSource: {
+        type: PropType<readonly TimelineData[]>;
+        default: undefined;
+    };
+    mode: {
+        type: PropType<TimelineMode>;
+        default: string;
+    };
+    style: {
+        type: PropType<TimelineProps["style"]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    class: import('vue').ClassValue;
+    mode: "center" | "alternate" | "left" | "right";
+    ariaLabel: string;
+    dataSource: readonly TimelineData[];
+}, {}, {}, {}, 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/timeline/TimelineItem.vue.d.ts

@@ -0,0 +1,100 @@
+import { PropType, VNodeChild } from 'vue';
+import { TimelineItemProps, TimelineItemSlots, TimelineItemType } from './types';
+type __VLS_Slots = TimelineItemSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<TimelineItemProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<TimelineItemProps["className"]>;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    dot: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    extra: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    position: {
+        type: PropType<TimelineItemProps["position"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<TimelineItemProps["style"]>;
+        default: undefined;
+    };
+    time: {
+        type: PropType<VNodeChild>;
+        default: string;
+    };
+    type: {
+        type: PropType<TimelineItemType>;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<TimelineItemProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<TimelineItemProps["className"]>;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    dot: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    extra: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    position: {
+        type: PropType<TimelineItemProps["position"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<TimelineItemProps["style"]>;
+        default: undefined;
+    };
+    time: {
+        type: PropType<VNodeChild>;
+        default: string;
+    };
+    type: {
+        type: PropType<TimelineItemType>;
+        default: string;
+    };
+}>> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+}>, {
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    type: "warning" | "success" | "default" | "error" | "ongoing";
+    class: import('vue').ClassValue;
+    time: VNodeChild;
+    color: string;
+    position: "left" | "right" | undefined;
+    dot: VNodeChild;
+    extra: 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/timeline/TimelineNodeRenderer.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/timeline/index.d.ts

@@ -0,0 +1,10 @@
+import { DefineComponent } from 'vue';
+import { TimelineItemProps, TimelineProps } from './types';
+export type TimelineCompoundComponent = DefineComponent<TimelineProps> & {
+    Item: DefineComponent<TimelineItemProps>;
+};
+export declare const TimelineItem: DefineComponent<TimelineItemProps>;
+export declare const Timeline: TimelineCompoundComponent;
+export { TIMELINE_ITEM_POSITIONS, TIMELINE_ITEM_TYPES, TIMELINE_MODES } from './types';
+export type { TimelineData, TimelineItemEmits, TimelineItemPosition, TimelineItemProps, TimelineItemSlots, TimelineItemType, TimelineMode, TimelineProps, TimelineSlots, } from './types';
+export default Timeline;

package/dist/timeline/index.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, r, t as i } from "../timeline-2D5xCZsU.js";
+export { r as TIMELINE_ITEM_POSITIONS, t as TIMELINE_ITEM_TYPES, e as TIMELINE_MODES, i as Timeline, i as default, n as TimelineItem };

package/dist/timeline/types.d.ts

@@ -0,0 +1,43 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const TIMELINE_MODES: readonly ["left", "right", "center", "alternate"];
+export declare const TIMELINE_ITEM_POSITIONS: readonly ["left", "right"];
+export declare const TIMELINE_ITEM_TYPES: readonly ["default", "ongoing", "success", "warning", "error"];
+export type TimelineMode = (typeof TIMELINE_MODES)[number];
+export type TimelineItemPosition = (typeof TIMELINE_ITEM_POSITIONS)[number];
+export type TimelineItemType = (typeof TIMELINE_ITEM_TYPES)[number];
+export interface TimelineItemProps {
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    color?: string;
+    dot?: VNodeChild;
+    extra?: VNodeChild;
+    position?: TimelineItemPosition;
+    style?: StyleValue;
+    time?: VNodeChild;
+    type?: TimelineItemType;
+}
+export interface TimelineItemEmits {
+    click: [event: MouseEvent];
+}
+export interface TimelineItemSlots {
+    default?: () => VNodeChild;
+    dot?: () => VNodeChild;
+    extra?: () => VNodeChild;
+    time?: () => VNodeChild;
+}
+export interface TimelineData extends TimelineItemProps {
+    content: VNodeChild;
+    onClick?: (event: MouseEvent) => void;
+    [dataAttribute: `data-${string}`]: unknown;
+}
+export interface TimelineProps {
+    ariaLabel?: string;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    dataSource?: readonly TimelineData[];
+    mode?: TimelineMode;
+    style?: StyleValue;
+}
+export interface TimelineSlots {
+    default?: () => VNodeChild;
+}

package/dist/timeline-2D5xCZsU.js

@@ -0,0 +1,191 @@
+import { Comment as e, Fragment as t, Text as n, cloneVNode as r, computed as i, createBlock as a, createCommentVNode as o, createElementBlock as s, createElementVNode as c, createVNode as l, defineComponent as u, h as d, isVNode as f, mergeProps as p, normalizeClass as m, normalizeStyle as h, openBlock as g, renderList as _, renderSlot as v, resolveDynamicComponent as y, unref as b, useAttrs as x, useSlots as S } from "vue";
+//#region src/timeline/TimelineNodeRenderer.ts
+var C = u({
+	name: "TimelineNodeRenderer",
+	props: { content: {
+		type: null,
+		default: void 0
+	} },
+	setup(e) {
+		return () => e.content;
+	}
+}), w = "semi-timeline-item", T = /* @__PURE__ */ u({
+	name: "TimelineItem",
+	inheritAttrs: !1,
+	__name: "TimelineItem",
+	props: {
+		class: {
+			type: null,
+			default: void 0
+		},
+		className: {
+			type: null,
+			default: void 0
+		},
+		color: {
+			type: String,
+			default: void 0
+		},
+		dot: {
+			type: null,
+			default: void 0
+		},
+		extra: {
+			type: null,
+			default: void 0
+		},
+		position: {
+			type: String,
+			default: void 0
+		},
+		style: {
+			type: null,
+			default: void 0
+		},
+		time: {
+			type: null,
+			default: ""
+		},
+		type: {
+			type: String,
+			default: "default"
+		}
+	},
+	emits: ["click"],
+	setup(e, { emit: t }) {
+		let n = e, r = t, u = x(), d = S(), f = i(() => [
+			w,
+			n.class,
+			n.className,
+			u.class
+		]), _ = i(() => Object.fromEntries(Object.entries(u).filter(([e]) => e.startsWith("data-")))), y = i(() => d.dot?.() ?? n.dot), T = i(() => d.extra?.() ?? n.extra), E = i(() => d.time?.() ?? n.time), D = i(() => !!(d.dot?.().length || n.dot)), O = i(() => !!(d.extra?.().length || n.extra)), k = i(() => !!(d.time?.().length || n.time)), A = i(() => [
+			`${w}-head`,
+			D.value ? `${w}-head-custom` : void 0,
+			`${w}-head-${n.type}`
+		]);
+		return (t, i) => (g(), s("li", p(_.value, {
+			class: f.value,
+			style: [n.style, b(u).style],
+			onClick: i[0] ||= (e) => r("click", e)
+		}), [
+			c("div", {
+				class: m(`${w}-tail`),
+				"aria-hidden": "true"
+			}, null, 2),
+			c("div", {
+				class: m(A.value),
+				style: h(e.color ? { backgroundColor: e.color } : void 0),
+				"aria-hidden": "true"
+			}, [D.value ? (g(), a(b(C), {
+				key: 0,
+				content: y.value
+			}, null, 8, ["content"])) : o("", !0)], 6),
+			c("div", { class: m(`${w}-content`) }, [
+				v(t.$slots, "default"),
+				O.value ? (g(), s("div", {
+					key: 0,
+					class: m(`${w}-content-extra`)
+				}, [l(b(C), { content: T.value }, null, 8, ["content"])], 2)) : o("", !0),
+				k.value ? (g(), s("div", {
+					key: 1,
+					class: m(`${w}-content-time`)
+				}, [l(b(C), { content: E.value }, null, 8, ["content"])], 2)) : o("", !0)
+			], 2)
+		], 16));
+	}
+}), E = ["aria-label"], D = "semi-timeline", O = /* @__PURE__ */ u({
+	name: "Timeline",
+	inheritAttrs: !1,
+	__name: "Timeline",
+	props: {
+		ariaLabel: {
+			type: String,
+			default: void 0
+		},
+		class: {
+			type: null,
+			default: void 0
+		},
+		className: {
+			type: null,
+			default: void 0
+		},
+		dataSource: {
+			type: Array,
+			default: void 0
+		},
+		mode: {
+			type: String,
+			default: "left"
+		},
+		style: {
+			type: null,
+			default: void 0
+		}
+	},
+	setup(o) {
+		let c = o, l = x(), u = S(), m = i(() => [
+			D,
+			`${D}-${c.mode}`,
+			c.class,
+			c.className,
+			l.class
+		]), h = i(() => Object.fromEntries(Object.entries(l).filter(([e]) => e.startsWith("data-")))), v = i(() => c.ariaLabel ?? l["aria-label"]);
+		function C(r) {
+			let i = [], a = (r) => {
+				if (Array.isArray(r)) {
+					r.forEach(a);
+					return;
+				}
+				if (!(!f(r) || r.type === e)) {
+					if (r.type === t && Array.isArray(r.children)) {
+						r.children.forEach((e) => a(e));
+						return;
+					}
+					(r.type !== n || String(r.children ?? "").trim() !== "") && i.push(r);
+				}
+			};
+			return r.forEach(a), i;
+		}
+		function w(e, t) {
+			let n = e.props?.position;
+			return c.mode === "alternate" ? n ? `${D}-item-${n}` : `${D}-item-${t % 2 == 0 ? "left" : "right"}` : c.mode === "center" ? `${D}-item-${n || "left"}` : `${D}-item-${c.mode}`;
+		}
+		let O = i(() => c.dataSource?.length ? c.dataSource.map((e, t) => {
+			let { content: n, ...r } = e;
+			return d(T, {
+				...r,
+				key: `timeline-item-${t}`
+			}, { default: () => n });
+		}) : C(u.default?.() ?? [])), k = i(() => {
+			let e = 0;
+			return O.value.map((t) => {
+				if (t.type === n) return t;
+				let i = r(t, { class: [
+					t.props?.class,
+					t.props?.className,
+					w(t, e)
+				] });
+				return e += 1, i;
+			});
+		});
+		return (e, n) => (g(), s("ul", p(h.value, {
+			"aria-label": v.value,
+			class: m.value,
+			style: [c.style, b(l).style]
+		}), [(g(!0), s(t, null, _(k.value, (e, t) => (g(), a(y(e), { key: e.key ?? t }))), 128))], 16, E));
+	}
+}), k = [
+	"left",
+	"right",
+	"center",
+	"alternate"
+], A = ["left", "right"], j = [
+	"default",
+	"ongoing",
+	"success",
+	"warning",
+	"error"
+], M = T, N = Object.assign(O, { Item: M });
+//#endregion
+export { k as a, j as i, M as n, A as r, N as t };

package/dist/toast/ToastHost.vue.d.ts

@@ -0,0 +1,7 @@
+import { ToastStore } from './toast-store';
+type __VLS_Props = {
+    store: ToastStore;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/toast/ToastIconRenderer.d.ts

@@ -0,0 +1,17 @@
+import { PropType, VNode, 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 | 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/toast/ToastNodeRenderer.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/toast/ToastNotice.vue.d.ts

@@ -0,0 +1,20 @@
+import { ToastEntry } from './types';
+type __VLS_Props = {
+    animationClass?: string | undefined;
+    entry: ToastEntry;
+    positionInList: {
+        index: number;
+        length: number;
+    };
+    stack: boolean;
+    stackExpanded: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    animationEnd: (id: string) => any;
+    remove: (id: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAnimationEnd?: (id: string) => any;
+    onRemove?: (id: string) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/toast/imperative.d.ts

@@ -0,0 +1,3 @@
+import { ToastConfig, ToastStaticMethods } from './types';
+export declare function createToastStatic(initialConfig?: ToastConfig): ToastStaticMethods;
+export declare function resetToastSeedsForTests(): void;

package/dist/toast/index.d.ts

@@ -0,0 +1,6 @@
+import { ToastFactoryStatic } from './types';
+export declare const ToastFactory: ToastFactoryStatic;
+export declare const Toast: import('./types').ToastStaticMethods;
+export { useToast } from './use-toast';
+export { TOAST_THEMES, TOAST_TYPES, type ToastConfig, type ToastEntry, type ToastFactoryStatic, type ToastHookMethod, type ToastId, type ToastInput, type ToastInputId, type ToastMethod, type ToastMethods, type ToastOptions, type ToastStaticMethods, type ToastTheme, type ToastType, type ToastUseResult, } from './types';
+export default Toast;

package/dist/toast/index.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, r, t as i } from "../toast-s8nFLf8t.js";
+export { r as TOAST_THEMES, t as TOAST_TYPES, i as Toast, i as default, n as ToastFactory, e as useToast };

package/dist/toast/toast-store.d.ts

@@ -0,0 +1,30 @@
+import { ToastEntry, ToastId, ToastOptions } from './types';
+interface ToastListState {
+    list: ToastEntry[];
+    mouseInSide: boolean;
+    removedItems: ToastEntry[];
+    updatedItems: ToastEntry[];
+}
+export declare class ToastStore {
+    readonly state: import('vue').ShallowReactive<ToastListState>;
+    readonly animated: boolean;
+    stack: boolean;
+    private readonly cache;
+    private innerWrapper;
+    private readonly removalTimers;
+    private readonly foundation;
+    constructor(animated: boolean);
+    add(entry: ToastEntry): void;
+    has(id: ToastId): boolean;
+    update(id: ToastId, options: ToastOptions & Partial<ToastEntry>): void;
+    remove(id: ToastId): void;
+    finishEnter(id: ToastId): void;
+    finishRemove(id: ToastId): void;
+    setMouseInside(mouseInSide: boolean): void;
+    getInnerWrapperRect(): DOMRect | undefined;
+    setInnerWrapper(element: HTMLElement | undefined): void;
+    destroyAll(): void;
+    destroy(): void;
+    private scheduleRemovalFallback;
+}
+export {};

package/dist/toast/types.d.ts

@@ -0,0 +1,65 @@
+import { Component, HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { ConfigDirection } from '../config-provider';
+export declare const TOAST_TYPES: readonly ["warning", "success", "info", "error", "default"];
+export declare const TOAST_THEMES: readonly ["normal", "light"];
+export type ToastType = (typeof TOAST_TYPES)[number];
+export type ToastTheme = (typeof TOAST_THEMES)[number];
+export type ToastId = string;
+export type ToastInputId = string | number;
+export interface ToastConfig {
+    bottom?: number | string;
+    duration?: number;
+    getPopupContainer?: () => HTMLElement | null;
+    left?: number | string;
+    right?: number | string;
+    theme?: ToastTheme;
+    top?: number | string;
+    zIndex?: number;
+}
+export interface ToastOptions extends ToastConfig {
+    className?: HTMLAttributes['class'];
+    content?: VNodeChild;
+    direction?: ConfigDirection;
+    icon?: VNodeChild;
+    id?: ToastInputId;
+    motion?: boolean;
+    onClose?: () => void;
+    showClose?: boolean;
+    stack?: boolean;
+    style?: StyleValue;
+    textMaxWidth?: number | string;
+    type?: ToastType;
+}
+export interface ToastEntry extends Omit<ToastOptions, 'id'> {
+    id: ToastId;
+    motion: boolean;
+    phase: 'enter' | 'stable' | 'leave';
+    revision: number;
+    type: ToastType;
+}
+export type ToastInput = ToastOptions | string;
+export type ToastMethod = (options: ToastInput) => ToastId;
+export type ToastHookMethod = (options: ToastOptions) => ToastId;
+export interface ToastMethods {
+    close: (id: ToastInputId) => ToastId;
+    error: ToastHookMethod;
+    info: ToastHookMethod;
+    open: ToastHookMethod;
+    success: ToastHookMethod;
+    warning: ToastHookMethod;
+}
+export type ToastUseResult = readonly [ToastMethods, Component];
+export interface ToastStaticMethods {
+    close: (id: ToastInputId) => ToastId;
+    config: (config: ToastConfig) => void;
+    destroyAll: () => void;
+    error: ToastMethod;
+    getWrapperId: () => string | null;
+    info: ToastMethod;
+    success: ToastMethod;
+    useToast: () => ToastUseResult;
+    warning: ToastMethod;
+}
+export interface ToastFactoryStatic {
+    create: (config?: ToastConfig) => ToastStaticMethods;
+}

package/dist/toast/use-toast.d.ts

@@ -0,0 +1,2 @@
+import { ToastUseResult } from './types';
+export declare function useToast(): ToastUseResult;