完全跑通1.0版本

frontend/node_modules/element-plus/es/components/input-otp/index.d.ts

@@ -0,0 +1,9 @@
+import { SFCWithInstall } from "../../utils/vue/typescript.js";
+import { InputOtpEmits, InputOtpProps, inputOtpEmits } from "./src/input-otp.js";
+import _default from "./src/input-otp.vue.js";
+import { InputOtpInstance } from "./src/instance.js";
+
+//#region ../../packages/components/input-otp/index.d.ts
+declare const ElInputOtp: SFCWithInstall<typeof _default>;
+//#endregion
+export { ElInputOtp, ElInputOtp as default, InputOtpEmits, type InputOtpInstance, InputOtpProps, inputOtpEmits };

frontend/node_modules/element-plus/es/components/input-otp/index.mjs

@@ -0,0 +1,9 @@
+import { withInstall } from "../../utils/vue/install.mjs";
+import { inputOtpEmits } from "./src/input-otp.mjs";
+import input_otp_default from "./src/input-otp2.mjs";
+//#region ../../packages/components/input-otp/index.ts
+const ElInputOtp = withInstall(input_otp_default);
+//#endregion
+export { ElInputOtp, ElInputOtp as default, inputOtpEmits };
+
+//# sourceMappingURL=index.mjs.map

frontend/node_modules/element-plus/es/components/input-otp/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["InputOtp"],"sources":["../../../../../packages/components/input-otp/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport InputOtp from './src/input-otp.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElInputOtp: SFCWithInstall<typeof InputOtp> = withInstall(InputOtp)\nexport default ElInputOtp\n\nexport * from './src/input-otp'\nexport type { InputOtpInstance } from './src/instance'\n"],"mappings":";;;;AAKA,MAAa,aAA8C,YAAYA,kBAAS"}

frontend/node_modules/element-plus/es/components/input-otp/src/input-otp.d.ts

@@ -0,0 +1,74 @@
+import { ComponentSize } from "../../../constants/size.js";
+import { AriaProps } from "../../../hooks/use-aria/index.js";
+import { InputHTMLAttributes, VNode } from "vue";
+
+//#region ../../packages/components/input-otp/src/input-otp.d.ts
+interface InputOtpProps extends Pick<AriaProps, 'ariaLabel'> {
+  /**
+   * @description The value of the OTP fields.
+   *
+   * Since numbers must not have leading zeros, `modelValue` is allowed to be a number only during initialization.
+   *
+   * @default undefined
+   */
+  modelValue?: string | number;
+  /**
+   * @description The OTP fields length
+   * @default 6
+   */
+  length?: number;
+  /**
+   * @description Custom validator function
+   * @default () => true
+   */
+  validator?: (char: string, index: number) => boolean;
+  /**
+   * @description Native input mode for virtual keyboards
+   */
+  inputmode?: InputHTMLAttributes['inputmode'];
+  /**
+   * @description The type of the OTP fields
+   * @default 'outlined'
+   */
+  type?: 'outlined' | 'filled' | 'underlined';
+  /**
+   * @description The size of the OTP fields
+   * @default 'default'
+   */
+  size?: ComponentSize;
+  /**
+   * @description Whether to enable password mode
+   */
+  mask?: boolean;
+  /**
+   * @description Whether the OTP fields are disabled
+   * @default undefined
+   */
+  disabled?: boolean;
+  /**
+   * @description Same as `readonly` in native input
+   */
+  readonly?: boolean;
+  /**
+   * @description Same as `id` in native input
+   */
+  id?: string;
+  /**
+   * @description Whether to trigger form validation
+   */
+  validateEvent?: boolean;
+  /**
+   * @description The separator between OTP fields
+   */
+  separator?: string | VNode | ((index: number) => string | VNode);
+}
+declare const inputOtpEmits: {
+  "update:modelValue": (value: string) => boolean;
+  change: (value: string) => boolean;
+  finish: (value: string) => boolean;
+  focus: (eve: FocusEvent) => boolean;
+  blur: (eve: FocusEvent) => boolean;
+};
+type InputOtpEmits = typeof inputOtpEmits;
+//#endregion
+export { InputOtpEmits, InputOtpProps, inputOtpEmits };

