@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/input/useInput.js

@@ -0,0 +1,133 @@
+import { useCompactItemContext } from "../_base/compact.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import { useDisabled, useSize } from "../config-provider/context.js";
+import { useFormItemInputContext, useMergedStatus, useVariant } from "../form/context.js";
+import { computed, nextTick, ref } from "vue";
+// src/input/useInput.ts
+var toText = (value) => value === void 0 || value === null ? "" : String(value);
+/** A synthetic event whose `target` is the native control, used when the value changes without a native event. */
+function resolveEvent(event, target) {
+	return Object.create(event, {
+		target: { value: target },
+		currentTarget: { value: target }
+	});
+}
+/**
+* Shared logic of Input / TextArea: controlled value, IME composition, focus state,
+* clear, and the FormItem contract.
+*/
+function useInput(props, emit, elRef) {
+	const formItem = useFormItemInputContext();
+	const disabled = useDisabled(() => props.disabled);
+	const compact = useCompactItemContext();
+	const size = useSize(() => props.size ?? compact.size.value);
+	const status = useMergedStatus(() => props.status);
+	const variant = useVariant(() => props.variant);
+	const readOnly = computed(() => !!(props.readOnly || props.readonly));
+	const fieldId = computed(() => props.id ?? formItem.id.value);
+	const [rawValue, setRawValue] = useControlled(props, "value", {
+		defaultValue: () => props.defaultValue ?? "",
+		onChange: (value) => emit("update:value", toText(value))
+	});
+	const value = computed(() => toText(rawValue.value));
+	const focused = ref(false);
+	let composing = false;
+	let justComposed = false;
+	/** A controlled input whose parent ignored the update must show the prop value again. */
+	function syncElement() {
+		nextTick(() => {
+			const el = elRef.value;
+			if (el && !composing && el.value !== value.value) el.value = value.value;
+		});
+	}
+	function commit(next, event) {
+		if (next !== value.value) setRawValue(next);
+		emit("input", event);
+		emit("change", event);
+		formItem.onFieldChange();
+		syncElement();
+	}
+	function handleInput(event) {
+		if (composing || event.isComposing) return;
+		if (justComposed && event.target.value === value.value) return;
+		commit(event.target.value, event);
+	}
+	function handleCompositionStart(event) {
+		composing = true;
+		emit("compositionstart", event);
+	}
+	function handleCompositionEnd(event) {
+		composing = false;
+		emit("compositionend", event);
+		commit(event.target.value, event);
+		justComposed = true;
+		setTimeout(() => {
+			justComposed = false;
+		});
+	}
+	function handleFocus(event) {
+		focused.value = true;
+		emit("focus", event);
+	}
+	function handleBlur(event) {
+		focused.value = false;
+		composing = false;
+		emit("blur", event);
+		formItem.onFieldBlur();
+	}
+	function handleClear(event) {
+		const el = elRef.value;
+		if (el) el.value = "";
+		if (value.value !== "") setRawValue("");
+		emit("clear");
+		if (el) {
+			const synthetic = resolveEvent(event, el);
+			emit("input", synthetic);
+			emit("change", synthetic);
+		}
+		formItem.onFieldChange();
+		syncElement();
+		el?.focus();
+	}
+	function focus(options) {
+		const el = elRef.value;
+		if (!el) return;
+		el.focus({ preventScroll: options?.preventScroll });
+		const cursor = options?.cursor;
+		if (!cursor) return;
+		const length = el.value.length;
+		try {
+			if (cursor === "start") el.setSelectionRange(0, 0);
+			else if (cursor === "end") el.setSelectionRange(length, length);
+			else el.setSelectionRange(0, length);
+		} catch {}
+	}
+	const blur = () => elRef.value?.blur();
+	const select = () => elRef.value?.select();
+	return {
+		value,
+		focused,
+		disabled,
+		size,
+		/** classes that make the field part of a Space.Compact group */
+		compactClasses: compact.classes,
+		status,
+		variant,
+		readOnly,
+		fieldId,
+		handleInput,
+		handleCompositionStart,
+		handleCompositionEnd,
+		handleFocus,
+		handleBlur,
+		handleClear,
+		focus,
+		blur,
+		select
+	};
+}
+/** Counts user-perceived characters (an emoji is one). */
+function countText(text) {
+	return Array.from(text).length;
+}
+export { countText, resolveEvent, useInput };

