@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/form/style/index.css

@@ -0,0 +1,256 @@
+.am-form,
+.am-form-item-standalone {
+  /* component tokens */
+  --am-form-background: var(--am-color-bg-container);
+  --am-form-font-size: var(--am-font-size-lg);
+  --am-form-label-width: 5.6em;
+  --am-form-label-color: var(--am-color-text);
+  --am-form-label-gap: var(--am-padding-sm);
+  --am-form-item-padding-block: 9px;
+  --am-form-item-padding-inline: var(--am-padding);
+  --am-form-item-content-min-height: 30px;
+  --am-form-item-active-background: var(--am-color-fill-tertiary);
+  --am-form-explain-font-size: var(--am-font-size-sm);
+  --am-form-header-color: var(--am-color-text-tertiary);
+  --am-form-card-radius: var(--am-border-radius-lg);
+  --am-form-card-margin: var(--am-margin-sm);
+}
+
+.am-form {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: var(--am-color-text);
+  font-size: var(--am-form-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height-lg);
+}
+
+.am-form-header {
+  box-sizing: border-box;
+  padding: var(--am-padding-sm) var(--am-form-item-padding-inline) var(--am-padding-xs);
+  color: var(--am-form-header-color);
+  font-size: var(--am-font-size);
+}
+
+.am-form-body {
+  position: relative;
+  background: var(--am-form-background);
+}
+
+.am-form-footer {
+  box-sizing: border-box;
+  padding: var(--am-padding) var(--am-form-item-padding-inline);
+}
+
+/* ---------- card mode ---------- */
+.am-form-card .am-form-body {
+  margin: 0 var(--am-form-card-margin);
+  overflow: hidden;
+  border-radius: var(--am-form-card-radius);
+}
+
+.am-form-card .am-form-header,
+.am-form-card .am-form-footer {
+  padding-inline: calc(var(--am-form-card-margin) + var(--am-form-item-padding-inline));
+}
+
+/* ---------- item ---------- */
+.am-form-item {
+  position: relative;
+  display: flex;
+  align-items: flex-start;
+  box-sizing: border-box;
+  padding: var(--am-form-item-padding-block) var(--am-form-item-padding-inline);
+  color: var(--am-color-text);
+  font-size: var(--am-form-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height-lg);
+  -webkit-tap-highlight-color: transparent;
+}
+
+.am-form-item-standalone {
+  background: var(--am-form-background);
+}
+
+.am-form-item-hidden {
+  display: none;
+}
+
+/* hairline between two visible items */
+.am-form-item:not(.am-form-item-hidden) ~ .am-form-item:not(.am-form-item-hidden)::before {
+  position: absolute;
+  top: 0;
+  right: 0;
+  left: var(--am-form-item-padding-inline);
+  box-sizing: border-box;
+  border-top: var(--am-line-width) var(--am-line-type) var(--am-color-split);
+  transform: scaleY(0.5);
+  transform-origin: top;
+  content: '';
+  pointer-events: none;
+}
+
+.am-form-item-clickable {
+  cursor: pointer;
+  transition: background-color var(--am-motion-duration-mid);
+}
+
+.am-form-item-clickable:active {
+  background: var(--am-form-item-active-background);
+}
+
+/* ---------- label ---------- */
+.am-form-item-label {
+  display: flex;
+  flex: none;
+  align-items: center;
+  box-sizing: border-box;
+  width: var(--am-form-label-width);
+  min-height: var(--am-form-item-content-min-height);
+  margin-inline-end: var(--am-form-label-gap);
+  color: var(--am-form-label-color);
+}
+
+.am-form-item-label > label {
+  display: inline-flex;
+  align-items: center;
+  max-width: 100%;
+  color: inherit;
+  font-size: inherit;
+}
+
+.am-form-item-label-end {
+  justify-content: flex-end;
+  text-align: end;
+}
+
+.am-form-item-label-text {
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.am-form-item-label-wrap .am-form-item-label-text {
+  white-space: normal;
+  word-break: break-word;
+}
+
+.am-form-item-colon::after {
+  margin-inline: 2px 0;
+  content: ':';
+}
+
+.am-form-item-required-mark {
+  flex: none;
+  margin-inline-end: 4px;
+  color: var(--am-color-error);
+  font-family: SimSun, sans-serif;
+  line-height: 1;
+}
+
+.am-form-item-optional {
+  flex: none;
+  margin-inline-start: 2px;
+  color: var(--am-color-text-tertiary);
+  font-size: var(--am-font-size-sm);
+}
+
+/* ---------- control ---------- */
+.am-form-item-control {
+  flex: 1;
+  min-width: 0;
+}
+
+.am-form-item-control-input {
+  display: flex;
+  align-items: center;
+  min-height: var(--am-form-item-content-min-height);
+}
+
+.am-form-item-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.am-form-item-content > * {
+  vertical-align: middle;
+}
+
+.am-form-item-content-end .am-form-item-content,
+.am-form-item-content-end .am-form-item-explain,
+.am-form-item-content-end .am-form-item-extra {
+  text-align: end;
+}
+
+.am-form-item-arrow,
+.am-form-item-feedback-icon {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  margin-inline-start: var(--am-margin-xs);
+  font-size: var(--am-font-size);
+}
+
+.am-form-item-arrow {
+  color: var(--am-color-text-quaternary);
+}
+
+.am-form-item-has-success .am-form-item-feedback-icon {
+  color: var(--am-color-success);
+}
+
+.am-form-item-has-warning .am-form-item-feedback-icon {
+  color: var(--am-color-warning);
+}
+
+.am-form-item-has-error .am-form-item-feedback-icon {
+  color: var(--am-color-error);
+}
+
+.am-form-item-has-validating .am-form-item-feedback-icon {
+  color: var(--am-color-primary);
+}
+
+.am-form-item-explain,
+.am-form-item-extra {
+  margin-top: var(--am-margin-xxs);
+  color: var(--am-color-text-tertiary);
+  font-size: var(--am-form-explain-font-size);
+  line-height: var(--am-line-height);
+  word-break: break-word;
+}
+
+.am-form-item-explain-error {
+  color: var(--am-color-error);
+}
+
+.am-form-item-explain-warning {
+  color: var(--am-color-warning);
+}
+
+/* ---------- vertical ---------- */
+.am-form-item-vertical {
+  flex-direction: column;
+  align-items: stretch;
+}
+
+.am-form-item-vertical > .am-form-item-label {
+  width: auto;
+  min-height: 0;
+  margin-inline-end: 0;
+  margin-bottom: var(--am-margin-xxs);
+  color: var(--am-color-text-secondary);
+  font-size: var(--am-font-size);
+}
+
+/* ---------- rtl ---------- */
+[dir='rtl'] .am-form-item:not(.am-form-item-hidden) ~ .am-form-item:not(.am-form-item-hidden)::before {
+  right: var(--am-form-item-padding-inline);
+  left: 0;
+}
+
+[dir='rtl'] .am-form-item-arrow {
+  transform: scaleX(-1);
+}

package/dist/form/utils.d.ts

@@ -0,0 +1,23 @@
+import type { ValidateMessages } from '../locale/interface';
+import type { FormInternalNamePath, FormNamePath, FormRuleObject } from './interface';
+export interface FormRuleError {
+    errors: string[];
+    rule: FormRuleObject;
+}
+export declare function getNamePath(name?: FormNamePath | null): FormInternalNamePath;
+export declare function isSameNamePath(a: FormInternalNamePath, b: FormInternalNamePath): boolean;
+export declare function getValue(store: any, namePath: FormInternalNamePath): any;
+/** Sets a value in place (the model is a reactive object owned by the user). */
+export declare function setValue(store: any, namePath: FormInternalNamePath, value: any): void;
+/** Deep clone of plain objects / arrays; class instances (Date, dayjs, File ...) are kept by reference. */
+export declare function cloneValue<T>(value: T): T;
+export declare function isEqualValue(a: any, b: any): boolean;
+export declare function getFieldId(namePath: FormInternalNamePath, formName?: string): string | undefined;
+export declare function mergeMessages(...sources: (ValidateMessages | undefined)[]): ValidateMessages;
+/**
+ * Validates one value against its rules with `@v-c/async-validator` (one rule at a time,
+ * so every rule reports its own message). Resolves with `[]`, rejects with the rule errors.
+ */
+export declare function validateRules(namePath: FormInternalNamePath, value: any, rules: FormRuleObject[], messages: ValidateMessages, validateFirst: boolean | 'parallel', messageVariables?: Record<string, string>): Promise<FormRuleError[]>;
+/** Resolves when every promise resolved, rejects (after all settled) with every result otherwise. */
+export declare function allPromiseFinish<T>(promiseList: Promise<T>[]): Promise<T[]>;

package/dist/form/utils.js

@@ -0,0 +1,218 @@
+import { toArray } from "../_util/index.js";
+import RawAsyncValidator from "@v-c/async-validator";
+// src/form/utils.ts
+var AsyncValidator = RawAsyncValidator;
+function getNamePath(name) {
+	return toArray(name);
+}
+function isSameNamePath(a, b) {
+	return a.length === b.length && a.every((seg, i) => String(seg) === String(b[i]));
+}
+function getValue(store, namePath) {
+	let current = store;
+	for (let i = 0; i < namePath.length; i += 1) {
+		if (current === null || current === void 0) return void 0;
+		current = current[namePath[i]];
+	}
+	return current;
+}
+/** Sets a value in place (the model is a reactive object owned by the user). */
+function setValue(store, namePath, value) {
+	if (!store || !namePath.length) return;
+	let current = store;
+	for (let i = 0; i < namePath.length - 1; i += 1) {
+		const key = namePath[i];
+		if (current[key] === null || typeof current[key] !== "object") current[key] = typeof namePath[i + 1] === "number" ? [] : {};
+		current = current[key];
+	}
+	current[namePath[namePath.length - 1]] = value;
+}
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/** Deep clone of plain objects / arrays; class instances (Date, dayjs, File ...) are kept by reference. */
+function cloneValue(value) {
+	if (Array.isArray(value)) return value.map(cloneValue);
+	if (isPlainObject(value)) {
+		const ret = {};
+		Object.keys(value).forEach((key) => {
+			ret[key] = cloneValue(value[key]);
+		});
+		return ret;
+	}
+	return value;
+}
+function isEqualValue(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, i) => isEqualValue(item, b[i]));
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const keys = Object.keys(a);
+		return keys.length === Object.keys(b).length && keys.every((key) => isEqualValue(a[key], b[key]));
+	}
+	return false;
+}
+var illegalIds = [
+	"parentNode",
+	"tagName",
+	"nextSibling"
+];
+function getFieldId(namePath, formName) {
+	if (!namePath.length) return void 0;
+	const mergedId = namePath.join("_");
+	if (formName) return `${formName}_${mergedId}`;
+	return illegalIds.includes(mergedId) ? `form_item_${mergedId}` : mergedId;
+}
+function mergeMessages(...sources) {
+	const target = {};
+	sources.forEach((source) => {
+		if (!source) return;
+		Object.keys(source).forEach((key) => {
+			const value = source[key];
+			if (value === void 0) return;
+			target[key] = isPlainObject(value) ? {
+				...target[key],
+				...value
+			} : value;
+		});
+	});
+	return target;
+}
+/** `'${label} is required'` + `{ label: 'Name' }` -> `'Name is required'` */
+function replaceMessage(template, kv) {
+	return template.replace(/\\?\$\{\w+\}/g, (str) => {
+		if (str.startsWith("\\")) return str.slice(1);
+		const key = str.slice(2, -1);
+		return kv[key] === void 0 || kv[key] === null ? "" : String(kv[key]);
+	});
+}
+var CODE_LOGIC_ERROR = "CODE_LOGIC_ERROR";
+async function validateRule(name, value, rule, messages, messageVariables) {
+	const cloneRule = { ...rule };
+	delete cloneRule.ruleIndex;
+	delete cloneRule.trigger;
+	delete cloneRule.validateTrigger;
+	AsyncValidator.warning = () => {};
+	if (cloneRule.validator) {
+		const originValidator = cloneRule.validator;
+		cloneRule.validator = (...args) => {
+			try {
+				return originValidator(...args);
+			} catch (error) {
+				console.error(error);
+				return Promise.reject(CODE_LOGIC_ERROR);
+			}
+		};
+	}
+	let subRuleField = null;
+	if (cloneRule.type === "array" && cloneRule.defaultField) {
+		subRuleField = cloneRule.defaultField;
+		delete cloneRule.defaultField;
+	}
+	const validator = new AsyncValidator({ [name]: [cloneRule] });
+	validator.messages(messages);
+	let result = [];
+	try {
+		await Promise.resolve(validator.validate({ [name]: value }, {}));
+	} catch (errObj) {
+		if (errObj?.errors) result = errObj.errors.map(({ message }) => {
+			const merged = message === CODE_LOGIC_ERROR ? messages.default : message;
+			return typeof merged === "string" ? merged : String(merged?.message ?? merged ?? "");
+		});
+	}
+	if (!result.length && subRuleField && Array.isArray(value) && value.length > 0) return (await Promise.all(value.map((subValue, i) => validateRule(`${name}.${i}`, subValue, subRuleField, messages, messageVariables)))).reduce((prev, errors) => [...prev, ...errors], []);
+	const kv = {
+		...rule,
+		name,
+		label: messageVariables?.label || name,
+		enum: (rule.enum || []).join(", "),
+		...messageVariables
+	};
+	return result.map((error) => replaceMessage(error, kv));
+}
+/**
+* Validates one value against its rules with `@v-c/async-validator` (one rule at a time,
+* so every rule reports its own message). Resolves with `[]`, rejects with the rule errors.
+*/
+function validateRules(namePath, value, rules, messages, validateFirst, messageVariables) {
+	const name = namePath.join(".");
+	const filledRules = rules.map((currentRule, ruleIndex) => {
+		const originValidator = currentRule.validator;
+		const cloneRule = {
+			...currentRule,
+			ruleIndex
+		};
+		if (originValidator) cloneRule.validator = (rule, val, callback) => {
+			let hasPromise = false;
+			const wrappedCallback = (...args) => {
+				Promise.resolve().then(() => {
+					if (!hasPromise) callback(...args);
+				});
+			};
+			const promise = originValidator(rule, val, wrappedCallback);
+			hasPromise = !!promise && typeof promise.then === "function" && typeof promise.catch === "function";
+			if (hasPromise) promise.then(() => callback()).catch((err) => callback(typeof err === "string" ? err || " " : err?.message || " "));
+		};
+		return cloneRule;
+	}).sort((a, b) => {
+		if (!!a.warningOnly === !!b.warningOnly) return a.ruleIndex - b.ruleIndex;
+		return a.warningOnly ? 1 : -1;
+	});
+	let summaryPromise;
+	if (validateFirst === true) summaryPromise = (async () => {
+		for (let i = 0; i < filledRules.length; i += 1) {
+			const rule = filledRules[i];
+			const errors = await validateRule(name, value, rule, messages, messageVariables);
+			if (errors.length) throw [{
+				errors,
+				rule
+			}];
+		}
+		return [];
+	})();
+	else {
+		const rulePromises = filledRules.map((rule) => validateRule(name, value, rule, messages, messageVariables).then((errors) => ({
+			errors,
+			rule
+		})));
+		summaryPromise = (validateFirst ? finishOnFirstFailed(rulePromises) : Promise.all(rulePromises)).then((errors) => Promise.reject(errors));
+	}
+	summaryPromise.catch((e) => e);
+	return summaryPromise;
+}
+function finishOnFirstFailed(rulePromises) {
+	let count = 0;
+	return new Promise((resolve) => {
+		if (!rulePromises.length) resolve([]);
+		rulePromises.forEach((promise) => {
+			promise.then((ruleError) => {
+				if (ruleError.errors.length) resolve([ruleError]);
+				count += 1;
+				if (count === rulePromises.length) resolve([]);
+			});
+		});
+	});
+}
+/** Resolves when every promise resolved, rejects (after all settled) with every result otherwise. */
+function allPromiseFinish(promiseList) {
+	let hasError = false;
+	let count = promiseList.length;
+	const results = [];
+	if (!promiseList.length) return Promise.resolve([]);
+	return new Promise((resolve, reject) => {
+		promiseList.forEach((promise, index) => {
+			promise.catch((e) => {
+				hasError = true;
+				return e;
+			}).then((result) => {
+				count -= 1;
+				results[index] = result;
+				if (count > 0) return;
+				if (hasError) reject(results);
+				resolve(results);
+			});
+		});
+	});
+}
+export { allPromiseFinish, cloneValue, getFieldId, getNamePath, getValue, isEqualValue, isSameNamePath, mergeMessages, setValue, validateRules };

