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

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

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    direction: 'ltr' | 'rtl';
+    pages: number[];
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (page: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: (page: number) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/pagination/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Pagination } from './Pagination.vue';
+export { default } from './Pagination.vue';
+export type { PaginationEmits, PaginationLocale, PaginationPage, PaginationPageList, PaginationProps, PaginationSize, PaginationSlots, } from './types';

package/dist/pagination/index.js

@@ -0,0 +1,2 @@
+import { t as e } from "../Pagination-4JvS-gHR.js";
+export { e as Pagination, e as default };

package/dist/pagination/types.d.ts

@@ -0,0 +1,46 @@
+import { CSSProperties, HTMLAttributes, VNodeChild } from 'vue';
+import { TooltipPosition } from '../tooltip';
+export type PaginationSize = 'small' | 'default';
+export type PaginationPage = number | '...';
+export type PaginationPageList = PaginationPage[];
+export interface PaginationLocale {
+    pageSize: string;
+    total: string;
+    jumpTo: string;
+    page: string;
+}
+export interface PaginationProps {
+    class?: HTMLAttributes['class'];
+    className?: string;
+    currentPage?: number;
+    defaultCurrentPage?: number;
+    disabled?: boolean;
+    hideOnSinglePage?: boolean;
+    hoverShowPageSelect?: boolean;
+    modelValue?: number;
+    nextText?: VNodeChild;
+    pageSize?: number;
+    pageSizeOpts?: number[];
+    popoverPosition?: TooltipPosition;
+    popoverZIndex?: number;
+    preventPageChangeOnPageSizeChange?: boolean;
+    prevText?: VNodeChild;
+    showQuickJumper?: boolean;
+    showSizeChanger?: boolean;
+    showTotal?: boolean;
+    size?: PaginationSize;
+    style?: CSSProperties;
+    total?: number;
+}
+export interface PaginationEmits {
+    change: [currentPage: number, pageSize: number];
+    pageChange: [currentPage: number];
+    pageSizeChange: [pageSize: number];
+    'update:currentPage': [currentPage: number];
+    'update:modelValue': [currentPage: number];
+    'update:pageSize': [pageSize: number];
+}
+export interface PaginationSlots {
+    next?: () => VNodeChild;
+    prev?: () => VNodeChild;
+}

package/dist/pin-code/PinCode.vue.d.ts

