@lablup/ui-common 0.1.0-alpha.8 → 0.2.0-alpha.15

package/dist/components/Form/messages.d.ts

@@ -0,0 +1,15 @@
+import { formMessages } from './Form.messages';
+import { ValidateMessages } from './interface';
+/** Formats a catalog key with the given values, like `useUicTranslator`'s `t`. */
+export type ValidateMessageTranslate = (key: keyof typeof formMessages, values: Record<string, string>) => string;
+/** The engine's template table, in the language `translate` resolves. */
+export declare function buildValidateMessages(translate: ValidateMessageTranslate): ValidateMessages;
+/** The English templates: the fallback under every other table. */
+export declare const defaultValidateMessages: ValidateMessages;
+/**
+ * Shallow-per-section merge, matching async-validator's `deepMerge`: a
+ * provided `types` object is spread over the default `types` object rather
+ * than replacing it, so a table that only sets `required` keeps the other
+ * templates.
+ */
+export declare function mergeValidateMessages(...sources: (ValidateMessages | undefined | null)[]): ValidateMessages;

package/dist/components/Form/messages.js

@@ -0,0 +1,52 @@
+import { formMessages as e } from "./Form.messages.js";
+import t from "intl-messageformat";
+//#region src/components/Form/messages.ts
+var n = Object.fromEntries([
+	"label",
+	"type",
+	"len",
+	"min",
+	"max",
+	"pattern"
+].map((e) => [e, `\${${e}}`]));
+function r(e) {
+	let t = (t) => e(t, n), r = (e) => ({
+		len: t(`uic.Form.${e}Len`),
+		min: t(`uic.Form.${e}Min`),
+		max: t(`uic.Form.${e}Max`),
+		range: t(`uic.Form.${e}Range`)
+	});
+	return {
+		default: t("uic.Form.default"),
+		required: t("uic.Form.required"),
+		whitespace: t("uic.Form.whitespace"),
+		types: {
+			string: t("uic.Form.typeString"),
+			number: t("uic.Form.typeNumber"),
+			object: t("uic.Form.typeObject"),
+			email: t("uic.Form.typeEmail"),
+			url: t("uic.Form.typeUrl")
+		},
+		string: r("string"),
+		number: r("number"),
+		array: r("array"),
+		pattern: { mismatch: t("uic.Form.patternMismatch") }
+	};
+}
+var i = r((n, r) => String(new t(e[n].defaultMessage, "en").format(r)));
+function a(...e) {
+	let t = { ...i };
+	return e.forEach((e) => {
+		e && Object.keys(e).forEach((n) => {
+			let r = e[n], i = t[n];
+			r && typeof r == "object" && i && typeof i == "object" ? t[n] = {
+				...i,
+				...r
+			} : t[n] = r;
+		});
+	}), t;
+}
+//#endregion
+export { r as buildValidateMessages, i as defaultValidateMessages, a as mergeValidateMessages };
+
+//# sourceMappingURL=messages.js.map

package/dist/components/Form/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","names":[],"sources":["../../../src/components/Form/messages.ts"],"sourcesContent":["/**\n * Validate-message templates.\n *\n * The strings live in ui-common's catalog (`./Form.messages.ts`) as ICU\n * messages. The engine interpolates rule values itself, with `${name}`-style\n * placeholders (see `validate.ts`), so a template is the catalog message\n * formatted with each placeholder standing for itself: `{label}` becomes\n * `${label}`.\n */\nimport IntlMessageFormat from \"intl-messageformat\";\n\nimport { formMessages } from \"./Form.messages\";\nimport type { ValidateMessages } from \"./interface\";\n\n/** Formats a catalog key with the given values, like `useUicTranslator`'s `t`. */\nexport type ValidateMessageTranslate = (\n  key: keyof typeof formMessages,\n  values: Record<string, string>,\n) => string;\n\nconst PLACEHOLDERS = [\"label\", \"type\", \"len\", \"min\", \"max\", \"pattern\"] as const;\nconst TEMPLATE_VALUES = Object.fromEntries(PLACEHOLDERS.map((p) => [p, `\\${${p}}`]));\n\n/** The engine's template table, in the language `translate` resolves. */\nexport function buildValidateMessages(\n  translate: ValidateMessageTranslate,\n): ValidateMessages {\n  const m = (key: keyof typeof formMessages) => translate(key, TEMPLATE_VALUES);\n  const lengths = (group: \"string\" | \"number\" | \"array\") => ({\n    len: m(`uic.Form.${group}Len`),\n    min: m(`uic.Form.${group}Min`),\n    max: m(`uic.Form.${group}Max`),\n    range: m(`uic.Form.${group}Range`),\n  });\n  return {\n    default: m(\"uic.Form.default\"),\n    required: m(\"uic.Form.required\"),\n    whitespace: m(\"uic.Form.whitespace\"),\n    types: {\n      string: m(\"uic.Form.typeString\"),\n      number: m(\"uic.Form.typeNumber\"),\n      object: m(\"uic.Form.typeObject\"),\n      email: m(\"uic.Form.typeEmail\"),\n      url: m(\"uic.Form.typeUrl\"),\n    },\n    string: lengths(\"string\"),\n    number: lengths(\"number\"),\n    array: lengths(\"array\"),\n    pattern: { mismatch: m(\"uic.Form.patternMismatch\") },\n  };\n}\n\n/** The English templates: the fallback under every other table. */\nexport const defaultValidateMessages: ValidateMessages = buildValidateMessages(\n  (key, values) =>\n    String(\n      new IntlMessageFormat(formMessages[key].defaultMessage, \"en\").format(values),\n    ),\n);\n\n/**\n * Shallow-per-section merge, matching async-validator's `deepMerge`: a\n * provided `types` object is spread over the default `types` object rather\n * than replacing it, so a table that only sets `required` keeps the other\n * templates.\n */\nexport function mergeValidateMessages(\n  ...sources: (ValidateMessages | undefined | null)[]\n): ValidateMessages {\n  const target: ValidateMessages = { ...defaultValidateMessages };\n  sources.forEach((source) => {\n    if (!source) return;\n    Object.keys(source).forEach((key) => {\n      const value = source[key];\n      const existing = target[key];\n      if (\n        value &&\n        typeof value === \"object\" &&\n        existing &&\n        typeof existing === \"object\"\n      ) {\n        target[key] = { ...existing, ...value };\n      } else {\n        target[key] = value;\n      }\n    });\n  });\n  return target;\n}\n"],"mappings":";;;AAqBA,IAAM,IAAkB,OAAO,YAAY;CADrB;CAAS;CAAQ;CAAO;CAAO;CAAO;AACjB,CAAA,CAAa,KAAK,MAAM,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,CAAC;AAGnF,SAAgB,EACd,GACkB;CAClB,IAAM,KAAK,MAAmC,EAAU,GAAK,CAAe,GACtE,KAAW,OAA0C;EACzD,KAAK,EAAE,YAAY,EAAM,IAAI;EAC7B,KAAK,EAAE,YAAY,EAAM,IAAI;EAC7B,KAAK,EAAE,YAAY,EAAM,IAAI;EAC7B,OAAO,EAAE,YAAY,EAAM,MAAM;CACnC;CACA,OAAO;EACL,SAAS,EAAE,kBAAkB;EAC7B,UAAU,EAAE,mBAAmB;EAC/B,YAAY,EAAE,qBAAqB;EACnC,OAAO;GACL,QAAQ,EAAE,qBAAqB;GAC/B,QAAQ,EAAE,qBAAqB;GAC/B,QAAQ,EAAE,qBAAqB;GAC/B,OAAO,EAAE,oBAAoB;GAC7B,KAAK,EAAE,kBAAkB;EAC3B;EACA,QAAQ,EAAQ,QAAQ;EACxB,QAAQ,EAAQ,QAAQ;EACxB,OAAO,EAAQ,OAAO;EACtB,SAAS,EAAE,UAAU,EAAE,0BAA0B,EAAE;CACrD;AACF;AAGA,IAAa,IAA4C,GACtD,GAAK,MACJ,OACE,IAAI,EAAkB,EAAa,EAAI,CAAC,gBAAgB,IAAI,CAAC,CAAC,OAAO,CAAM,CAC7E,CACJ;AAQA,SAAgB,EACd,GAAG,GACe;CAClB,IAAM,IAA2B,EAAE,GAAG,EAAwB;CAkB9D,OAjBA,EAAQ,SAAS,MAAW;EACrB,KACL,OAAO,KAAK,CAAM,CAAC,CAAC,SAAS,MAAQ;GACnC,IAAM,IAAQ,EAAO,IACf,IAAW,EAAO;GACxB,AACE,KACA,OAAO,KAAU,YACjB,KACA,OAAO,KAAa,WAEpB,EAAO,KAAO;IAAE,GAAG;IAAU,GAAG;GAAM,IAEtC,EAAO,KAAO;EAElB,CAAC;CACH,CAAC,GACM;AACT"}

