@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/floating-panel/interface.d.ts

@@ -0,0 +1,48 @@
+import type { CSSProperties } from 'vue';
+export interface FloatingPanelSemanticClassNames {
+    root?: string;
+    header?: string;
+    content?: string;
+}
+export interface FloatingPanelSemanticStyles {
+    root?: CSSProperties;
+    header?: CSSProperties;
+    content?: CSSProperties;
+}
+export interface FloatingPanelProps {
+    /** Visible height of the panel in px. Supports `v-model:height`. */
+    height?: number;
+    /** Heights (px) the panel snaps to. Default `[100, 60% of the viewport (or of the positioned parent)]`. */
+    anchors?: number[];
+    /** Dragging the content moves the panel (the content scrolls once the panel is fully expanded) */
+    contentDraggable?: boolean;
+    /** Duration of the snap animation in ms */
+    duration?: number;
+    /** Reserve the bottom safe area */
+    safeArea?: boolean;
+    /** Lock page scroll, by default it is only locked while dragging */
+    lockScroll?: boolean;
+    /** `true`: fixed to the viewport. `false`: absolutely positioned inside the nearest positioned ancestor. */
+    fixed?: boolean;
+    zIndex?: number;
+    rootClass?: string;
+    classes?: FloatingPanelSemanticClassNames;
+    styles?: FloatingPanelSemanticStyles;
+}
+export interface FloatingPanelEmits {
+    'update:height': [height: number];
+    /** Fires while dragging (`animating: false`) and when snapping to an anchor (`animating: true`) */
+    'heightChange': [height: number, info: {
+        animating: boolean;
+    }];
+}
+export interface FloatingPanelSlots {
+    default?: () => any;
+    /** replaces the drag handle */
+    header?: () => any;
+}
+export interface FloatingPanelRef {
+    setHeight: (height: number, options?: {
+        immediate?: boolean;
+    }) => void;
+}

package/dist/floating-panel/style/index.css

@@ -0,0 +1,92 @@
+.am-floating-panel {
+  --am-floating-panel-z-index: 999;
+  --am-floating-panel-bg: var(--am-color-bg-elevated);
+  --am-floating-panel-border-radius: var(--am-border-radius-xl);
+  --am-floating-panel-header-height: 30px;
+  --am-floating-panel-bar-width: 32px;
+  --am-floating-panel-bar-height: 4px;
+  --am-floating-panel-bar-color: var(--am-color-fill);
+  --am-floating-panel-shadow: var(--am-box-shadow);
+
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  z-index: var(--am-floating-panel-z-index);
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+  width: 100%;
+  color: var(--am-color-text);
+  font-size: var(--am-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height);
+  background: var(--am-floating-panel-bg);
+  border-start-start-radius: var(--am-floating-panel-border-radius);
+  border-start-end-radius: var(--am-floating-panel-border-radius);
+  box-shadow: var(--am-floating-panel-shadow);
+  transition-timing-function: var(--am-motion-ease-out-circ);
+  transition-property: transform;
+  will-change: transform;
+  touch-action: none;
+  -webkit-tap-highlight-color: transparent;
+}
+
+/* inside a positioned box (the parent should clip with `overflow: hidden`) */
+.am-floating-panel-absolute {
+  position: absolute;
+}
+
+/* fills the gap below the panel when it is pulled above its last anchor */
+.am-floating-panel::after {
+  position: absolute;
+  bottom: -100vh;
+  left: 0;
+  display: block;
+  width: 100%;
+  height: 100vh;
+  background: inherit;
+  content: '';
+}
+
+.am-floating-panel-header {
+  display: flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  min-height: var(--am-floating-panel-header-height);
+  cursor: grab;
+  user-select: none;
+}
+
+.am-floating-panel-dragging .am-floating-panel-header {
+  cursor: grabbing;
+}
+
+.am-floating-panel-bar {
+  width: var(--am-floating-panel-bar-width);
+  height: var(--am-floating-panel-bar-height);
+  background: var(--am-floating-panel-bar-color);
+  border-radius: var(--am-floating-panel-bar-height);
+}
+
+.am-floating-panel-content {
+  flex: 1;
+  box-sizing: border-box;
+  min-height: 0;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+  -webkit-overflow-scrolling: touch;
+  touch-action: pan-y;
+}
+
+.am-floating-panel-safe-area .am-floating-panel-content {
+  padding-bottom: constant(safe-area-inset-bottom);
+  padding-bottom: env(safe-area-inset-bottom);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .am-floating-panel {
+    transition-duration: 0.01s !important;
+  }
+}

