3050 lines
107 KiB
JavaScript
3050 lines
107 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 334606b5978d0903.36ee2c232b.js
|
|
* Module id: 165109
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
var t,
|
|
r = e.i(358379);
|
|
e.i(23741);
|
|
var n = e.i(511334),
|
|
a = e.i(750149),
|
|
i = e.i(351652),
|
|
o = e.i(449750),
|
|
l = e.i(54168),
|
|
s = e.i(935492),
|
|
u = e.i(634885),
|
|
c = e.i(914528),
|
|
f = e.i(892388),
|
|
d = e.i(504997),
|
|
p = e.i(483926),
|
|
m = e.i(640404),
|
|
h = e.i(484274),
|
|
v = e.i(804372),
|
|
g = e.i(992734),
|
|
b = "RC_FORM_INTERNAL_HOOKS",
|
|
y = function () {
|
|
(0, g.default)(
|
|
!1,
|
|
"Can not find FormContext. Please make sure you wrap Field under Form.",
|
|
);
|
|
},
|
|
x = r.createContext({
|
|
getFieldValue: y,
|
|
getFieldsValue: y,
|
|
getFieldError: y,
|
|
getFieldWarning: y,
|
|
getFieldsError: y,
|
|
isFieldsTouched: y,
|
|
isFieldTouched: y,
|
|
isFieldValidating: y,
|
|
isFieldsValidating: y,
|
|
resetFields: y,
|
|
setFields: y,
|
|
setFieldValue: y,
|
|
setFieldsValue: y,
|
|
validateFields: y,
|
|
submit: y,
|
|
getInternalHooks: function () {
|
|
return (
|
|
y(),
|
|
{
|
|
dispatch: y,
|
|
initEntityValue: y,
|
|
registerField: y,
|
|
useSubscribe: y,
|
|
setInitialValues: y,
|
|
destroyForm: y,
|
|
setCallbacks: y,
|
|
registerWatch: y,
|
|
getFields: y,
|
|
setValidateMessages: y,
|
|
setPreserve: y,
|
|
getInitialValue: y,
|
|
}
|
|
);
|
|
},
|
|
}),
|
|
w = r.createContext(null);
|
|
function k(e) {
|
|
return null == e ? [] : Array.isArray(e) ? e : [e];
|
|
}
|
|
var C = e.i(624977);
|
|
function E() {
|
|
return {
|
|
default: "Validation error on field %s",
|
|
required: "%s is required",
|
|
enum: "%s must be one of %s",
|
|
whitespace: "%s cannot be empty",
|
|
date: {
|
|
format: "%s date %s is invalid for format %s",
|
|
parse: "%s date could not be parsed, %s is invalid ",
|
|
invalid: "%s date %s is invalid",
|
|
},
|
|
types: {
|
|
string: "%s is not a %s",
|
|
method: "%s is not a %s (function)",
|
|
array: "%s is not an %s",
|
|
object: "%s is not an %s",
|
|
number: "%s is not a %s",
|
|
date: "%s is not a %s",
|
|
boolean: "%s is not a %s",
|
|
integer: "%s is not an %s",
|
|
float: "%s is not a %s",
|
|
regexp: "%s is not a valid %s",
|
|
email: "%s is not a valid %s",
|
|
tel: "%s is not a valid %s",
|
|
url: "%s is not a valid %s",
|
|
hex: "%s is not a valid %s",
|
|
},
|
|
string: {
|
|
len: "%s must be exactly %s characters",
|
|
min: "%s must be at least %s characters",
|
|
max: "%s cannot be longer than %s characters",
|
|
range: "%s must be between %s and %s characters",
|
|
},
|
|
number: {
|
|
len: "%s must equal %s",
|
|
min: "%s cannot be less than %s",
|
|
max: "%s cannot be greater than %s",
|
|
range: "%s must be between %s and %s",
|
|
},
|
|
array: {
|
|
len: "%s must be exactly %s in length",
|
|
min: "%s cannot be less than %s in length",
|
|
max: "%s cannot be greater than %s in length",
|
|
range: "%s must be between %s and %s in length",
|
|
},
|
|
pattern: { mismatch: "%s value %s does not match pattern %s" },
|
|
clone: function () {
|
|
var e = JSON.parse(JSON.stringify(this));
|
|
return (e.clone = this.clone), e;
|
|
},
|
|
};
|
|
}
|
|
var j = E(),
|
|
P = e.i(451159),
|
|
F = e.i(363537),
|
|
_ = e.i(116423);
|
|
function S(e) {
|
|
var t = "function" == typeof Map ? new Map() : void 0;
|
|
return (S = function (e) {
|
|
if (
|
|
null === e ||
|
|
!(function (e) {
|
|
try {
|
|
return -1 !== Function.toString.call(e).indexOf("[native code]");
|
|
} catch (t) {
|
|
return "function" == typeof e;
|
|
}
|
|
})(e)
|
|
)
|
|
return e;
|
|
if ("function" != typeof e)
|
|
throw TypeError("Super expression must either be null or a function");
|
|
if (void 0 !== t) {
|
|
if (t.has(e)) return t.get(e);
|
|
t.set(e, r);
|
|
}
|
|
function r() {
|
|
return (function (e, t, r) {
|
|
if ((0, _.default)())
|
|
return Reflect.construct.apply(null, arguments);
|
|
var n = [null];
|
|
n.push.apply(n, t);
|
|
var a = new (e.bind.apply(e, n))();
|
|
return r && (0, F.default)(a, r.prototype), a;
|
|
})(e, arguments, (0, P.default)(this).constructor);
|
|
}
|
|
return (
|
|
(r.prototype = Object.create(e.prototype, {
|
|
constructor: {
|
|
value: r,
|
|
enumerable: !1,
|
|
writable: !0,
|
|
configurable: !0,
|
|
},
|
|
})),
|
|
(0, F.default)(r, e)
|
|
);
|
|
})(e);
|
|
}
|
|
var N = /%[sdj%]/g;
|
|
function O(e) {
|
|
if (!e || !e.length) return null;
|
|
var t = {};
|
|
return (
|
|
e.forEach(function (e) {
|
|
var r = e.field;
|
|
(t[r] = t[r] || []), t[r].push(e);
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
function A(e) {
|
|
for (
|
|
var t = arguments.length, r = Array(t > 1 ? t - 1 : 0), n = 1;
|
|
n < t;
|
|
n++
|
|
)
|
|
r[n - 1] = arguments[n];
|
|
var a = 0,
|
|
i = r.length;
|
|
return "function" == typeof e
|
|
? e.apply(null, r)
|
|
: "string" == typeof e
|
|
? e.replace(N, function (e) {
|
|
if ("%%" === e) return "%";
|
|
if (a >= i) return e;
|
|
switch (e) {
|
|
case "%s":
|
|
return String(r[a++]);
|
|
case "%d":
|
|
return Number(r[a++]);
|
|
case "%j":
|
|
try {
|
|
return JSON.stringify(r[a++]);
|
|
} catch (e) {
|
|
return "[Circular]";
|
|
}
|
|
default:
|
|
return e;
|
|
}
|
|
})
|
|
: e;
|
|
}
|
|
function M(e, t) {
|
|
return (
|
|
!!(null == e || ("array" === t && Array.isArray(e) && !e.length)) ||
|
|
(("string" === t ||
|
|
"url" === t ||
|
|
"hex" === t ||
|
|
"email" === t ||
|
|
"date" === t ||
|
|
"pattern" === t ||
|
|
"tel" === t) &&
|
|
"string" == typeof e &&
|
|
!e) ||
|
|
!1
|
|
);
|
|
}
|
|
function T(e, t, r) {
|
|
var n = 0,
|
|
a = e.length;
|
|
!(function i(o) {
|
|
if (o && o.length) return void r(o);
|
|
var l = n;
|
|
(n += 1), l < a ? t(e[l], i) : r([]);
|
|
})([]);
|
|
}
|
|
var $ = (function (e) {
|
|
(0, d.default)(r, e);
|
|
var t = (0, p.default)(r);
|
|
function r(e, n) {
|
|
var a;
|
|
return (
|
|
(0, u.default)(this, r),
|
|
(a = t.call(this, "Async Validation Error")),
|
|
(0, m.default)((0, f.default)(a), "errors", void 0),
|
|
(0, m.default)((0, f.default)(a), "fields", void 0),
|
|
(a.errors = e),
|
|
(a.fields = n),
|
|
a
|
|
);
|
|
}
|
|
return (0, c.default)(r);
|
|
})(S(Error));
|
|
function I(e, t) {
|
|
return function (r) {
|
|
var n;
|
|
return ((n = e.fullFields
|
|
? (function (e, t) {
|
|
for (var r = e, n = 0; n < t.length && void 0 != r; n++)
|
|
r = r[t[n]];
|
|
return r;
|
|
})(t, e.fullFields)
|
|
: t[r.field || e.fullField]),
|
|
r && void 0 !== r.message)
|
|
? ((r.field = r.field || e.fullField), (r.fieldValue = n), r)
|
|
: {
|
|
message: "function" == typeof r ? r() : r,
|
|
fieldValue: n,
|
|
field: r.field || e.fullField,
|
|
};
|
|
};
|
|
}
|
|
function R(e, t) {
|
|
if (t) {
|
|
for (var r in t)
|
|
if (t.hasOwnProperty(r)) {
|
|
var n = t[r];
|
|
"object" === (0, C.default)(n) && "object" === (0, C.default)(e[r])
|
|
? (e[r] = (0, l.default)((0, l.default)({}, e[r]), n))
|
|
: (e[r] = n);
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
var D = "enum";
|
|
let V = function (e, t, r, n, a, i) {
|
|
e.required &&
|
|
(!r.hasOwnProperty(e.field) || M(t, i || e.type)) &&
|
|
n.push(A(a.messages.required, e.fullField));
|
|
},
|
|
L = function () {
|
|
if (t) return t;
|
|
var e = "[a-fA-F\\d:]",
|
|
r = function (t) {
|
|
return t && t.includeBoundaries
|
|
? "(?:(?<=\\s|^)(?=".concat(e, ")|(?<=").concat(e, ")(?=\\s|$))")
|
|
: "";
|
|
},
|
|
n =
|
|
"(?: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}",
|
|
a = "[a-fA-F\\d]{1,4}",
|
|
i = [
|
|
"(?:".concat(a, ":){7}(?:").concat(a, "|:)"),
|
|
"(?:".concat(a, ":){6}(?:").concat(n, "|:").concat(a, "|:)"),
|
|
"(?:"
|
|
.concat(a, ":){5}(?::")
|
|
.concat(n, "|(?::")
|
|
.concat(a, "){1,2}|:)"),
|
|
"(?:"
|
|
.concat(a, ":){4}(?:(?::")
|
|
.concat(a, "){0,1}:")
|
|
.concat(n, "|(?::")
|
|
.concat(a, "){1,3}|:)"),
|
|
"(?:"
|
|
.concat(a, ":){3}(?:(?::")
|
|
.concat(a, "){0,2}:")
|
|
.concat(n, "|(?::")
|
|
.concat(a, "){1,4}|:)"),
|
|
"(?:"
|
|
.concat(a, ":){2}(?:(?::")
|
|
.concat(a, "){0,3}:")
|
|
.concat(n, "|(?::")
|
|
.concat(a, "){1,5}|:)"),
|
|
"(?:"
|
|
.concat(a, ":){1}(?:(?::")
|
|
.concat(a, "){0,4}:")
|
|
.concat(n, "|(?::")
|
|
.concat(a, "){1,6}|:)"),
|
|
"(?::(?:(?::"
|
|
.concat(a, "){0,5}:")
|
|
.concat(n, "|(?::")
|
|
.concat(a, "){1,7}|:))"),
|
|
],
|
|
o = "(?:".concat(i.join("|"), ")").concat("(?:%[0-9a-zA-Z]{1,})?"),
|
|
l = new RegExp("(?:^".concat(n, "$)|(?:^").concat(o, "$)")),
|
|
s = new RegExp("^".concat(n, "$")),
|
|
u = new RegExp("^".concat(o, "$")),
|
|
c = function (e) {
|
|
return e && e.exact
|
|
? l
|
|
: RegExp(
|
|
"(?:"
|
|
.concat(r(e))
|
|
.concat(n)
|
|
.concat(r(e), ")|(?:")
|
|
.concat(r(e))
|
|
.concat(o)
|
|
.concat(r(e), ")"),
|
|
"g",
|
|
);
|
|
};
|
|
(c.v4 = function (e) {
|
|
return e && e.exact
|
|
? s
|
|
: RegExp("".concat(r(e)).concat(n).concat(r(e)), "g");
|
|
}),
|
|
(c.v6 = function (e) {
|
|
return e && e.exact
|
|
? u
|
|
: RegExp("".concat(r(e)).concat(o).concat(r(e)), "g");
|
|
});
|
|
var f = c.v4().source,
|
|
d = c.v6().source,
|
|
p = "(?:"
|
|
.concat("(?:(?:[a-z]+:)?//)", "|www\\.)")
|
|
.concat("(?:\\S+(?::\\S*)?@)?", "(?:localhost|")
|
|
.concat(f, "|")
|
|
.concat(d, "|")
|
|
.concat(
|
|
"(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)",
|
|
)
|
|
.concat(
|
|
"(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*",
|
|
)
|
|
.concat("(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))", ")")
|
|
.concat("(?::\\d{2,5})?")
|
|
.concat('(?:[/?#][^\\s"]*)?');
|
|
return (t = RegExp("(?:^".concat(p, "$)"), "i"));
|
|
};
|
|
var B =
|
|
/^(([^<>()\[\]\\.,;:\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,}))$/,
|
|
z =
|
|
/^(\+[0-9]{1,3}[-\s\u2011]?)?(\([0-9]{1,4}\)[-\s\u2011]?)?([0-9]+[-\s\u2011]?)*[0-9]+$/,
|
|
U = /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
|
|
H = {
|
|
integer: function (e) {
|
|
return H.number(e) && parseInt(e, 10) === e;
|
|
},
|
|
float: function (e) {
|
|
return H.number(e) && !H.integer(e);
|
|
},
|
|
array: function (e) {
|
|
return Array.isArray(e);
|
|
},
|
|
regexp: function (e) {
|
|
if (e instanceof RegExp) return !0;
|
|
try {
|
|
return new RegExp(e), !0;
|
|
} catch (e) {
|
|
return !1;
|
|
}
|
|
},
|
|
date: function (e) {
|
|
return (
|
|
"function" == typeof e.getTime &&
|
|
"function" == typeof e.getMonth &&
|
|
"function" == typeof e.getYear &&
|
|
!isNaN(e.getTime())
|
|
);
|
|
},
|
|
number: function (e) {
|
|
return !isNaN(e) && "number" == typeof e;
|
|
},
|
|
object: function (e) {
|
|
return "object" === (0, C.default)(e) && !H.array(e);
|
|
},
|
|
method: function (e) {
|
|
return "function" == typeof e;
|
|
},
|
|
email: function (e) {
|
|
return "string" == typeof e && e.length <= 320 && !!e.match(B);
|
|
},
|
|
tel: function (e) {
|
|
return "string" == typeof e && e.length <= 32 && !!e.match(z);
|
|
},
|
|
url: function (e) {
|
|
return "string" == typeof e && e.length <= 2048 && !!e.match(L());
|
|
},
|
|
hex: function (e) {
|
|
return "string" == typeof e && !!e.match(U);
|
|
},
|
|
};
|
|
let q = V,
|
|
W = function (e, t, r, n, a) {
|
|
(/^\s+$/.test(t) || "" === t) &&
|
|
n.push(A(a.messages.whitespace, e.fullField));
|
|
},
|
|
Y = function (e, t, r, n, a) {
|
|
if (e.required && void 0 === t) return void V(e, t, r, n, a);
|
|
var i = e.type;
|
|
[
|
|
"integer",
|
|
"float",
|
|
"array",
|
|
"regexp",
|
|
"object",
|
|
"method",
|
|
"email",
|
|
"tel",
|
|
"number",
|
|
"date",
|
|
"url",
|
|
"hex",
|
|
].indexOf(i) > -1
|
|
? H[i](t) || n.push(A(a.messages.types[i], e.fullField, e.type))
|
|
: i &&
|
|
(0, C.default)(t) !== e.type &&
|
|
n.push(A(a.messages.types[i], e.fullField, e.type));
|
|
},
|
|
K = function (e, t, r, n, a) {
|
|
var i = "number" == typeof e.len,
|
|
o = "number" == typeof e.min,
|
|
l = "number" == typeof e.max,
|
|
s = t,
|
|
u = null,
|
|
c = "number" == typeof t,
|
|
f = "string" == typeof t,
|
|
d = Array.isArray(t);
|
|
if ((c ? (u = "number") : f ? (u = "string") : d && (u = "array"), !u))
|
|
return !1;
|
|
d && (s = t.length),
|
|
f && (s = t.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "_").length),
|
|
i
|
|
? s !== e.len && n.push(A(a.messages[u].len, e.fullField, e.len))
|
|
: o && !l && s < e.min
|
|
? n.push(A(a.messages[u].min, e.fullField, e.min))
|
|
: l && !o && s > e.max
|
|
? n.push(A(a.messages[u].max, e.fullField, e.max))
|
|
: o &&
|
|
l &&
|
|
(s < e.min || s > e.max) &&
|
|
n.push(A(a.messages[u].range, e.fullField, e.min, e.max));
|
|
},
|
|
G = function (e, t, r, n, a) {
|
|
(e[D] = Array.isArray(e[D]) ? e[D] : []),
|
|
-1 === e[D].indexOf(t) &&
|
|
n.push(A(a.messages[D], e.fullField, e[D].join(", ")));
|
|
},
|
|
X = function (e, t, r, n, a) {
|
|
e.pattern &&
|
|
(e.pattern instanceof RegExp
|
|
? ((e.pattern.lastIndex = 0),
|
|
e.pattern.test(t) ||
|
|
n.push(
|
|
A(a.messages.pattern.mismatch, e.fullField, t, e.pattern),
|
|
))
|
|
: "string" == typeof e.pattern &&
|
|
(new RegExp(e.pattern).test(t) ||
|
|
n.push(
|
|
A(a.messages.pattern.mismatch, e.fullField, t, e.pattern),
|
|
)));
|
|
},
|
|
Z = function (e, t, r, n, a) {
|
|
var i = e.type,
|
|
o = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t, i) && !e.required) return r();
|
|
q(e, t, n, o, a, i), M(t, i) || Y(e, t, n, o, a);
|
|
}
|
|
r(o);
|
|
},
|
|
J = {
|
|
string: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t, "string") && !e.required) return r();
|
|
q(e, t, n, i, a, "string"),
|
|
M(t, "string") ||
|
|
(Y(e, t, n, i, a),
|
|
K(e, t, n, i, a),
|
|
X(e, t, n, i, a),
|
|
!0 === e.whitespace && W(e, t, n, i, a));
|
|
}
|
|
r(i);
|
|
},
|
|
method: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a), void 0 !== t && Y(e, t, n, i, a);
|
|
}
|
|
r(i);
|
|
},
|
|
number: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (("" === t && (t = void 0), M(t) && !e.required)) return r();
|
|
q(e, t, n, i, a),
|
|
void 0 !== t && (Y(e, t, n, i, a), K(e, t, n, i, a));
|
|
}
|
|
r(i);
|
|
},
|
|
boolean: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a), void 0 !== t && Y(e, t, n, i, a);
|
|
}
|
|
r(i);
|
|
},
|
|
regexp: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a), M(t) || Y(e, t, n, i, a);
|
|
}
|
|
r(i);
|
|
},
|
|
integer: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a),
|
|
void 0 !== t && (Y(e, t, n, i, a), K(e, t, n, i, a));
|
|
}
|
|
r(i);
|
|
},
|
|
float: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a),
|
|
void 0 !== t && (Y(e, t, n, i, a), K(e, t, n, i, a));
|
|
}
|
|
r(i);
|
|
},
|
|
array: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (null == t && !e.required) return r();
|
|
q(e, t, n, i, a, "array"),
|
|
null != t && (Y(e, t, n, i, a), K(e, t, n, i, a));
|
|
}
|
|
r(i);
|
|
},
|
|
object: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a), void 0 !== t && Y(e, t, n, i, a);
|
|
}
|
|
r(i);
|
|
},
|
|
enum: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a), void 0 !== t && G(e, t, n, i, a);
|
|
}
|
|
r(i);
|
|
},
|
|
pattern: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t, "string") && !e.required) return r();
|
|
q(e, t, n, i, a), M(t, "string") || X(e, t, n, i, a);
|
|
}
|
|
r(i);
|
|
},
|
|
date: function (e, t, r, n, a) {
|
|
var i,
|
|
o = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t, "date") && !e.required) return r();
|
|
q(e, t, n, o, a),
|
|
!M(t, "date") &&
|
|
((i = t instanceof Date ? t : new Date(t)),
|
|
Y(e, i, n, o, a),
|
|
i && K(e, i.getTime(), n, o, a));
|
|
}
|
|
r(o);
|
|
},
|
|
url: Z,
|
|
hex: Z,
|
|
email: Z,
|
|
tel: Z,
|
|
required: function (e, t, r, n, a) {
|
|
var i = [],
|
|
o = Array.isArray(t) ? "array" : (0, C.default)(t);
|
|
q(e, t, n, i, a, o), r(i);
|
|
},
|
|
any: function (e, t, r, n, a) {
|
|
var i = [];
|
|
if (e.required || (!e.required && n.hasOwnProperty(e.field))) {
|
|
if (M(t) && !e.required) return r();
|
|
q(e, t, n, i, a);
|
|
}
|
|
r(i);
|
|
},
|
|
};
|
|
var Q = (function () {
|
|
function e(t) {
|
|
(0, u.default)(this, e),
|
|
(0, m.default)(this, "rules", null),
|
|
(0, m.default)(this, "_messages", j),
|
|
this.define(t);
|
|
}
|
|
return (
|
|
(0, c.default)(e, [
|
|
{
|
|
key: "define",
|
|
value: function (e) {
|
|
var t = this;
|
|
if (!e) throw Error("Cannot configure a schema with no rules");
|
|
if ("object" !== (0, C.default)(e) || Array.isArray(e))
|
|
throw Error("Rules must be an object");
|
|
(this.rules = {}),
|
|
Object.keys(e).forEach(function (r) {
|
|
var n = e[r];
|
|
t.rules[r] = Array.isArray(n) ? n : [n];
|
|
});
|
|
},
|
|
},
|
|
{
|
|
key: "messages",
|
|
value: function (e) {
|
|
return e && (this._messages = R(E(), e)), this._messages;
|
|
},
|
|
},
|
|
{
|
|
key: "validate",
|
|
value: function (t) {
|
|
var r = this,
|
|
n =
|
|
arguments.length > 1 && void 0 !== arguments[1]
|
|
? arguments[1]
|
|
: {},
|
|
a =
|
|
arguments.length > 2 && void 0 !== arguments[2]
|
|
? arguments[2]
|
|
: function () {},
|
|
i = t,
|
|
o = n,
|
|
u = a;
|
|
if (
|
|
("function" == typeof o && ((u = o), (o = {})),
|
|
!this.rules || 0 === Object.keys(this.rules).length)
|
|
)
|
|
return u && u(null, i), Promise.resolve(i);
|
|
if (o.messages) {
|
|
var c = this.messages();
|
|
c === j && (c = E()), R(c, o.messages), (o.messages = c);
|
|
} else o.messages = this.messages();
|
|
var f = {};
|
|
(o.keys || Object.keys(this.rules)).forEach(function (e) {
|
|
var n = r.rules[e],
|
|
a = i[e];
|
|
n.forEach(function (n) {
|
|
var o = n;
|
|
"function" == typeof o.transform &&
|
|
(i === t && (i = (0, l.default)({}, i)),
|
|
null != (a = i[e] = o.transform(a)) &&
|
|
(o.type =
|
|
o.type ||
|
|
(Array.isArray(a) ? "array" : (0, C.default)(a)))),
|
|
((o =
|
|
"function" == typeof o
|
|
? { validator: o }
|
|
: (0, l.default)({}, o)).validator =
|
|
r.getValidationMethod(o)),
|
|
o.validator &&
|
|
((o.field = e),
|
|
(o.fullField = o.fullField || e),
|
|
(o.type = r.getType(o)),
|
|
(f[e] = f[e] || []),
|
|
f[e].push({ rule: o, value: a, source: i, field: e }));
|
|
});
|
|
});
|
|
var d = {};
|
|
return (function (e, t, r, n, a) {
|
|
if (t.first) {
|
|
var i = new Promise(function (t, i) {
|
|
var o;
|
|
T(
|
|
((o = []),
|
|
Object.keys(e).forEach(function (t) {
|
|
o.push.apply(o, (0, s.default)(e[t] || []));
|
|
}),
|
|
o),
|
|
r,
|
|
function (e) {
|
|
return n(e), e.length ? i(new $(e, O(e))) : t(a);
|
|
},
|
|
);
|
|
});
|
|
return (
|
|
i.catch(function (e) {
|
|
return e;
|
|
}),
|
|
i
|
|
);
|
|
}
|
|
var o =
|
|
!0 === t.firstFields ? Object.keys(e) : t.firstFields || [],
|
|
l = Object.keys(e),
|
|
u = l.length,
|
|
c = 0,
|
|
f = [],
|
|
d = new Promise(function (t, i) {
|
|
var d = function (e) {
|
|
if ((f.push.apply(f, e), ++c === u))
|
|
return n(f), f.length ? i(new $(f, O(f))) : t(a);
|
|
};
|
|
l.length || (n(f), t(a)),
|
|
l.forEach(function (t) {
|
|
var n = e[t];
|
|
if (-1 !== o.indexOf(t)) T(n, r, d);
|
|
else {
|
|
var a = [],
|
|
i = 0,
|
|
l = n.length;
|
|
function u(e) {
|
|
a.push.apply(a, (0, s.default)(e || [])),
|
|
++i === l && d(a);
|
|
}
|
|
n.forEach(function (e) {
|
|
r(e, u);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
return (
|
|
d.catch(function (e) {
|
|
return e;
|
|
}),
|
|
d
|
|
);
|
|
})(
|
|
f,
|
|
o,
|
|
function (t, r) {
|
|
var n,
|
|
a,
|
|
u,
|
|
c = t.rule,
|
|
f =
|
|
("object" === c.type || "array" === c.type) &&
|
|
("object" === (0, C.default)(c.fields) ||
|
|
"object" === (0, C.default)(c.defaultField));
|
|
function p(e, t) {
|
|
return (0, l.default)(
|
|
(0, l.default)({}, t),
|
|
{},
|
|
{
|
|
fullField: "".concat(c.fullField, ".").concat(e),
|
|
fullFields: c.fullFields
|
|
? [].concat((0, s.default)(c.fullFields), [e])
|
|
: [e],
|
|
},
|
|
);
|
|
}
|
|
function m() {
|
|
var n =
|
|
arguments.length > 0 && void 0 !== arguments[0]
|
|
? arguments[0]
|
|
: [],
|
|
a = Array.isArray(n) ? n : [n];
|
|
!o.suppressWarning &&
|
|
a.length &&
|
|
e.warning("async-validator:", a),
|
|
a.length &&
|
|
void 0 !== c.message &&
|
|
null !== c.message &&
|
|
(a = [].concat(c.message));
|
|
var u = a.map(I(c, i));
|
|
if (o.first && u.length) return (d[c.field] = 1), r(u);
|
|
if (f) {
|
|
if (c.required && !t.value)
|
|
return (
|
|
void 0 !== c.message
|
|
? (u = [].concat(c.message).map(I(c, i)))
|
|
: o.error &&
|
|
(u = [
|
|
o.error(c, A(o.messages.required, c.field)),
|
|
]),
|
|
r(u)
|
|
);
|
|
var m = {};
|
|
c.defaultField &&
|
|
Object.keys(t.value).map(function (e) {
|
|
m[e] = c.defaultField;
|
|
});
|
|
var h = {};
|
|
Object.keys(
|
|
(m = (0, l.default)(
|
|
(0, l.default)({}, m),
|
|
t.rule.fields,
|
|
)),
|
|
).forEach(function (e) {
|
|
var t = m[e],
|
|
r = Array.isArray(t) ? t : [t];
|
|
h[e] = r.map(p.bind(null, e));
|
|
});
|
|
var v = new e(h);
|
|
v.messages(o.messages),
|
|
t.rule.options &&
|
|
((t.rule.options.messages = o.messages),
|
|
(t.rule.options.error = o.error)),
|
|
v.validate(t.value, t.rule.options || o, function (e) {
|
|
var t = [];
|
|
u && u.length && t.push.apply(t, (0, s.default)(u)),
|
|
e && e.length && t.push.apply(t, (0, s.default)(e)),
|
|
r(t.length ? t : null);
|
|
});
|
|
} else r(u);
|
|
}
|
|
if (
|
|
((f = f && (c.required || (!c.required && t.value))),
|
|
(c.field = t.field),
|
|
c.asyncValidator)
|
|
)
|
|
n = c.asyncValidator(c, t.value, m, t.source, o);
|
|
else if (c.validator) {
|
|
try {
|
|
n = c.validator(c, t.value, m, t.source, o);
|
|
} catch (e) {
|
|
null == (a = (u = console).error) || a.call(u, e),
|
|
o.suppressValidatorError ||
|
|
setTimeout(function () {
|
|
throw e;
|
|
}, 0),
|
|
m(e.message);
|
|
}
|
|
!0 === n
|
|
? m()
|
|
: !1 === n
|
|
? m(
|
|
"function" == typeof c.message
|
|
? c.message(c.fullField || c.field)
|
|
: c.message ||
|
|
"".concat(c.fullField || c.field, " fails"),
|
|
)
|
|
: n instanceof Array
|
|
? m(n)
|
|
: n instanceof Error && m(n.message);
|
|
}
|
|
n &&
|
|
n.then &&
|
|
n.then(
|
|
function () {
|
|
return m();
|
|
},
|
|
function (e) {
|
|
return m(e);
|
|
},
|
|
);
|
|
},
|
|
function (e) {
|
|
for (var t = [], r = {}, n = 0; n < e.length; n++)
|
|
!(function (e) {
|
|
if (Array.isArray(e)) {
|
|
var r;
|
|
t = (r = t).concat.apply(r, (0, s.default)(e));
|
|
} else t.push(e);
|
|
})(e[n]);
|
|
t.length ? ((r = O(t)), u(t, r)) : u(null, i);
|
|
},
|
|
i,
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: "getType",
|
|
value: function (e) {
|
|
if (
|
|
(void 0 === e.type &&
|
|
e.pattern instanceof RegExp &&
|
|
(e.type = "pattern"),
|
|
"function" != typeof e.validator &&
|
|
e.type &&
|
|
!J.hasOwnProperty(e.type))
|
|
)
|
|
throw Error(A("Unknown rule type %s", e.type));
|
|
return e.type || "string";
|
|
},
|
|
},
|
|
{
|
|
key: "getValidationMethod",
|
|
value: function (e) {
|
|
if ("function" == typeof e.validator) return e.validator;
|
|
var t = Object.keys(e),
|
|
r = t.indexOf("message");
|
|
return (-1 !== r && t.splice(r, 1),
|
|
1 === t.length && "required" === t[0])
|
|
? J.required
|
|
: J[this.getType(e)] || void 0;
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})();
|
|
(0, m.default)(Q, "register", function (e, t) {
|
|
if ("function" != typeof t)
|
|
throw Error(
|
|
"Cannot register a validator by type, validator is not a function",
|
|
);
|
|
J[e] = t;
|
|
}),
|
|
(0, m.default)(Q, "warning", function () {}),
|
|
(0, m.default)(Q, "messages", j),
|
|
(0, m.default)(Q, "validators", J);
|
|
var ee = "'${name}' is not a valid ${type}",
|
|
et = {
|
|
default: "Validation error on field '${name}'",
|
|
required: "'${name}' is required",
|
|
enum: "'${name}' must be one of [${enum}]",
|
|
whitespace: "'${name}' cannot be empty",
|
|
date: {
|
|
format: "'${name}' is invalid for format date",
|
|
parse: "'${name}' could not be parsed as date",
|
|
invalid: "'${name}' is invalid date",
|
|
},
|
|
types: {
|
|
string: ee,
|
|
method: ee,
|
|
array: ee,
|
|
object: ee,
|
|
number: ee,
|
|
date: ee,
|
|
boolean: ee,
|
|
integer: ee,
|
|
float: ee,
|
|
regexp: ee,
|
|
email: ee,
|
|
url: ee,
|
|
hex: ee,
|
|
},
|
|
string: {
|
|
len: "'${name}' must be exactly ${len} characters",
|
|
min: "'${name}' must be at least ${min} characters",
|
|
max: "'${name}' cannot be longer than ${max} characters",
|
|
range: "'${name}' must be between ${min} and ${max} characters",
|
|
},
|
|
number: {
|
|
len: "'${name}' must equal ${len}",
|
|
min: "'${name}' cannot be less than ${min}",
|
|
max: "'${name}' cannot be greater than ${max}",
|
|
range: "'${name}' must be between ${min} and ${max}",
|
|
},
|
|
array: {
|
|
len: "'${name}' must be exactly ${len} in length",
|
|
min: "'${name}' cannot be less than ${min} in length",
|
|
max: "'${name}' cannot be greater than ${max} in length",
|
|
range: "'${name}' must be between ${min} and ${max} in length",
|
|
},
|
|
pattern: { mismatch: "'${name}' does not match pattern ${pattern}" },
|
|
},
|
|
er = e.i(615260),
|
|
en = "CODE_LOGIC_ERROR";
|
|
function ea(e, t, r, n, a) {
|
|
return ei.apply(this, arguments);
|
|
}
|
|
function ei() {
|
|
return (ei = (0, o.default)(
|
|
(0, i.default)().mark(function e(t, n, a, o, u) {
|
|
var c, f, d, p, h, v, g, b, y;
|
|
return (0, i.default)().wrap(
|
|
function (e) {
|
|
for (;;)
|
|
switch ((e.prev = e.next)) {
|
|
case 0:
|
|
return (
|
|
(c = (0, l.default)({}, a)),
|
|
delete c.ruleIndex,
|
|
(Q.warning = function () {}),
|
|
c.validator &&
|
|
((f = c.validator),
|
|
(c.validator = function () {
|
|
try {
|
|
return f.apply(void 0, arguments);
|
|
} catch (e) {
|
|
return console.error(e), Promise.reject(en);
|
|
}
|
|
})),
|
|
(d = null),
|
|
c &&
|
|
"array" === c.type &&
|
|
c.defaultField &&
|
|
((d = c.defaultField), delete c.defaultField),
|
|
(p = new Q((0, m.default)({}, t, [c]))),
|
|
(h = (0, er.merge)(et, o.validateMessages)),
|
|
p.messages(h),
|
|
(v = []),
|
|
(e.prev = 10),
|
|
(e.next = 13),
|
|
Promise.resolve(
|
|
p.validate(
|
|
(0, m.default)({}, t, n),
|
|
(0, l.default)({}, o),
|
|
),
|
|
)
|
|
);
|
|
case 13:
|
|
e.next = 18;
|
|
break;
|
|
case 15:
|
|
(e.prev = 15),
|
|
(e.t0 = e.catch(10)),
|
|
e.t0.errors &&
|
|
(v = e.t0.errors.map(function (e, t) {
|
|
var n = e.message,
|
|
a = n === en ? h.default : n;
|
|
return r.isValidElement(a)
|
|
? r.cloneElement(a, { key: "error_".concat(t) })
|
|
: a;
|
|
}));
|
|
case 18:
|
|
if (!(!v.length && d && Array.isArray(n) && n.length > 0)) {
|
|
e.next = 23;
|
|
break;
|
|
}
|
|
return (
|
|
(e.next = 21),
|
|
Promise.all(
|
|
n.map(function (e, r) {
|
|
return ea("".concat(t, ".").concat(r), e, d, o, u);
|
|
}),
|
|
)
|
|
);
|
|
case 21:
|
|
return (
|
|
(g = e.sent),
|
|
e.abrupt(
|
|
"return",
|
|
g.reduce(function (e, t) {
|
|
return [].concat(
|
|
(0, s.default)(e),
|
|
(0, s.default)(t),
|
|
);
|
|
}, []),
|
|
)
|
|
);
|
|
case 23:
|
|
return (
|
|
(b = (0, l.default)(
|
|
(0, l.default)({}, a),
|
|
{},
|
|
{ name: t, enum: (a.enum || []).join(", ") },
|
|
u,
|
|
)),
|
|
(y = v.map(function (e) {
|
|
return "string" == typeof e
|
|
? (function (e, t) {
|
|
return e.replace(/\\?\$\{\w+\}/g, function (e) {
|
|
return e.startsWith("\\")
|
|
? e.slice(1)
|
|
: t[e.slice(2, -1)];
|
|
});
|
|
})(e, b)
|
|
: e;
|
|
})),
|
|
e.abrupt("return", y)
|
|
);
|
|
case 26:
|
|
case "end":
|
|
return e.stop();
|
|
}
|
|
},
|
|
e,
|
|
null,
|
|
[[10, 15]],
|
|
);
|
|
}),
|
|
)).apply(this, arguments);
|
|
}
|
|
function eo() {
|
|
return (eo = (0, o.default)(
|
|
(0, i.default)().mark(function e(t) {
|
|
return (0, i.default)().wrap(function (e) {
|
|
for (;;)
|
|
switch ((e.prev = e.next)) {
|
|
case 0:
|
|
return e.abrupt(
|
|
"return",
|
|
Promise.all(t).then(function (e) {
|
|
var t;
|
|
return (t = []).concat.apply(t, (0, s.default)(e));
|
|
}),
|
|
);
|
|
case 1:
|
|
case "end":
|
|
return e.stop();
|
|
}
|
|
}, e);
|
|
}),
|
|
)).apply(this, arguments);
|
|
}
|
|
function el() {
|
|
return (el = (0, o.default)(
|
|
(0, i.default)().mark(function e(t) {
|
|
var r;
|
|
return (0, i.default)().wrap(function (e) {
|
|
for (;;)
|
|
switch ((e.prev = e.next)) {
|
|
case 0:
|
|
return (
|
|
(r = 0),
|
|
e.abrupt(
|
|
"return",
|
|
new Promise(function (e) {
|
|
t.forEach(function (n) {
|
|
n.then(function (n) {
|
|
n.errors.length && e([n]),
|
|
(r += 1) === t.length && e([]);
|
|
});
|
|
});
|
|
}),
|
|
)
|
|
);
|
|
case 2:
|
|
case "end":
|
|
return e.stop();
|
|
}
|
|
}, e);
|
|
}),
|
|
)).apply(this, arguments);
|
|
}
|
|
var es = e.i(766331);
|
|
function eu(e) {
|
|
return k(e);
|
|
}
|
|
function ec(e, t) {
|
|
var r = {};
|
|
return (
|
|
t.forEach(function (t) {
|
|
var n = (0, es.default)(e, t);
|
|
r = (0, er.default)(r, t, n);
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
function ef(e, t) {
|
|
var r = arguments.length > 2 && void 0 !== arguments[2] && arguments[2];
|
|
return (
|
|
e &&
|
|
e.some(function (e) {
|
|
return ed(t, e, r);
|
|
})
|
|
);
|
|
}
|
|
function ed(e, t) {
|
|
var r = arguments.length > 2 && void 0 !== arguments[2] && arguments[2];
|
|
return (
|
|
!!e &&
|
|
!!t &&
|
|
(!!r || e.length === t.length) &&
|
|
t.every(function (t, r) {
|
|
return e[r] === t;
|
|
})
|
|
);
|
|
}
|
|
function ep(e) {
|
|
var t = arguments.length <= 1 ? void 0 : arguments[1];
|
|
return t &&
|
|
t.target &&
|
|
"object" === (0, C.default)(t.target) &&
|
|
e in t.target
|
|
? t.target[e]
|
|
: t;
|
|
}
|
|
function em(e, t, r) {
|
|
var n = e.length;
|
|
if (t < 0 || t >= n || r < 0 || r >= n) return e;
|
|
var a = e[t],
|
|
i = t - r;
|
|
return i > 0
|
|
? [].concat(
|
|
(0, s.default)(e.slice(0, r)),
|
|
[a],
|
|
(0, s.default)(e.slice(r, t)),
|
|
(0, s.default)(e.slice(t + 1, n)),
|
|
)
|
|
: i < 0
|
|
? [].concat(
|
|
(0, s.default)(e.slice(0, t)),
|
|
(0, s.default)(e.slice(t + 1, r + 1)),
|
|
[a],
|
|
(0, s.default)(e.slice(r + 1, n)),
|
|
)
|
|
: e;
|
|
}
|
|
var eh = es,
|
|
ev = ["name"],
|
|
eg = [];
|
|
function eb(e, t, r, n, a, i) {
|
|
return "function" == typeof e
|
|
? e(t, r, "source" in i ? { source: i.source } : {})
|
|
: n !== a;
|
|
}
|
|
var ey = (function (e) {
|
|
(0, d.default)(n, e);
|
|
var t = (0, p.default)(n);
|
|
function n(e) {
|
|
var a;
|
|
return (
|
|
(0, u.default)(this, n),
|
|
(a = t.call(this, e)),
|
|
(0, m.default)((0, f.default)(a), "state", { resetCount: 0 }),
|
|
(0, m.default)((0, f.default)(a), "cancelRegisterFunc", null),
|
|
(0, m.default)((0, f.default)(a), "mounted", !1),
|
|
(0, m.default)((0, f.default)(a), "touched", !1),
|
|
(0, m.default)((0, f.default)(a), "dirty", !1),
|
|
(0, m.default)((0, f.default)(a), "validatePromise", void 0),
|
|
(0, m.default)((0, f.default)(a), "prevValidating", void 0),
|
|
(0, m.default)((0, f.default)(a), "errors", eg),
|
|
(0, m.default)((0, f.default)(a), "warnings", eg),
|
|
(0, m.default)((0, f.default)(a), "cancelRegister", function () {
|
|
var e = a.props,
|
|
t = e.preserve,
|
|
r = e.isListField,
|
|
n = e.name;
|
|
a.cancelRegisterFunc && a.cancelRegisterFunc(r, t, eu(n)),
|
|
(a.cancelRegisterFunc = null);
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getNamePath", function () {
|
|
var e = a.props,
|
|
t = e.name,
|
|
r = e.fieldContext.prefixName;
|
|
return void 0 !== t
|
|
? [].concat(
|
|
(0, s.default)(void 0 === r ? [] : r),
|
|
(0, s.default)(t),
|
|
)
|
|
: [];
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getRules", function () {
|
|
var e = a.props,
|
|
t = e.rules,
|
|
r = e.fieldContext;
|
|
return (void 0 === t ? [] : t).map(function (e) {
|
|
return "function" == typeof e ? e(r) : e;
|
|
});
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "refresh", function () {
|
|
a.mounted &&
|
|
a.setState(function (e) {
|
|
return { resetCount: e.resetCount + 1 };
|
|
});
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "metaCache", null),
|
|
(0, m.default)((0, f.default)(a), "triggerMetaEvent", function (e) {
|
|
var t = a.props.onMetaChange;
|
|
if (t) {
|
|
var r = (0, l.default)(
|
|
(0, l.default)({}, a.getMeta()),
|
|
{},
|
|
{ destroy: e },
|
|
);
|
|
(0, v.default)(a.metaCache, r) || t(r), (a.metaCache = r);
|
|
} else a.metaCache = null;
|
|
}),
|
|
(0, m.default)(
|
|
(0, f.default)(a),
|
|
"onStoreChange",
|
|
function (e, t, r) {
|
|
var n = a.props,
|
|
i = n.shouldUpdate,
|
|
o = n.dependencies,
|
|
l = void 0 === o ? [] : o,
|
|
s = n.onReset,
|
|
u = r.store,
|
|
c = a.getNamePath(),
|
|
f = a.getValue(e),
|
|
d = a.getValue(u),
|
|
p = t && ef(t, c);
|
|
switch (
|
|
("valueUpdate" === r.type &&
|
|
"external" === r.source &&
|
|
!(0, v.default)(f, d) &&
|
|
((a.touched = !0),
|
|
(a.dirty = !0),
|
|
(a.validatePromise = null),
|
|
(a.errors = eg),
|
|
(a.warnings = eg),
|
|
a.triggerMetaEvent()),
|
|
r.type)
|
|
) {
|
|
case "reset":
|
|
if (!t || p) {
|
|
(a.touched = !1),
|
|
(a.dirty = !1),
|
|
(a.validatePromise = void 0),
|
|
(a.errors = eg),
|
|
(a.warnings = eg),
|
|
a.triggerMetaEvent(),
|
|
null == s || s(),
|
|
a.refresh();
|
|
return;
|
|
}
|
|
break;
|
|
case "remove":
|
|
if (i && eb(i, e, u, f, d, r)) return void a.reRender();
|
|
break;
|
|
case "setField":
|
|
var m = r.data;
|
|
if (p) {
|
|
"touched" in m && (a.touched = m.touched),
|
|
"validating" in m &&
|
|
!("originRCField" in m) &&
|
|
(a.validatePromise = m.validating
|
|
? Promise.resolve([])
|
|
: null),
|
|
"errors" in m && (a.errors = m.errors || eg),
|
|
"warnings" in m && (a.warnings = m.warnings || eg),
|
|
(a.dirty = !0),
|
|
a.triggerMetaEvent(),
|
|
a.reRender();
|
|
return;
|
|
}
|
|
if (
|
|
("value" in m && ef(t, c, !0)) ||
|
|
(i && !c.length && eb(i, e, u, f, d, r))
|
|
)
|
|
return void a.reRender();
|
|
break;
|
|
case "dependenciesUpdate":
|
|
if (
|
|
l.map(eu).some(function (e) {
|
|
return ef(r.relatedFields, e);
|
|
})
|
|
)
|
|
return void a.reRender();
|
|
break;
|
|
default:
|
|
if (
|
|
p ||
|
|
((!l.length || c.length || i) && eb(i, e, u, f, d, r))
|
|
)
|
|
return void a.reRender();
|
|
}
|
|
!0 === i && a.reRender();
|
|
},
|
|
),
|
|
(0, m.default)((0, f.default)(a), "validateRules", function (e) {
|
|
var t = a.getNamePath(),
|
|
r = a.getValue(),
|
|
n = e || {},
|
|
u = n.triggerName,
|
|
c = n.validateOnly,
|
|
f = Promise.resolve().then(
|
|
(0, o.default)(
|
|
(0, i.default)().mark(function n() {
|
|
var c, d, p, m, h, v, b;
|
|
return (0, i.default)().wrap(function (n) {
|
|
for (;;)
|
|
switch ((n.prev = n.next)) {
|
|
case 0:
|
|
if (a.mounted) {
|
|
n.next = 2;
|
|
break;
|
|
}
|
|
return n.abrupt("return", []);
|
|
case 2:
|
|
if (
|
|
((p =
|
|
void 0 !== (d = (c = a.props).validateFirst) &&
|
|
d),
|
|
(m = c.messageVariables),
|
|
(h = c.validateDebounce),
|
|
(v = a.getRules()),
|
|
u &&
|
|
(v = v
|
|
.filter(function (e) {
|
|
return e;
|
|
})
|
|
.filter(function (e) {
|
|
var t = e.validateTrigger;
|
|
return !t || k(t).includes(u);
|
|
})),
|
|
!(h && u))
|
|
) {
|
|
n.next = 10;
|
|
break;
|
|
}
|
|
return (
|
|
(n.next = 8),
|
|
new Promise(function (e) {
|
|
setTimeout(e, h);
|
|
})
|
|
);
|
|
case 8:
|
|
if (a.validatePromise === f) {
|
|
n.next = 10;
|
|
break;
|
|
}
|
|
return n.abrupt("return", []);
|
|
case 10:
|
|
return (
|
|
(b = (function (e, t, r, n, a, s) {
|
|
var u,
|
|
c,
|
|
f = e.join("."),
|
|
d = r
|
|
.map(function (e, t) {
|
|
var r = e.validator,
|
|
n = (0, l.default)(
|
|
(0, l.default)({}, e),
|
|
{},
|
|
{ ruleIndex: t },
|
|
);
|
|
return (
|
|
r &&
|
|
(n.validator = function (e, t, n) {
|
|
var a = !1,
|
|
i = r(e, t, function () {
|
|
for (
|
|
var e = arguments.length,
|
|
t = Array(e),
|
|
r = 0;
|
|
r < e;
|
|
r++
|
|
)
|
|
t[r] = arguments[r];
|
|
Promise.resolve().then(
|
|
function () {
|
|
(0, g.default)(
|
|
!a,
|
|
"Your validator function has already return a promise. `callback` will be ignored.",
|
|
),
|
|
a || n.apply(void 0, t);
|
|
},
|
|
);
|
|
});
|
|
(a =
|
|
i &&
|
|
"function" == typeof i.then &&
|
|
"function" == typeof i.catch),
|
|
(0, g.default)(
|
|
a,
|
|
"`callback` is deprecated. Please return a promise instead.",
|
|
),
|
|
a &&
|
|
i
|
|
.then(function () {
|
|
n();
|
|
})
|
|
.catch(function (e) {
|
|
n(e || " ");
|
|
});
|
|
}),
|
|
n
|
|
);
|
|
})
|
|
.sort(function (e, t) {
|
|
var r = e.warningOnly,
|
|
n = e.ruleIndex,
|
|
a = t.warningOnly,
|
|
i = t.ruleIndex;
|
|
return !!r == !!a ? n - i : r ? 1 : -1;
|
|
});
|
|
if (!0 === a)
|
|
c = new Promise(
|
|
((u = (0, o.default)(
|
|
(0, i.default)().mark(function e(r, a) {
|
|
var o, l, u;
|
|
return (0, i.default)().wrap(function (
|
|
e,
|
|
) {
|
|
for (;;)
|
|
switch ((e.prev = e.next)) {
|
|
case 0:
|
|
o = 0;
|
|
case 1:
|
|
if (!(o < d.length)) {
|
|
e.next = 12;
|
|
break;
|
|
}
|
|
return (
|
|
(l = d[o]),
|
|
(e.next = 5),
|
|
ea(f, t, l, n, s)
|
|
);
|
|
case 5:
|
|
if (!(u = e.sent).length) {
|
|
e.next = 9;
|
|
break;
|
|
}
|
|
return (
|
|
a([{ errors: u, rule: l }]),
|
|
e.abrupt("return")
|
|
);
|
|
case 9:
|
|
(o += 1), (e.next = 1);
|
|
break;
|
|
case 12:
|
|
r([]);
|
|
case 13:
|
|
case "end":
|
|
return e.stop();
|
|
}
|
|
}, e);
|
|
}),
|
|
)),
|
|
function (e, t) {
|
|
return u.apply(this, arguments);
|
|
}),
|
|
);
|
|
else {
|
|
var p = d.map(function (e) {
|
|
return ea(f, t, e, n, s).then(function (t) {
|
|
return { errors: t, rule: e };
|
|
});
|
|
});
|
|
c = (
|
|
a
|
|
? (function (e) {
|
|
return el.apply(this, arguments);
|
|
})(p)
|
|
: (function (e) {
|
|
return eo.apply(this, arguments);
|
|
})(p)
|
|
).then(function (e) {
|
|
return Promise.reject(e);
|
|
});
|
|
}
|
|
return (
|
|
c.catch(function (e) {
|
|
return e;
|
|
}),
|
|
c
|
|
);
|
|
})(t, r, v, e, p, m))
|
|
.catch(function (e) {
|
|
return e;
|
|
})
|
|
.then(function () {
|
|
var e =
|
|
arguments.length > 0 &&
|
|
void 0 !== arguments[0]
|
|
? arguments[0]
|
|
: eg;
|
|
if (a.validatePromise === f) {
|
|
a.validatePromise = null;
|
|
var t,
|
|
r = [],
|
|
n = [];
|
|
null == (t = e.forEach) ||
|
|
t.call(e, function (e) {
|
|
var t = e.rule.warningOnly,
|
|
a = e.errors,
|
|
i = void 0 === a ? eg : a;
|
|
t
|
|
? n.push.apply(n, (0, s.default)(i))
|
|
: r.push.apply(r, (0, s.default)(i));
|
|
}),
|
|
(a.errors = r),
|
|
(a.warnings = n),
|
|
a.triggerMetaEvent(),
|
|
a.reRender();
|
|
}
|
|
}),
|
|
n.abrupt("return", b)
|
|
);
|
|
case 13:
|
|
case "end":
|
|
return n.stop();
|
|
}
|
|
}, n);
|
|
}),
|
|
),
|
|
);
|
|
return (
|
|
(void 0 !== c && c) ||
|
|
((a.validatePromise = f),
|
|
(a.dirty = !0),
|
|
(a.errors = eg),
|
|
(a.warnings = eg),
|
|
a.triggerMetaEvent(),
|
|
a.reRender()),
|
|
f
|
|
);
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "isFieldValidating", function () {
|
|
return !!a.validatePromise;
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "isFieldTouched", function () {
|
|
return a.touched;
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "isFieldDirty", function () {
|
|
return (
|
|
!!a.dirty ||
|
|
void 0 !== a.props.initialValue ||
|
|
void 0 !==
|
|
(0, a.props.fieldContext.getInternalHooks(b).getInitialValue)(
|
|
a.getNamePath(),
|
|
)
|
|
);
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getErrors", function () {
|
|
return a.errors;
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getWarnings", function () {
|
|
return a.warnings;
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "isListField", function () {
|
|
return a.props.isListField;
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "isList", function () {
|
|
return a.props.isList;
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "isPreserve", function () {
|
|
return a.props.preserve;
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getMeta", function () {
|
|
return (
|
|
(a.prevValidating = a.isFieldValidating()),
|
|
{
|
|
touched: a.isFieldTouched(),
|
|
validating: a.prevValidating,
|
|
errors: a.errors,
|
|
warnings: a.warnings,
|
|
name: a.getNamePath(),
|
|
validated: null === a.validatePromise,
|
|
}
|
|
);
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getOnlyChild", function (e) {
|
|
if ("function" == typeof e) {
|
|
var t = a.getMeta();
|
|
return (0, l.default)(
|
|
(0, l.default)(
|
|
{},
|
|
a.getOnlyChild(e(a.getControlled(), t, a.props.fieldContext)),
|
|
),
|
|
{},
|
|
{ isFunction: !0 },
|
|
);
|
|
}
|
|
var n = (0, h.default)(e);
|
|
return 1 === n.length && r.isValidElement(n[0])
|
|
? { child: n[0], isFunction: !1 }
|
|
: { child: n, isFunction: !1 };
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getValue", function (e) {
|
|
var t = a.props.fieldContext.getFieldsValue,
|
|
r = a.getNamePath();
|
|
return (0, eh.default)(e || t(!0), r);
|
|
}),
|
|
(0, m.default)((0, f.default)(a), "getControlled", function () {
|
|
var e =
|
|
arguments.length > 0 && void 0 !== arguments[0]
|
|
? arguments[0]
|
|
: {},
|
|
t = a.props,
|
|
r = t.name,
|
|
n = t.trigger,
|
|
i = t.validateTrigger,
|
|
o = t.getValueFromEvent,
|
|
s = t.normalize,
|
|
u = t.valuePropName,
|
|
c = t.getValueProps,
|
|
f = t.fieldContext,
|
|
d = void 0 !== i ? i : f.validateTrigger,
|
|
p = a.getNamePath(),
|
|
h = f.getInternalHooks,
|
|
v = f.getFieldsValue,
|
|
g = h(b).dispatch,
|
|
y = a.getValue(),
|
|
x =
|
|
c ||
|
|
function (e) {
|
|
return (0, m.default)({}, u, e);
|
|
},
|
|
w = e[n],
|
|
C = void 0 !== r ? x(y) : {},
|
|
E = (0, l.default)((0, l.default)({}, e), C);
|
|
return (
|
|
(E[n] = function () {
|
|
(a.touched = !0), (a.dirty = !0), a.triggerMetaEvent();
|
|
for (
|
|
var e, t = arguments.length, r = Array(t), n = 0;
|
|
n < t;
|
|
n++
|
|
)
|
|
r[n] = arguments[n];
|
|
(e = o ? o.apply(void 0, r) : ep.apply(void 0, [u].concat(r))),
|
|
s && (e = s(e, y, v(!0))),
|
|
e !== y && g({ type: "updateValue", namePath: p, value: e }),
|
|
w && w.apply(void 0, r);
|
|
}),
|
|
k(d || []).forEach(function (e) {
|
|
var t = E[e];
|
|
E[e] = function () {
|
|
t && t.apply(void 0, arguments);
|
|
var r = a.props.rules;
|
|
r &&
|
|
r.length &&
|
|
g({ type: "validateField", namePath: p, triggerName: e });
|
|
};
|
|
}),
|
|
E
|
|
);
|
|
}),
|
|
e.fieldContext &&
|
|
(0, (0, e.fieldContext.getInternalHooks)(b).initEntityValue)(
|
|
(0, f.default)(a),
|
|
),
|
|
a
|
|
);
|
|
}
|
|
return (
|
|
(0, c.default)(n, [
|
|
{
|
|
key: "componentDidMount",
|
|
value: function () {
|
|
var e = this.props,
|
|
t = e.shouldUpdate,
|
|
r = e.fieldContext;
|
|
if (((this.mounted = !0), r)) {
|
|
var n = (0, r.getInternalHooks)(b).registerField;
|
|
this.cancelRegisterFunc = n(this);
|
|
}
|
|
!0 === t && this.reRender();
|
|
},
|
|
},
|
|
{
|
|
key: "componentWillUnmount",
|
|
value: function () {
|
|
this.cancelRegister(),
|
|
this.triggerMetaEvent(!0),
|
|
(this.mounted = !1);
|
|
},
|
|
},
|
|
{
|
|
key: "reRender",
|
|
value: function () {
|
|
this.mounted && this.forceUpdate();
|
|
},
|
|
},
|
|
{
|
|
key: "render",
|
|
value: function () {
|
|
var e,
|
|
t = this.state.resetCount,
|
|
n = this.props.children,
|
|
a = this.getOnlyChild(n),
|
|
i = a.child;
|
|
return (
|
|
a.isFunction
|
|
? (e = i)
|
|
: r.isValidElement(i)
|
|
? (e = r.cloneElement(i, this.getControlled(i.props)))
|
|
: ((0, g.default)(
|
|
!i,
|
|
"`children` of Field is not validate ReactElement.",
|
|
),
|
|
(e = i)),
|
|
r.createElement(r.Fragment, { key: t }, e)
|
|
);
|
|
},
|
|
},
|
|
]),
|
|
n
|
|
);
|
|
})(r.Component);
|
|
(0, m.default)(ey, "contextType", x),
|
|
(0, m.default)(ey, "defaultProps", {
|
|
trigger: "onChange",
|
|
valuePropName: "value",
|
|
});
|
|
let ex = function (e) {
|
|
var t,
|
|
i = e.name,
|
|
o = (0, a.default)(e, ev),
|
|
l = r.useContext(x),
|
|
s = r.useContext(w),
|
|
u = void 0 !== i ? eu(i) : void 0,
|
|
c = null != (t = o.isListField) ? t : !!s,
|
|
f = "keep";
|
|
return (
|
|
c || (f = "_".concat((u || []).join("_"))),
|
|
r.createElement(
|
|
ey,
|
|
(0, n.default)({ key: f, name: u, isListField: c }, o, {
|
|
fieldContext: l,
|
|
}),
|
|
)
|
|
);
|
|
};
|
|
var ew = e.i(552659),
|
|
ek = "__@field_split__";
|
|
function eC(e) {
|
|
return e
|
|
.map(function (e) {
|
|
return "".concat((0, C.default)(e), ":").concat(e);
|
|
})
|
|
.join(ek);
|
|
}
|
|
var eE = (function () {
|
|
function e() {
|
|
(0, u.default)(this, e), (0, m.default)(this, "kvs", new Map());
|
|
}
|
|
return (
|
|
(0, c.default)(e, [
|
|
{
|
|
key: "set",
|
|
value: function (e, t) {
|
|
this.kvs.set(eC(e), t);
|
|
},
|
|
},
|
|
{
|
|
key: "get",
|
|
value: function (e) {
|
|
return this.kvs.get(eC(e));
|
|
},
|
|
},
|
|
{
|
|
key: "update",
|
|
value: function (e, t) {
|
|
var r = t(this.get(e));
|
|
r ? this.set(e, r) : this.delete(e);
|
|
},
|
|
},
|
|
{
|
|
key: "delete",
|
|
value: function (e) {
|
|
this.kvs.delete(eC(e));
|
|
},
|
|
},
|
|
{
|
|
key: "map",
|
|
value: function (e) {
|
|
return (0, s.default)(this.kvs.entries()).map(function (t) {
|
|
var r = (0, ew.default)(t, 2),
|
|
n = r[0],
|
|
a = r[1];
|
|
return e({
|
|
key: n.split(ek).map(function (e) {
|
|
var t = e.match(/^([^:]*):(.*)$/),
|
|
r = (0, ew.default)(t, 3),
|
|
n = r[1],
|
|
a = r[2];
|
|
return "number" === n ? Number(a) : a;
|
|
}),
|
|
value: a,
|
|
});
|
|
});
|
|
},
|
|
},
|
|
{
|
|
key: "toJSON",
|
|
value: function () {
|
|
var e = {};
|
|
return (
|
|
this.map(function (t) {
|
|
var r = t.key,
|
|
n = t.value;
|
|
return (e[r.join(".")] = n), null;
|
|
}),
|
|
e
|
|
);
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})(),
|
|
eh = es,
|
|
ej = ["name"],
|
|
eP = (0, c.default)(function e(t) {
|
|
var r = this;
|
|
(0, u.default)(this, e),
|
|
(0, m.default)(this, "formHooked", !1),
|
|
(0, m.default)(this, "forceRootUpdate", void 0),
|
|
(0, m.default)(this, "subscribable", !0),
|
|
(0, m.default)(this, "store", {}),
|
|
(0, m.default)(this, "fieldEntities", []),
|
|
(0, m.default)(this, "initialValues", {}),
|
|
(0, m.default)(this, "callbacks", {}),
|
|
(0, m.default)(this, "validateMessages", null),
|
|
(0, m.default)(this, "preserve", null),
|
|
(0, m.default)(this, "lastValidatePromise", null),
|
|
(0, m.default)(this, "getForm", function () {
|
|
return {
|
|
getFieldValue: r.getFieldValue,
|
|
getFieldsValue: r.getFieldsValue,
|
|
getFieldError: r.getFieldError,
|
|
getFieldWarning: r.getFieldWarning,
|
|
getFieldsError: r.getFieldsError,
|
|
isFieldsTouched: r.isFieldsTouched,
|
|
isFieldTouched: r.isFieldTouched,
|
|
isFieldValidating: r.isFieldValidating,
|
|
isFieldsValidating: r.isFieldsValidating,
|
|
resetFields: r.resetFields,
|
|
setFields: r.setFields,
|
|
setFieldValue: r.setFieldValue,
|
|
setFieldsValue: r.setFieldsValue,
|
|
validateFields: r.validateFields,
|
|
submit: r.submit,
|
|
_init: !0,
|
|
getInternalHooks: r.getInternalHooks,
|
|
};
|
|
}),
|
|
(0, m.default)(this, "getInternalHooks", function (e) {
|
|
return e === b
|
|
? ((r.formHooked = !0),
|
|
{
|
|
dispatch: r.dispatch,
|
|
initEntityValue: r.initEntityValue,
|
|
registerField: r.registerField,
|
|
useSubscribe: r.useSubscribe,
|
|
setInitialValues: r.setInitialValues,
|
|
destroyForm: r.destroyForm,
|
|
setCallbacks: r.setCallbacks,
|
|
setValidateMessages: r.setValidateMessages,
|
|
getFields: r.getFields,
|
|
setPreserve: r.setPreserve,
|
|
getInitialValue: r.getInitialValue,
|
|
registerWatch: r.registerWatch,
|
|
})
|
|
: ((0, g.default)(
|
|
!1,
|
|
"`getInternalHooks` is internal usage. Should not call directly.",
|
|
),
|
|
null);
|
|
}),
|
|
(0, m.default)(this, "useSubscribe", function (e) {
|
|
r.subscribable = e;
|
|
}),
|
|
(0, m.default)(this, "prevWithoutPreserves", null),
|
|
(0, m.default)(this, "setInitialValues", function (e, t) {
|
|
if (((r.initialValues = e || {}), t)) {
|
|
var n,
|
|
a = (0, er.merge)(e, r.store);
|
|
null == (n = r.prevWithoutPreserves) ||
|
|
n.map(function (t) {
|
|
var r = t.key;
|
|
a = (0, er.default)(a, r, (0, eh.default)(e, r));
|
|
}),
|
|
(r.prevWithoutPreserves = null),
|
|
r.updateStore(a);
|
|
}
|
|
}),
|
|
(0, m.default)(this, "destroyForm", function (e) {
|
|
if (e) r.updateStore({});
|
|
else {
|
|
var t = new eE();
|
|
r.getFieldEntities(!0).forEach(function (e) {
|
|
r.isMergedPreserve(e.isPreserve()) ||
|
|
t.set(e.getNamePath(), !0);
|
|
}),
|
|
(r.prevWithoutPreserves = t);
|
|
}
|
|
}),
|
|
(0, m.default)(this, "getInitialValue", function (e) {
|
|
var t = (0, eh.default)(r.initialValues, e);
|
|
return e.length ? (0, er.merge)(t) : t;
|
|
}),
|
|
(0, m.default)(this, "setCallbacks", function (e) {
|
|
r.callbacks = e;
|
|
}),
|
|
(0, m.default)(this, "setValidateMessages", function (e) {
|
|
r.validateMessages = e;
|
|
}),
|
|
(0, m.default)(this, "setPreserve", function (e) {
|
|
r.preserve = e;
|
|
}),
|
|
(0, m.default)(this, "watchList", []),
|
|
(0, m.default)(this, "registerWatch", function (e) {
|
|
return (
|
|
r.watchList.push(e),
|
|
function () {
|
|
r.watchList = r.watchList.filter(function (t) {
|
|
return t !== e;
|
|
});
|
|
}
|
|
);
|
|
}),
|
|
(0, m.default)(this, "notifyWatch", function () {
|
|
var e =
|
|
arguments.length > 0 && void 0 !== arguments[0]
|
|
? arguments[0]
|
|
: [];
|
|
if (r.watchList.length) {
|
|
var t = r.getFieldsValue(),
|
|
n = r.getFieldsValue(!0);
|
|
r.watchList.forEach(function (r) {
|
|
r(t, n, e);
|
|
});
|
|
}
|
|
}),
|
|
(0, m.default)(this, "timeoutId", null),
|
|
(0, m.default)(this, "warningUnhooked", function () {}),
|
|
(0, m.default)(this, "updateStore", function (e) {
|
|
r.store = e;
|
|
}),
|
|
(0, m.default)(this, "getFieldEntities", function () {
|
|
var e =
|
|
arguments.length > 0 && void 0 !== arguments[0] && arguments[0];
|
|
return e
|
|
? r.fieldEntities.filter(function (e) {
|
|
return e.getNamePath().length;
|
|
})
|
|
: r.fieldEntities;
|
|
}),
|
|
(0, m.default)(this, "getFieldsMap", function () {
|
|
var e =
|
|
arguments.length > 0 && void 0 !== arguments[0] && arguments[0],
|
|
t = new eE();
|
|
return (
|
|
r.getFieldEntities(e).forEach(function (e) {
|
|
var r = e.getNamePath();
|
|
t.set(r, e);
|
|
}),
|
|
t
|
|
);
|
|
}),
|
|
(0, m.default)(this, "getFieldEntitiesForNamePathList", function (e) {
|
|
if (!e) return r.getFieldEntities(!0);
|
|
var t = r.getFieldsMap(!0);
|
|
return e.map(function (e) {
|
|
var r = eu(e);
|
|
return t.get(r) || { INVALIDATE_NAME_PATH: eu(e) };
|
|
});
|
|
}),
|
|
(0, m.default)(this, "getFieldsValue", function (e, t) {
|
|
if (
|
|
(r.warningUnhooked(),
|
|
!0 === e || Array.isArray(e)
|
|
? ((n = e), (a = t))
|
|
: e &&
|
|
"object" === (0, C.default)(e) &&
|
|
((i = e.strict), (a = e.filter)),
|
|
!0 === n && !a)
|
|
)
|
|
return r.store;
|
|
var n,
|
|
a,
|
|
i,
|
|
o = r.getFieldEntitiesForNamePathList(
|
|
Array.isArray(n) ? n : null,
|
|
),
|
|
l = [];
|
|
return (
|
|
o.forEach(function (e) {
|
|
var t,
|
|
r,
|
|
o,
|
|
s =
|
|
"INVALIDATE_NAME_PATH" in e
|
|
? e.INVALIDATE_NAME_PATH
|
|
: e.getNamePath();
|
|
if (i) {
|
|
if (null != (o = e.isList) && o.call(e)) return;
|
|
} else if (!n && null != (t = (r = e).isListField) && t.call(r))
|
|
return;
|
|
if (a) {
|
|
var u = "getMeta" in e ? e.getMeta() : null;
|
|
a(u) && l.push(s);
|
|
} else l.push(s);
|
|
}),
|
|
ec(r.store, l.map(eu))
|
|
);
|
|
}),
|
|
(0, m.default)(this, "getFieldValue", function (e) {
|
|
r.warningUnhooked();
|
|
var t = eu(e);
|
|
return (0, eh.default)(r.store, t);
|
|
}),
|
|
(0, m.default)(this, "getFieldsError", function (e) {
|
|
return (
|
|
r.warningUnhooked(),
|
|
r.getFieldEntitiesForNamePathList(e).map(function (t, r) {
|
|
return !t || "INVALIDATE_NAME_PATH" in t
|
|
? { name: eu(e[r]), errors: [], warnings: [] }
|
|
: {
|
|
name: t.getNamePath(),
|
|
errors: t.getErrors(),
|
|
warnings: t.getWarnings(),
|
|
};
|
|
})
|
|
);
|
|
}),
|
|
(0, m.default)(this, "getFieldError", function (e) {
|
|
r.warningUnhooked();
|
|
var t = eu(e);
|
|
return r.getFieldsError([t])[0].errors;
|
|
}),
|
|
(0, m.default)(this, "getFieldWarning", function (e) {
|
|
r.warningUnhooked();
|
|
var t = eu(e);
|
|
return r.getFieldsError([t])[0].warnings;
|
|
}),
|
|
(0, m.default)(this, "isFieldsTouched", function () {
|
|
r.warningUnhooked();
|
|
for (var e, t = arguments.length, n = Array(t), a = 0; a < t; a++)
|
|
n[a] = arguments[a];
|
|
var i = n[0],
|
|
o = n[1],
|
|
l = !1;
|
|
0 === n.length
|
|
? (e = null)
|
|
: 1 === n.length
|
|
? Array.isArray(i)
|
|
? ((e = i.map(eu)), (l = !1))
|
|
: ((e = null), (l = i))
|
|
: ((e = i.map(eu)), (l = o));
|
|
var u = r.getFieldEntities(!0),
|
|
c = function (e) {
|
|
return e.isFieldTouched();
|
|
};
|
|
if (!e)
|
|
return l
|
|
? u.every(function (e) {
|
|
return c(e) || e.isList();
|
|
})
|
|
: u.some(c);
|
|
var f = new eE();
|
|
e.forEach(function (e) {
|
|
f.set(e, []);
|
|
}),
|
|
u.forEach(function (t) {
|
|
var r = t.getNamePath();
|
|
e.forEach(function (e) {
|
|
e.every(function (e, t) {
|
|
return r[t] === e;
|
|
}) &&
|
|
f.update(e, function (e) {
|
|
return [].concat((0, s.default)(e), [t]);
|
|
});
|
|
});
|
|
});
|
|
var d = function (e) {
|
|
return e.some(c);
|
|
},
|
|
p = f.map(function (e) {
|
|
return e.value;
|
|
});
|
|
return l ? p.every(d) : p.some(d);
|
|
}),
|
|
(0, m.default)(this, "isFieldTouched", function (e) {
|
|
return r.warningUnhooked(), r.isFieldsTouched([e]);
|
|
}),
|
|
(0, m.default)(this, "isFieldsValidating", function (e) {
|
|
r.warningUnhooked();
|
|
var t = r.getFieldEntities();
|
|
if (!e)
|
|
return t.some(function (e) {
|
|
return e.isFieldValidating();
|
|
});
|
|
var n = e.map(eu);
|
|
return t.some(function (e) {
|
|
return ef(n, e.getNamePath()) && e.isFieldValidating();
|
|
});
|
|
}),
|
|
(0, m.default)(this, "isFieldValidating", function (e) {
|
|
return r.warningUnhooked(), r.isFieldsValidating([e]);
|
|
}),
|
|
(0, m.default)(this, "resetWithFieldInitialValue", function () {
|
|
var e,
|
|
t =
|
|
arguments.length > 0 && void 0 !== arguments[0]
|
|
? arguments[0]
|
|
: {},
|
|
n = new eE(),
|
|
a = r.getFieldEntities(!0);
|
|
a.forEach(function (e) {
|
|
var t = e.props.initialValue,
|
|
r = e.getNamePath();
|
|
if (void 0 !== t) {
|
|
var a = n.get(r) || new Set();
|
|
a.add({ entity: e, value: t }), n.set(r, a);
|
|
}
|
|
}),
|
|
t.entities
|
|
? (e = t.entities)
|
|
: t.namePathList
|
|
? ((e = []),
|
|
t.namePathList.forEach(function (t) {
|
|
var r,
|
|
a = n.get(t);
|
|
a &&
|
|
(r = e).push.apply(
|
|
r,
|
|
(0, s.default)(
|
|
(0, s.default)(a).map(function (e) {
|
|
return e.entity;
|
|
}),
|
|
),
|
|
);
|
|
}))
|
|
: (e = a),
|
|
e.forEach(function (e) {
|
|
if (void 0 !== e.props.initialValue) {
|
|
var a = e.getNamePath();
|
|
if (void 0 !== r.getInitialValue(a))
|
|
(0, g.default)(
|
|
!1,
|
|
"Form already set 'initialValues' with path '".concat(
|
|
a.join("."),
|
|
"'. Field can not overwrite it.",
|
|
),
|
|
);
|
|
else {
|
|
var i = n.get(a);
|
|
if (i && i.size > 1)
|
|
(0, g.default)(
|
|
!1,
|
|
"Multiple Field with path '".concat(
|
|
a.join("."),
|
|
"' set 'initialValue'. Can not decide which one to pick.",
|
|
),
|
|
);
|
|
else if (i) {
|
|
var o = r.getFieldValue(a);
|
|
e.isListField() ||
|
|
(t.skipExist && void 0 !== o) ||
|
|
r.updateStore(
|
|
(0, er.default)(
|
|
r.store,
|
|
a,
|
|
(0, s.default)(i)[0].value,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}),
|
|
(0, m.default)(this, "resetFields", function (e) {
|
|
r.warningUnhooked();
|
|
var t = r.store;
|
|
if (!e) {
|
|
r.updateStore((0, er.merge)(r.initialValues)),
|
|
r.resetWithFieldInitialValue(),
|
|
r.notifyObservers(t, null, { type: "reset" }),
|
|
r.notifyWatch();
|
|
return;
|
|
}
|
|
var n = e.map(eu);
|
|
n.forEach(function (e) {
|
|
var t = r.getInitialValue(e);
|
|
r.updateStore((0, er.default)(r.store, e, t));
|
|
}),
|
|
r.resetWithFieldInitialValue({ namePathList: n }),
|
|
r.notifyObservers(t, n, { type: "reset" }),
|
|
r.notifyWatch(n);
|
|
}),
|
|
(0, m.default)(this, "setFields", function (e) {
|
|
r.warningUnhooked();
|
|
var t = r.store,
|
|
n = [];
|
|
e.forEach(function (e) {
|
|
var i = e.name,
|
|
o = (0, a.default)(e, ej),
|
|
l = eu(i);
|
|
n.push(l),
|
|
"value" in o &&
|
|
r.updateStore((0, er.default)(r.store, l, o.value)),
|
|
r.notifyObservers(t, [l], { type: "setField", data: e });
|
|
}),
|
|
r.notifyWatch(n);
|
|
}),
|
|
(0, m.default)(this, "getFields", function () {
|
|
return r.getFieldEntities(!0).map(function (e) {
|
|
var t = e.getNamePath(),
|
|
n = e.getMeta(),
|
|
a = (0, l.default)(
|
|
(0, l.default)({}, n),
|
|
{},
|
|
{ name: t, value: r.getFieldValue(t) },
|
|
);
|
|
return (
|
|
Object.defineProperty(a, "originRCField", { value: !0 }), a
|
|
);
|
|
});
|
|
}),
|
|
(0, m.default)(this, "initEntityValue", function (e) {
|
|
var t = e.props.initialValue;
|
|
if (void 0 !== t) {
|
|
var n = e.getNamePath();
|
|
void 0 === (0, eh.default)(r.store, n) &&
|
|
r.updateStore((0, er.default)(r.store, n, t));
|
|
}
|
|
}),
|
|
(0, m.default)(this, "isMergedPreserve", function (e) {
|
|
var t = void 0 !== e ? e : r.preserve;
|
|
return null == t || t;
|
|
}),
|
|
(0, m.default)(this, "registerField", function (e) {
|
|
r.fieldEntities.push(e);
|
|
var t = e.getNamePath();
|
|
if ((r.notifyWatch([t]), void 0 !== e.props.initialValue)) {
|
|
var n = r.store;
|
|
r.resetWithFieldInitialValue({ entities: [e], skipExist: !0 }),
|
|
r.notifyObservers(n, [e.getNamePath()], {
|
|
type: "valueUpdate",
|
|
source: "internal",
|
|
});
|
|
}
|
|
return function (n, a) {
|
|
var i =
|
|
arguments.length > 2 && void 0 !== arguments[2]
|
|
? arguments[2]
|
|
: [];
|
|
if (
|
|
((r.fieldEntities = r.fieldEntities.filter(function (t) {
|
|
return t !== e;
|
|
})),
|
|
!r.isMergedPreserve(a) && (!n || i.length > 1))
|
|
) {
|
|
var o = n ? void 0 : r.getInitialValue(t);
|
|
if (
|
|
t.length &&
|
|
r.getFieldValue(t) !== o &&
|
|
r.fieldEntities.every(function (e) {
|
|
return !ed(e.getNamePath(), t);
|
|
})
|
|
) {
|
|
var l = r.store;
|
|
r.updateStore((0, er.default)(l, t, o, !0)),
|
|
r.notifyObservers(l, [t], { type: "remove" }),
|
|
r.triggerDependenciesUpdate(l, t);
|
|
}
|
|
}
|
|
r.notifyWatch([t]);
|
|
};
|
|
}),
|
|
(0, m.default)(this, "dispatch", function (e) {
|
|
switch (e.type) {
|
|
case "updateValue":
|
|
var t = e.namePath,
|
|
n = e.value;
|
|
r.updateValue(t, n);
|
|
break;
|
|
case "validateField":
|
|
var a = e.namePath,
|
|
i = e.triggerName;
|
|
r.validateFields([a], { triggerName: i });
|
|
}
|
|
}),
|
|
(0, m.default)(this, "notifyObservers", function (e, t, n) {
|
|
if (r.subscribable) {
|
|
var a = (0, l.default)(
|
|
(0, l.default)({}, n),
|
|
{},
|
|
{ store: r.getFieldsValue(!0) },
|
|
);
|
|
r.getFieldEntities().forEach(function (r) {
|
|
(0, r.onStoreChange)(e, t, a);
|
|
});
|
|
} else r.forceRootUpdate();
|
|
}),
|
|
(0, m.default)(this, "triggerDependenciesUpdate", function (e, t) {
|
|
var n = r.getDependencyChildrenFields(t);
|
|
return (
|
|
n.length && r.validateFields(n),
|
|
r.notifyObservers(e, n, {
|
|
type: "dependenciesUpdate",
|
|
relatedFields: [t].concat((0, s.default)(n)),
|
|
}),
|
|
n
|
|
);
|
|
}),
|
|
(0, m.default)(this, "updateValue", function (e, t) {
|
|
var n = eu(e),
|
|
a = r.store;
|
|
r.updateStore((0, er.default)(r.store, n, t)),
|
|
r.notifyObservers(a, [n], {
|
|
type: "valueUpdate",
|
|
source: "internal",
|
|
}),
|
|
r.notifyWatch([n]);
|
|
var i = r.triggerDependenciesUpdate(a, n),
|
|
o = r.callbacks.onValuesChange;
|
|
o && o(ec(r.store, [n]), r.getFieldsValue()),
|
|
r.triggerOnFieldsChange([n].concat((0, s.default)(i)));
|
|
}),
|
|
(0, m.default)(this, "setFieldsValue", function (e) {
|
|
r.warningUnhooked();
|
|
var t = r.store;
|
|
if (e) {
|
|
var n = (0, er.merge)(r.store, e);
|
|
r.updateStore(n);
|
|
}
|
|
r.notifyObservers(t, null, {
|
|
type: "valueUpdate",
|
|
source: "external",
|
|
}),
|
|
r.notifyWatch();
|
|
}),
|
|
(0, m.default)(this, "setFieldValue", function (e, t) {
|
|
r.setFields([{ name: e, value: t, errors: [], warnings: [] }]);
|
|
}),
|
|
(0, m.default)(this, "getDependencyChildrenFields", function (e) {
|
|
var t = new Set(),
|
|
n = [],
|
|
a = new eE();
|
|
return (
|
|
r.getFieldEntities().forEach(function (e) {
|
|
(e.props.dependencies || []).forEach(function (t) {
|
|
var r = eu(t);
|
|
a.update(r, function () {
|
|
var t =
|
|
arguments.length > 0 && void 0 !== arguments[0]
|
|
? arguments[0]
|
|
: new Set();
|
|
return t.add(e), t;
|
|
});
|
|
});
|
|
}),
|
|
!(function e(r) {
|
|
(a.get(r) || new Set()).forEach(function (r) {
|
|
if (!t.has(r)) {
|
|
t.add(r);
|
|
var a = r.getNamePath();
|
|
r.isFieldDirty() && a.length && (n.push(a), e(a));
|
|
}
|
|
});
|
|
})(e),
|
|
n
|
|
);
|
|
}),
|
|
(0, m.default)(this, "triggerOnFieldsChange", function (e, t) {
|
|
var n = r.callbacks.onFieldsChange;
|
|
if (n) {
|
|
var a = r.getFields();
|
|
if (t) {
|
|
var i = new eE();
|
|
t.forEach(function (e) {
|
|
var t = e.name,
|
|
r = e.errors;
|
|
i.set(t, r);
|
|
}),
|
|
a.forEach(function (e) {
|
|
e.errors = i.get(e.name) || e.errors;
|
|
});
|
|
}
|
|
var o = a.filter(function (t) {
|
|
return ef(e, t.name);
|
|
});
|
|
o.length && n(o, a);
|
|
}
|
|
}),
|
|
(0, m.default)(this, "validateFields", function (e, t) {
|
|
r.warningUnhooked(),
|
|
Array.isArray(e) || "string" == typeof e || "string" == typeof t
|
|
? ((o = e), (u = t))
|
|
: (u = e);
|
|
var n,
|
|
a,
|
|
i,
|
|
o,
|
|
u,
|
|
c = !!o,
|
|
f = c ? o.map(eu) : [],
|
|
d = [],
|
|
p = String(Date.now()),
|
|
m = new Set(),
|
|
h = u || {},
|
|
v = h.recursive,
|
|
g = h.dirty;
|
|
r.getFieldEntities(!0).forEach(function (e) {
|
|
if (
|
|
(c || f.push(e.getNamePath()),
|
|
e.props.rules && e.props.rules.length) &&
|
|
(!g || e.isFieldDirty())
|
|
) {
|
|
var t = e.getNamePath();
|
|
if ((m.add(t.join(p)), !c || ef(f, t, v))) {
|
|
var n = e.validateRules(
|
|
(0, l.default)(
|
|
{
|
|
validateMessages: (0, l.default)(
|
|
(0, l.default)({}, et),
|
|
r.validateMessages,
|
|
),
|
|
},
|
|
u,
|
|
),
|
|
);
|
|
d.push(
|
|
n
|
|
.then(function () {
|
|
return { name: t, errors: [], warnings: [] };
|
|
})
|
|
.catch(function (e) {
|
|
var r,
|
|
n = [],
|
|
a = [];
|
|
return (null == (r = e.forEach) ||
|
|
r.call(e, function (e) {
|
|
var t = e.rule.warningOnly,
|
|
r = e.errors;
|
|
t
|
|
? a.push.apply(a, (0, s.default)(r))
|
|
: n.push.apply(n, (0, s.default)(r));
|
|
}),
|
|
n.length)
|
|
? Promise.reject({ name: t, errors: n, warnings: a })
|
|
: { name: t, errors: n, warnings: a };
|
|
}),
|
|
);
|
|
}
|
|
}
|
|
});
|
|
var b =
|
|
((n = !1),
|
|
(a = d.length),
|
|
(i = []),
|
|
d.length
|
|
? new Promise(function (e, t) {
|
|
d.forEach(function (r, o) {
|
|
r.catch(function (e) {
|
|
return (n = !0), e;
|
|
}).then(function (r) {
|
|
(a -= 1), (i[o] = r), a > 0 || (n && t(i), e(i));
|
|
});
|
|
});
|
|
})
|
|
: Promise.resolve([]));
|
|
(r.lastValidatePromise = b),
|
|
b
|
|
.catch(function (e) {
|
|
return e;
|
|
})
|
|
.then(function (e) {
|
|
var t = e.map(function (e) {
|
|
return e.name;
|
|
});
|
|
r.notifyObservers(r.store, t, { type: "validateFinish" }),
|
|
r.triggerOnFieldsChange(t, e);
|
|
});
|
|
var y = b
|
|
.then(function () {
|
|
return r.lastValidatePromise === b
|
|
? Promise.resolve(r.getFieldsValue(f))
|
|
: Promise.reject([]);
|
|
})
|
|
.catch(function (e) {
|
|
var t = e.filter(function (e) {
|
|
return e && e.errors.length;
|
|
});
|
|
return Promise.reject({
|
|
values: r.getFieldsValue(f),
|
|
errorFields: t,
|
|
outOfDate: r.lastValidatePromise !== b,
|
|
});
|
|
});
|
|
y.catch(function (e) {
|
|
return e;
|
|
});
|
|
var x = f.filter(function (e) {
|
|
return m.has(e.join(p));
|
|
});
|
|
return r.triggerOnFieldsChange(x), y;
|
|
}),
|
|
(0, m.default)(this, "submit", function () {
|
|
r.warningUnhooked(),
|
|
r
|
|
.validateFields()
|
|
.then(function (e) {
|
|
var t = r.callbacks.onFinish;
|
|
if (t)
|
|
try {
|
|
t(e);
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
})
|
|
.catch(function (e) {
|
|
var t = r.callbacks.onFinishFailed;
|
|
t && t(e);
|
|
});
|
|
}),
|
|
(this.forceRootUpdate = t);
|
|
});
|
|
let eF = function (e) {
|
|
var t = r.useRef(),
|
|
n = r.useState({}),
|
|
a = (0, ew.default)(n, 2)[1];
|
|
return (
|
|
t.current ||
|
|
(e
|
|
? (t.current = e)
|
|
: (t.current = new eP(function () {
|
|
a({});
|
|
}).getForm())),
|
|
[t.current]
|
|
);
|
|
};
|
|
var e_ = r.createContext({
|
|
triggerFormChange: function () {},
|
|
triggerFormFinish: function () {},
|
|
registerForm: function () {},
|
|
unregisterForm: function () {},
|
|
}),
|
|
eS = function (e) {
|
|
var t = e.validateMessages,
|
|
n = e.onFormChange,
|
|
a = e.onFormFinish,
|
|
i = e.children,
|
|
o = r.useContext(e_),
|
|
s = r.useRef({});
|
|
return r.createElement(
|
|
e_.Provider,
|
|
{
|
|
value: (0, l.default)(
|
|
(0, l.default)({}, o),
|
|
{},
|
|
{
|
|
validateMessages: (0, l.default)(
|
|
(0, l.default)({}, o.validateMessages),
|
|
t,
|
|
),
|
|
triggerFormChange: function (e, t) {
|
|
n && n(e, { changedFields: t, forms: s.current }),
|
|
o.triggerFormChange(e, t);
|
|
},
|
|
triggerFormFinish: function (e, t) {
|
|
a && a(e, { values: t, forms: s.current }),
|
|
o.triggerFormFinish(e, t);
|
|
},
|
|
registerForm: function (e, t) {
|
|
e &&
|
|
(s.current = (0, l.default)(
|
|
(0, l.default)({}, s.current),
|
|
{},
|
|
(0, m.default)({}, e, t),
|
|
)),
|
|
o.registerForm(e, t);
|
|
},
|
|
unregisterForm: function (e) {
|
|
var t = (0, l.default)({}, s.current);
|
|
delete t[e], (s.current = t), o.unregisterForm(e);
|
|
},
|
|
},
|
|
),
|
|
},
|
|
i,
|
|
);
|
|
};
|
|
e.s(["FormProvider", () => eS, "default", 0, e_], 165109);
|
|
var eN = [
|
|
"name",
|
|
"initialValues",
|
|
"fields",
|
|
"form",
|
|
"preserve",
|
|
"children",
|
|
"component",
|
|
"validateMessages",
|
|
"validateTrigger",
|
|
"onValuesChange",
|
|
"onFieldsChange",
|
|
"onFinish",
|
|
"onFinishFailed",
|
|
"clearOnDestroy",
|
|
],
|
|
eh = es;
|
|
function eO(e) {
|
|
try {
|
|
return JSON.stringify(e);
|
|
} catch (e) {
|
|
return Math.random();
|
|
}
|
|
}
|
|
var eA = function () {},
|
|
eM = r.forwardRef(function (e, t) {
|
|
var i,
|
|
o = e.name,
|
|
u = e.initialValues,
|
|
c = e.fields,
|
|
f = e.form,
|
|
d = e.preserve,
|
|
p = e.children,
|
|
m = e.component,
|
|
h = void 0 === m ? "form" : m,
|
|
v = e.validateMessages,
|
|
g = e.validateTrigger,
|
|
y = void 0 === g ? "onChange" : g,
|
|
k = e.onValuesChange,
|
|
E = e.onFieldsChange,
|
|
j = e.onFinish,
|
|
P = e.onFinishFailed,
|
|
F = e.clearOnDestroy,
|
|
_ = (0, a.default)(e, eN),
|
|
S = r.useRef(null),
|
|
N = r.useContext(e_),
|
|
O = eF(f),
|
|
A = (0, ew.default)(O, 1)[0],
|
|
M = A.getInternalHooks(b),
|
|
T = M.useSubscribe,
|
|
$ = M.setInitialValues,
|
|
I = M.setCallbacks,
|
|
R = M.setValidateMessages,
|
|
D = M.setPreserve,
|
|
V = M.destroyForm;
|
|
r.useImperativeHandle(t, function () {
|
|
return (0, l.default)(
|
|
(0, l.default)({}, A),
|
|
{},
|
|
{ nativeElement: S.current },
|
|
);
|
|
}),
|
|
r.useEffect(
|
|
function () {
|
|
return (
|
|
N.registerForm(o, A),
|
|
function () {
|
|
N.unregisterForm(o);
|
|
}
|
|
);
|
|
},
|
|
[N, A, o],
|
|
),
|
|
R((0, l.default)((0, l.default)({}, N.validateMessages), v)),
|
|
I({
|
|
onValuesChange: k,
|
|
onFieldsChange: function (e) {
|
|
if ((N.triggerFormChange(o, e), E)) {
|
|
for (
|
|
var t = arguments.length, r = Array(t > 1 ? t - 1 : 0), n = 1;
|
|
n < t;
|
|
n++
|
|
)
|
|
r[n - 1] = arguments[n];
|
|
E.apply(void 0, [e].concat(r));
|
|
}
|
|
},
|
|
onFinish: function (e) {
|
|
N.triggerFormFinish(o, e), j && j(e);
|
|
},
|
|
onFinishFailed: P,
|
|
}),
|
|
D(d);
|
|
var L = r.useRef(null);
|
|
$(u, !L.current),
|
|
L.current || (L.current = !0),
|
|
r.useEffect(function () {
|
|
return function () {
|
|
return V(F);
|
|
};
|
|
}, []);
|
|
var B = "function" == typeof p;
|
|
(i = B ? p(A.getFieldsValue(!0), A) : p), T(!B);
|
|
var z = r.useRef();
|
|
r.useEffect(
|
|
function () {
|
|
!(function (e, t) {
|
|
if (e === t) return !0;
|
|
if (
|
|
(!e && t) ||
|
|
(e && !t) ||
|
|
!e ||
|
|
!t ||
|
|
"object" !== (0, C.default)(e) ||
|
|
"object" !== (0, C.default)(t)
|
|
)
|
|
return !1;
|
|
var r = new Set([].concat(Object.keys(e), Object.keys(t)));
|
|
return (0, s.default)(r).every(function (r) {
|
|
var n = e[r],
|
|
a = t[r];
|
|
return (
|
|
("function" == typeof n && "function" == typeof a) || n === a
|
|
);
|
|
});
|
|
})(z.current || [], c || []) && A.setFields(c || []),
|
|
(z.current = c);
|
|
},
|
|
[c, A],
|
|
);
|
|
var U = r.useMemo(
|
|
function () {
|
|
return (0, l.default)(
|
|
(0, l.default)({}, A),
|
|
{},
|
|
{ validateTrigger: y },
|
|
);
|
|
},
|
|
[A, y],
|
|
),
|
|
H = r.createElement(
|
|
w.Provider,
|
|
{ value: null },
|
|
r.createElement(x.Provider, { value: U }, i),
|
|
);
|
|
return !1 === h
|
|
? H
|
|
: r.createElement(
|
|
h,
|
|
(0, n.default)({}, _, {
|
|
ref: S,
|
|
onSubmit: function (e) {
|
|
e.preventDefault(), e.stopPropagation(), A.submit();
|
|
},
|
|
onReset: function (e) {
|
|
var t;
|
|
e.preventDefault(),
|
|
A.resetFields(),
|
|
null == (t = _.onReset) || t.call(_, e);
|
|
},
|
|
}),
|
|
H,
|
|
);
|
|
});
|
|
(eM.FormProvider = eS),
|
|
(eM.Field = ex),
|
|
(eM.List = function (e) {
|
|
var t = e.name,
|
|
n = e.initialValue,
|
|
a = e.children,
|
|
i = e.rules,
|
|
o = e.validateTrigger,
|
|
u = e.isListField,
|
|
c = r.useContext(x),
|
|
f = r.useContext(w),
|
|
d = r.useRef({ keys: [], id: 0 }).current,
|
|
p = r.useMemo(
|
|
function () {
|
|
var e = eu(c.prefixName) || [];
|
|
return [].concat((0, s.default)(e), (0, s.default)(eu(t)));
|
|
},
|
|
[c.prefixName, t],
|
|
),
|
|
m = r.useMemo(
|
|
function () {
|
|
return (0, l.default)(
|
|
(0, l.default)({}, c),
|
|
{},
|
|
{ prefixName: p },
|
|
);
|
|
},
|
|
[c, p],
|
|
),
|
|
h = r.useMemo(
|
|
function () {
|
|
return {
|
|
getKey: function (e) {
|
|
var t = p.length,
|
|
r = e[t];
|
|
return [d.keys[r], e.slice(t + 1)];
|
|
},
|
|
};
|
|
},
|
|
[p],
|
|
);
|
|
return "function" != typeof a
|
|
? ((0, g.default)(!1, "Form.List only accepts function as children."),
|
|
null)
|
|
: r.createElement(
|
|
w.Provider,
|
|
{ value: h },
|
|
r.createElement(
|
|
x.Provider,
|
|
{ value: m },
|
|
r.createElement(
|
|
ex,
|
|
{
|
|
name: [],
|
|
shouldUpdate: function (e, t, r) {
|
|
return "internal" !== r.source && e !== t;
|
|
},
|
|
rules: i,
|
|
validateTrigger: o,
|
|
initialValue: n,
|
|
isList: !0,
|
|
isListField: null != u ? u : !!f,
|
|
},
|
|
function (e, t) {
|
|
var r = e.value,
|
|
n = e.onChange,
|
|
i = c.getFieldValue,
|
|
o = function () {
|
|
return i(p || []) || [];
|
|
},
|
|
l = (void 0 === r ? [] : r) || [];
|
|
return (
|
|
Array.isArray(l) || (l = []),
|
|
a(
|
|
l.map(function (e, t) {
|
|
var r = d.keys[t];
|
|
return (
|
|
void 0 === r &&
|
|
((d.keys[t] = d.id),
|
|
(r = d.keys[t]),
|
|
(d.id += 1)),
|
|
{ name: t, key: r, isListField: !0 }
|
|
);
|
|
}),
|
|
{
|
|
add: function (e, t) {
|
|
var r = o();
|
|
t >= 0 && t <= r.length
|
|
? ((d.keys = [].concat(
|
|
(0, s.default)(d.keys.slice(0, t)),
|
|
[d.id],
|
|
(0, s.default)(d.keys.slice(t)),
|
|
)),
|
|
n(
|
|
[].concat(
|
|
(0, s.default)(r.slice(0, t)),
|
|
[e],
|
|
(0, s.default)(r.slice(t)),
|
|
),
|
|
))
|
|
: ((d.keys = [].concat((0, s.default)(d.keys), [
|
|
d.id,
|
|
])),
|
|
n([].concat((0, s.default)(r), [e]))),
|
|
(d.id += 1);
|
|
},
|
|
remove: function (e) {
|
|
var t = o(),
|
|
r = new Set(Array.isArray(e) ? e : [e]);
|
|
r.size <= 0 ||
|
|
((d.keys = d.keys.filter(function (e, t) {
|
|
return !r.has(t);
|
|
})),
|
|
n(
|
|
t.filter(function (e, t) {
|
|
return !r.has(t);
|
|
}),
|
|
));
|
|
},
|
|
move: function (e, t) {
|
|
if (e !== t) {
|
|
var r = o();
|
|
e < 0 ||
|
|
e >= r.length ||
|
|
t < 0 ||
|
|
t >= r.length ||
|
|
((d.keys = em(d.keys, e, t)), n(em(r, e, t)));
|
|
}
|
|
},
|
|
},
|
|
t,
|
|
)
|
|
);
|
|
},
|
|
),
|
|
),
|
|
);
|
|
}),
|
|
(eM.useForm = eF),
|
|
(eM.useWatch = function () {
|
|
for (var e = arguments.length, t = Array(e), n = 0; n < e; n++)
|
|
t[n] = arguments[n];
|
|
var a = t[0],
|
|
i = t[1],
|
|
o = void 0 === i ? {} : i,
|
|
l = o && o._init ? { form: o } : o,
|
|
s = l.form,
|
|
u = (0, r.useState)(),
|
|
c = (0, ew.default)(u, 2),
|
|
f = c[0],
|
|
d = c[1],
|
|
p = (0, r.useMemo)(
|
|
function () {
|
|
return eO(f);
|
|
},
|
|
[f],
|
|
),
|
|
m = (0, r.useRef)(p);
|
|
m.current = p;
|
|
var h = (0, r.useContext)(x),
|
|
v = s || h,
|
|
g = v && v._init,
|
|
y = eu(a),
|
|
w = (0, r.useRef)(y);
|
|
return (
|
|
(w.current = y),
|
|
eA(y),
|
|
(0, r.useEffect)(
|
|
function () {
|
|
if (g) {
|
|
var e = v.getFieldsValue,
|
|
t = (0, v.getInternalHooks)(b).registerWatch,
|
|
r = function (e, t) {
|
|
var r = l.preserve ? t : e;
|
|
return "function" == typeof a
|
|
? a(r)
|
|
: (0, eh.default)(r, w.current);
|
|
},
|
|
n = t(function (e, t) {
|
|
var n = r(e, t),
|
|
a = eO(n);
|
|
m.current !== a && ((m.current = a), d(n));
|
|
}),
|
|
i = r(e(), e(!0));
|
|
return f !== i && d(i), n;
|
|
}
|
|
},
|
|
[g],
|
|
),
|
|
f
|
|
);
|
|
}),
|
|
e.s([], 849168);
|
|
};
|
|
|
|
export default moduleFactory;
|