frontend/node_modules/element-plus/es/components/input-otp/src/input-otp.mjs

@@ -0,0 +1,14 @@
+import { CHANGE_EVENT, UPDATE_MODEL_EVENT } from "../../../constants/event.mjs";
+import { isString } from "../../../utils/types.mjs";
+//#region ../../packages/components/input-otp/src/input-otp.ts
+const inputOtpEmits = {
+	[UPDATE_MODEL_EVENT]: (value) => isString(value),
+	[CHANGE_EVENT]: (value) => isString(value),
+	finish: (value) => isString(value),
+	focus: (eve) => eve instanceof FocusEvent,
+	blur: (eve) => eve instanceof FocusEvent
+};
+//#endregion
+export { inputOtpEmits };
+
+//# sourceMappingURL=input-otp.mjs.map

frontend/node_modules/element-plus/es/components/input-otp/src/input-otp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-otp.mjs","names":[],"sources":["../../../../../../packages/components/input-otp/src/input-otp.ts"],"sourcesContent":["import { CHANGE_EVENT, UPDATE_MODEL_EVENT } from '@element-plus/constants'\nimport { isString } from '@element-plus/utils'\n\nimport type { InputHTMLAttributes, VNode } from 'vue'\nimport type { ComponentSize } from '@element-plus/constants'\nimport type { AriaProps } from '@element-plus/hooks'\n\nexport interface InputOtpProps extends Pick<AriaProps, 'ariaLabel'> {\n  /**\n   * @description The value of the OTP fields.\n   *\n   * Since numbers must not have leading zeros, `modelValue` is allowed to be a number only during initialization.\n   *\n   * @default undefined\n   */\n  modelValue?: string | number\n  /**\n   * @description The OTP fields length\n   * @default 6\n   */\n  length?: number\n  /**\n   * @description Custom validator function\n   * @default () => true\n   */\n  validator?: (char: string, index: number) => boolean\n  /**\n   * @description Native input mode for virtual keyboards\n   */\n  inputmode?: InputHTMLAttributes['inputmode']\n  /**\n   * @description The type of the OTP fields\n   * @default 'outlined'\n   */\n  type?: 'outlined' | 'filled' | 'underlined'\n  /**\n   * @description The size of the OTP fields\n   * @default 'default'\n   */\n  size?: ComponentSize\n  /**\n   * @description Whether to enable password mode\n   */\n  mask?: boolean\n  /**\n   * @description Whether the OTP fields are disabled\n   * @default undefined\n   */\n  disabled?: boolean\n  /**\n   * @description Same as `readonly` in native input\n   */\n  readonly?: boolean\n  /**\n   * @description Same as `id` in native input\n   */\n  id?: string\n  /**\n   * @description Whether to trigger form validation\n   */\n  validateEvent?: boolean\n  /**\n   * @description The separator between OTP fields\n   */\n  separator?: string | VNode | ((index: number) => string | VNode)\n}\n\nexport const inputOtpEmits = {\n  [UPDATE_MODEL_EVENT]: (value: string) => isString(value),\n  [CHANGE_EVENT]: (value: string) => isString(value),\n  finish: (value: string) => isString(value),\n  focus: (eve: FocusEvent) => eve instanceof FocusEvent,\n  blur: (eve: FocusEvent) => eve instanceof FocusEvent,\n}\n\nexport type InputOtpEmits = typeof inputOtpEmits\n"],"mappings":";;;AAmEA,MAAa,gBAAgB;EAC1B,sBAAsB,UAAkB,SAAS,MAAM;EACvD,gBAAgB,UAAkB,SAAS,MAAM;CAClD,SAAS,UAAkB,SAAS,MAAM;CAC1C,QAAQ,QAAoB,eAAe;CAC3C,OAAO,QAAoB,eAAe;CAC3C"}

frontend/node_modules/element-plus/es/components/input-otp/src/input-otp.vue.d.ts