package/dist/components/Form/namePath.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Path and store primitives: a behavioural port of rc-field-form's
+ * `utils/valueUtil` and `utils/NameMap` and rc-util's `get` / `set` / `merge`.
+ * Pure and dependency-free.
+ *
+ * `set` must keep upstream's copy-on-write with numeric-segment array
+ * creation: `setValue({}, ['a', 0, 'b'], 1)` produces `{ a: [{ b: 1 }] }`,
+ * not `{ a: { '0': { b: 1 } } }`, or Form.List values are reshaped.
+ */
+/** A single addressable segment of a field path. */
+export type NamePathSegment = string | number;
+/** Normalised, always-array internal path — what `errorFields[].name` carries. */
+export type InternalNamePath = NamePathSegment[];
+export type BaseNamePath = string | number | boolean | (string | number | boolean)[];
+/**
+ * antd's own deep path type, copied so `NamePath` behaves identically.
+ *
+ * For a typed store it walks up to three levels and produces the tuples that
+ * store admits; for an untyped `FormInstance` (`Store = any`) the conditional
+ * collapses to `any`, which is why `[listName, index, 'variable']` with a
+ * `NamePath`-typed `listName` type-checks. Tightening it rejects such code.
+ */
+export type DeepNamePath<Store = any, ParentNamePath extends any[] = []> = ParentNamePath["length"] extends 3 ? never : true extends (Store extends BaseNamePath ? true : false) ? ParentNamePath["length"] extends 0 ? Store | BaseNamePath : Store extends any[] ? [...ParentNamePath, number] : never : Store extends any[] ? [...ParentNamePath, number] | DeepNamePath<Store[number], [...ParentNamePath, number]> : keyof Store extends never ? Store : {
+    [FieldKey in keyof Store]: Store[FieldKey] extends (...args: any[]) => any ? never : (ParentNamePath["length"] extends 0 ? FieldKey : never) | [...ParentNamePath, FieldKey] | DeepNamePath<Required<Store>[FieldKey], [
+        ...ParentNamePath,
+        FieldKey
+    ]>;
+}[keyof Store];
+/** Public name path shape accepted by every engine API. */
+export type NamePath<Store = any> = DeepNamePath<Store>;
+/** Arbitrary form value store. Values are never coerced (Relay objects live here). */
+export type Store = Record<string, any>;
+export declare function toArray<T>(value: T | T[] | undefined | null): T[];
+/**
+ * `'a'` -> `['a']`, `123` -> `[123]`, `['a', 123]` -> `['a', 123]`.
+ * Deliberately NOT dot-splitting: `'a.b'` stays a single segment, matching
+ * rc-field-form (its `getNamePath` is `toArray`, nothing more).
+ */
+export declare function getNamePath(path: NamePath | undefined | null): InternalNamePath;
+export declare function getValue(entity: any, path: InternalNamePath): any;
+export declare function setValue<T = Store>(entity: T, paths: InternalNamePath, value: any, removeIfUndefined?: boolean): T;
+/**
+ * Deep merge with ARRAY REPLACEMENT (not concatenation / index merge).
+ * `setFieldsValue({ resource: {...} })` partially merges the `resource`
+ * object but replaces any array it contains wholesale. Non-plain objects
+ * (class instances, records from a data store) are assigned by reference.
+ */
+export declare function merge<T = Store>(...sources: any[]): T;
+/** Build a store containing only the given paths (used by `validateFields`' resolve value). */
+export declare function cloneByNamePathList(store: Store, namePathList: InternalNamePath[]): Store;
+/**
+ * Is `namePath` equal to (or, with `partialMatch`, prefixed by) `subNamePath`?
+ * `partialMatch` is what makes `validateFields(['resource'], {recursive:true})`
+ * reach `['resource','cpu']`.
+ */
+export declare function matchNamePath(namePath: InternalNamePath | undefined | null, subNamePath: InternalNamePath | undefined | null, partialMatch?: boolean): boolean;
+export declare function containsNamePath(namePathList: InternalNamePath[] | undefined | null, namePath: InternalNamePath, partialMatch?: boolean): boolean;
+/**
+ * Pull the next value out of a control's change payload. Mirrors
+ * rc-field-form: DOM-ish events expose the value under `event.target[
+ * valuePropName]` (so `valuePropName="checked"` reads `target.checked`),
+ * everything else is passed through as-is.
+ */
+export declare function defaultGetValueFromEvent(valuePropName: string, ...args: any[]): any;
+/** `Map` keyed by name path. */
+export default class NameMap<T> {
+    private kvs;
+    set(key: InternalNamePath, value: T): void;
+    get(key: InternalNamePath): T | undefined;
+    /** The entry at `key` plus every entry nested underneath it. */
+    getAsPrefix(key: InternalNamePath): T[];
+    update(key: InternalNamePath, updater: (origin: T | undefined) => T | null): void;
+    delete(key: InternalNamePath): void;
+    map<U>(callback: (entry: {
+        key: InternalNamePath;
+        value: T;
+    }) => U): U[];
+}