package/dist/grid/Col.js

@@ -0,0 +1,4 @@
+import Col_vue_vue_type_script_setup_true_lang_default from "./Col.vue_vue_type_script_setup_true_lang.js";
+// src/grid/Col.vue
+var Col_default = Col_vue_vue_type_script_setup_true_lang_default;
+export { Col_default as default };

package/dist/grid/Col.vue.d.ts

@@ -0,0 +1,13 @@
+import type { ColProps, ColSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = ColSlots;
+declare const __VLS_base: import("vue").DefineComponent<ColProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColProps> & Readonly<{}>, {}, {}, {}, {}, 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/grid/Col.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,69 @@
+import { mergeAttrsStyle } from "../_util/vnode.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createElementBlock, defineComponent, mergeProps, openBlock, renderSlot, unref } from "vue";
+// src/grid/Col.vue?vue&type=script&setup=true&lang.ts
+var COLUMNS = 24;
+var Col_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmCol",
+	inheritAttrs: false,
+	__name: "Col",
+	props: {
+		span: {},
+		offset: {},
+		order: {},
+		push: {},
+		pull: {},
+		flex: {},
+		rootClass: {}
+	},
+	setup(__props) {
+		const props = __props;
+		function toNumber(value) {
+			if (value === void 0 || value === null || value === "") return void 0;
+			const num = Number(value);
+			return Number.isNaN(num) ? void 0 : num;
+		}
+		function percent(value) {
+			return `${Number((value / COLUMNS * 100).toFixed(6))}%`;
+		}
+		function parseFlex(flex) {
+			if (typeof flex === "number") return `${flex} ${flex} auto`;
+			if (/^\d+(?:\.\d+)?(?:px|em|rem|%|vw|vh)$/.test(flex)) return `0 0 ${flex}`;
+			return flex;
+		}
+		const span = computed(() => toNumber(props.span));
+		const classNames = computed(() => [
+			"am-col",
+			{
+				[`am-col-${span.value}`]: span.value !== void 0,
+				"am-col-hidden": span.value === 0,
+				"am-col-flex": props.flex !== void 0 && props.flex !== null
+			},
+			props.rootClass
+		]);
+		const mergedStyle = computed(() => {
+			const style = {};
+			if (span.value !== void 0 && span.value > 0) {
+				style.flex = `0 0 ${percent(span.value)}`;
+				style.maxWidth = percent(span.value);
+			}
+			const offset = toNumber(props.offset);
+			if (offset) style.marginInlineStart = percent(offset);
+			const push = toNumber(props.push);
+			if (push) style.insetInlineStart = percent(push);
+			const pull = toNumber(props.pull);
+			if (pull) style.insetInlineEnd = percent(pull);
+			if (props.order !== void 0 && props.order !== null && props.order !== "") style.order = Number(props.order);
+			if (props.flex !== void 0 && props.flex !== null) style.flex = parseFlex(props.flex);
+			return style;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, {
+				class: classNames.value,
+				style: unref(mergeAttrsStyle)(mergedStyle.value, _ctx.$attrs.style)
+			}), [renderSlot(_ctx.$slots, "default")], 16);
+		};
+	}
+});
+export { Col_vue_vue_type_script_setup_true_lang_default as default };

package/dist/grid/Grid.js

@@ -0,0 +1,4 @@
+import Grid_vue_vue_type_script_setup_true_lang_default from "./Grid.vue_vue_type_script_setup_true_lang.js";
+// src/grid/Grid.vue
+var Grid_default = Grid_vue_vue_type_script_setup_true_lang_default;
+export { Grid_default as default };

package/dist/grid/Grid.vue.d.ts

@@ -0,0 +1,23 @@
+import type { GridItemType, GridProps, GridSlots } from './interface';
+import '../style';
+import './style/grid.css';
+type __VLS_Slots = GridSlots;
+declare const __VLS_base: import("vue").DefineComponent<GridProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    itemClick: (item: GridItemType, index: number, event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<GridProps> & Readonly<{
+    onItemClick?: ((item: GridItemType, index: number, event: MouseEvent) => any) | undefined;
+}>, {
+    bordered: boolean;
+    square: boolean;
+    orientation: import("./interface").GridOrientation;
+    items: GridItemType[];
+    clickable: boolean;
+}, {}, {}, {}, 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;
+    };
+};