@@ -0,0 +1,53 @@
+import { ComponentSize } from "../../../constants/size.js";
+import { InputOtpProps } from "./input-otp.js";
+import * as _$vue from "vue";
+
+//#region ../../packages/components/input-otp/src/input-otp.vue.d.ts
+declare var __VLS_1: {
+  index: number;
+};
+type __VLS_Slots = {} & {
+  separator?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: _$vue.DefineComponent<InputOtpProps, {
+  /**
+   * @description HTML input elements array
+   */
+  inputRefs: _$vue.Ref<(HTMLInputElement | undefined)[], (HTMLInputElement | undefined)[]>;
+  /**
+   * @description Focus an OTP input field
+   */
+  focus: (index?: number) => void;
+  /**
+   * @description Blur the focused OTP input field
+   */
+  blur: () => void;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+  finish: (value: string) => void;
+  change: (value: string) => void;
+  "update:modelValue": (value: string) => void;
+  focus: (eve: FocusEvent) => void;
+  blur: (eve: FocusEvent) => void;
+}, string, _$vue.PublicProps, Readonly<InputOtpProps> & Readonly<{
+  onFinish?: ((value: string) => any) | undefined;
+  "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+  onChange?: ((value: string) => any) | undefined;
+  onFocus?: ((eve: FocusEvent) => any) | undefined;
+  onBlur?: ((eve: FocusEvent) => any) | undefined;
+}>, {
+  length: number;
+  type: "outlined" | "filled" | "underlined";
+  validator: (char: string, index: number) => boolean;
+  disabled: boolean;
+  size: ComponentSize;
+  validateEvent: boolean;
+}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { _default as default };

frontend/node_modules/element-plus/es/components/input-otp/src/input-otp.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,283 @@
+import { EVENT_CODE } from "../../../constants/aria.mjs";
+import { CHANGE_EVENT, UPDATE_MODEL_EVENT } from "../../../constants/event.mjs";
+import { getEventCode } from "../../../utils/dom/event.mjs";
+import { isFunction } from "../../../utils/types.mjs";
+import { rAF } from "../../../utils/raf.mjs";
+import { NOOP } from "../../../utils/functions.mjs";
+import { useLocale } from "../../../hooks/use-locale/index.mjs";
+import { useNamespace } from "../../../hooks/use-namespace/index.mjs";
+import { useFormDisabled } from "../../form/src/hooks/use-form-common-props.mjs";
+import { useFormItem, useFormItemInputId } from "../../form/src/hooks/use-form-item.mjs";
+import { inputOtpEmits } from "./input-otp.mjs";
+import { clamp } from "@vueuse/core";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, normalizeClass, openBlock, ref, renderList, renderSlot, resolveDynamicComponent, unref, watch } from "vue";
+//#region ../../packages/components/input-otp/src/input-otp.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"id",
+	"aria-label",
+	"aria-labelledby"
+];
+const _hoisted_2 = [
+	"value",
+	"type",
+	"disabled",
+	"readonly",
+	"inputmode",
+	"aria-label",
+	"onClick",
+	"onKeydown",
+	"onInput"
+];
+var input_otp_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "ElInputOtp",
+	__name: "input-otp",
+	props: {
+		modelValue: {
+			type: [String, Number],
+			required: false
+		},
+		length: {
+			type: Number,
+			required: false,
+			default: 6
+		},
+		validator: {
+			type: Function,
+			required: false,
+			default: () => true
+		},
+		inputmode: {
+			type: null,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false,
+			default: "outlined"
+		},
+		size: {
+			type: null,
+			required: false,
+			default: "default"
+		},
+		mask: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		readonly: {
+			type: Boolean,
+			required: false
+		},
+		id: {
+			type: String,
+			required: false
+		},
+		validateEvent: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		separator: {
+			type: [
+				String,
+				Object,
+				Function
+			],
+			required: false
+		},
+		ariaLabel: {
+			type: String,
+			required: false
+		}
+	},
+	emits: inputOtpEmits,
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const initialValue = computed(() => {
+			const value = String(props.modelValue ?? "");
+			return Array.from({ length: props.length }, (_, i) => value.charAt(i));
+		});
+		const separators = computed(() => {
+			const { separator } = props;
+			const _separator = isFunction(separator) ? separator : () => separator;
+			return Array.from({ length: props.length - 1 }, (_, i) => _separator(i));
+		});
+		const innerValue = ref(initialValue.value);
+		const isFocused = ref(false);
+		const inputRefs = ref([]);
+		const ns = useNamespace("input-otp");
+		const { t } = useLocale();
+		const { formItem } = useFormItem();
+		const { inputId, isLabeledByFormItem } = useFormItemInputId(props, { formItemContext: formItem });
+		const disabled = useFormDisabled();
+		let modelValueOnFocus = props.modelValue;
+		const getFirstIndex = (maxIndex) => {
+			const index = innerValue.value.findIndex((char, i) => !char && i <= maxIndex);
+			return index === -1 ? maxIndex : index;
+		};
+		const handleFocus = (event) => {
+			if (inputRefs.value?.includes(event.relatedTarget)) return;
+			isFocused.value = true;
+			emit("focus", event);
+		};
+		const handleBlur = (event) => {
+			if (inputRefs.value?.includes(event.relatedTarget)) return;
+			isFocused.value = false;
+			emit("blur", event);
+			if (props.validateEvent) formItem?.validate?.("blur").catch(NOOP);
+		};
+		const updateModelValue = (emitFinish = true) => {
+			const value = innerValue.value.join("").slice(0, props.length);
+			if (value !== props.modelValue) {
+				emit(UPDATE_MODEL_EVENT, value);
+				if (emitFinish && value.length === props.length) emit("finish", value);
+			}
+		};
+		const handleKeydown = (event, index) => {
+			const code = getEventCode(event);
+			let preventDefault = true;
+			switch (code) {
+				case EVENT_CODE.backspace:
+					if (props.readonly) break;
+					innerValue.value[index] = "";
+					focus(index - 1);
+					updateModelValue();
+					break;
+				case EVENT_CODE.delete:
+					if (props.readonly) break;
+					innerValue.value[index] = "";
+					focus(index);
+					updateModelValue();
+					break;
+				case EVENT_CODE.up:
+				case EVENT_CODE.left:
+					focus(index - 1);
+					break;
+				case EVENT_CODE.down:
+				case EVENT_CODE.right:
+					focus(index + 1);
+					break;
+				default: preventDefault = false;
+			}
+			if (preventDefault) event.preventDefault();
+		};
+		const handleInput = (event, index) => {
+			const target = event.target;
+			const targetIndex = getFirstIndex(index);
+			let focusIndex = targetIndex + 1;
+			let value = target.value;
+			if (value.length > 1) {
+				const chars = castValues(value, targetIndex);
+				target.value = innerValue.value[index] ?? "";
+				chars.forEach((char, i) => innerValue.value[targetIndex + i] = char);
+				focus(targetIndex + chars.length);
+				updateModelValue();
+				return;
+			}
+			if (!props.validator(value, targetIndex)) {
+				target.value = innerValue.value[index] ?? "";
+				value = target.value;
+				focusIndex = targetIndex;
+			}
+			innerValue.value[targetIndex] = value;
+			if (targetIndex !== index) target.value = innerValue.value[index] ?? "";
+			focus(focusIndex);
+			updateModelValue();
+		};
+		const castValues = (value, startIndex = 0) => {
+			const chars = `${value ?? ""}`.split("");
+			const result = [];
+			for (const char of chars) {
+				if (result.length + startIndex >= props.length) break;
+				if (props.validator(char, result.length + startIndex)) result.push(char);
+			}
+			return result;
+		};
+		const focus = (index = 0) => {
+			const focusIndex = clamp(index, 0, props.length - 1);
+			const target = inputRefs.value?.[focusIndex];
+			if (document.activeElement !== target) target?.focus();
+			rAF(() => {
+				if (!props.readonly && document.activeElement === target) target?.select();
+			});
+		};
+		const blur = () => {
+			(inputRefs.value?.find((input) => document.activeElement === input))?.blur();
+		};
+		watch(() => props.modelValue, () => {
+			innerValue.value = initialValue.value;
+			if (props.validateEvent) formItem?.validate?.("change").catch(NOOP);
+		});
+		watch(() => props.length, () => {
+			innerValue.value = initialValue.value;
+			updateModelValue(false);
+		});
+		watch(isFocused, (value) => {
+			if (value) {
+				modelValueOnFocus = props.modelValue;
+				return;
+			}
+			if (modelValueOnFocus !== props.modelValue) emit(CHANGE_EVENT, props.modelValue);
+		});
+		__expose({
+			/**
+			* @description HTML input elements array
+			*/
+			inputRefs,
+			/**
+			* @description Focus an OTP input field
+			*/
+			focus,
+			/**
+			* @description Blur the focused OTP input field
+			*/
+			blur
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				id: unref(inputId),
+				class: normalizeClass([
+					unref(ns).b(),
+					unref(ns).m(__props.size),
+					unref(ns).m(__props.type),
+					unref(ns).is("disabled", unref(disabled))
+				]),
+				role: "group",
+				"aria-label": !unref(isLabeledByFormItem) ? __props.ariaLabel || unref(t)("el.inputOTP.groupLabel") : void 0,
+				"aria-labelledby": unref(isLabeledByFormItem) ? unref(formItem)?.labelId : void 0
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.length, (_, index) => {
+				return openBlock(), createElementBlock(Fragment, { key: index }, [createElementVNode("label", { class: normalizeClass(unref(ns).e("input-field")) }, [createElementVNode("input", {
+					ref_for: true,
+					ref_key: "inputRefs",
+					ref: inputRefs,
+					value: innerValue.value[index],
+					class: normalizeClass(unref(ns).e("input")),
+					type: __props.mask ? "password" : "text",
+					disabled: unref(disabled),
+					readonly: __props.readonly,
+					inputmode: __props.inputmode,
+					autocomplete: "one-time-code",
+					"aria-label": unref(t)("el.inputOTP.defaultLabel", { index: index + 1 }),
+					onFocus: handleFocus,
+					onBlur: handleBlur,
+					onClick: ($event) => focus(index),
+					onKeydown: ($event) => handleKeydown($event, index),
+					onInput: ($event) => handleInput($event, index)
+				}, null, 42, _hoisted_2)], 2), (_ctx.$slots.separator || separators.value[index]) && index < __props.length - 1 ? renderSlot(_ctx.$slots, "separator", {
+					key: 0,
+					index
+				}, () => [(openBlock(), createBlock(resolveDynamicComponent(() => separators.value[index])))]) : createCommentVNode("v-if", true)], 64);
+			}), 128))], 10, _hoisted_1);
+		};
+	}
+});
+//#endregion
+export { input_otp_vue_vue_type_script_setup_true_lang_default as default };
+
+//# sourceMappingURL=input-otp.vue_vue_type_script_setup_true_lang.mjs.map

frontend/node_modules/element-plus/es/components/input-otp/src/input-otp2.mjs

@@ -0,0 +1,7 @@
+import input_otp_vue_vue_type_script_setup_true_lang_default from "./input-otp.vue_vue_type_script_setup_true_lang.mjs";
+//#region ../../packages/components/input-otp/src/input-otp.vue
+var input_otp_default = input_otp_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { input_otp_default as default };
+
+//# sourceMappingURL=input-otp2.mjs.map

frontend/node_modules/element-plus/es/components/input-otp/src/instance.d.ts

@@ -0,0 +1,6 @@
+import _default from "./input-otp.vue.js";
+
+//#region ../../packages/components/input-otp/src/instance.d.ts
+type InputOtpInstance = InstanceType<typeof _default> & unknown;
+//#endregion
+export { InputOtpInstance };

frontend/node_modules/element-plus/es/components/input-otp/style/css.mjs

@@ -0,0 +1,2 @@
+import "../../base/style/css.mjs";
+import "element-plus/theme-chalk/el-input-otp.css";

frontend/node_modules/element-plus/es/components/input-otp/style/index.mjs

@@ -0,0 +1,2 @@
+import "../../base/style/index.mjs";
+import "element-plus/theme-chalk/src/input-otp.scss";