package/dist/components/Form/namePath.js

@@ -0,0 +1,120 @@
+//#region src/components/Form/namePath.ts
+function e(e) {
+	return e == null ? [] : Array.isArray(e) ? e : [e];
+}
+function t(t) {
+	return e(t);
+}
+function n(e, t) {
+	let n = e;
+	for (let e = 0; e < t.length; e += 1) {
+		if (n == null) return;
+		n = n[t[e]];
+	}
+	return n;
+}
+var r = (e) => e === "__proto__" || e === "constructor" || e === "prototype", i = (e, t, n) => {
+	if (r(t)) {
+		Object.defineProperty(e, t, {
+			value: n,
+			enumerable: !0,
+			writable: !0,
+			configurable: !0
+		});
+		return;
+	}
+	e[t] = n;
+}, a = (e, t) => {
+	if (e != null) return r(t) ? Object.prototype.hasOwnProperty.call(e, t) ? Object.getOwnPropertyDescriptor(e, t)?.value : void 0 : e[t];
+};
+function o(e, t, n, s) {
+	if (!t.length) return n;
+	let [c, ...l] = t, u;
+	if (u = !e && typeof c == "number" ? [] : Array.isArray(e) ? [...e] : { ...e }, s && n === void 0 && l.length === 1) {
+		let e = a(u, c), t = l[0];
+		e != null && !r(t) && delete e[t];
+	} else i(u, c, o(a(u, c), l, n, s));
+	return u;
+}
+function s(e, t, r, i = !1) {
+	return t.length && i && r === void 0 && !n(e, t.slice(0, -1)) ? e : o(e, t, r, i);
+}
+function c(e) {
+	return typeof e == "object" && !!e && Object.getPrototypeOf(e) === Object.prototype;
+}
+function l(e) {
+	return Array.isArray(e) ? [] : {};
+}
+function u(...e) {
+	let t = l(e[0]);
+	return e.forEach((e) => {
+		let r = (i, a) => {
+			let o = new Set(a), u = n(e, i), d = Array.isArray(u);
+			if (d || c(u)) {
+				if (o.has(u)) return;
+				o.add(u);
+				let e = n(t, i);
+				d ? t = s(t, i, []) : (!e || typeof e != "object") && (t = s(t, i, l(u))), Reflect.ownKeys(u).forEach((e) => {
+					Object.getOwnPropertyDescriptor(u, e)?.enumerable && r([...i, e], o);
+				});
+			} else t = s(t, i, u);
+		};
+		r([], /* @__PURE__ */ new Set());
+	}), t;
+}
+function d(e, t) {
+	let r = {};
+	return t.forEach((t) => {
+		let i = n(e, t);
+		r = s(r, t, i);
+	}), r;
+}
+function f(e, t, n = !1) {
+	return !e || !t || !n && e.length !== t.length ? !1 : t.every((t, n) => e[n] === t);
+}
+function p(e, t, n = !1) {
+	return !!e && e.some((e) => f(t, e, n));
+}
+function m(e, ...t) {
+	let n = t[0];
+	return n && n.target && typeof n.target == "object" && e in n.target ? n.target[e] : n;
+}
+var h = "__@field_split__";
+function g(e) {
+	return e.map((e) => `${typeof e}:${e}`).join(h);
+}
+var _ = class {
+	kvs = /* @__PURE__ */ new Map();
+	set(e, t) {
+		this.kvs.set(g(e), t);
+	}
+	get(e) {
+		return this.kvs.get(g(e));
+	}
+	getAsPrefix(e) {
+		let t = g(e), n = t + h, r = [], i = this.kvs.get(t);
+		return i !== void 0 && r.push(i), this.kvs.forEach((e, t) => {
+			t.startsWith(n) && r.push(e);
+		}), r;
+	}
+	update(e, t) {
+		let n = t(this.get(e));
+		n ? this.set(e, n) : this.delete(e);
+	}
+	delete(e) {
+		this.kvs.delete(g(e));
+	}
+	map(e) {
+		return [...this.kvs.entries()].map(([t, n]) => e({
+			key: t.split(h).map((e) => {
+				let [, t, n] = /^([^:]*):(.*)$/.exec(e);
+				return t === "number" ? Number(n) : n;
+			}),
+			value: n
+		}));
+	}
+};
+//#endregion
+export { d as cloneByNamePathList, p as containsNamePath, _ as default, m as defaultGetValueFromEvent, t as getNamePath, n as getValue, f as matchNamePath, u as merge, s as setValue, e as toArray };
+
+//# sourceMappingURL=namePath.js.map