@@ -0,0 +1,20 @@
+import { PinCodeExposed, PinCodeProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<PinCodeProps, PinCodeExposed, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+    "update:value": (value: string) => any;
+    complete: (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<PinCodeProps> & Readonly<{
+    onChange?: (value: string) => any;
+    "onUpdate:modelValue"?: (value: string) => any;
+    "onUpdate:value"?: (value: string) => any;
+    onComplete?: (value: string) => any;
+}>, {
+    disabled: boolean;
+    size: import('..').InputSize;
+    autoFocus: boolean;
+    count: number;
+    format: import('./types').PinCodeFormat;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/pin-code/index.d.ts

@@ -0,0 +1,10 @@
+import { ComponentOptionsMixin, DefineComponent } from 'vue';
+import { PinCodeEmits, PinCodeProps } from './types';
+type PinCodeComponentEmits = {
+    [EventName in keyof PinCodeEmits]: (...args: PinCodeEmits[EventName]) => void;
+};
+type EmptyComponentOptions = Record<never, never>;
+export type PinCodeComponent = DefineComponent<PinCodeProps, EmptyComponentOptions, EmptyComponentOptions, EmptyComponentOptions, EmptyComponentOptions, ComponentOptionsMixin, ComponentOptionsMixin, PinCodeComponentEmits>;
+export declare const PinCode: PinCodeComponent;
+export type { PinCodeEmits, PinCodeExposed, PinCodeFormat, PinCodeProps } from './types';
+export default PinCode;

package/dist/pin-code/index.js

@@ -0,0 +1,2 @@
+import { t as e } from "../pin-code-wY5g0KLD.js";
+export { e as PinCode, e as default };

package/dist/pin-code/types.d.ts

@@ -0,0 +1,25 @@
+import { HTMLAttributes, StyleValue } from 'vue';
+import { InputSize } from '../input';
+export type PinCodeFormat = 'number' | 'mixed' | RegExp | ((character: string) => boolean);
+export interface PinCodeProps {
+    autoFocus?: boolean;
+    className?: HTMLAttributes['class'];
+    count?: number;
+    defaultValue?: string;
+    disabled?: boolean;
+    format?: PinCodeFormat;
+    modelValue?: string | undefined;
+    size?: InputSize;
+    style?: StyleValue;
+    value?: string | undefined;
+}
+export interface PinCodeEmits {
+    change: [value: string];
+    complete: [value: string];
+    'update:modelValue': [value: string];
+    'update:value': [value: string];
+}
+export interface PinCodeExposed {
+    blur(index: number): void;
+    focus(index: number): void;
+}

package/dist/pin-code-wY5g0KLD.js

@@ -0,0 +1,193 @@
+import "./src-DNBBthjO.js";
+import { t as e } from "./foundation-Cawx37mp.js";
+import { t } from "./input-wf0nZCRS.js";
+import { Fragment as n, computed as r, createBlock as i, createElementBlock as a, defineComponent as o, getCurrentInstance as s, markRaw as c, mergeProps as l, nextTick as u, openBlock as d, renderList as f, shallowReactive as p, unref as m, useAttrs as h, watch as g } from "vue";
+//#region bundled-foundation
+var _ = class t extends e {
+	constructor(e) {
+		super({ ...e }), this.handleCurrentActiveIndexChange = (e, t) => {
+			t === "focus" && this._adapter.onCurrentActiveIndexChange(e);
+		}, this.completeSingleInput = async (e, t) => {
+			let n = this._isInProps("value");
+			await this._adapter.onCurrentActiveIndexChange(e + 1);
+			let r = [...this.getState("valueList")];
+			r[e] = t, this._adapter.notifyValueChange(r), n || await this.updateValueList(r);
+			let i = this.getProp("count");
+			e + 1 > i - 1 ? (this._adapter.changeSpecificInputFocusState(e, "blur"), this.getProp("onComplete")?.(r.join(""))) : this._adapter.changeSpecificInputFocusState(e + 1, "focus");
+		}, this.validateValue = (e = "") => {
+			let n = this.getProp("format"), r = (e) => !0;
+			return typeof n == "string" ? n === "number" ? r = (e) => e.length === 0 || t.numberReg.test(e) : n === "mixed" && (r = (e) => e.length === 0 || t.mixedReg.test(e)) : n instanceof RegExp ? r = (e) => n.test(e) : typeof n == "function" && (r = n), r(e);
+		}, this.updateValueList = async (e) => {
+			this._adapter.updateValueList(e);
+		}, this.handlePaste = async (e, t) => {
+			e.preventDefault();
+			let n = e.clipboardData.getData("text"), r = this.getProp("count");
+			for (let e = t, i = 0; e < r && i < n.length; e++, i++) {
+				let t = n[i];
+				if (this.validateValue(t)) await this.completeSingleInput(e, t);
+				else break;
+			}
+		}, this.handleKeyDownOnSingleInput = (e, t) => {
+			let n = [...this.getState("valueList")];
+			e.key === "Backspace" ? (n[t] = "", this.updateValueList(n), this._adapter.notifyValueChange(n), this._adapter.changeSpecificInputFocusState(Math.max(0, t - 1), "focus"), e.preventDefault()) : e.key === "Delete" ? (n[t] = "", this.updateValueList(n), this._adapter.notifyValueChange(n), this._adapter.changeSpecificInputFocusState(Math.min(n.length - 1, t + 1), "focus"), e.preventDefault()) : e.key === "ArrowLeft" ? (this._adapter.changeSpecificInputFocusState(Math.max(0, t - 1), "focus"), e.preventDefault()) : e.key === "ArrowRight" && (this._adapter.changeSpecificInputFocusState(Math.min(n.length - 1, t + 1), "focus"), e.preventDefault());
+		};
+	}
+	static {
+		this.numberReg = /^\d*$/;
+	}
+	static {
+		this.mixedReg = /^[0-9a-zA-Z]$/;
+	}
+}, v = /* @__PURE__ */ o({
+	name: "PinCode",
+	inheritAttrs: !1,
+	__name: "PinCode",
+	props: {
+		autoFocus: {
+			type: Boolean,
+			default: !0
+		},
+		className: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		count: { default: 6 },
+		defaultValue: {},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		format: {
+			type: [String, Function],
+			default: "number"
+		},
+		modelValue: {},
+		size: { default: "default" },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		value: {}
+	},
+	emits: [
+		"change",
+		"complete",
+		"update:modelValue",
+		"update:value"
+	],
+	setup(e, { expose: o, emit: v }) {
+		let y = e, b = v, x = h(), S = s(), C = [], w = /* @__PURE__ */ new Map();
+		function T(e) {
+			let t = e.replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`), n = S?.vnode.props;
+			return !!(n && (Object.prototype.hasOwnProperty.call(n, e) || Object.prototype.hasOwnProperty.call(n, t)));
+		}
+		let E = r(() => T("value")), D = r(() => T("modelValue")), O = r(() => E.value || D.value), k = r(() => E.value ? y.value : y.modelValue), A = k.value || y.defaultValue, j = p({
+			valueList: A ? A.split("") : [],
+			currentActiveIndex: 0
+		}), M = r(() => [
+			x.class,
+			y.className,
+			"semi-pincode-wrapper"
+		]), N = r(() => [y.style, x.style]), P = r(() => Object.fromEntries(Object.entries(x).filter(([e]) => e !== "class" && e !== "style")));
+		function F() {
+			let e = {
+				...y,
+				onComplete: (e) => b("complete", e)
+			};
+			return O.value ? e.value = k.value : delete e.value, e;
+		}
+		let I = c(new _({
+			getContext: () => void 0,
+			getContexts: () => void 0,
+			getProp: (e) => F()[e],
+			getProps: F,
+			getState: (e) => j[e],
+			getStates: () => j,
+			setState: (e, t) => {
+				Object.assign(j, e), t?.();
+			},
+			getCache: (e) => w.get(e),
+			getCaches: () => w,
+			setCache: (e, t) => w.set(String(e), t),
+			stopPropagation: (e) => e?.stopPropagation?.(),
+			persistEvent: () => void 0,
+			onCurrentActiveIndexChange: async (e) => {
+				j.currentActiveIndex = e, await u();
+			},
+			notifyValueChange: (e) => {
+				let t = e.join("");
+				b("change", t), b("update:value", t), b("update:modelValue", t);
+			},
+			changeSpecificInputFocusState: (e, t) => {
+				t === "focus" ? C[e]?.focus() : C[e]?.blur();
+			},
+			updateValueList: async (e) => {
+				j.valueList = e, await u();
+			}
+		}));
+		function L(e, t) {
+			C[e] = t;
+		}
+		function R(e) {
+			let t = C[e];
+			t?.focus(), t?.input?.setSelectionRange(1, 1);
+		}
+		function z(e) {
+			C[e]?.blur();
+		}
+		function B(e, t, n) {
+			if ("isComposing" in t && t.isComposing) return;
+			let r = e[e.length - 1];
+			I.validateValue(r) && I.completeSingleInput(n, r);
+		}
+		let V = r(() => Array.from({ length: y.count }, (e, t) => (e, n) => B(e, n, t)));
+		function H(e, t) {
+			I.handlePaste(e, t);
+		}
+		function U(e, t) {
+			I.handleKeyDownOnSingleInput(e, t);
+		}
+		return g(k, (e) => {
+			O.value && I.updateValueList((e || "").split(""));
+		}), o({
+			focus: R,
+			blur: z
+		}), (e, r) => (d(), a("div", l(P.value, {
+			class: M.value,
+			style: N.value
+		}), [(d(!0), a(n, null, f(y.count, (e) => (d(), i(m(t), {
+			key: `input-${e - 1}`,
+			ref_for: !0,
+			ref: (t) => L(e - 1, t),
+			"auto-focus": y.autoFocus && e === 1,
+			inputmode: y.format === "number" ? "numeric" : "text",
+			value: m(j).valueList[e - 1],
+			size: y.size,
+			disabled: y.disabled,
+			onBlur: (t) => m(I).handleCurrentActiveIndexChange(e - 1, "blur"),
+			onFocus: (t) => m(I).handleCurrentActiveIndexChange(e - 1, "focus"),
+			onPaste: (t) => H(t, e - 1),
+			onKeydown: (t) => U(t, e - 1),
+			onChange: V.value[e - 1]
+		}, null, 8, [
+			"auto-focus",
+			"inputmode",
+			"value",
+			"size",
+			"disabled",
+			"onBlur",
+			"onFocus",
+			"onPaste",
+			"onKeydown",
+			"onChange"
+		]))), 128))], 16));
+	}
+});
+//#endregion
+export { v as t };

package/dist/popconfirm/Popconfirm.vue.d.ts

@@ -0,0 +1,25 @@
+import { PopconfirmProps, PopconfirmSlots } from './types';
+type __VLS_Slots = PopconfirmSlots;
+declare const __VLS_base: import('vue').DefineComponent<PopconfirmProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: (event: MouseEvent) => any;
+    clickOutside: (event: MouseEvent) => any;
+    escKeydown: (event: KeyboardEvent) => any;
+    visibleChange: (visible: boolean) => any;
+    "update:visible": (visible: boolean) => any;
+    confirm: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<PopconfirmProps> & Readonly<{
+    onCancel?: (event: MouseEvent) => any;
+    onClickOutside?: (event: MouseEvent) => any;
+    onEscKeydown?: (event: KeyboardEvent) => any;
+    onVisibleChange?: (visible: boolean) => any;
+    "onUpdate:visible"?: (visible: boolean) => any;
+    onConfirm?: (event: MouseEvent) => 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/popconfirm/PopconfirmNodeRenderer.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/popconfirm/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Popconfirm } from './Popconfirm.vue';
+export { Popconfirm };
+export default Popconfirm;
+export type { PopconfirmActionHandler, PopconfirmActionResult, PopconfirmButtonProps, PopconfirmEmits, PopconfirmLocale, PopconfirmProps, PopconfirmSlots, } from './types';

package/dist/popconfirm/index.js

@@ -0,0 +1,2 @@
+import { n as e, t } from "../popconfirm-DQUtvI0A.js";
+export { e as Popconfirm, t as default };

package/dist/popconfirm/types.d.ts

@@ -0,0 +1,57 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { ButtonProps, ButtonType } from '../button';
+import { PopoverProps } from '../popover';
+import { TooltipInitialFocusRef } from '../tooltip';
+export type PopconfirmActionResult = Promise<unknown> | void;
+export type PopconfirmActionHandler = (event: MouseEvent) => PopconfirmActionResult;
+export interface PopconfirmButtonProps extends ButtonProps {
+    autoFocus?: boolean;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    onClick?: (event: MouseEvent) => void;
+    style?: StyleValue;
+    [attribute: `aria-${string}`]: unknown;
+    [attribute: `data-${string}`]: unknown;
+}
+export interface PopconfirmLocale {
+    cancel: string;
+    confirm: string;
+}
+export interface PopconfirmProps extends Omit<PopoverProps, 'class' | 'className' | 'content' | 'position' | 'prefixCls' | 'style' | 'trigger' | 'zIndex'> {
+    cancelButtonProps?: PopconfirmButtonProps;
+    cancelText?: string;
+    cancelType?: ButtonType;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    content?: VNodeChild;
+    defaultVisible?: boolean;
+    disabled?: boolean;
+    icon?: VNodeChild;
+    okButtonProps?: PopconfirmButtonProps;
+    okText?: string;
+    okType?: ButtonType;
+    position?: PopoverProps['position'];
+    prefixCls?: string;
+    showCloseIcon?: boolean;
+    style?: StyleValue;
+    title?: VNodeChild;
+    trigger?: PopoverProps['trigger'];
+    visible?: boolean;
+    zIndex?: number;
+}
+export interface PopconfirmEmits {
+    cancel: [event: MouseEvent];
+    clickOutside: [event: MouseEvent];
+    confirm: [event: MouseEvent];
+    escKeydown: [event: KeyboardEvent];
+    visibleChange: [visible: boolean];
+    'update:visible': [visible: boolean];
+}
+export interface PopconfirmSlots {
+    content?: (props: {
+        initialFocusRef: TooltipInitialFocusRef;
+    }) => VNodeChild;
+    default?: () => VNodeChild;
+    icon?: () => VNodeChild;
+    title?: () => VNodeChild;
+}