package/dist/form/Form.js

@@ -0,0 +1,4 @@
+import Form_vue_vue_type_script_setup_true_lang_default from "./Form.vue_vue_type_script_setup_true_lang.js";
+// src/form/Form.vue
+var Form_default = Form_vue_vue_type_script_setup_true_lang_default;
+export { Form_default as default };

package/dist/form/Form.vue.d.ts

@@ -0,0 +1,41 @@
+import type { FormInstance, FormInternalNamePath, FormProps, FormScrollOptions, FormSlots, FormValidateErrorEntity } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = FormSlots;
+declare const __VLS_base: import("vue").DefineComponent<FormProps, FormInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: (event: Event) => any;
+    reset: (event: Event) => any;
+    finish: (values: Record<string, any>) => any;
+    finishFailed: (errorInfo: FormValidateErrorEntity<any>) => any;
+    validate: (name: FormInternalNamePath, status: boolean, errors: string[] | null) => any;
+    valuesChange: (changedValues: Record<string, any>, values: Record<string, any>) => any;
+}, string, import("vue").PublicProps, Readonly<FormProps> & Readonly<{
+    onSubmit?: ((event: Event) => any) | undefined;
+    onReset?: ((event: Event) => any) | undefined;
+    onFinish?: ((values: Record<string, any>) => any) | undefined;
+    onFinishFailed?: ((errorInfo: FormValidateErrorEntity<any>) => any) | undefined;
+    onValidate?: ((name: FormInternalNamePath, status: boolean, errors: string[] | null) => any) | undefined;
+    onValuesChange?: ((changedValues: Record<string, any>, values: Record<string, any>) => any) | undefined;
+}>, {
+    footer: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    header: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    layout: import("./interface").FormLayout;
+    disabled: boolean;
+    mode: import("./interface").FormMode;
+    colon: boolean;
+    validateTrigger: import("./interface").FormValidateTrigger;
+    requiredMark: import("./interface").FormRequiredMark;
+    scrollToFirstError: boolean | FormScrollOptions;
+}, {}, {}, {}, 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/form/Form.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,367 @@
+import { inBrowser } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { configContextKey, disabledContextKey, useConfig } from "../config-provider/context.js";
+import { useLocale } from "../locale/index.js";
+import { variantContextKey } from "./context.js";
+import { defaultScrollOptions, formInternalContextKey } from "./internal.js";
+import { allPromiseFinish, cloneValue, getNamePath, getValue, isSameNamePath, mergeMessages, setValue } from "./utils.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, inject, mergeProps, normalizeClass, normalizeStyle, openBlock, provide, ref, renderSlot, unref } from "vue";
+// src/form/Form.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["name", "autocomplete"];
+var Form_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmForm",
+	inheritAttrs: false,
+	__name: "Form",
+	props: {
+		model: {},
+		rules: {},
+		name: {},
+		layout: { default: "horizontal" },
+		labelAlign: {},
+		labelWidth: {},
+		labelWrap: { type: Boolean },
+		colon: {
+			type: Boolean,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		size: {},
+		variant: {},
+		requiredMark: {
+			type: [Boolean, String],
+			default: true
+		},
+		validateTrigger: {
+			type: [
+				String,
+				Array,
+				Boolean
+			],
+			default: void 0
+		},
+		validateMessages: {},
+		scrollToFirstError: {
+			type: [Boolean, Object],
+			default: false
+		},
+		mode: { default: "default" },
+		contentAlign: {},
+		header: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		footer: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		autocomplete: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: [
+		"finish",
+		"finishFailed",
+		"submit",
+		"reset",
+		"validate",
+		"valuesChange"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const config = useConfig();
+		const locale = useLocale("Form");
+		const formRef = ref();
+		const parentDisabled = inject(disabledContextKey, void 0);
+		provide(disabledContextKey, computed(() => props.disabled ?? parentDisabled?.value));
+		provide(variantContextKey, computed(() => props.variant ?? "borderless"));
+		provide(configContextKey, {
+			...config,
+			componentSize: computed(() => props.size ?? config.componentSize.value)
+		});
+		const validateMessages = computed(() => mergeMessages(locale.value.defaultValidateMessages, props.validateMessages));
+		const fields = [];
+		let lastValidatePromise;
+		function addField(field) {
+			if (!fields.includes(field)) fields.push(field);
+		}
+		function removeField(field) {
+			const index = fields.indexOf(field);
+			if (index > -1) fields.splice(index, 1);
+		}
+		function getFieldEntities(nameList) {
+			const named = fields.filter((field) => field.namePath().length);
+			if (!nameList) return named;
+			return named.filter((field) => nameList.some((name) => isSameNamePath(name, field.namePath())));
+		}
+		function toNameList(nameList) {
+			return nameList?.length ? nameList.map(getNamePath) : void 0;
+		}
+		function getFieldValue(name) {
+			return getValue(props.model, getNamePath(name));
+		}
+		function pickValues(nameList) {
+			const values = {};
+			nameList.forEach((namePath) => {
+				setValue(values, namePath, cloneValue(getValue(props.model, namePath)));
+			});
+			return values;
+		}
+		function getFieldsValue(nameList) {
+			if (nameList === true) return cloneValue(props.model ?? {});
+			if (Array.isArray(nameList)) return pickValues(nameList.map(getNamePath));
+			return pickValues(getFieldEntities().map((field) => field.namePath()));
+		}
+		function getFieldsError(nameList) {
+			return getFieldEntities(toNameList(nameList)).map((field) => {
+				const meta = field.getMeta();
+				return {
+					name: field.namePath(),
+					errors: meta.errors,
+					warnings: meta.warnings
+				};
+			});
+		}
+		function getFieldMeta(name) {
+			return getFieldEntities([getNamePath(name)])[0]?.getMeta();
+		}
+		function isFieldsTouched(nameList, allFieldsTouched) {
+			if (nameList === false) return false;
+			const all = typeof nameList === "boolean" ? nameList : allFieldsTouched;
+			const entities = getFieldEntities(Array.isArray(nameList) ? nameList.map(getNamePath) : void 0);
+			if (!entities.length) return false;
+			return all ? entities.every((field) => field.getMeta().touched) : entities.some((field) => field.getMeta().touched);
+		}
+		function resetFields(nameList) {
+			getFieldEntities(toNameList(nameList)).forEach((field) => field.resetField());
+		}
+		function clearValidate(nameList) {
+			getFieldEntities(toNameList(nameList)).forEach((field) => field.clearValidate());
+		}
+		function triggerValuesChange(namePath, value) {
+			if (!props.model) return;
+			const changedValues = {};
+			setValue(changedValues, namePath, value);
+			emit("valuesChange", changedValues, props.model);
+		}
+		function setFieldValue(name, value) {
+			if (!props.model) return;
+			const namePath = getNamePath(name);
+			setValue(props.model, namePath, value);
+			triggerValuesChange(namePath, value);
+		}
+		function setFieldsValue(values) {
+			if (!props.model) return;
+			Object.keys(values || {}).forEach((key) => {
+				setValue(props.model, [key], values[key]);
+			});
+		}
+		function setFields(data) {
+			data.forEach((item) => {
+				const namePath = getNamePath(item.name);
+				const target = getFieldEntities([namePath])[0];
+				if (target) {
+					const meta = target.getMeta();
+					target.setFieldState({
+						errors: item.errors ?? [],
+						warnings: item.warnings ?? [],
+						touched: item.touched ?? meta.touched,
+						validating: item.validating ?? meta.validating
+					});
+				}
+				if (Object.prototype.hasOwnProperty.call(item, "value") && props.model) setValue(props.model, namePath, item.value);
+			});
+		}
+		function validateFields(arg1, arg2) {
+			const nameList = Array.isArray(arg1) ? arg1 : void 0;
+			const options = (Array.isArray(arg1) ? arg2 : arg1) ?? {};
+			const provideNameList = !!nameList?.length;
+			const namePathList = provideNameList ? nameList.map(getNamePath) : [];
+			const promiseList = [];
+			getFieldEntities(provideNameList ? namePathList : void 0).forEach((field) => {
+				if (!provideNameList) namePathList.push(field.namePath());
+				if (!field.rules().length) return;
+				if (options.dirty) {
+					const meta = field.getMeta();
+					if (!meta.touched && !meta.validated) return;
+				}
+				const name = field.namePath();
+				promiseList.push(field.validateRules(options).then(() => ({
+					name,
+					errors: [],
+					warnings: []
+				})).catch((ruleErrors) => {
+					const errors = [];
+					const warnings = [];
+					ruleErrors?.forEach?.(({ rule, errors: ruleErrorList }) => {
+						if (rule?.warningOnly) warnings.push(...ruleErrorList);
+						else errors.push(...ruleErrorList);
+					});
+					if (errors.length) return Promise.reject({
+						name,
+						errors,
+						warnings
+					});
+					return {
+						name,
+						errors,
+						warnings
+					};
+				}));
+			});
+			const summaryPromise = allPromiseFinish(promiseList);
+			lastValidatePromise = summaryPromise;
+			const returnPromise = summaryPromise.then(() => {
+				if (lastValidatePromise === summaryPromise) return getFieldsValue(namePathList);
+				return Promise.reject([]);
+			}).catch((results) => {
+				const errorFields = results.filter((result) => result && result.errors.length);
+				const errorInfo = {
+					message: errorFields[0]?.errors?.[0],
+					values: getFieldsValue(namePathList),
+					errorFields,
+					outOfDate: lastValidatePromise !== summaryPromise
+				};
+				return Promise.reject(errorInfo);
+			});
+			returnPromise.catch((e) => e);
+			return returnPromise;
+		}
+		function focusField(name) {
+			if (!inBrowser) return;
+			const id = getFieldEntities([getNamePath(name)])[0]?.getId();
+			const node = id ? document.getElementById(id) : null;
+			try {
+				node?.focus({ preventScroll: true });
+			} catch {}
+		}
+		function scrollToField(name, options = {}) {
+			const el = getFieldEntities([getNamePath(name)])[0]?.getElement();
+			if (!el) return;
+			const merged = {
+				...defaultScrollOptions,
+				...typeof options === "object" ? options : void 0
+			};
+			el.scrollIntoView?.({
+				behavior: merged.behavior,
+				block: merged.block
+			});
+			if (merged.focus) focusField(name);
+		}
+		function handleFinishFailed(errorInfo) {
+			emit("finishFailed", errorInfo);
+			const first = errorInfo.errorFields?.[0]?.name;
+			if (first && props.scrollToFirstError) scrollToField(first, props.scrollToFirstError);
+		}
+		function handleSubmit(event) {
+			event.preventDefault();
+			event.stopPropagation();
+			emit("submit", event);
+			if (!props.model) return;
+			validateFields().then((values) => emit("finish", values)).catch((errorInfo) => handleFinishFailed(errorInfo));
+		}
+		function handleReset(event) {
+			event.preventDefault();
+			emit("reset", event);
+			resetFields();
+		}
+		function submit() {
+			handleSubmit(new Event("submit", { cancelable: true }));
+		}
+		provide(formInternalContextKey, {
+			props,
+			validateMessages,
+			addField,
+			removeField,
+			onValidate: (name, status, errors) => emit("validate", name, status, errors),
+			triggerValuesChange
+		});
+		const classNames = computed(() => [
+			"am-form",
+			`am-form-${props.layout}`,
+			{
+				"am-form-card": props.mode === "card",
+				"am-form-disabled": props.disabled,
+				"am-form-rtl": config.direction.value === "rtl"
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		__expose({
+			getFieldValue,
+			getFieldsValue,
+			getFieldError: (name) => getFieldMeta(name)?.errors ?? [],
+			getFieldsError,
+			getFieldWarning: (name) => getFieldMeta(name)?.warnings ?? [],
+			isFieldTouched: (name) => !!getFieldMeta(name)?.touched,
+			isFieldsTouched,
+			isFieldValidating: (name) => !!getFieldMeta(name)?.validating,
+			isFieldsValidating: (nameList) => getFieldEntities(toNameList(nameList)).some((field) => field.getMeta().validating),
+			resetFields,
+			clearValidate,
+			setFields,
+			setFieldValue,
+			setFieldsValue,
+			validateFields,
+			validate: validateFields,
+			submit,
+			scrollToField,
+			focusField,
+			get nativeElement() {
+				return formRef.value;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("form", mergeProps({
+				ref_key: "formRef",
+				ref: formRef
+			}, _ctx.$attrs, {
+				class: classNames.value,
+				style: __props.styles?.root,
+				name: __props.name,
+				autocomplete: __props.autocomplete,
+				novalidate: "",
+				onSubmit: handleSubmit,
+				onReset: handleReset
+			}), [
+				_ctx.$slots.header || __props.header !== void 0 && __props.header !== null && __props.header !== false ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(["am-form-header", __props.classes?.header]),
+					style: normalizeStyle(__props.styles?.header)
+				}, [renderSlot(_ctx.$slots, "header", {}, () => [createVNode(unref(RenderNode_default), { node: __props.header }, null, 8, ["node"])])], 6)) : createCommentVNode("", true),
+				createElementVNode("div", {
+					class: normalizeClass(["am-form-body", __props.classes?.body]),
+					style: normalizeStyle(__props.styles?.body)
+				}, [renderSlot(_ctx.$slots, "default")], 6),
+				_ctx.$slots.footer || __props.footer !== void 0 && __props.footer !== null && __props.footer !== false ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					class: normalizeClass(["am-form-footer", __props.classes?.footer]),
+					style: normalizeStyle(__props.styles?.footer)
+				}, [renderSlot(_ctx.$slots, "footer", {}, () => [createVNode(unref(RenderNode_default), { node: __props.footer }, null, 8, ["node"])])], 6)) : createCommentVNode("", true)
+			], 16, _hoisted_1);
+		};
+	}
+});
+export { Form_vue_vue_type_script_setup_true_lang_default as default };

package/dist/form/FormItem.js

@@ -0,0 +1,4 @@
+import FormItem_vue_vue_type_script_setup_true_lang_default from "./FormItem.vue_vue_type_script_setup_true_lang.js";
+// src/form/FormItem.vue
+var FormItem_default = FormItem_vue_vue_type_script_setup_true_lang_default;
+export { FormItem_default as default };

package/dist/form/FormItem.vue.d.ts

@@ -0,0 +1,34 @@
+import type { FormItemInstance, FormItemProps, FormItemSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = FormItemSlots;
+declare const __VLS_base: import("vue").DefineComponent<FormItemProps, FormItemInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<FormItemProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    label: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    help: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    extra: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    required: boolean;
+    colon: boolean;
+    validateTrigger: import("./interface").FormValidateTrigger;
+    validateFirst: boolean | "parallel";
+    arrow: 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;
+    };
+};