package/dist/components/Form/namePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"namePath.js","names":[],"sources":["../../../src/components/Form/namePath.ts"],"sourcesContent":["/**\n * Path and store primitives: a behavioural port of rc-field-form's\n * `utils/valueUtil` and `utils/NameMap` and rc-util's `get` / `set` / `merge`.\n * Pure and dependency-free.\n *\n * `set` must keep upstream's copy-on-write with numeric-segment array\n * creation: `setValue({}, ['a', 0, 'b'], 1)` produces `{ a: [{ b: 1 }] }`,\n * not `{ a: { '0': { b: 1 } } }`, or Form.List values are reshaped.\n */\n\n/** A single addressable segment of a field path. */\nexport type NamePathSegment = string | number;\n/** Normalised, always-array internal path — what `errorFields[].name` carries. */\nexport type InternalNamePath = NamePathSegment[];\n\nexport type BaseNamePath = string | number | boolean | (string | number | boolean)[];\n\n/**\n * antd's own deep path type, copied so `NamePath` behaves identically.\n *\n * For a typed store it walks up to three levels and produces the tuples that\n * store admits; for an untyped `FormInstance` (`Store = any`) the conditional\n * collapses to `any`, which is why `[listName, index, 'variable']` with a\n * `NamePath`-typed `listName` type-checks. Tightening it rejects such code.\n */\nexport type DeepNamePath<\n  Store = any,\n  ParentNamePath extends any[] = [],\n> = ParentNamePath[\"length\"] extends 3\n  ? never\n  : true extends (Store extends BaseNamePath ? true : false)\n    ? ParentNamePath[\"length\"] extends 0\n      ? Store | BaseNamePath\n      : Store extends any[]\n        ? [...ParentNamePath, number]\n        : never\n    : Store extends any[]\n      ? | [...ParentNamePath, number]\n        | DeepNamePath<Store[number], [...ParentNamePath, number]>\n      : keyof Store extends never\n        ? Store\n        : {\n            [FieldKey in keyof Store]: Store[FieldKey] extends (...args: any[]) => any\n              ? never\n              : | (ParentNamePath[\"length\"] extends 0 ? FieldKey : never)\n                | [...ParentNamePath, FieldKey]\n                | DeepNamePath<\n                    Required<Store>[FieldKey],\n                    [...ParentNamePath, FieldKey]\n                  >;\n          }[keyof Store];\n\n/** Public name path shape accepted by every engine API. */\nexport type NamePath<Store = any> = DeepNamePath<Store>;\n\n/** Arbitrary form value store. Values are never coerced (Relay objects live here). */\nexport type Store = Record<string, any>;\n\nexport function toArray<T>(value: T | T[] | undefined | null): T[] {\n  if (value === undefined || value === null) {\n    return [];\n  }\n  return Array.isArray(value) ? value : [value];\n}\n\n/**\n * `'a'` -> `['a']`, `123` -> `[123]`, `['a', 123]` -> `['a', 123]`.\n * Deliberately NOT dot-splitting: `'a.b'` stays a single segment, matching\n * rc-field-form (its `getNamePath` is `toArray`, nothing more).\n */\nexport function getNamePath(path: NamePath | undefined | null): InternalNamePath {\n  return toArray(path as NamePathSegment);\n}\n\nexport function getValue(entity: any, path: InternalNamePath): any {\n  let current = entity;\n  for (let i = 0; i < path.length; i += 1) {\n    if (current === null || current === undefined) {\n      return undefined;\n    }\n    current = current[path[i]!];\n  }\n  return current;\n}\n\n/**\n * Segments that must never reach a plain `obj[key] = v`.\n *\n * `clone.__proto__ = v` mutates the prototype CHAIN instead of storing a value,\n * and `constructor` / `prototype` are the adjacent reachable slots. A form\n * whose field is literally named one of these is pathological, but name paths\n * flow in from `Form.List` indices and caller-built arrays, so the engine\n * should not be the thing that trusts them (CodeQL `js/prototype-polluting-\n * assignment`).\n *\n * Written as explicit `===` comparisons rather than a `Set.has()` lookup on\n * purpose: CodeQL recognises the former as a barrier guard and does not track\n * through the latter, so the `Set` version left the alert standing even though\n * the runtime behaviour was identical.\n */\nconst isUnsafeSegment = (key: NamePathSegment): boolean =>\n  key === \"__proto__\" || key === \"constructor\" || key === \"prototype\";\n\n/**\n * Store `value` at `key` WITHOUT ever walking the prototype chain.\n *\n * For an ordinary key this is a plain assignment — the hot path is unchanged.\n * For a dangerous one it defines an own, enumerable, writable data property,\n * which is what the caller meant: the value is kept and readable through the\n * same path, it simply stops being a prototype mutation. Nothing is silently\n * dropped, so a field genuinely named `constructor` still round-trips.\n */\nconst safeAssign = (target: any, key: NamePathSegment, value: any): void => {\n  if (isUnsafeSegment(key)) {\n    Object.defineProperty(target, key, {\n      value,\n      enumerable: true,\n      writable: true,\n      configurable: true,\n    });\n    return;\n  }\n  target[key] = value;\n};\n\n/** Read a segment without falling through to the prototype chain. */\nconst safeRead = (source: any, key: NamePathSegment): any => {\n  if (source == null) return undefined;\n  if (isUnsafeSegment(key)) {\n    return Object.prototype.hasOwnProperty.call(source, key)\n      ? (Object.getOwnPropertyDescriptor(source, key)?.value as unknown)\n      : undefined;\n  }\n  return source[key];\n};\n\nfunction internalSet(\n  entity: any,\n  paths: InternalNamePath,\n  value: any,\n  removeIfUndefined: boolean,\n): any {\n  if (!paths.length) {\n    return value;\n  }\n  const [path, ...restPath] = paths as [InternalNamePath[number], ...InternalNamePath];\n  let clone: any;\n  if (!entity && typeof path === \"number\") {\n    clone = [];\n  } else if (Array.isArray(entity)) {\n    clone = [...entity];\n  } else {\n    clone = { ...entity };\n  }\n\n  // `removeIfUndefined` deletes the key instead of writing `undefined` — this\n  // is what makes `preserve={false}` drop the key from `getFieldsValue()`\n  // rather than leaving `{ field: undefined }`.\n  if (removeIfUndefined && value === undefined && restPath.length === 1) {\n    const child = safeRead(clone, path);\n    const leaf = restPath[0]!;\n    // Guarded for the same reason as `safeAssign`: a computed `delete` on\n    // `__proto__` / `constructor` / `prototype` reaches the prototype chain.\n    // Nothing legitimate deletes those, so skipping is the whole behaviour.\n    if (child != null && !isUnsafeSegment(leaf)) delete child[leaf];\n  } else {\n    safeAssign(\n      clone,\n      path,\n      internalSet(safeRead(clone, path), restPath, value, removeIfUndefined),\n    );\n  }\n  return clone;\n}\n\nexport function setValue<T = Store>(\n  entity: T,\n  paths: InternalNamePath,\n  value: any,\n  removeIfUndefined = false,\n): T {\n  if (\n    paths.length &&\n    removeIfUndefined &&\n    value === undefined &&\n    !getValue(entity, paths.slice(0, -1))\n  ) {\n    return entity;\n  }\n  return internalSet(entity, paths, value, removeIfUndefined);\n}\n\nfunction isPlainObject(obj: any): boolean {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    Object.getPrototypeOf(obj) === Object.prototype\n  );\n}\n\nfunction createEmpty(source: any): any {\n  return Array.isArray(source) ? [] : {};\n}\n\n/**\n * Deep merge with ARRAY REPLACEMENT (not concatenation / index merge).\n * `setFieldsValue({ resource: {...} })` partially merges the `resource`\n * object but replaces any array it contains wholesale. Non-plain objects\n * (class instances, records from a data store) are assigned by reference.\n */\nexport function merge<T = Store>(...sources: any[]): T {\n  let clone: any = createEmpty(sources[0]);\n\n  sources.forEach((src) => {\n    const walk = (path: InternalNamePath, loop: Set<any>) => {\n      const loopSet = new Set(loop);\n      const value = getValue(src, path);\n      const isArr = Array.isArray(value);\n      if (isArr || isPlainObject(value)) {\n        if (loopSet.has(value)) {\n          return;\n        }\n        loopSet.add(value);\n        const originValue = getValue(clone, path);\n        if (isArr) {\n          clone = setValue(clone, path, []);\n        } else if (!originValue || typeof originValue !== \"object\") {\n          clone = setValue(clone, path, createEmpty(value));\n        }\n        Reflect.ownKeys(value as object).forEach((key) => {\n          if (Object.getOwnPropertyDescriptor(value, key)?.enumerable) {\n            walk([...path, key as NamePathSegment], loopSet);\n          }\n        });\n      } else {\n        clone = setValue(clone, path, value);\n      }\n    };\n    walk([], new Set());\n  });\n\n  return clone as T;\n}\n\n/** Build a store containing only the given paths (used by `validateFields`' resolve value). */\nexport function cloneByNamePathList(\n  store: Store,\n  namePathList: InternalNamePath[],\n): Store {\n  let newStore: Store = {};\n  namePathList.forEach((namePath) => {\n    const value = getValue(store, namePath);\n    newStore = setValue(newStore, namePath, value);\n  });\n  return newStore;\n}\n\n/**\n * Is `namePath` equal to (or, with `partialMatch`, prefixed by) `subNamePath`?\n * `partialMatch` is what makes `validateFields(['resource'], {recursive:true})`\n * reach `['resource','cpu']`.\n */\nexport function matchNamePath(\n  namePath: InternalNamePath | undefined | null,\n  subNamePath: InternalNamePath | undefined | null,\n  partialMatch = false,\n): boolean {\n  if (!namePath || !subNamePath) {\n    return false;\n  }\n  if (!partialMatch && namePath.length !== subNamePath.length) {\n    return false;\n  }\n  return subNamePath.every((nameUnit, i) => namePath[i] === nameUnit);\n}\n\nexport function containsNamePath(\n  namePathList: InternalNamePath[] | undefined | null,\n  namePath: InternalNamePath,\n  partialMatch = false,\n): boolean {\n  return (\n    !!namePathList &&\n    namePathList.some((path) => matchNamePath(namePath, path, partialMatch))\n  );\n}\n\n/**\n * Pull the next value out of a control's change payload. Mirrors\n * rc-field-form: DOM-ish events expose the value under `event.target[\n * valuePropName]` (so `valuePropName=\"checked\"` reads `target.checked`),\n * everything else is passed through as-is.\n */\nexport function defaultGetValueFromEvent(valuePropName: string, ...args: any[]): any {\n  const event = args[0];\n  if (\n    event &&\n    event.target &&\n    typeof event.target === \"object\" &&\n    valuePropName in event.target\n  ) {\n    return (event.target as any)[valuePropName];\n  }\n  return event;\n}\n\nconst SPLIT = \"__@field_split__\";\n\nfunction normalizeKey(namePath: InternalNamePath): string {\n  // The `typeof` prefix keeps `['a', 0]` and `['a', '0']` distinct keys —\n  // Form.List indices are numbers and object keys are strings.\n  return namePath.map((cell) => `${typeof cell}:${cell}`).join(SPLIT);\n}\n\n/** `Map` keyed by name path. */\nexport default class NameMap<T> {\n  private kvs = new Map<string, T>();\n\n  set(key: InternalNamePath, value: T) {\n    this.kvs.set(normalizeKey(key), value);\n  }\n\n  get(key: InternalNamePath): T | undefined {\n    return this.kvs.get(normalizeKey(key));\n  }\n\n  /** The entry at `key` plus every entry nested underneath it. */\n  getAsPrefix(key: InternalNamePath): T[] {\n    const normalizedKey = normalizeKey(key);\n    const normalizedPrefix = normalizedKey + SPLIT;\n    const results: T[] = [];\n    const current = this.kvs.get(normalizedKey);\n    if (current !== undefined) {\n      results.push(current);\n    }\n    this.kvs.forEach((value, itemNormalizedKey) => {\n      if (itemNormalizedKey.startsWith(normalizedPrefix)) {\n        results.push(value);\n      }\n    });\n    return results;\n  }\n\n  update(key: InternalNamePath, updater: (origin: T | undefined) => T | null) {\n    const origin = this.get(key);\n    const next = updater(origin);\n    if (!next) {\n      this.delete(key);\n    } else {\n      this.set(key, next);\n    }\n  }\n\n  delete(key: InternalNamePath) {\n    this.kvs.delete(normalizeKey(key));\n  }\n\n  map<U>(callback: (entry: { key: InternalNamePath; value: T }) => U): U[] {\n    return [...this.kvs.entries()].map(([key, value]) => {\n      const cells = key.split(SPLIT);\n      return callback({\n        key: cells.map((cell) => {\n          const [, type, unit] = /^([^:]*):(.*)$/.exec(cell) as RegExpExecArray;\n          return type === \"number\" ? Number(unit) : unit!;\n        }),\n        value,\n      });\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/components/Form/useWatch.d.ts

@@ -0,0 +1,11 @@
+import { FormInstance, StoreValue } from './interface';
+import { NamePath, Store } from './namePath';
+export interface WatchOptions<Form = FormInstance> {
+    form?: Form;
+    /** Read the raw store, including values whose field is unmounted. */
+    preserve?: boolean;
+}
+declare function useWatch<Values = StoreValue>(dependencies: NamePath | ((values: Store) => Values), formOrOptions?: FormInstance | WatchOptions): Values;
+export default useWatch;
+/** The nearest `<Form>`'s instance, or `undefined` outside one. */
+export declare function useFormInstance<Values = any>(): FormInstance<Values>;

package/dist/components/Form/useWatch.js

@@ -0,0 +1,43 @@
+import { FieldContext as e, FormItemLayoutContext as t, HOOK_MARK as n } from "./context.js";
+import { getNamePath as r, getValue as i } from "./namePath.js";
+import * as a from "react";
+//#region src/components/Form/useWatch.ts
+function o(e) {
+	try {
+		return JSON.stringify(e);
+	} catch {
+		return Math.random();
+	}
+}
+function s(e) {
+	return e && !!e._init;
+}
+function c(t, c) {
+	let l = s(c) ? { form: c } : c ?? {}, u = l.form, d = a.useContext(e), f = u || d, p = !!f && !!f._init, m = (e, n) => {
+		let a = l.preserve ? n ?? f.getFieldsValue(!0) : e ?? f.getFieldsValue();
+		return typeof t == "function" ? t(a) : i(a, r(t));
+	}, [h, g] = a.useState(() => p ? m() : typeof t == "function" ? t({}) : void 0), _ = a.useEffectEvent((e, t) => {
+		if (!p) return;
+		let n = m(e, t);
+		o(h) !== o(n) && g(n);
+	}), v = typeof t == "function" ? t : JSON.stringify(t);
+	return a.useEffect(() => {
+		if (!p) return;
+		let e = f.getInternalHooks(n)?.registerWatch, t = e?.((e, t) => {
+			_(e, t);
+		});
+		return _(), t;
+	}, [
+		p,
+		f,
+		v
+	]), h;
+}
+function l() {
+	let { form: e } = a.useContext(t);
+	return e;
+}
+//#endregion
+export { c as default, l as useFormInstance };
+
+//# sourceMappingURL=useWatch.js.map

package/dist/components/Form/useWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWatch.js","names":[],"sources":["../../../src/components/Form/useWatch.ts"],"sourcesContent":["/**\n * `Form.useWatch` and `Form.useFormInstance`.\n *\n * `{ preserve: true }` reads the raw store rather than the registered-field\n * projection, so a value whose field is unmounted is still observed. Paths are\n * absolute even inside a `Form.List`, because `useWatch` reads from the form\n * instance, never from `prefixName`.\n *\n * Change detection is by JSON stringification, matching upstream, so a watcher\n * on an object path settles instead of re-rendering on every new identity.\n */\nimport { FieldContext, FormItemLayoutContext, HOOK_MARK } from \"./context\";\nimport type { FormInstance, InternalFormInstance, StoreValue } from \"./interface\";\nimport { getNamePath, getValue, type NamePath, type Store } from \"./namePath\";\nimport * as React from \"react\";\n\nfunction stringify(value: any): string | number {\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return Math.random();\n  }\n}\n\nfunction isFormInstance(form: any): form is InternalFormInstance {\n  return form && !!form._init;\n}\n\nexport interface WatchOptions<Form = FormInstance> {\n  form?: Form;\n  /** Read the raw store, including values whose field is unmounted. */\n  preserve?: boolean;\n}\n\nfunction useWatch<Values = StoreValue>(\n  dependencies: NamePath | ((values: Store) => Values),\n  formOrOptions?: FormInstance | WatchOptions,\n): Values {\n  const options: WatchOptions = isFormInstance(formOrOptions)\n    ? { form: formOrOptions }\n    : ((formOrOptions ?? {}) as WatchOptions);\n  const form = options.form as InternalFormInstance | undefined;\n\n  const fieldContext = React.useContext(FieldContext);\n  const formInstance = (form || fieldContext) as InternalFormInstance;\n  const isValidForm = !!formInstance && !!formInstance._init;\n\n  const read = (values?: Store, allValues?: Store) => {\n    const watchValue = options.preserve\n      ? (allValues ?? formInstance.getFieldsValue(true))\n      : (values ?? formInstance.getFieldsValue());\n    return typeof dependencies === \"function\"\n      ? (dependencies as any)(watchValue)\n      : getValue(watchValue, getNamePath(dependencies as NamePath));\n  };\n\n  // Seed from the store rather than from `undefined`. Upstream starts empty\n  // and syncs in a mount effect; reading here removes that extra render (and\n  // the `undefined` flash a `useWatch`-gated subtree shows because of it).\n  // Fields that register AFTER this hook still reach us: `registerField`\n  // notifies every watcher, and that notification is batched onto a\n  // macrotask, by which point the subscription below is in place.\n  const [value, setValue] = React.useState<any>(() =>\n    isValidForm\n      ? read()\n      : typeof dependencies === \"function\"\n        ? (dependencies as any)({})\n        : undefined,\n  );\n\n  /**\n   * Stable across renders while always reading the latest `dependencies` /\n   * `value` / `options`. That combination is the whole point: the watcher is\n   * registered ONCE (re-registering on every render would churn the store's\n   * subscriber set), yet a selector function redefined inline at the call\n   * site must still be the one that runs.\n   */\n  const triggerUpdate = React.useEffectEvent((values?: Store, allValues?: Store) => {\n    if (!isValidForm) return;\n    const nextValue = read(values, allValues);\n    // Compare by serialisation, not identity: the store hands back a fresh\n    // object on every write, so identity comparison would never settle.\n    if (stringify(value) !== stringify(nextValue)) {\n      setValue(nextValue);\n    }\n  });\n\n  // A selector function has no stable serialisation, so it identifies itself.\n  const flattenDeps =\n    typeof dependencies === \"function\" ? dependencies : JSON.stringify(dependencies);\n\n  React.useEffect(() => {\n    if (!isValidForm) return undefined;\n    const registerWatch = formInstance.getInternalHooks(HOOK_MARK)?.registerWatch;\n    const cancel = registerWatch?.((values, allValues) => {\n      triggerUpdate(values, allValues);\n    });\n    // Re-read once the WATCHED PATH itself changes (not the value — the store\n    // notifies us for that). This matters for dynamic paths such as\n    // `useWatch(['rows', index, 'slot'])`, where removing a list row shifts\n    // the index: without this the hook keeps reporting the OLD row's value\n    // until some unrelated write happens to notify the watchers.\n    // The `useState` seed above covers mount, so this only fires on a genuine\n    // path change: a synchronisation against the form store.\n    triggerUpdate();\n    return cancel;\n    // `triggerUpdate` is recreated every render; these are the real triggers.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [isValidForm, formInstance, flattenDeps]);\n\n  return value;\n}\n\nexport default useWatch;\n\n/** The nearest `<Form>`'s instance, or `undefined` outside one. */\nexport function useFormInstance<Values = any>(): FormInstance<Values> {\n  const { form } = React.useContext(FormItemLayoutContext);\n  return form as FormInstance<Values>;\n}\n"],"mappings":";;;;AAgBA,SAAS,EAAU,GAA6B;CAC9C,IAAI;EACF,OAAO,KAAK,UAAU,CAAK;CAC7B,QAAQ;EACN,OAAO,KAAK,OAAO;CACrB;AACF;AAEA,SAAS,EAAe,GAAyC;CAC/D,OAAO,KAAQ,CAAC,CAAC,EAAK;AACxB;AAQA,SAAS,EACP,GACA,GACQ;CACR,IAAM,IAAwB,EAAe,CAAa,IACtD,EAAE,MAAM,EAAc,IACpB,KAAiB,CAAC,GAClB,IAAO,EAAQ,MAEf,IAAe,EAAM,WAAW,CAAY,GAC5C,IAAgB,KAAQ,GACxB,IAAc,CAAC,CAAC,KAAgB,CAAC,CAAC,EAAa,OAE/C,KAAQ,GAAgB,MAAsB;EAClD,IAAM,IAAa,EAAQ,WACtB,KAAa,EAAa,eAAe,EAAI,IAC7C,KAAU,EAAa,eAAe;EAC3C,OAAO,OAAO,KAAiB,aAC1B,EAAqB,CAAU,IAChC,EAAS,GAAY,EAAY,CAAwB,CAAC;CAChE,GAQM,CAAC,GAAO,KAAY,EAAM,eAC9B,IACI,EAAK,IACL,OAAO,KAAiB,aACrB,EAAqB,CAAC,CAAC,IACxB,KAAA,CACR,GASM,IAAgB,EAAM,gBAAgB,GAAgB,MAAsB;EAChF,IAAI,CAAC,GAAa;EAClB,IAAM,IAAY,EAAK,GAAQ,CAAS;EAGxC,AAAI,EAAU,CAAK,MAAM,EAAU,CAAS,KAC1C,EAAS,CAAS;CAEtB,CAAC,GAGK,IACJ,OAAO,KAAiB,aAAa,IAAe,KAAK,UAAU,CAAY;CAqBjF,OAnBA,EAAM,gBAAgB;EACpB,IAAI,CAAC,GAAa;EAClB,IAAM,IAAgB,EAAa,iBAAiB,CAAS,CAAC,EAAE,eAC1D,IAAS,KAAiB,GAAQ,MAAc;GACpD,EAAc,GAAQ,CAAS;EACjC,CAAC;EASD,OADA,EAAc,GACP;CAGT,GAAG;EAAC;EAAa;EAAc;CAAW,CAAC,GAEpC;AACT;AAKA,SAAgB,IAAsD;CACpE,IAAM,EAAE,YAAS,EAAM,WAAW,CAAqB;CACvD,OAAO;AACT"}