package/dist/input-number/InputNumber.js

@@ -0,0 +1,4 @@
+import InputNumber_vue_vue_type_script_setup_true_lang_default from "./InputNumber.vue_vue_type_script_setup_true_lang.js";
+// src/input-number/InputNumber.vue
+var InputNumber_default = InputNumber_vue_vue_type_script_setup_true_lang_default;
+export { InputNumber_default as default };

package/dist/input-number/InputNumber.vue.d.ts

@@ -0,0 +1,45 @@
+import type { InputNumberInstance, InputNumberProps, InputNumberSlots, InputNumberValueType } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = InputNumberSlots;
+declare const __VLS_base: import("vue").DefineComponent<InputNumberProps, InputNumberInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (text: string) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: InputNumberValueType | null) => any;
+    focus: (event: FocusEvent) => any;
+    "update:value": (value: InputNumberValueType | null) => any;
+    step: (value: InputNumberValueType, info: import("./interface").InputNumberStepContext) => any;
+    pressEnter: (event: KeyboardEvent) => any;
+}, string, import("vue").PublicProps, Readonly<InputNumberProps> & Readonly<{
+    onInput?: ((text: string) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: InputNumberValueType | null) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:value"?: ((value: InputNumberValueType | null) => any) | undefined;
+    onStep?: ((value: InputNumberValueType, info: import("./interface").InputNumberStepContext) => any) | undefined;
+    onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    prefix: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    disabled: boolean;
+    mode: import("./interface").InputNumberMode;
+    inputmode: string;
+    value: InputNumberValueType | null;
+    keyboard: boolean;
+    step: InputNumberValueType;
+    controls: boolean | import("./interface").InputNumberControlsConfig;
+    changeOnBlur: boolean;
+    longPress: boolean;
+    suffix: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+}, {}, {}, {}, 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/input-number/InputNumber.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,424 @@
+import { useCompactItemContext } from "../_base/compact.js";
+import { clamp, isRenderable, preventDefault } from "../_util/index.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useDisabled, useSize } from "../config-provider/context.js";
+import { useFormItemInputContext, useMergedStatus, useVariant } from "../form/context.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderSlot, unref, useSlots, watch } from "vue";
+import { MinusOutlined, PlusOutlined } from "@antdv-next/icons";
+// src/input-number/InputNumber.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["disabled"];
+var _hoisted_2 = { class: "am-input-number-wrapper" };
+var _hoisted_3 = [
+	"id",
+	"value",
+	"name",
+	"placeholder",
+	"disabled",
+	"readonly",
+	"inputmode",
+	"aria-valuemin",
+	"aria-valuemax",
+	"aria-valuenow",
+	"aria-invalid"
+];
+var _hoisted_4 = ["disabled"];
+var LONG_PRESS_DELAY = 500;
+var LONG_PRESS_INTERVAL = 120;
+var InputNumber_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmInputNumber",
+	inheritAttrs: false,
+	__name: "InputNumber",
+	props: {
+		value: { default: void 0 },
+		defaultValue: {},
+		min: {},
+		max: {},
+		step: { default: 1 },
+		precision: {},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		readOnly: { type: Boolean },
+		readonly: { type: Boolean },
+		controls: {
+			type: [Boolean, Object],
+			default: true
+		},
+		mode: { default: "spinner" },
+		formatter: {},
+		parser: {},
+		stringMode: { type: Boolean },
+		changeOnBlur: {
+			type: Boolean,
+			default: true
+		},
+		keyboard: {
+			type: Boolean,
+			default: true
+		},
+		longPress: {
+			type: Boolean,
+			default: true
+		},
+		prefix: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		suffix: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		status: {},
+		size: {},
+		variant: {},
+		placeholder: {},
+		inputmode: { default: "decimal" },
+		autofocus: { type: Boolean },
+		name: {},
+		id: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: [
+		"update:value",
+		"change",
+		"input",
+		"step",
+		"pressEnter",
+		"focus",
+		"blur"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const formItem = useFormItemInputContext();
+		const disabled = useDisabled(() => props.disabled);
+		const compact = useCompactItemContext();
+		const size = useSize(() => props.size ?? compact.size.value);
+		const status = useMergedStatus(() => props.status);
+		const variant = useVariant(() => props.variant);
+		const readOnly = computed(() => !!(props.readOnly || props.readonly));
+		const fieldId = computed(() => props.id ?? formItem.id.value);
+		const rootRef = ref();
+		const inputRef = ref();
+		const focused = ref(false);
+		function toNumber(value) {
+			if (value === "" || value === null || value === void 0) return NaN;
+			return typeof value === "number" ? value : Number(String(value).trim());
+		}
+		const isEmpty = (value) => value === "" || value === null || value === void 0;
+		function getDecimals(value) {
+			const text = String(value ?? "");
+			if (/e-/i.test(text)) return Number(text.split(/e-/i)[1]) || 0;
+			const index = text.indexOf(".");
+			return index === -1 ? 0 : text.length - index - 1;
+		}
+		const min = computed(() => isEmpty(props.min) ? Number.NEGATIVE_INFINITY : toNumber(props.min));
+		const max = computed(() => isEmpty(props.max) ? Number.POSITIVE_INFINITY : toNumber(props.max));
+		const stepNumber = computed(() => {
+			const step = toNumber(props.step);
+			return Number.isNaN(step) || step === 0 ? 1 : Math.abs(step);
+		});
+		function round(num, decimals) {
+			return Number(num.toFixed(clamp(decimals, 0, 20)));
+		}
+		function clampNumber(num) {
+			return clamp(num, min.value, max.value);
+		}
+		/** number -> emitted value (`precision` applied, string in `stringMode`). */
+		function toValue(num, decimals = getDecimals(num)) {
+			const rounded = round(num, props.precision ?? decimals);
+			if (props.stringMode) return props.precision !== void 0 ? rounded.toFixed(props.precision) : String(rounded);
+			return rounded;
+		}
+		function formatValue(value, userTyping = false, input = "") {
+			if (isEmpty(value)) return "";
+			const num = toNumber(value);
+			let text = String(value);
+			if (!Number.isNaN(num) && props.precision !== void 0) text = num.toFixed(props.precision);
+			return props.formatter ? props.formatter(text, {
+				userTyping,
+				input
+			}) : text;
+		}
+		function parseText(text) {
+			return toNumber(props.parser ? props.parser(text) : text.replace(/,/g, "").replace(/。/g, "."));
+		}
+		const [value, setValue] = useControlled(props, "value", {
+			defaultValue: () => props.defaultValue ?? null,
+			onChange: (next) => {
+				emit("update:value", next);
+				emit("change", next);
+			}
+		});
+		const mergedValue = computed(() => props.value === null ? null : value.value);
+		const inputText = ref(formatValue(mergedValue.value));
+		watch([
+			mergedValue,
+			() => props.precision,
+			() => props.formatter
+		], () => {
+			if (focused.value && parseText(inputText.value) === toNumber(mergedValue.value)) return;
+			inputText.value = formatValue(mergedValue.value);
+		});
+		function isSame(a, b) {
+			if (isEmpty(a) || isEmpty(b)) return isEmpty(a) && isEmpty(b);
+			return String(a) === String(b);
+		}
+		function updateValue(next) {
+			if (isSame(next, mergedValue.value)) return false;
+			setValue(next);
+			formItem.onFieldChange();
+			return true;
+		}
+		const currentNumber = computed(() => toNumber(mergedValue.value));
+		const upDisabled = computed(() => disabled.value || readOnly.value || !Number.isNaN(currentNumber.value) && currentNumber.value >= max.value);
+		const downDisabled = computed(() => disabled.value || readOnly.value || !Number.isNaN(currentNumber.value) && currentNumber.value <= min.value);
+		function handleInput(event) {
+			const text = event.target.value;
+			inputText.value = text;
+			emit("input", text);
+			if (event.isComposing) return;
+			if (text.trim() === "") {
+				updateValue(null);
+				return;
+			}
+			const num = parseText(text);
+			if (Number.isNaN(num) || num < min.value || num > max.value) return;
+			updateValue(toValue(num, getDecimals(num)));
+		}
+		function commitText() {
+			const text = inputText.value;
+			if (text.trim() === "") updateValue(null);
+			else {
+				const num = parseText(text);
+				if (!Number.isNaN(num)) {
+					const next = clampNumber(num);
+					updateValue(toValue(next, getDecimals(next)));
+				}
+			}
+			inputText.value = formatValue(mergedValue.value);
+		}
+		function handleFocus(event) {
+			focused.value = true;
+			emit("focus", event);
+		}
+		function handleBlur(event) {
+			focused.value = false;
+			if (props.changeOnBlur) commitText();
+			else inputText.value = formatValue(mergedValue.value);
+			emit("blur", event);
+			formItem.onFieldBlur();
+		}
+		function step(type, emitter) {
+			if (type === "up" ? upDisabled.value : downDisabled.value) return false;
+			const offset = stepNumber.value;
+			let base = currentNumber.value;
+			if (Number.isNaN(base)) {
+				base = clampNumber(0);
+				if (base !== 0 || (type === "up" ? max.value : -min.value) < offset) {
+					const next = toValue(base, getDecimals(base));
+					if (updateValue(next)) emit("step", next, {
+						offset: props.step,
+						type,
+						emitter
+					});
+					inputText.value = formatValue(mergedValue.value);
+					return true;
+				}
+			}
+			const decimals = Math.max(getDecimals(base), getDecimals(offset));
+			const next = toValue(clampNumber(round(type === "up" ? base + offset : base - offset, decimals)), decimals);
+			const changed = updateValue(next);
+			inputText.value = formatValue(mergedValue.value);
+			if (changed) emit("step", next, {
+				offset: props.step,
+				type,
+				emitter
+			});
+			return changed;
+		}
+		let pressTimer;
+		let pressed = false;
+		function stopPress() {
+			pressed = false;
+			clearTimeout(pressTimer);
+			pressTimer = void 0;
+		}
+		function startPress(type, event) {
+			preventDefault(event);
+			stopPress();
+			if (!step(type, "handler") || !props.longPress) return;
+			pressed = true;
+			const loop = () => {
+				if (!pressed) return;
+				if (!step(type, "handler")) {
+					stopPress();
+					return;
+				}
+				pressTimer = setTimeout(loop, LONG_PRESS_INTERVAL);
+			};
+			pressTimer = setTimeout(loop, LONG_PRESS_DELAY);
+		}
+		function handleMouseDown(type, event) {
+			if (event.button !== 0) return;
+			startPress(type, event);
+		}
+		/** Keyboard / assistive activation (pointer presses are handled on touchstart / mousedown). */
+		function handleActionClick(type, event) {
+			if (event.detail === 0) step(type, "handler");
+		}
+		function handleKeydown(event) {
+			if (event.key === "Enter" && !event.isComposing) {
+				if (props.changeOnBlur) commitText();
+				emit("pressEnter", event);
+				return;
+			}
+			if (!props.keyboard || event.key !== "ArrowUp" && event.key !== "ArrowDown") return;
+			event.preventDefault();
+			step(event.key === "ArrowUp" ? "up" : "down", "keyboard");
+		}
+		onMounted(() => {
+			if (props.autofocus) inputRef.value?.focus();
+		});
+		onBeforeUnmount(stopPress);
+		const showControls = computed(() => props.mode === "spinner" && !!props.controls);
+		const upIcon = computed(() => typeof props.controls === "object" ? props.controls?.upIcon : void 0);
+		const downIcon = computed(() => typeof props.controls === "object" ? props.controls?.downIcon : void 0);
+		const hasPrefix = computed(() => !!slots.prefix || isRenderable(props.prefix));
+		const hasSuffix = computed(() => !!slots.suffix || isRenderable(props.suffix));
+		const classNames = computed(() => [
+			"am-input-number",
+			`am-input-number-mode-${props.mode}`,
+			`am-input-number-${variant.value}`,
+			{
+				"am-input-number-sm": size.value === "small",
+				"am-input-number-lg": size.value === "large",
+				"am-input-number-disabled": disabled.value,
+				"am-input-number-readonly": readOnly.value,
+				"am-input-number-focused": focused.value,
+				[`am-input-number-status-${status.value}`]: !!status.value
+			},
+			compact.classes.value,
+			props.rootClass,
+			props.classes?.root
+		]);
+		__expose({
+			focus: (options) => inputRef.value?.focus(options),
+			blur: () => inputRef.value?.blur(),
+			get input() {
+				return inputRef.value;
+			},
+			get nativeElement() {
+				return rootRef.value;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: classNames.value,
+				style: __props.styles?.root
+			}), [
+				showControls.value ? (openBlock(), createElementBlock("button", {
+					key: 0,
+					type: "button",
+					class: normalizeClass(["am-input-number-action am-input-number-action-down", [{ "am-input-number-action-disabled": downDisabled.value }, __props.classes?.action]]),
+					style: normalizeStyle(__props.styles?.action),
+					disabled: downDisabled.value,
+					tabindex: "-1",
+					"aria-label": "-",
+					onTouchstart: _cache[0] || (_cache[0] = ($event) => startPress("down", $event)),
+					onTouchend: stopPress,
+					onTouchcancel: stopPress,
+					onMousedown: _cache[1] || (_cache[1] = ($event) => handleMouseDown("down", $event)),
+					onMouseup: stopPress,
+					onMouseleave: stopPress,
+					onClick: _cache[2] || (_cache[2] = ($event) => handleActionClick("down", $event))
+				}, [renderSlot(_ctx.$slots, "downIcon", {}, () => [unref(isRenderable)(downIcon.value) ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: downIcon.value
+				}, null, 8, ["node"])) : (openBlock(), createBlock(unref(MinusOutlined), { key: 1 }))])], 46, _hoisted_1)) : createCommentVNode("", true),
+				createElementVNode("span", _hoisted_2, [
+					hasPrefix.value ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: normalizeClass(["am-input-number-prefix", __props.classes?.prefix]),
+						style: normalizeStyle(__props.styles?.prefix)
+					}, [renderSlot(_ctx.$slots, "prefix", {}, () => [createVNode(unref(RenderNode_default), { node: __props.prefix }, null, 8, ["node"])])], 6)) : createCommentVNode("", true),
+					createElementVNode("input", {
+						id: fieldId.value,
+						ref_key: "inputRef",
+						ref: inputRef,
+						class: normalizeClass(["am-input-number-input", __props.classes?.input]),
+						style: normalizeStyle(__props.styles?.input),
+						type: "text",
+						role: "spinbutton",
+						value: inputText.value,
+						name: __props.name,
+						placeholder: __props.placeholder,
+						disabled: unref(disabled),
+						readonly: readOnly.value,
+						inputmode: __props.inputmode,
+						autocomplete: "off",
+						"aria-valuemin": Number.isFinite(min.value) ? min.value : void 0,
+						"aria-valuemax": Number.isFinite(max.value) ? max.value : void 0,
+						"aria-valuenow": Number.isNaN(currentNumber.value) ? void 0 : currentNumber.value,
+						"aria-invalid": unref(status) === "error" || void 0,
+						onInput: handleInput,
+						onFocus: handleFocus,
+						onBlur: handleBlur,
+						onKeydown: handleKeydown
+					}, null, 46, _hoisted_3),
+					hasSuffix.value ? (openBlock(), createElementBlock("span", {
+						key: 1,
+						class: normalizeClass(["am-input-number-suffix", __props.classes?.suffix]),
+						style: normalizeStyle(__props.styles?.suffix)
+					}, [renderSlot(_ctx.$slots, "suffix", {}, () => [createVNode(unref(RenderNode_default), { node: __props.suffix }, null, 8, ["node"])])], 6)) : createCommentVNode("", true)
+				]),
+				showControls.value ? (openBlock(), createElementBlock("button", {
+					key: 1,
+					type: "button",
+					class: normalizeClass(["am-input-number-action am-input-number-action-up", [{ "am-input-number-action-disabled": upDisabled.value }, __props.classes?.action]]),
+					style: normalizeStyle(__props.styles?.action),
+					disabled: upDisabled.value,
+					tabindex: "-1",
+					"aria-label": "+",
+					onTouchstart: _cache[3] || (_cache[3] = ($event) => startPress("up", $event)),
+					onTouchend: stopPress,
+					onTouchcancel: stopPress,
+					onMousedown: _cache[4] || (_cache[4] = ($event) => handleMouseDown("up", $event)),
+					onMouseup: stopPress,
+					onMouseleave: stopPress,
+					onClick: _cache[5] || (_cache[5] = ($event) => handleActionClick("up", $event))
+				}, [renderSlot(_ctx.$slots, "upIcon", {}, () => [unref(isRenderable)(upIcon.value) ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: upIcon.value
+				}, null, 8, ["node"])) : (openBlock(), createBlock(unref(PlusOutlined), { key: 1 }))])], 46, _hoisted_4)) : createCommentVNode("", true)
+			], 16);
+		};
+	}
+});
+export { InputNumber_vue_vue_type_script_setup_true_lang_default as default };