package/dist/components/Form/validate.d.ts

@@ -0,0 +1,16 @@
+import { RuleObject, StoreValue, ValidateMessages } from './interface';
+import { InternalNamePath, toArray } from './namePath';
+/**
+ * Validate one field's value against its rules.
+ *
+ * ALWAYS REJECTS in the default (parallel) mode — with a `RuleError[]` that
+ * may well be empty. This is upstream's contract and both `Field` and
+ * `FormStore` are written against it: the caller partitions the array into
+ * errors and warnings by each rule's `warningOnly`, and an empty array means
+ * "valid". `validateFirst === true` instead resolves `[]` on success.
+ */
+export declare function validateRules(namePath: InternalNamePath, value: StoreValue, rules: RuleObject[], messages: ValidateMessages, validateFirst?: boolean | "parallel", messageVariables?: Record<string, string>): Promise<{
+    errors: any[];
+    rule: RuleObject;
+}[]>;
+export { toArray };

package/dist/components/Form/validate.js

@@ -0,0 +1,214 @@
+import "./namePath.js";
+import { cloneElement as e, isValidElement as t } from "react";
+//#region src/components/Form/validate.ts
+var n = "CODE_LOGIC_ERROR", r = /%[sdj%]/g;
+function i(e, ...t) {
+	let n = 0, i = t.length;
+	return typeof e == "function" ? e(...t) : typeof e == "string" ? e.replace(r, (e) => {
+		if (e === "%%") return "%";
+		if (n >= i) return e;
+		switch (e) {
+			case "%s": return String(t[n++]);
+			case "%d": return String(Number(t[n++]));
+			case "%j": try {
+				return JSON.stringify(t[n++]);
+			} catch {
+				return "[Circular]";
+			}
+			default: return e;
+		}
+	}) : e;
+}
+function a(e, t) {
+	return e.replace(/\\?\$\{\w+\}/g, (e) => e.startsWith("\\") ? e.slice(1) : t[e.slice(2, -1)]);
+}
+var o = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/, s;
+function c() {
+	if (s) return s;
+	let e = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}", t = "[a-fA-F\\d]{1,4}", n = `(?:(?:(?:[a-z]+:)?//)|www\\.)(?:\\S+(?::\\S*)?@)?(?:localhost|${e}|${`(?:${[
+		`(?:${t}:){7}(?:${t}|:)`,
+		`(?:${t}:){6}(?:${e}|:${t}|:)`,
+		`(?:${t}:){5}(?::${e}|(?::${t}){1,2}|:)`,
+		`(?:${t}:){4}(?:(?::${t}){0,1}:${e}|(?::${t}){1,3}|:)`,
+		`(?:${t}:){3}(?:(?::${t}){0,2}:${e}|(?::${t}){1,4}|:)`,
+		`(?:${t}:){2}(?:(?::${t}){0,3}:${e}|(?::${t}){1,5}|:)`,
+		`(?:${t}:){1}(?:(?::${t}){0,4}:${e}|(?::${t}){1,6}|:)`,
+		`(?::(?:(?::${t}){0,5}:${e}|(?::${t}){1,7}|:))`
+	].join("|")})(?:%[0-9a-zA-Z]{1,})?`}|(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))(?::\\d{2,5})?(?:[/?#][^\\s"]*)?`;
+	return s = RegExp(`(?:^${n}$)`, "i"), s;
+}
+var l = {
+	number: (e) => !isNaN(e) && typeof e == "number",
+	object: (e) => typeof e == "object" && !Array.isArray(e),
+	email: (e) => typeof e == "string" && e.length <= 320 && o.test(e),
+	url: (e) => typeof e == "string" && e.length <= 2048 && c().test(e)
+};
+function u(e) {
+	return e === "string" || e === "url" || e === "email" || e === "pattern";
+}
+function d(e, t) {
+	return !!(e == null || t === "array" && Array.isArray(e) && !e.length || u(t) && typeof e == "string" && !e);
+}
+function f({ rule: e, value: t, name: n, messages: r, errors: a }, o) {
+	e.required && d(t, o || e.type) && a.push(i(r.required, n));
+}
+function p({ rule: e, value: t, name: n, messages: r, errors: a }) {
+	if (e.required && t === void 0) {
+		f({
+			rule: e,
+			value: t,
+			name: n,
+			messages: r,
+			errors: a
+		});
+		return;
+	}
+	let o = e.type, s = l[o];
+	s ? s(t) || a.push(i(r.types?.[o], n, o)) : o && typeof t !== o && a.push(i(r.types?.[o], n, o));
+}
+var m = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+function h({ rule: e, value: t, name: n, messages: r, errors: a }) {
+	let o = typeof e.min == "number", s = typeof e.max == "number", c, l;
+	if (typeof t == "number") l = "number", c = t;
+	else if (typeof t == "string") l = "string", c = t.replace(m, "_").length;
+	else if (Array.isArray(t)) l = "array", c = t.length;
+	else return;
+	let u = r[l];
+	o && !s && c < e.min ? a.push(i(u?.min, n, e.min)) : s && !o && c > e.max ? a.push(i(u?.max, n, e.max)) : o && s && (c < e.min || c > e.max) && a.push(i(u?.range, n, e.min, e.max));
+}
+function g({ rule: e, value: t, name: n, messages: r, errors: a }) {
+	e.pattern instanceof RegExp && (e.pattern.lastIndex = 0, e.pattern.test(t) || a.push(i(r.pattern?.mismatch, n, t, e.pattern)));
+}
+function _({ value: e, name: t, messages: n, errors: r }) {
+	(/^\s+$/.test(e) || e === "") && r.push(i(n.whitespace, t));
+}
+function v(e, t) {
+	let { rule: n, value: r } = t;
+	switch (e) {
+		case "required":
+			f(t, Array.isArray(r) ? "array" : typeof r);
+			return;
+		case "number": {
+			let e = {
+				...t,
+				value: r === "" ? void 0 : r
+			};
+			if (d(e.value) && !n.required) return;
+			f(e), e.value !== void 0 && (p(e), h(e));
+			return;
+		}
+		case "object":
+			if (d(r) && !n.required) return;
+			f(t), r !== void 0 && p(t);
+			return;
+		case "email":
+		case "url":
+			if (d(r, e) && !n.required) return;
+			f(t, e), d(r, e) || p(t);
+			return;
+		case "pattern":
+			if (d(r, "string") && !n.required) return;
+			f(t), d(r, "string") || g(t);
+			return;
+		default:
+			if (d(r, "string") && !n.required) return;
+			f(t, "string"), d(r, "string") || (p(t), h(t), g(t), n.whitespace === !0 && _(t));
+	}
+}
+function y(e, t) {
+	return new Promise((r) => {
+		let i = !1, a = !1, o = (e) => {
+			i || (i = !0, r(e));
+		}, s = (...e) => {
+			Promise.resolve().then(() => {
+				a || o(e.length ? e[0] : void 0);
+			});
+		}, c;
+		try {
+			c = e.validator(e, t, s);
+		} catch (e) {
+			console.error(e), o(n);
+			return;
+		}
+		a = !!c && typeof c.then == "function" && typeof c.catch == "function", a && c.then(() => o(void 0), (e) => o(e || " "));
+	});
+}
+function b(e) {
+	let t = Object.keys(e).filter((e) => e !== "message");
+	return t.length === 1 && t[0] === "required" ? "required" : e.type === void 0 && e.pattern instanceof RegExp ? "pattern" : e.type ?? "string";
+}
+async function x(r, i, o, s, c) {
+	let l = [], u = o;
+	if (o.validator) {
+		let e = await y(o, i);
+		l = e === void 0 ? [] : Array.isArray(e) ? e : [e];
+	} else {
+		let e = b(o);
+		u = {
+			...o,
+			type: e === "required" ? o.type : e
+		};
+		let t = {
+			rule: u,
+			value: i,
+			name: r,
+			messages: s,
+			errors: []
+		};
+		v(e, t), l = t.errors;
+	}
+	l.length && o.message !== void 0 && o.message !== null && (l = [].concat(o.message));
+	let d = l.map((r, i) => {
+		let a = r && r.message !== void 0 ? r.message : typeof r == "function" ? r() : r, o = a === n ? s.default : a;
+		return t(o) ? e(o, { key: `error_${i}` }) : o;
+	}), f = {
+		...u,
+		name: r,
+		label: r,
+		...c
+	};
+	return d.map((e) => typeof e == "string" ? a(e, f) : e);
+}
+function S(e, t, n, r, i, a) {
+	let o = e.join("."), s = n.map((e, t) => ({
+		rule: e,
+		ruleIndex: t
+	})).sort((e, t) => !!e.rule.warningOnly == !!t.rule.warningOnly ? e.ruleIndex - t.ruleIndex : e.rule.warningOnly ? 1 : -1).map(({ rule: e }) => e), c;
+	if (i === !0) c = new Promise((e, n) => {
+		(async () => {
+			for (let e = 0; e < s.length; e += 1) {
+				let i = s[e], c = await x(o, t, i, r, a);
+				if (c.length) {
+					n([{
+						errors: c,
+						rule: i
+					}]);
+					return;
+				}
+			}
+			e([]);
+		})();
+	});
+	else {
+		let e = s.map((e) => x(o, t, e, r, a).then((t) => ({
+			errors: t,
+			rule: e
+		})));
+		c = (i ? C(e) : Promise.all(e)).then((e) => Promise.reject(e));
+	}
+	return c.catch((e) => e), c;
+}
+function C(e) {
+	let t = 0;
+	return new Promise((n) => {
+		e.forEach((r) => {
+			r.then((r) => {
+				r.errors.length && n([r]), t += 1, t === e.length && n([]);
+			});
+		});
+	});
+}
+//#endregion
+export { S as validateRules };
+
+//# sourceMappingURL=validate.js.map