@getopenpay/openpay-js-react 0.0.2-beta.1 → 0.0.3-alpha.4e3a3ab
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +59 -8
- package/dist/index.d.ts +24 -154
- package/dist/index.js +727 -688
- package/package.json +2 -2
package/dist/index.js
CHANGED
|
@@ -1,41 +1,43 @@
|
|
|
1
|
-
import { createContext as
|
|
2
|
-
import { jsx as
|
|
3
|
-
const
|
|
4
|
-
|
|
1
|
+
import { createContext as Jt, useContext as Gt, useState as R, useMemo as Pe, useRef as _t, useCallback as Ae, useEffect as De } from "react";
|
|
2
|
+
import { jsx as W } from "react/jsx-runtime";
|
|
3
|
+
const xt = Jt({
|
|
4
|
+
formId: "",
|
|
5
5
|
formHeight: "",
|
|
6
6
|
referer: void 0,
|
|
7
|
-
checkoutSecureToken: void 0
|
|
8
|
-
|
|
9
|
-
|
|
7
|
+
checkoutSecureToken: void 0,
|
|
8
|
+
registerIframe: () => {
|
|
9
|
+
}
|
|
10
|
+
}), Ft = () => {
|
|
11
|
+
const r = Gt(xt);
|
|
10
12
|
if (!r)
|
|
11
13
|
throw new Error("useOpenPayElements must be used within an OpenPayElementsProvider");
|
|
12
14
|
return r;
|
|
13
15
|
};
|
|
14
|
-
var
|
|
15
|
-
for (var
|
|
16
|
-
|
|
17
|
-
function
|
|
18
|
-
return (
|
|
16
|
+
var w = [];
|
|
17
|
+
for (var Xe = 0; Xe < 256; ++Xe)
|
|
18
|
+
w.push((Xe + 256).toString(16).slice(1));
|
|
19
|
+
function Xt(r, e = 0) {
|
|
20
|
+
return (w[r[e + 0]] + w[r[e + 1]] + w[r[e + 2]] + w[r[e + 3]] + "-" + w[r[e + 4]] + w[r[e + 5]] + "-" + w[r[e + 6]] + w[r[e + 7]] + "-" + w[r[e + 8]] + w[r[e + 9]] + "-" + w[r[e + 10]] + w[r[e + 11]] + w[r[e + 12]] + w[r[e + 13]] + w[r[e + 14]] + w[r[e + 15]]).toLowerCase();
|
|
19
21
|
}
|
|
20
|
-
var
|
|
21
|
-
function
|
|
22
|
-
if (!
|
|
22
|
+
var je, Qt = new Uint8Array(16);
|
|
23
|
+
function er() {
|
|
24
|
+
if (!je && (je = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !je))
|
|
23
25
|
throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
|
|
24
|
-
return
|
|
26
|
+
return je(Qt);
|
|
25
27
|
}
|
|
26
|
-
var
|
|
27
|
-
const
|
|
28
|
-
randomUUID:
|
|
28
|
+
var tr = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
|
|
29
|
+
const pt = {
|
|
30
|
+
randomUUID: tr
|
|
29
31
|
};
|
|
30
|
-
function
|
|
31
|
-
if (
|
|
32
|
-
return
|
|
32
|
+
function kt(r, e, t) {
|
|
33
|
+
if (pt.randomUUID && !e && !r)
|
|
34
|
+
return pt.randomUUID();
|
|
33
35
|
r = r || {};
|
|
34
|
-
var n = r.random || (r.rng ||
|
|
35
|
-
return n[6] = n[6] & 15 | 64, n[8] = n[8] & 63 | 128,
|
|
36
|
+
var n = r.random || (r.rng || er)();
|
|
37
|
+
return n[6] = n[6] & 15 | 64, n[8] = n[8] & 63 | 128, Xt(n);
|
|
36
38
|
}
|
|
37
|
-
const
|
|
38
|
-
var
|
|
39
|
+
const st = "https://cde.openpaystaging.com";
|
|
40
|
+
var _;
|
|
39
41
|
(function(r) {
|
|
40
42
|
r.assertEqual = (s) => s;
|
|
41
43
|
function e(s) {
|
|
@@ -70,16 +72,16 @@ var x;
|
|
|
70
72
|
return s.map((i) => typeof i == "string" ? `'${i}'` : i).join(a);
|
|
71
73
|
}
|
|
72
74
|
r.joinValues = n, r.jsonStringifyReplacer = (s, a) => typeof a == "bigint" ? a.toString() : a;
|
|
73
|
-
})(
|
|
74
|
-
var
|
|
75
|
+
})(_ || (_ = {}));
|
|
76
|
+
var et;
|
|
75
77
|
(function(r) {
|
|
76
78
|
r.mergeShapes = (e, t) => ({
|
|
77
79
|
...e,
|
|
78
80
|
...t
|
|
79
81
|
// second overwrites first
|
|
80
82
|
});
|
|
81
|
-
})(
|
|
82
|
-
const f =
|
|
83
|
+
})(et || (et = {}));
|
|
84
|
+
const f = _.arrayToEnum([
|
|
83
85
|
"string",
|
|
84
86
|
"nan",
|
|
85
87
|
"number",
|
|
@@ -121,7 +123,7 @@ const f = x.arrayToEnum([
|
|
|
121
123
|
default:
|
|
122
124
|
return f.unknown;
|
|
123
125
|
}
|
|
124
|
-
}, c =
|
|
126
|
+
}, c = _.arrayToEnum([
|
|
125
127
|
"invalid_type",
|
|
126
128
|
"invalid_literal",
|
|
127
129
|
"custom",
|
|
@@ -138,8 +140,8 @@ const f = x.arrayToEnum([
|
|
|
138
140
|
"invalid_intersection_types",
|
|
139
141
|
"not_multiple_of",
|
|
140
142
|
"not_finite"
|
|
141
|
-
]),
|
|
142
|
-
class
|
|
143
|
+
]), rr = (r) => JSON.stringify(r, null, 2).replace(/"([^"]+)":/g, "$1:");
|
|
144
|
+
class I extends Error {
|
|
143
145
|
constructor(e) {
|
|
144
146
|
super(), this.issues = [], this.addIssue = (n) => {
|
|
145
147
|
this.issues = [...this.issues, n];
|
|
@@ -176,14 +178,14 @@ class O extends Error {
|
|
|
176
178
|
return s(this), n;
|
|
177
179
|
}
|
|
178
180
|
static assert(e) {
|
|
179
|
-
if (!(e instanceof
|
|
181
|
+
if (!(e instanceof I))
|
|
180
182
|
throw new Error(`Not a ZodError: ${e}`);
|
|
181
183
|
}
|
|
182
184
|
toString() {
|
|
183
185
|
return this.message;
|
|
184
186
|
}
|
|
185
187
|
get message() {
|
|
186
|
-
return JSON.stringify(this.issues,
|
|
188
|
+
return JSON.stringify(this.issues, _.jsonStringifyReplacer, 2);
|
|
187
189
|
}
|
|
188
190
|
get isEmpty() {
|
|
189
191
|
return this.issues.length === 0;
|
|
@@ -198,27 +200,27 @@ class O extends Error {
|
|
|
198
200
|
return this.flatten();
|
|
199
201
|
}
|
|
200
202
|
}
|
|
201
|
-
|
|
202
|
-
const
|
|
203
|
+
I.create = (r) => new I(r);
|
|
204
|
+
const ue = (r, e) => {
|
|
203
205
|
let t;
|
|
204
206
|
switch (r.code) {
|
|
205
207
|
case c.invalid_type:
|
|
206
208
|
r.received === f.undefined ? t = "Required" : t = `Expected ${r.expected}, received ${r.received}`;
|
|
207
209
|
break;
|
|
208
210
|
case c.invalid_literal:
|
|
209
|
-
t = `Invalid literal value, expected ${JSON.stringify(r.expected,
|
|
211
|
+
t = `Invalid literal value, expected ${JSON.stringify(r.expected, _.jsonStringifyReplacer)}`;
|
|
210
212
|
break;
|
|
211
213
|
case c.unrecognized_keys:
|
|
212
|
-
t = `Unrecognized key(s) in object: ${
|
|
214
|
+
t = `Unrecognized key(s) in object: ${_.joinValues(r.keys, ", ")}`;
|
|
213
215
|
break;
|
|
214
216
|
case c.invalid_union:
|
|
215
217
|
t = "Invalid input";
|
|
216
218
|
break;
|
|
217
219
|
case c.invalid_union_discriminator:
|
|
218
|
-
t = `Invalid discriminator value. Expected ${
|
|
220
|
+
t = `Invalid discriminator value. Expected ${_.joinValues(r.options)}`;
|
|
219
221
|
break;
|
|
220
222
|
case c.invalid_enum_value:
|
|
221
|
-
t = `Invalid enum value. Expected ${
|
|
223
|
+
t = `Invalid enum value. Expected ${_.joinValues(r.options)}, received '${r.received}'`;
|
|
222
224
|
break;
|
|
223
225
|
case c.invalid_arguments:
|
|
224
226
|
t = "Invalid function arguments";
|
|
@@ -230,7 +232,7 @@ const se = (r, e) => {
|
|
|
230
232
|
t = "Invalid date";
|
|
231
233
|
break;
|
|
232
234
|
case c.invalid_string:
|
|
233
|
-
typeof r.validation == "object" ? "includes" in r.validation ? (t = `Invalid input: must include "${r.validation.includes}"`, typeof r.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${r.validation.position}`)) : "startsWith" in r.validation ? t = `Invalid input: must start with "${r.validation.startsWith}"` : "endsWith" in r.validation ? t = `Invalid input: must end with "${r.validation.endsWith}"` :
|
|
235
|
+
typeof r.validation == "object" ? "includes" in r.validation ? (t = `Invalid input: must include "${r.validation.includes}"`, typeof r.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${r.validation.position}`)) : "startsWith" in r.validation ? t = `Invalid input: must start with "${r.validation.startsWith}"` : "endsWith" in r.validation ? t = `Invalid input: must end with "${r.validation.endsWith}"` : _.assertNever(r.validation) : r.validation !== "regex" ? t = `Invalid ${r.validation}` : t = "Invalid";
|
|
234
236
|
break;
|
|
235
237
|
case c.too_small:
|
|
236
238
|
r.type === "array" ? t = `Array must contain ${r.exact ? "exactly" : r.inclusive ? "at least" : "more than"} ${r.minimum} element(s)` : r.type === "string" ? t = `String must contain ${r.exact ? "exactly" : r.inclusive ? "at least" : "over"} ${r.minimum} character(s)` : r.type === "number" ? t = `Number must be ${r.exact ? "exactly equal to " : r.inclusive ? "greater than or equal to " : "greater than "}${r.minimum}` : r.type === "date" ? t = `Date must be ${r.exact ? "exactly equal to " : r.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(r.minimum))}` : t = "Invalid input";
|
|
@@ -251,18 +253,18 @@ const se = (r, e) => {
|
|
|
251
253
|
t = "Number must be finite";
|
|
252
254
|
break;
|
|
253
255
|
default:
|
|
254
|
-
t = e.defaultError,
|
|
256
|
+
t = e.defaultError, _.assertNever(r);
|
|
255
257
|
}
|
|
256
258
|
return { message: t };
|
|
257
259
|
};
|
|
258
|
-
let
|
|
259
|
-
function
|
|
260
|
-
|
|
260
|
+
let bt = ue;
|
|
261
|
+
function nr(r) {
|
|
262
|
+
bt = r;
|
|
261
263
|
}
|
|
262
|
-
function
|
|
263
|
-
return
|
|
264
|
+
function Me() {
|
|
265
|
+
return bt;
|
|
264
266
|
}
|
|
265
|
-
const
|
|
267
|
+
const Ue = (r) => {
|
|
266
268
|
const { data: e, path: t, errorMaps: n, issueData: s } = r, a = [...t, ...s.path || []], i = {
|
|
267
269
|
...s,
|
|
268
270
|
path: a
|
|
@@ -282,9 +284,9 @@ const Ze = (r) => {
|
|
|
282
284
|
path: a,
|
|
283
285
|
message: o
|
|
284
286
|
};
|
|
285
|
-
},
|
|
287
|
+
}, sr = [];
|
|
286
288
|
function l(r, e) {
|
|
287
|
-
const t =
|
|
289
|
+
const t = Me(), n = Ue({
|
|
288
290
|
issueData: e,
|
|
289
291
|
data: r.data,
|
|
290
292
|
path: r.path,
|
|
@@ -292,7 +294,7 @@ function l(r, e) {
|
|
|
292
294
|
r.common.contextualErrorMap,
|
|
293
295
|
r.schemaErrorMap,
|
|
294
296
|
t,
|
|
295
|
-
t ===
|
|
297
|
+
t === ue ? void 0 : ue
|
|
296
298
|
// then global default map
|
|
297
299
|
].filter((s) => !!s)
|
|
298
300
|
});
|
|
@@ -312,7 +314,7 @@ class E {
|
|
|
312
314
|
const n = [];
|
|
313
315
|
for (const s of t) {
|
|
314
316
|
if (s.status === "aborted")
|
|
315
|
-
return
|
|
317
|
+
return y;
|
|
316
318
|
s.status === "dirty" && e.dirty(), n.push(s.value);
|
|
317
319
|
}
|
|
318
320
|
return { status: e.value, value: n };
|
|
@@ -333,20 +335,20 @@ class E {
|
|
|
333
335
|
for (const s of t) {
|
|
334
336
|
const { key: a, value: i } = s;
|
|
335
337
|
if (a.status === "aborted" || i.status === "aborted")
|
|
336
|
-
return
|
|
338
|
+
return y;
|
|
337
339
|
a.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), a.value !== "__proto__" && (typeof i.value < "u" || s.alwaysSet) && (n[a.value] = i.value);
|
|
338
340
|
}
|
|
339
341
|
return { status: e.value, value: n };
|
|
340
342
|
}
|
|
341
343
|
}
|
|
342
|
-
const
|
|
344
|
+
const y = Object.freeze({
|
|
343
345
|
status: "aborted"
|
|
344
|
-
}),
|
|
345
|
-
function
|
|
346
|
+
}), ce = (r) => ({ status: "dirty", value: r }), S = (r) => ({ status: "valid", value: r }), tt = (r) => r.status === "aborted", rt = (r) => r.status === "dirty", ye = (r) => r.status === "valid", ve = (r) => typeof Promise < "u" && r instanceof Promise;
|
|
347
|
+
function Le(r, e, t, n) {
|
|
346
348
|
if (typeof e == "function" ? r !== e || !n : !e.has(r)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
|
|
347
349
|
return e.get(r);
|
|
348
350
|
}
|
|
349
|
-
function
|
|
351
|
+
function Tt(r, e, t, n, s) {
|
|
350
352
|
if (typeof e == "function" ? r !== e || !s : !e.has(r)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
|
|
351
353
|
return e.set(r, t), t;
|
|
352
354
|
}
|
|
@@ -354,8 +356,8 @@ var h;
|
|
|
354
356
|
(function(r) {
|
|
355
357
|
r.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, r.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
|
|
356
358
|
})(h || (h = {}));
|
|
357
|
-
var
|
|
358
|
-
class
|
|
359
|
+
var me, pe;
|
|
360
|
+
class U {
|
|
359
361
|
constructor(e, t, n, s) {
|
|
360
362
|
this._cachedPath = [], this.parent = e, this.data = t, this._path = n, this._key = s;
|
|
361
363
|
}
|
|
@@ -363,8 +365,8 @@ class P {
|
|
|
363
365
|
return this._cachedPath.length || (this._key instanceof Array ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
|
|
364
366
|
}
|
|
365
367
|
}
|
|
366
|
-
const
|
|
367
|
-
if (
|
|
368
|
+
const yt = (r, e) => {
|
|
369
|
+
if (ye(e))
|
|
368
370
|
return { success: !0, data: e.value };
|
|
369
371
|
if (!r.common.issues.length)
|
|
370
372
|
throw new Error("Validation failed but no issues detected.");
|
|
@@ -373,7 +375,7 @@ const rt = (r, e) => {
|
|
|
373
375
|
get error() {
|
|
374
376
|
if (this._error)
|
|
375
377
|
return this._error;
|
|
376
|
-
const t = new
|
|
378
|
+
const t = new I(r.common.issues);
|
|
377
379
|
return this._error = t, this._error;
|
|
378
380
|
}
|
|
379
381
|
};
|
|
@@ -386,11 +388,11 @@ function v(r) {
|
|
|
386
388
|
throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
|
|
387
389
|
return e ? { errorMap: e, description: s } : { errorMap: (i, o) => {
|
|
388
390
|
var u, d;
|
|
389
|
-
const { message:
|
|
390
|
-
return i.code === "invalid_enum_value" ? { message:
|
|
391
|
+
const { message: m } = r;
|
|
392
|
+
return i.code === "invalid_enum_value" ? { message: m ?? o.defaultError } : typeof o.data > "u" ? { message: (u = m ?? n) !== null && u !== void 0 ? u : o.defaultError } : i.code !== "invalid_type" ? { message: o.defaultError } : { message: (d = m ?? t) !== null && d !== void 0 ? d : o.defaultError };
|
|
391
393
|
}, description: s };
|
|
392
394
|
}
|
|
393
|
-
class
|
|
395
|
+
class g {
|
|
394
396
|
constructor(e) {
|
|
395
397
|
this.spa = this.safeParseAsync, this._def = e, this.parse = this.parse.bind(this), this.safeParse = this.safeParse.bind(this), this.parseAsync = this.parseAsync.bind(this), this.safeParseAsync = this.safeParseAsync.bind(this), this.spa = this.spa.bind(this), this.refine = this.refine.bind(this), this.refinement = this.refinement.bind(this), this.superRefine = this.superRefine.bind(this), this.optional = this.optional.bind(this), this.nullable = this.nullable.bind(this), this.nullish = this.nullish.bind(this), this.array = this.array.bind(this), this.promise = this.promise.bind(this), this.or = this.or.bind(this), this.and = this.and.bind(this), this.transform = this.transform.bind(this), this.brand = this.brand.bind(this), this.default = this.default.bind(this), this.catch = this.catch.bind(this), this.describe = this.describe.bind(this), this.pipe = this.pipe.bind(this), this.readonly = this.readonly.bind(this), this.isNullable = this.isNullable.bind(this), this.isOptional = this.isOptional.bind(this);
|
|
396
398
|
}
|
|
@@ -425,7 +427,7 @@ class _ {
|
|
|
425
427
|
}
|
|
426
428
|
_parseSync(e) {
|
|
427
429
|
const t = this._parse(e);
|
|
428
|
-
if (
|
|
430
|
+
if (ve(t))
|
|
429
431
|
throw new Error("Synchronous parse encountered promise.");
|
|
430
432
|
return t;
|
|
431
433
|
}
|
|
@@ -453,7 +455,7 @@ class _ {
|
|
|
453
455
|
data: e,
|
|
454
456
|
parsedType: H(e)
|
|
455
457
|
}, a = this._parseSync({ data: e, path: s.path, parent: s });
|
|
456
|
-
return
|
|
458
|
+
return yt(s, a);
|
|
457
459
|
}
|
|
458
460
|
async parseAsync(e, t) {
|
|
459
461
|
const n = await this.safeParseAsync(e, t);
|
|
@@ -473,8 +475,8 @@ class _ {
|
|
|
473
475
|
parent: null,
|
|
474
476
|
data: e,
|
|
475
477
|
parsedType: H(e)
|
|
476
|
-
}, s = this._parse({ data: e, path: n.path, parent: n }), a = await (
|
|
477
|
-
return
|
|
478
|
+
}, s = this._parse({ data: e, path: n.path, parent: n }), a = await (ve(s) ? s : Promise.resolve(s));
|
|
479
|
+
return yt(n, a);
|
|
478
480
|
}
|
|
479
481
|
refine(e, t) {
|
|
480
482
|
const n = (s) => typeof t == "string" || typeof t > "u" ? { message: t } : typeof t == "function" ? t(s) : t;
|
|
@@ -490,9 +492,9 @@ class _ {
|
|
|
490
492
|
return this._refinement((n, s) => e(n) ? !0 : (s.addIssue(typeof t == "function" ? t(n, s) : t), !1));
|
|
491
493
|
}
|
|
492
494
|
_refinement(e) {
|
|
493
|
-
return new
|
|
495
|
+
return new D({
|
|
494
496
|
schema: this,
|
|
495
|
-
typeName:
|
|
497
|
+
typeName: p.ZodEffects,
|
|
496
498
|
effect: { type: "refinement", refinement: e }
|
|
497
499
|
});
|
|
498
500
|
}
|
|
@@ -500,57 +502,57 @@ class _ {
|
|
|
500
502
|
return this._refinement(e);
|
|
501
503
|
}
|
|
502
504
|
optional() {
|
|
503
|
-
return
|
|
505
|
+
return M.create(this, this._def);
|
|
504
506
|
}
|
|
505
507
|
nullable() {
|
|
506
|
-
return
|
|
508
|
+
return J.create(this, this._def);
|
|
507
509
|
}
|
|
508
510
|
nullish() {
|
|
509
511
|
return this.nullable().optional();
|
|
510
512
|
}
|
|
511
513
|
array() {
|
|
512
|
-
return
|
|
514
|
+
return P.create(this, this._def);
|
|
513
515
|
}
|
|
514
516
|
promise() {
|
|
515
|
-
return
|
|
517
|
+
return fe.create(this, this._def);
|
|
516
518
|
}
|
|
517
519
|
or(e) {
|
|
518
|
-
return
|
|
520
|
+
return ke.create([this, e], this._def);
|
|
519
521
|
}
|
|
520
522
|
and(e) {
|
|
521
|
-
return
|
|
523
|
+
return be.create(this, e, this._def);
|
|
522
524
|
}
|
|
523
525
|
transform(e) {
|
|
524
|
-
return new
|
|
526
|
+
return new D({
|
|
525
527
|
...v(this._def),
|
|
526
528
|
schema: this,
|
|
527
|
-
typeName:
|
|
529
|
+
typeName: p.ZodEffects,
|
|
528
530
|
effect: { type: "transform", transform: e }
|
|
529
531
|
});
|
|
530
532
|
}
|
|
531
533
|
default(e) {
|
|
532
534
|
const t = typeof e == "function" ? e : () => e;
|
|
533
|
-
return new
|
|
535
|
+
return new Se({
|
|
534
536
|
...v(this._def),
|
|
535
537
|
innerType: this,
|
|
536
538
|
defaultValue: t,
|
|
537
|
-
typeName:
|
|
539
|
+
typeName: p.ZodDefault
|
|
538
540
|
});
|
|
539
541
|
}
|
|
540
542
|
brand() {
|
|
541
|
-
return new
|
|
542
|
-
typeName:
|
|
543
|
+
return new at({
|
|
544
|
+
typeName: p.ZodBranded,
|
|
543
545
|
type: this,
|
|
544
546
|
...v(this._def)
|
|
545
547
|
});
|
|
546
548
|
}
|
|
547
549
|
catch(e) {
|
|
548
550
|
const t = typeof e == "function" ? e : () => e;
|
|
549
|
-
return new
|
|
551
|
+
return new Oe({
|
|
550
552
|
...v(this._def),
|
|
551
553
|
innerType: this,
|
|
552
554
|
catchValue: t,
|
|
553
|
-
typeName:
|
|
555
|
+
typeName: p.ZodCatch
|
|
554
556
|
});
|
|
555
557
|
}
|
|
556
558
|
describe(e) {
|
|
@@ -561,10 +563,10 @@ class _ {
|
|
|
561
563
|
});
|
|
562
564
|
}
|
|
563
565
|
pipe(e) {
|
|
564
|
-
return
|
|
566
|
+
return Ie.create(this, e);
|
|
565
567
|
}
|
|
566
568
|
readonly() {
|
|
567
|
-
return
|
|
569
|
+
return Re.create(this);
|
|
568
570
|
}
|
|
569
571
|
isOptional() {
|
|
570
572
|
return this.safeParse(void 0).success;
|
|
@@ -573,25 +575,25 @@ class _ {
|
|
|
573
575
|
return this.safeParse(null).success;
|
|
574
576
|
}
|
|
575
577
|
}
|
|
576
|
-
const
|
|
577
|
-
let
|
|
578
|
-
const
|
|
579
|
-
function
|
|
578
|
+
const ar = /^c[^\s-]{8,}$/i, ir = /^[0-9a-z]+$/, or = /^[0-9A-HJKMNP-TV-Z]{26}$/, cr = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i, dr = /^[a-z0-9_-]{21}$/i, ur = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/, lr = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, fr = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
|
|
579
|
+
let Qe;
|
|
580
|
+
const hr = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, mr = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/, pr = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, wt = "((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))", yr = new RegExp(`^${wt}$`);
|
|
581
|
+
function Et(r) {
|
|
580
582
|
let e = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
|
|
581
583
|
return r.precision ? e = `${e}\\.\\d{${r.precision}}` : r.precision == null && (e = `${e}(\\.\\d+)?`), e;
|
|
582
584
|
}
|
|
583
|
-
function
|
|
584
|
-
return new RegExp(`^${
|
|
585
|
+
function vr(r) {
|
|
586
|
+
return new RegExp(`^${Et(r)}$`);
|
|
585
587
|
}
|
|
586
|
-
function
|
|
587
|
-
let e = `${
|
|
588
|
+
function Ct(r) {
|
|
589
|
+
let e = `${wt}T${Et(r)}`;
|
|
588
590
|
const t = [];
|
|
589
591
|
return t.push(r.local ? "Z?" : "Z"), r.offset && t.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${t.join("|")})`, new RegExp(`^${e}$`);
|
|
590
592
|
}
|
|
591
|
-
function
|
|
592
|
-
return !!((e === "v4" || !e) &&
|
|
593
|
+
function gr(r, e) {
|
|
594
|
+
return !!((e === "v4" || !e) && hr.test(r) || (e === "v6" || !e) && mr.test(r));
|
|
593
595
|
}
|
|
594
|
-
class
|
|
596
|
+
class j extends g {
|
|
595
597
|
_parse(e) {
|
|
596
598
|
if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== f.string) {
|
|
597
599
|
const a = this._getOrReturnCtx(e);
|
|
@@ -599,7 +601,7 @@ class I extends _ {
|
|
|
599
601
|
code: c.invalid_type,
|
|
600
602
|
expected: f.string,
|
|
601
603
|
received: a.parsedType
|
|
602
|
-
}),
|
|
604
|
+
}), y;
|
|
603
605
|
}
|
|
604
606
|
const n = new E();
|
|
605
607
|
let s;
|
|
@@ -640,43 +642,43 @@ class I extends _ {
|
|
|
640
642
|
message: a.message
|
|
641
643
|
}), n.dirty());
|
|
642
644
|
} else if (a.kind === "email")
|
|
643
|
-
|
|
645
|
+
lr.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
644
646
|
validation: "email",
|
|
645
647
|
code: c.invalid_string,
|
|
646
648
|
message: a.message
|
|
647
649
|
}), n.dirty());
|
|
648
650
|
else if (a.kind === "emoji")
|
|
649
|
-
|
|
651
|
+
Qe || (Qe = new RegExp(fr, "u")), Qe.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
650
652
|
validation: "emoji",
|
|
651
653
|
code: c.invalid_string,
|
|
652
654
|
message: a.message
|
|
653
655
|
}), n.dirty());
|
|
654
656
|
else if (a.kind === "uuid")
|
|
655
|
-
|
|
657
|
+
cr.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
656
658
|
validation: "uuid",
|
|
657
659
|
code: c.invalid_string,
|
|
658
660
|
message: a.message
|
|
659
661
|
}), n.dirty());
|
|
660
662
|
else if (a.kind === "nanoid")
|
|
661
|
-
|
|
663
|
+
dr.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
662
664
|
validation: "nanoid",
|
|
663
665
|
code: c.invalid_string,
|
|
664
666
|
message: a.message
|
|
665
667
|
}), n.dirty());
|
|
666
668
|
else if (a.kind === "cuid")
|
|
667
|
-
|
|
669
|
+
ar.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
668
670
|
validation: "cuid",
|
|
669
671
|
code: c.invalid_string,
|
|
670
672
|
message: a.message
|
|
671
673
|
}), n.dirty());
|
|
672
674
|
else if (a.kind === "cuid2")
|
|
673
|
-
|
|
675
|
+
ir.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
674
676
|
validation: "cuid2",
|
|
675
677
|
code: c.invalid_string,
|
|
676
678
|
message: a.message
|
|
677
679
|
}), n.dirty());
|
|
678
680
|
else if (a.kind === "ulid")
|
|
679
|
-
|
|
681
|
+
or.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
680
682
|
validation: "ulid",
|
|
681
683
|
code: c.invalid_string,
|
|
682
684
|
message: a.message
|
|
@@ -707,31 +709,31 @@ class I extends _ {
|
|
|
707
709
|
code: c.invalid_string,
|
|
708
710
|
validation: { endsWith: a.value },
|
|
709
711
|
message: a.message
|
|
710
|
-
}), n.dirty()) : a.kind === "datetime" ?
|
|
712
|
+
}), n.dirty()) : a.kind === "datetime" ? Ct(a).test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
711
713
|
code: c.invalid_string,
|
|
712
714
|
validation: "datetime",
|
|
713
715
|
message: a.message
|
|
714
|
-
}), n.dirty()) : a.kind === "date" ?
|
|
716
|
+
}), n.dirty()) : a.kind === "date" ? yr.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
715
717
|
code: c.invalid_string,
|
|
716
718
|
validation: "date",
|
|
717
719
|
message: a.message
|
|
718
|
-
}), n.dirty()) : a.kind === "time" ?
|
|
720
|
+
}), n.dirty()) : a.kind === "time" ? vr(a).test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
719
721
|
code: c.invalid_string,
|
|
720
722
|
validation: "time",
|
|
721
723
|
message: a.message
|
|
722
|
-
}), n.dirty()) : a.kind === "duration" ?
|
|
724
|
+
}), n.dirty()) : a.kind === "duration" ? ur.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
723
725
|
validation: "duration",
|
|
724
726
|
code: c.invalid_string,
|
|
725
727
|
message: a.message
|
|
726
|
-
}), n.dirty()) : a.kind === "ip" ?
|
|
728
|
+
}), n.dirty()) : a.kind === "ip" ? gr(e.data, a.version) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
727
729
|
validation: "ip",
|
|
728
730
|
code: c.invalid_string,
|
|
729
731
|
message: a.message
|
|
730
|
-
}), n.dirty()) : a.kind === "base64" ?
|
|
732
|
+
}), n.dirty()) : a.kind === "base64" ? pr.test(e.data) || (s = this._getOrReturnCtx(e, s), l(s, {
|
|
731
733
|
validation: "base64",
|
|
732
734
|
code: c.invalid_string,
|
|
733
735
|
message: a.message
|
|
734
|
-
}), n.dirty()) :
|
|
736
|
+
}), n.dirty()) : _.assertNever(a);
|
|
735
737
|
return { status: n.value, value: e.data };
|
|
736
738
|
}
|
|
737
739
|
_regex(e, t, n) {
|
|
@@ -742,7 +744,7 @@ class I extends _ {
|
|
|
742
744
|
});
|
|
743
745
|
}
|
|
744
746
|
_addCheck(e) {
|
|
745
|
-
return new
|
|
747
|
+
return new j({
|
|
746
748
|
...this._def,
|
|
747
749
|
checks: [...this._def.checks, e]
|
|
748
750
|
});
|
|
@@ -868,19 +870,19 @@ class I extends _ {
|
|
|
868
870
|
return this.min(1, h.errToObj(e));
|
|
869
871
|
}
|
|
870
872
|
trim() {
|
|
871
|
-
return new
|
|
873
|
+
return new j({
|
|
872
874
|
...this._def,
|
|
873
875
|
checks: [...this._def.checks, { kind: "trim" }]
|
|
874
876
|
});
|
|
875
877
|
}
|
|
876
878
|
toLowerCase() {
|
|
877
|
-
return new
|
|
879
|
+
return new j({
|
|
878
880
|
...this._def,
|
|
879
881
|
checks: [...this._def.checks, { kind: "toLowerCase" }]
|
|
880
882
|
});
|
|
881
883
|
}
|
|
882
884
|
toUpperCase() {
|
|
883
|
-
return new
|
|
885
|
+
return new j({
|
|
884
886
|
...this._def,
|
|
885
887
|
checks: [...this._def.checks, { kind: "toUpperCase" }]
|
|
886
888
|
});
|
|
@@ -940,20 +942,20 @@ class I extends _ {
|
|
|
940
942
|
return e;
|
|
941
943
|
}
|
|
942
944
|
}
|
|
943
|
-
|
|
945
|
+
j.create = (r) => {
|
|
944
946
|
var e;
|
|
945
|
-
return new
|
|
947
|
+
return new j({
|
|
946
948
|
checks: [],
|
|
947
|
-
typeName:
|
|
949
|
+
typeName: p.ZodString,
|
|
948
950
|
coerce: (e = r == null ? void 0 : r.coerce) !== null && e !== void 0 ? e : !1,
|
|
949
951
|
...v(r)
|
|
950
952
|
});
|
|
951
953
|
};
|
|
952
|
-
function
|
|
954
|
+
function _r(r, e) {
|
|
953
955
|
const t = (r.toString().split(".")[1] || "").length, n = (e.toString().split(".")[1] || "").length, s = t > n ? t : n, a = parseInt(r.toFixed(s).replace(".", "")), i = parseInt(e.toFixed(s).replace(".", ""));
|
|
954
956
|
return a % i / Math.pow(10, s);
|
|
955
957
|
}
|
|
956
|
-
class
|
|
958
|
+
class K extends g {
|
|
957
959
|
constructor() {
|
|
958
960
|
super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf;
|
|
959
961
|
}
|
|
@@ -964,12 +966,12 @@ class W extends _ {
|
|
|
964
966
|
code: c.invalid_type,
|
|
965
967
|
expected: f.number,
|
|
966
968
|
received: a.parsedType
|
|
967
|
-
}),
|
|
969
|
+
}), y;
|
|
968
970
|
}
|
|
969
971
|
let n;
|
|
970
972
|
const s = new E();
|
|
971
973
|
for (const a of this._def.checks)
|
|
972
|
-
a.kind === "int" ?
|
|
974
|
+
a.kind === "int" ? _.isInteger(e.data) || (n = this._getOrReturnCtx(e, n), l(n, {
|
|
973
975
|
code: c.invalid_type,
|
|
974
976
|
expected: "integer",
|
|
975
977
|
received: "float",
|
|
@@ -988,14 +990,14 @@ class W extends _ {
|
|
|
988
990
|
inclusive: a.inclusive,
|
|
989
991
|
exact: !1,
|
|
990
992
|
message: a.message
|
|
991
|
-
}), s.dirty()) : a.kind === "multipleOf" ?
|
|
993
|
+
}), s.dirty()) : a.kind === "multipleOf" ? _r(e.data, a.value) !== 0 && (n = this._getOrReturnCtx(e, n), l(n, {
|
|
992
994
|
code: c.not_multiple_of,
|
|
993
995
|
multipleOf: a.value,
|
|
994
996
|
message: a.message
|
|
995
997
|
}), s.dirty()) : a.kind === "finite" ? Number.isFinite(e.data) || (n = this._getOrReturnCtx(e, n), l(n, {
|
|
996
998
|
code: c.not_finite,
|
|
997
999
|
message: a.message
|
|
998
|
-
}), s.dirty()) :
|
|
1000
|
+
}), s.dirty()) : _.assertNever(a);
|
|
999
1001
|
return { status: s.value, value: e.data };
|
|
1000
1002
|
}
|
|
1001
1003
|
gte(e, t) {
|
|
@@ -1011,7 +1013,7 @@ class W extends _ {
|
|
|
1011
1013
|
return this.setLimit("max", e, !1, h.toString(t));
|
|
1012
1014
|
}
|
|
1013
1015
|
setLimit(e, t, n, s) {
|
|
1014
|
-
return new
|
|
1016
|
+
return new K({
|
|
1015
1017
|
...this._def,
|
|
1016
1018
|
checks: [
|
|
1017
1019
|
...this._def.checks,
|
|
@@ -1025,7 +1027,7 @@ class W extends _ {
|
|
|
1025
1027
|
});
|
|
1026
1028
|
}
|
|
1027
1029
|
_addCheck(e) {
|
|
1028
|
-
return new
|
|
1030
|
+
return new K({
|
|
1029
1031
|
...this._def,
|
|
1030
1032
|
checks: [...this._def.checks, e]
|
|
1031
1033
|
});
|
|
@@ -1107,7 +1109,7 @@ class W extends _ {
|
|
|
1107
1109
|
return e;
|
|
1108
1110
|
}
|
|
1109
1111
|
get isInt() {
|
|
1110
|
-
return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" &&
|
|
1112
|
+
return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && _.isInteger(e.value));
|
|
1111
1113
|
}
|
|
1112
1114
|
get isFinite() {
|
|
1113
1115
|
let e = null, t = null;
|
|
@@ -1119,13 +1121,13 @@ class W extends _ {
|
|
|
1119
1121
|
return Number.isFinite(t) && Number.isFinite(e);
|
|
1120
1122
|
}
|
|
1121
1123
|
}
|
|
1122
|
-
|
|
1124
|
+
K.create = (r) => new K({
|
|
1123
1125
|
checks: [],
|
|
1124
|
-
typeName:
|
|
1126
|
+
typeName: p.ZodNumber,
|
|
1125
1127
|
coerce: (r == null ? void 0 : r.coerce) || !1,
|
|
1126
1128
|
...v(r)
|
|
1127
1129
|
});
|
|
1128
|
-
class q extends
|
|
1130
|
+
class q extends g {
|
|
1129
1131
|
constructor() {
|
|
1130
1132
|
super(...arguments), this.min = this.gte, this.max = this.lte;
|
|
1131
1133
|
}
|
|
@@ -1136,7 +1138,7 @@ class q extends _ {
|
|
|
1136
1138
|
code: c.invalid_type,
|
|
1137
1139
|
expected: f.bigint,
|
|
1138
1140
|
received: a.parsedType
|
|
1139
|
-
}),
|
|
1141
|
+
}), y;
|
|
1140
1142
|
}
|
|
1141
1143
|
let n;
|
|
1142
1144
|
const s = new E();
|
|
@@ -1157,7 +1159,7 @@ class q extends _ {
|
|
|
1157
1159
|
code: c.not_multiple_of,
|
|
1158
1160
|
multipleOf: a.value,
|
|
1159
1161
|
message: a.message
|
|
1160
|
-
}), s.dirty()) :
|
|
1162
|
+
}), s.dirty()) : _.assertNever(a);
|
|
1161
1163
|
return { status: s.value, value: e.data };
|
|
1162
1164
|
}
|
|
1163
1165
|
gte(e, t) {
|
|
@@ -1248,12 +1250,12 @@ q.create = (r) => {
|
|
|
1248
1250
|
var e;
|
|
1249
1251
|
return new q({
|
|
1250
1252
|
checks: [],
|
|
1251
|
-
typeName:
|
|
1253
|
+
typeName: p.ZodBigInt,
|
|
1252
1254
|
coerce: (e = r == null ? void 0 : r.coerce) !== null && e !== void 0 ? e : !1,
|
|
1253
1255
|
...v(r)
|
|
1254
1256
|
});
|
|
1255
1257
|
};
|
|
1256
|
-
class
|
|
1258
|
+
class ge extends g {
|
|
1257
1259
|
_parse(e) {
|
|
1258
1260
|
if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== f.boolean) {
|
|
1259
1261
|
const n = this._getOrReturnCtx(e);
|
|
@@ -1261,17 +1263,17 @@ class fe extends _ {
|
|
|
1261
1263
|
code: c.invalid_type,
|
|
1262
1264
|
expected: f.boolean,
|
|
1263
1265
|
received: n.parsedType
|
|
1264
|
-
}),
|
|
1266
|
+
}), y;
|
|
1265
1267
|
}
|
|
1266
1268
|
return S(e.data);
|
|
1267
1269
|
}
|
|
1268
1270
|
}
|
|
1269
|
-
|
|
1270
|
-
typeName:
|
|
1271
|
+
ge.create = (r) => new ge({
|
|
1272
|
+
typeName: p.ZodBoolean,
|
|
1271
1273
|
coerce: (r == null ? void 0 : r.coerce) || !1,
|
|
1272
1274
|
...v(r)
|
|
1273
1275
|
});
|
|
1274
|
-
class
|
|
1276
|
+
class Q extends g {
|
|
1275
1277
|
_parse(e) {
|
|
1276
1278
|
if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== f.date) {
|
|
1277
1279
|
const a = this._getOrReturnCtx(e);
|
|
@@ -1279,13 +1281,13 @@ class X extends _ {
|
|
|
1279
1281
|
code: c.invalid_type,
|
|
1280
1282
|
expected: f.date,
|
|
1281
1283
|
received: a.parsedType
|
|
1282
|
-
}),
|
|
1284
|
+
}), y;
|
|
1283
1285
|
}
|
|
1284
1286
|
if (isNaN(e.data.getTime())) {
|
|
1285
1287
|
const a = this._getOrReturnCtx(e);
|
|
1286
1288
|
return l(a, {
|
|
1287
1289
|
code: c.invalid_date
|
|
1288
|
-
}),
|
|
1290
|
+
}), y;
|
|
1289
1291
|
}
|
|
1290
1292
|
const n = new E();
|
|
1291
1293
|
let s;
|
|
@@ -1304,14 +1306,14 @@ class X extends _ {
|
|
|
1304
1306
|
exact: !1,
|
|
1305
1307
|
maximum: a.value,
|
|
1306
1308
|
type: "date"
|
|
1307
|
-
}), n.dirty()) :
|
|
1309
|
+
}), n.dirty()) : _.assertNever(a);
|
|
1308
1310
|
return {
|
|
1309
1311
|
status: n.value,
|
|
1310
1312
|
value: new Date(e.data.getTime())
|
|
1311
1313
|
};
|
|
1312
1314
|
}
|
|
1313
1315
|
_addCheck(e) {
|
|
1314
|
-
return new
|
|
1316
|
+
return new Q({
|
|
1315
1317
|
...this._def,
|
|
1316
1318
|
checks: [...this._def.checks, e]
|
|
1317
1319
|
});
|
|
@@ -1343,13 +1345,13 @@ class X extends _ {
|
|
|
1343
1345
|
return e != null ? new Date(e) : null;
|
|
1344
1346
|
}
|
|
1345
1347
|
}
|
|
1346
|
-
|
|
1348
|
+
Q.create = (r) => new Q({
|
|
1347
1349
|
checks: [],
|
|
1348
1350
|
coerce: (r == null ? void 0 : r.coerce) || !1,
|
|
1349
|
-
typeName:
|
|
1351
|
+
typeName: p.ZodDate,
|
|
1350
1352
|
...v(r)
|
|
1351
1353
|
});
|
|
1352
|
-
class
|
|
1354
|
+
class $e extends g {
|
|
1353
1355
|
_parse(e) {
|
|
1354
1356
|
if (this._getType(e) !== f.symbol) {
|
|
1355
1357
|
const n = this._getOrReturnCtx(e);
|
|
@@ -1357,16 +1359,16 @@ class Ie extends _ {
|
|
|
1357
1359
|
code: c.invalid_type,
|
|
1358
1360
|
expected: f.symbol,
|
|
1359
1361
|
received: n.parsedType
|
|
1360
|
-
}),
|
|
1362
|
+
}), y;
|
|
1361
1363
|
}
|
|
1362
1364
|
return S(e.data);
|
|
1363
1365
|
}
|
|
1364
1366
|
}
|
|
1365
|
-
|
|
1366
|
-
typeName:
|
|
1367
|
+
$e.create = (r) => new $e({
|
|
1368
|
+
typeName: p.ZodSymbol,
|
|
1367
1369
|
...v(r)
|
|
1368
1370
|
});
|
|
1369
|
-
class
|
|
1371
|
+
class _e extends g {
|
|
1370
1372
|
_parse(e) {
|
|
1371
1373
|
if (this._getType(e) !== f.undefined) {
|
|
1372
1374
|
const n = this._getOrReturnCtx(e);
|
|
@@ -1374,16 +1376,16 @@ class he extends _ {
|
|
|
1374
1376
|
code: c.invalid_type,
|
|
1375
1377
|
expected: f.undefined,
|
|
1376
1378
|
received: n.parsedType
|
|
1377
|
-
}),
|
|
1379
|
+
}), y;
|
|
1378
1380
|
}
|
|
1379
1381
|
return S(e.data);
|
|
1380
1382
|
}
|
|
1381
1383
|
}
|
|
1382
|
-
|
|
1383
|
-
typeName:
|
|
1384
|
+
_e.create = (r) => new _e({
|
|
1385
|
+
typeName: p.ZodUndefined,
|
|
1384
1386
|
...v(r)
|
|
1385
1387
|
});
|
|
1386
|
-
class
|
|
1388
|
+
class xe extends g {
|
|
1387
1389
|
_parse(e) {
|
|
1388
1390
|
if (this._getType(e) !== f.null) {
|
|
1389
1391
|
const n = this._getOrReturnCtx(e);
|
|
@@ -1391,16 +1393,16 @@ class pe extends _ {
|
|
|
1391
1393
|
code: c.invalid_type,
|
|
1392
1394
|
expected: f.null,
|
|
1393
1395
|
received: n.parsedType
|
|
1394
|
-
}),
|
|
1396
|
+
}), y;
|
|
1395
1397
|
}
|
|
1396
1398
|
return S(e.data);
|
|
1397
1399
|
}
|
|
1398
1400
|
}
|
|
1399
|
-
|
|
1400
|
-
typeName:
|
|
1401
|
+
xe.create = (r) => new xe({
|
|
1402
|
+
typeName: p.ZodNull,
|
|
1401
1403
|
...v(r)
|
|
1402
1404
|
});
|
|
1403
|
-
class
|
|
1405
|
+
class le extends g {
|
|
1404
1406
|
constructor() {
|
|
1405
1407
|
super(...arguments), this._any = !0;
|
|
1406
1408
|
}
|
|
@@ -1408,11 +1410,11 @@ class ae extends _ {
|
|
|
1408
1410
|
return S(e.data);
|
|
1409
1411
|
}
|
|
1410
1412
|
}
|
|
1411
|
-
|
|
1412
|
-
typeName:
|
|
1413
|
+
le.create = (r) => new le({
|
|
1414
|
+
typeName: p.ZodAny,
|
|
1413
1415
|
...v(r)
|
|
1414
1416
|
});
|
|
1415
|
-
class
|
|
1417
|
+
class X extends g {
|
|
1416
1418
|
constructor() {
|
|
1417
1419
|
super(...arguments), this._unknown = !0;
|
|
1418
1420
|
}
|
|
@@ -1420,25 +1422,25 @@ class J extends _ {
|
|
|
1420
1422
|
return S(e.data);
|
|
1421
1423
|
}
|
|
1422
1424
|
}
|
|
1423
|
-
|
|
1424
|
-
typeName:
|
|
1425
|
+
X.create = (r) => new X({
|
|
1426
|
+
typeName: p.ZodUnknown,
|
|
1425
1427
|
...v(r)
|
|
1426
1428
|
});
|
|
1427
|
-
class
|
|
1429
|
+
class V extends g {
|
|
1428
1430
|
_parse(e) {
|
|
1429
1431
|
const t = this._getOrReturnCtx(e);
|
|
1430
1432
|
return l(t, {
|
|
1431
1433
|
code: c.invalid_type,
|
|
1432
1434
|
expected: f.never,
|
|
1433
1435
|
received: t.parsedType
|
|
1434
|
-
}),
|
|
1436
|
+
}), y;
|
|
1435
1437
|
}
|
|
1436
1438
|
}
|
|
1437
|
-
|
|
1438
|
-
typeName:
|
|
1439
|
+
V.create = (r) => new V({
|
|
1440
|
+
typeName: p.ZodNever,
|
|
1439
1441
|
...v(r)
|
|
1440
1442
|
});
|
|
1441
|
-
class
|
|
1443
|
+
class Ve extends g {
|
|
1442
1444
|
_parse(e) {
|
|
1443
1445
|
if (this._getType(e) !== f.undefined) {
|
|
1444
1446
|
const n = this._getOrReturnCtx(e);
|
|
@@ -1446,16 +1448,16 @@ class Ae extends _ {
|
|
|
1446
1448
|
code: c.invalid_type,
|
|
1447
1449
|
expected: f.void,
|
|
1448
1450
|
received: n.parsedType
|
|
1449
|
-
}),
|
|
1451
|
+
}), y;
|
|
1450
1452
|
}
|
|
1451
1453
|
return S(e.data);
|
|
1452
1454
|
}
|
|
1453
1455
|
}
|
|
1454
|
-
|
|
1455
|
-
typeName:
|
|
1456
|
+
Ve.create = (r) => new Ve({
|
|
1457
|
+
typeName: p.ZodVoid,
|
|
1456
1458
|
...v(r)
|
|
1457
1459
|
});
|
|
1458
|
-
class
|
|
1460
|
+
class P extends g {
|
|
1459
1461
|
_parse(e) {
|
|
1460
1462
|
const { ctx: t, status: n } = this._processInputParams(e), s = this._def;
|
|
1461
1463
|
if (t.parsedType !== f.array)
|
|
@@ -1463,7 +1465,7 @@ class A extends _ {
|
|
|
1463
1465
|
code: c.invalid_type,
|
|
1464
1466
|
expected: f.array,
|
|
1465
1467
|
received: t.parsedType
|
|
1466
|
-
}),
|
|
1468
|
+
}), y;
|
|
1467
1469
|
if (s.exactLength !== null) {
|
|
1468
1470
|
const i = t.data.length > s.exactLength.value, o = t.data.length < s.exactLength.value;
|
|
1469
1471
|
(i || o) && (l(t, {
|
|
@@ -1491,27 +1493,27 @@ class A extends _ {
|
|
|
1491
1493
|
exact: !1,
|
|
1492
1494
|
message: s.maxLength.message
|
|
1493
1495
|
}), n.dirty()), t.common.async)
|
|
1494
|
-
return Promise.all([...t.data].map((i, o) => s.type._parseAsync(new
|
|
1495
|
-
const a = [...t.data].map((i, o) => s.type._parseSync(new
|
|
1496
|
+
return Promise.all([...t.data].map((i, o) => s.type._parseAsync(new U(t, i, t.path, o)))).then((i) => E.mergeArray(n, i));
|
|
1497
|
+
const a = [...t.data].map((i, o) => s.type._parseSync(new U(t, i, t.path, o)));
|
|
1496
1498
|
return E.mergeArray(n, a);
|
|
1497
1499
|
}
|
|
1498
1500
|
get element() {
|
|
1499
1501
|
return this._def.type;
|
|
1500
1502
|
}
|
|
1501
1503
|
min(e, t) {
|
|
1502
|
-
return new
|
|
1504
|
+
return new P({
|
|
1503
1505
|
...this._def,
|
|
1504
1506
|
minLength: { value: e, message: h.toString(t) }
|
|
1505
1507
|
});
|
|
1506
1508
|
}
|
|
1507
1509
|
max(e, t) {
|
|
1508
|
-
return new
|
|
1510
|
+
return new P({
|
|
1509
1511
|
...this._def,
|
|
1510
1512
|
maxLength: { value: e, message: h.toString(t) }
|
|
1511
1513
|
});
|
|
1512
1514
|
}
|
|
1513
1515
|
length(e, t) {
|
|
1514
|
-
return new
|
|
1516
|
+
return new P({
|
|
1515
1517
|
...this._def,
|
|
1516
1518
|
exactLength: { value: e, message: h.toString(t) }
|
|
1517
1519
|
});
|
|
@@ -1520,38 +1522,38 @@ class A extends _ {
|
|
|
1520
1522
|
return this.min(1, e);
|
|
1521
1523
|
}
|
|
1522
1524
|
}
|
|
1523
|
-
|
|
1525
|
+
P.create = (r, e) => new P({
|
|
1524
1526
|
type: r,
|
|
1525
1527
|
minLength: null,
|
|
1526
1528
|
maxLength: null,
|
|
1527
1529
|
exactLength: null,
|
|
1528
|
-
typeName:
|
|
1530
|
+
typeName: p.ZodArray,
|
|
1529
1531
|
...v(e)
|
|
1530
1532
|
});
|
|
1531
|
-
function
|
|
1532
|
-
if (r instanceof
|
|
1533
|
+
function oe(r) {
|
|
1534
|
+
if (r instanceof k) {
|
|
1533
1535
|
const e = {};
|
|
1534
1536
|
for (const t in r.shape) {
|
|
1535
1537
|
const n = r.shape[t];
|
|
1536
|
-
e[t] =
|
|
1538
|
+
e[t] = M.create(oe(n));
|
|
1537
1539
|
}
|
|
1538
|
-
return new
|
|
1540
|
+
return new k({
|
|
1539
1541
|
...r._def,
|
|
1540
1542
|
shape: () => e
|
|
1541
1543
|
});
|
|
1542
|
-
} else return r instanceof
|
|
1544
|
+
} else return r instanceof P ? new P({
|
|
1543
1545
|
...r._def,
|
|
1544
|
-
type:
|
|
1545
|
-
}) : r instanceof
|
|
1546
|
+
type: oe(r.element)
|
|
1547
|
+
}) : r instanceof M ? M.create(oe(r.unwrap())) : r instanceof J ? J.create(oe(r.unwrap())) : r instanceof L ? L.create(r.items.map((e) => oe(e))) : r;
|
|
1546
1548
|
}
|
|
1547
|
-
class
|
|
1549
|
+
class k extends g {
|
|
1548
1550
|
constructor() {
|
|
1549
1551
|
super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend;
|
|
1550
1552
|
}
|
|
1551
1553
|
_getCached() {
|
|
1552
1554
|
if (this._cached !== null)
|
|
1553
1555
|
return this._cached;
|
|
1554
|
-
const e = this._def.shape(), t =
|
|
1556
|
+
const e = this._def.shape(), t = _.objectKeys(e);
|
|
1555
1557
|
return this._cached = { shape: e, keys: t };
|
|
1556
1558
|
}
|
|
1557
1559
|
_parse(e) {
|
|
@@ -1561,28 +1563,28 @@ class b extends _ {
|
|
|
1561
1563
|
code: c.invalid_type,
|
|
1562
1564
|
expected: f.object,
|
|
1563
1565
|
received: d.parsedType
|
|
1564
|
-
}),
|
|
1566
|
+
}), y;
|
|
1565
1567
|
}
|
|
1566
1568
|
const { status: n, ctx: s } = this._processInputParams(e), { shape: a, keys: i } = this._getCached(), o = [];
|
|
1567
|
-
if (!(this._def.catchall instanceof
|
|
1569
|
+
if (!(this._def.catchall instanceof V && this._def.unknownKeys === "strip"))
|
|
1568
1570
|
for (const d in s.data)
|
|
1569
1571
|
i.includes(d) || o.push(d);
|
|
1570
1572
|
const u = [];
|
|
1571
1573
|
for (const d of i) {
|
|
1572
|
-
const
|
|
1574
|
+
const m = a[d], T = s.data[d];
|
|
1573
1575
|
u.push({
|
|
1574
1576
|
key: { status: "valid", value: d },
|
|
1575
|
-
value:
|
|
1577
|
+
value: m._parse(new U(s, T, s.path, d)),
|
|
1576
1578
|
alwaysSet: d in s.data
|
|
1577
1579
|
});
|
|
1578
1580
|
}
|
|
1579
|
-
if (this._def.catchall instanceof
|
|
1581
|
+
if (this._def.catchall instanceof V) {
|
|
1580
1582
|
const d = this._def.unknownKeys;
|
|
1581
1583
|
if (d === "passthrough")
|
|
1582
|
-
for (const
|
|
1584
|
+
for (const m of o)
|
|
1583
1585
|
u.push({
|
|
1584
|
-
key: { status: "valid", value:
|
|
1585
|
-
value: { status: "valid", value: s.data[
|
|
1586
|
+
key: { status: "valid", value: m },
|
|
1587
|
+
value: { status: "valid", value: s.data[m] }
|
|
1586
1588
|
});
|
|
1587
1589
|
else if (d === "strict")
|
|
1588
1590
|
o.length > 0 && (l(s, {
|
|
@@ -1592,26 +1594,26 @@ class b extends _ {
|
|
|
1592
1594
|
else if (d !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
|
|
1593
1595
|
} else {
|
|
1594
1596
|
const d = this._def.catchall;
|
|
1595
|
-
for (const
|
|
1596
|
-
const
|
|
1597
|
+
for (const m of o) {
|
|
1598
|
+
const T = s.data[m];
|
|
1597
1599
|
u.push({
|
|
1598
|
-
key: { status: "valid", value:
|
|
1600
|
+
key: { status: "valid", value: m },
|
|
1599
1601
|
value: d._parse(
|
|
1600
|
-
new
|
|
1602
|
+
new U(s, T, s.path, m)
|
|
1601
1603
|
//, ctx.child(key), value, getParsedType(value)
|
|
1602
1604
|
),
|
|
1603
|
-
alwaysSet:
|
|
1605
|
+
alwaysSet: m in s.data
|
|
1604
1606
|
});
|
|
1605
1607
|
}
|
|
1606
1608
|
}
|
|
1607
1609
|
return s.common.async ? Promise.resolve().then(async () => {
|
|
1608
1610
|
const d = [];
|
|
1609
|
-
for (const
|
|
1610
|
-
const
|
|
1611
|
+
for (const m of u) {
|
|
1612
|
+
const T = await m.key, z = await m.value;
|
|
1611
1613
|
d.push({
|
|
1612
|
-
key:
|
|
1613
|
-
value:
|
|
1614
|
-
alwaysSet:
|
|
1614
|
+
key: T,
|
|
1615
|
+
value: z,
|
|
1616
|
+
alwaysSet: m.alwaysSet
|
|
1615
1617
|
});
|
|
1616
1618
|
}
|
|
1617
1619
|
return d;
|
|
@@ -1621,7 +1623,7 @@ class b extends _ {
|
|
|
1621
1623
|
return this._def.shape();
|
|
1622
1624
|
}
|
|
1623
1625
|
strict(e) {
|
|
1624
|
-
return h.errToObj, new
|
|
1626
|
+
return h.errToObj, new k({
|
|
1625
1627
|
...this._def,
|
|
1626
1628
|
unknownKeys: "strict",
|
|
1627
1629
|
...e !== void 0 ? {
|
|
@@ -1638,13 +1640,13 @@ class b extends _ {
|
|
|
1638
1640
|
});
|
|
1639
1641
|
}
|
|
1640
1642
|
strip() {
|
|
1641
|
-
return new
|
|
1643
|
+
return new k({
|
|
1642
1644
|
...this._def,
|
|
1643
1645
|
unknownKeys: "strip"
|
|
1644
1646
|
});
|
|
1645
1647
|
}
|
|
1646
1648
|
passthrough() {
|
|
1647
|
-
return new
|
|
1649
|
+
return new k({
|
|
1648
1650
|
...this._def,
|
|
1649
1651
|
unknownKeys: "passthrough"
|
|
1650
1652
|
});
|
|
@@ -1667,7 +1669,7 @@ class b extends _ {
|
|
|
1667
1669
|
// }) as any;
|
|
1668
1670
|
// };
|
|
1669
1671
|
extend(e) {
|
|
1670
|
-
return new
|
|
1672
|
+
return new k({
|
|
1671
1673
|
...this._def,
|
|
1672
1674
|
shape: () => ({
|
|
1673
1675
|
...this._def.shape(),
|
|
@@ -1681,14 +1683,14 @@ class b extends _ {
|
|
|
1681
1683
|
* upgrade if you are experiencing issues.
|
|
1682
1684
|
*/
|
|
1683
1685
|
merge(e) {
|
|
1684
|
-
return new
|
|
1686
|
+
return new k({
|
|
1685
1687
|
unknownKeys: e._def.unknownKeys,
|
|
1686
1688
|
catchall: e._def.catchall,
|
|
1687
1689
|
shape: () => ({
|
|
1688
1690
|
...this._def.shape(),
|
|
1689
1691
|
...e._def.shape()
|
|
1690
1692
|
}),
|
|
1691
|
-
typeName:
|
|
1693
|
+
typeName: p.ZodObject
|
|
1692
1694
|
});
|
|
1693
1695
|
}
|
|
1694
1696
|
// merge<
|
|
@@ -1751,25 +1753,25 @@ class b extends _ {
|
|
|
1751
1753
|
// return merged;
|
|
1752
1754
|
// }
|
|
1753
1755
|
catchall(e) {
|
|
1754
|
-
return new
|
|
1756
|
+
return new k({
|
|
1755
1757
|
...this._def,
|
|
1756
1758
|
catchall: e
|
|
1757
1759
|
});
|
|
1758
1760
|
}
|
|
1759
1761
|
pick(e) {
|
|
1760
1762
|
const t = {};
|
|
1761
|
-
return
|
|
1763
|
+
return _.objectKeys(e).forEach((n) => {
|
|
1762
1764
|
e[n] && this.shape[n] && (t[n] = this.shape[n]);
|
|
1763
|
-
}), new
|
|
1765
|
+
}), new k({
|
|
1764
1766
|
...this._def,
|
|
1765
1767
|
shape: () => t
|
|
1766
1768
|
});
|
|
1767
1769
|
}
|
|
1768
1770
|
omit(e) {
|
|
1769
1771
|
const t = {};
|
|
1770
|
-
return
|
|
1772
|
+
return _.objectKeys(this.shape).forEach((n) => {
|
|
1771
1773
|
e[n] || (t[n] = this.shape[n]);
|
|
1772
|
-
}), new
|
|
1774
|
+
}), new k({
|
|
1773
1775
|
...this._def,
|
|
1774
1776
|
shape: () => t
|
|
1775
1777
|
});
|
|
@@ -1778,60 +1780,60 @@ class b extends _ {
|
|
|
1778
1780
|
* @deprecated
|
|
1779
1781
|
*/
|
|
1780
1782
|
deepPartial() {
|
|
1781
|
-
return
|
|
1783
|
+
return oe(this);
|
|
1782
1784
|
}
|
|
1783
1785
|
partial(e) {
|
|
1784
1786
|
const t = {};
|
|
1785
|
-
return
|
|
1787
|
+
return _.objectKeys(this.shape).forEach((n) => {
|
|
1786
1788
|
const s = this.shape[n];
|
|
1787
1789
|
e && !e[n] ? t[n] = s : t[n] = s.optional();
|
|
1788
|
-
}), new
|
|
1790
|
+
}), new k({
|
|
1789
1791
|
...this._def,
|
|
1790
1792
|
shape: () => t
|
|
1791
1793
|
});
|
|
1792
1794
|
}
|
|
1793
1795
|
required(e) {
|
|
1794
1796
|
const t = {};
|
|
1795
|
-
return
|
|
1797
|
+
return _.objectKeys(this.shape).forEach((n) => {
|
|
1796
1798
|
if (e && !e[n])
|
|
1797
1799
|
t[n] = this.shape[n];
|
|
1798
1800
|
else {
|
|
1799
1801
|
let a = this.shape[n];
|
|
1800
|
-
for (; a instanceof
|
|
1802
|
+
for (; a instanceof M; )
|
|
1801
1803
|
a = a._def.innerType;
|
|
1802
1804
|
t[n] = a;
|
|
1803
1805
|
}
|
|
1804
|
-
}), new
|
|
1806
|
+
}), new k({
|
|
1805
1807
|
...this._def,
|
|
1806
1808
|
shape: () => t
|
|
1807
1809
|
});
|
|
1808
1810
|
}
|
|
1809
1811
|
keyof() {
|
|
1810
|
-
return
|
|
1812
|
+
return St(_.objectKeys(this.shape));
|
|
1811
1813
|
}
|
|
1812
1814
|
}
|
|
1813
|
-
|
|
1815
|
+
k.create = (r, e) => new k({
|
|
1814
1816
|
shape: () => r,
|
|
1815
1817
|
unknownKeys: "strip",
|
|
1816
|
-
catchall:
|
|
1817
|
-
typeName:
|
|
1818
|
+
catchall: V.create(),
|
|
1819
|
+
typeName: p.ZodObject,
|
|
1818
1820
|
...v(e)
|
|
1819
1821
|
});
|
|
1820
|
-
|
|
1822
|
+
k.strictCreate = (r, e) => new k({
|
|
1821
1823
|
shape: () => r,
|
|
1822
1824
|
unknownKeys: "strict",
|
|
1823
|
-
catchall:
|
|
1824
|
-
typeName:
|
|
1825
|
+
catchall: V.create(),
|
|
1826
|
+
typeName: p.ZodObject,
|
|
1825
1827
|
...v(e)
|
|
1826
1828
|
});
|
|
1827
|
-
|
|
1829
|
+
k.lazycreate = (r, e) => new k({
|
|
1828
1830
|
shape: r,
|
|
1829
1831
|
unknownKeys: "strip",
|
|
1830
|
-
catchall:
|
|
1831
|
-
typeName:
|
|
1832
|
+
catchall: V.create(),
|
|
1833
|
+
typeName: p.ZodObject,
|
|
1832
1834
|
...v(e)
|
|
1833
1835
|
});
|
|
1834
|
-
class
|
|
1836
|
+
class ke extends g {
|
|
1835
1837
|
_parse(e) {
|
|
1836
1838
|
const { ctx: t } = this._processInputParams(e), n = this._def.options;
|
|
1837
1839
|
function s(a) {
|
|
@@ -1841,11 +1843,11 @@ class me extends _ {
|
|
|
1841
1843
|
for (const o of a)
|
|
1842
1844
|
if (o.result.status === "dirty")
|
|
1843
1845
|
return t.common.issues.push(...o.ctx.common.issues), o.result;
|
|
1844
|
-
const i = a.map((o) => new
|
|
1846
|
+
const i = a.map((o) => new I(o.ctx.common.issues));
|
|
1845
1847
|
return l(t, {
|
|
1846
1848
|
code: c.invalid_union,
|
|
1847
1849
|
unionErrors: i
|
|
1848
|
-
}),
|
|
1850
|
+
}), y;
|
|
1849
1851
|
}
|
|
1850
1852
|
if (t.common.async)
|
|
1851
1853
|
return Promise.all(n.map(async (a) => {
|
|
@@ -1877,35 +1879,35 @@ class me extends _ {
|
|
|
1877
1879
|
issues: []
|
|
1878
1880
|
},
|
|
1879
1881
|
parent: null
|
|
1880
|
-
},
|
|
1882
|
+
}, m = u._parseSync({
|
|
1881
1883
|
data: t.data,
|
|
1882
1884
|
path: t.path,
|
|
1883
1885
|
parent: d
|
|
1884
1886
|
});
|
|
1885
|
-
if (
|
|
1886
|
-
return
|
|
1887
|
-
|
|
1887
|
+
if (m.status === "valid")
|
|
1888
|
+
return m;
|
|
1889
|
+
m.status === "dirty" && !a && (a = { result: m, ctx: d }), d.common.issues.length && i.push(d.common.issues);
|
|
1888
1890
|
}
|
|
1889
1891
|
if (a)
|
|
1890
1892
|
return t.common.issues.push(...a.ctx.common.issues), a.result;
|
|
1891
|
-
const o = i.map((u) => new
|
|
1893
|
+
const o = i.map((u) => new I(u));
|
|
1892
1894
|
return l(t, {
|
|
1893
1895
|
code: c.invalid_union,
|
|
1894
1896
|
unionErrors: o
|
|
1895
|
-
}),
|
|
1897
|
+
}), y;
|
|
1896
1898
|
}
|
|
1897
1899
|
}
|
|
1898
1900
|
get options() {
|
|
1899
1901
|
return this._def.options;
|
|
1900
1902
|
}
|
|
1901
1903
|
}
|
|
1902
|
-
|
|
1904
|
+
ke.create = (r, e) => new ke({
|
|
1903
1905
|
options: r,
|
|
1904
|
-
typeName:
|
|
1906
|
+
typeName: p.ZodUnion,
|
|
1905
1907
|
...v(e)
|
|
1906
1908
|
});
|
|
1907
|
-
const
|
|
1908
|
-
class
|
|
1909
|
+
const $ = (r) => r instanceof we ? $(r.schema) : r instanceof D ? $(r.innerType()) : r instanceof Ee ? [r.value] : r instanceof Y ? r.options : r instanceof Ce ? _.objectValues(r.enum) : r instanceof Se ? $(r._def.innerType) : r instanceof _e ? [void 0] : r instanceof xe ? [null] : r instanceof M ? [void 0, ...$(r.unwrap())] : r instanceof J ? [null, ...$(r.unwrap())] : r instanceof at || r instanceof Re ? $(r.unwrap()) : r instanceof Oe ? $(r._def.innerType) : [];
|
|
1910
|
+
class He extends g {
|
|
1909
1911
|
_parse(e) {
|
|
1910
1912
|
const { ctx: t } = this._processInputParams(e);
|
|
1911
1913
|
if (t.parsedType !== f.object)
|
|
@@ -1913,7 +1915,7 @@ class Pe extends _ {
|
|
|
1913
1915
|
code: c.invalid_type,
|
|
1914
1916
|
expected: f.object,
|
|
1915
1917
|
received: t.parsedType
|
|
1916
|
-
}),
|
|
1918
|
+
}), y;
|
|
1917
1919
|
const n = this.discriminator, s = t.data[n], a = this.optionsMap.get(s);
|
|
1918
1920
|
return a ? t.common.async ? a._parseAsync({
|
|
1919
1921
|
data: t.data,
|
|
@@ -1927,7 +1929,7 @@ class Pe extends _ {
|
|
|
1927
1929
|
code: c.invalid_union_discriminator,
|
|
1928
1930
|
options: Array.from(this.optionsMap.keys()),
|
|
1929
1931
|
path: [n]
|
|
1930
|
-
}),
|
|
1932
|
+
}), y);
|
|
1931
1933
|
}
|
|
1932
1934
|
get discriminator() {
|
|
1933
1935
|
return this._def.discriminator;
|
|
@@ -1949,7 +1951,7 @@ class Pe extends _ {
|
|
|
1949
1951
|
static create(e, t, n) {
|
|
1950
1952
|
const s = /* @__PURE__ */ new Map();
|
|
1951
1953
|
for (const a of t) {
|
|
1952
|
-
const i =
|
|
1954
|
+
const i = $(a.shape[e]);
|
|
1953
1955
|
if (!i.length)
|
|
1954
1956
|
throw new Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`);
|
|
1955
1957
|
for (const o of i) {
|
|
@@ -1958,8 +1960,8 @@ class Pe extends _ {
|
|
|
1958
1960
|
s.set(o, a);
|
|
1959
1961
|
}
|
|
1960
1962
|
}
|
|
1961
|
-
return new
|
|
1962
|
-
typeName:
|
|
1963
|
+
return new He({
|
|
1964
|
+
typeName: p.ZodDiscriminatedUnion,
|
|
1963
1965
|
discriminator: e,
|
|
1964
1966
|
options: t,
|
|
1965
1967
|
optionsMap: s,
|
|
@@ -1967,14 +1969,14 @@ class Pe extends _ {
|
|
|
1967
1969
|
});
|
|
1968
1970
|
}
|
|
1969
1971
|
}
|
|
1970
|
-
function
|
|
1972
|
+
function nt(r, e) {
|
|
1971
1973
|
const t = H(r), n = H(e);
|
|
1972
1974
|
if (r === e)
|
|
1973
1975
|
return { valid: !0, data: r };
|
|
1974
1976
|
if (t === f.object && n === f.object) {
|
|
1975
|
-
const s =
|
|
1977
|
+
const s = _.objectKeys(e), a = _.objectKeys(r).filter((o) => s.indexOf(o) !== -1), i = { ...r, ...e };
|
|
1976
1978
|
for (const o of a) {
|
|
1977
|
-
const u =
|
|
1979
|
+
const u = nt(r[o], e[o]);
|
|
1978
1980
|
if (!u.valid)
|
|
1979
1981
|
return { valid: !1 };
|
|
1980
1982
|
i[o] = u.data;
|
|
@@ -1985,7 +1987,7 @@ function Ye(r, e) {
|
|
|
1985
1987
|
return { valid: !1 };
|
|
1986
1988
|
const s = [];
|
|
1987
1989
|
for (let a = 0; a < r.length; a++) {
|
|
1988
|
-
const i = r[a], o = e[a], u =
|
|
1990
|
+
const i = r[a], o = e[a], u = nt(i, o);
|
|
1989
1991
|
if (!u.valid)
|
|
1990
1992
|
return { valid: !1 };
|
|
1991
1993
|
s.push(u.data);
|
|
@@ -1993,15 +1995,15 @@ function Ye(r, e) {
|
|
|
1993
1995
|
return { valid: !0, data: s };
|
|
1994
1996
|
} else return t === f.date && n === f.date && +r == +e ? { valid: !0, data: r } : { valid: !1 };
|
|
1995
1997
|
}
|
|
1996
|
-
class
|
|
1998
|
+
class be extends g {
|
|
1997
1999
|
_parse(e) {
|
|
1998
2000
|
const { status: t, ctx: n } = this._processInputParams(e), s = (a, i) => {
|
|
1999
|
-
if (
|
|
2000
|
-
return
|
|
2001
|
-
const o =
|
|
2002
|
-
return o.valid ? ((
|
|
2001
|
+
if (tt(a) || tt(i))
|
|
2002
|
+
return y;
|
|
2003
|
+
const o = nt(a.value, i.value);
|
|
2004
|
+
return o.valid ? ((rt(a) || rt(i)) && t.dirty(), { status: t.value, value: o.data }) : (l(n, {
|
|
2003
2005
|
code: c.invalid_intersection_types
|
|
2004
|
-
}),
|
|
2006
|
+
}), y);
|
|
2005
2007
|
};
|
|
2006
2008
|
return n.common.async ? Promise.all([
|
|
2007
2009
|
this._def.left._parseAsync({
|
|
@@ -2025,13 +2027,13 @@ class ye extends _ {
|
|
|
2025
2027
|
}));
|
|
2026
2028
|
}
|
|
2027
2029
|
}
|
|
2028
|
-
|
|
2030
|
+
be.create = (r, e, t) => new be({
|
|
2029
2031
|
left: r,
|
|
2030
2032
|
right: e,
|
|
2031
|
-
typeName:
|
|
2033
|
+
typeName: p.ZodIntersection,
|
|
2032
2034
|
...v(t)
|
|
2033
2035
|
});
|
|
2034
|
-
class
|
|
2036
|
+
class L extends g {
|
|
2035
2037
|
_parse(e) {
|
|
2036
2038
|
const { status: t, ctx: n } = this._processInputParams(e);
|
|
2037
2039
|
if (n.parsedType !== f.array)
|
|
@@ -2039,7 +2041,7 @@ class D extends _ {
|
|
|
2039
2041
|
code: c.invalid_type,
|
|
2040
2042
|
expected: f.array,
|
|
2041
2043
|
received: n.parsedType
|
|
2042
|
-
}),
|
|
2044
|
+
}), y;
|
|
2043
2045
|
if (n.data.length < this._def.items.length)
|
|
2044
2046
|
return l(n, {
|
|
2045
2047
|
code: c.too_small,
|
|
@@ -2047,7 +2049,7 @@ class D extends _ {
|
|
|
2047
2049
|
inclusive: !0,
|
|
2048
2050
|
exact: !1,
|
|
2049
2051
|
type: "array"
|
|
2050
|
-
}),
|
|
2052
|
+
}), y;
|
|
2051
2053
|
!this._def.rest && n.data.length > this._def.items.length && (l(n, {
|
|
2052
2054
|
code: c.too_big,
|
|
2053
2055
|
maximum: this._def.items.length,
|
|
@@ -2057,7 +2059,7 @@ class D extends _ {
|
|
|
2057
2059
|
}), t.dirty());
|
|
2058
2060
|
const a = [...n.data].map((i, o) => {
|
|
2059
2061
|
const u = this._def.items[o] || this._def.rest;
|
|
2060
|
-
return u ? u._parse(new
|
|
2062
|
+
return u ? u._parse(new U(n, i, n.path, o)) : null;
|
|
2061
2063
|
}).filter((i) => !!i);
|
|
2062
2064
|
return n.common.async ? Promise.all(a).then((i) => E.mergeArray(t, i)) : E.mergeArray(t, a);
|
|
2063
2065
|
}
|
|
@@ -2065,23 +2067,23 @@ class D extends _ {
|
|
|
2065
2067
|
return this._def.items;
|
|
2066
2068
|
}
|
|
2067
2069
|
rest(e) {
|
|
2068
|
-
return new
|
|
2070
|
+
return new L({
|
|
2069
2071
|
...this._def,
|
|
2070
2072
|
rest: e
|
|
2071
2073
|
});
|
|
2072
2074
|
}
|
|
2073
2075
|
}
|
|
2074
|
-
|
|
2076
|
+
L.create = (r, e) => {
|
|
2075
2077
|
if (!Array.isArray(r))
|
|
2076
2078
|
throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
|
|
2077
|
-
return new
|
|
2079
|
+
return new L({
|
|
2078
2080
|
items: r,
|
|
2079
|
-
typeName:
|
|
2081
|
+
typeName: p.ZodTuple,
|
|
2080
2082
|
rest: null,
|
|
2081
2083
|
...v(e)
|
|
2082
2084
|
});
|
|
2083
2085
|
};
|
|
2084
|
-
class
|
|
2086
|
+
class Te extends g {
|
|
2085
2087
|
get keySchema() {
|
|
2086
2088
|
return this._def.keyType;
|
|
2087
2089
|
}
|
|
@@ -2095,12 +2097,12 @@ class ge extends _ {
|
|
|
2095
2097
|
code: c.invalid_type,
|
|
2096
2098
|
expected: f.object,
|
|
2097
2099
|
received: n.parsedType
|
|
2098
|
-
}),
|
|
2100
|
+
}), y;
|
|
2099
2101
|
const s = [], a = this._def.keyType, i = this._def.valueType;
|
|
2100
2102
|
for (const o in n.data)
|
|
2101
2103
|
s.push({
|
|
2102
|
-
key: a._parse(new
|
|
2103
|
-
value: i._parse(new
|
|
2104
|
+
key: a._parse(new U(n, o, n.path, o)),
|
|
2105
|
+
value: i._parse(new U(n, n.data[o], n.path, o)),
|
|
2104
2106
|
alwaysSet: o in n.data
|
|
2105
2107
|
});
|
|
2106
2108
|
return n.common.async ? E.mergeObjectAsync(t, s) : E.mergeObjectSync(t, s);
|
|
@@ -2109,20 +2111,20 @@ class ge extends _ {
|
|
|
2109
2111
|
return this._def.valueType;
|
|
2110
2112
|
}
|
|
2111
2113
|
static create(e, t, n) {
|
|
2112
|
-
return t instanceof
|
|
2114
|
+
return t instanceof g ? new Te({
|
|
2113
2115
|
keyType: e,
|
|
2114
2116
|
valueType: t,
|
|
2115
|
-
typeName:
|
|
2117
|
+
typeName: p.ZodRecord,
|
|
2116
2118
|
...v(n)
|
|
2117
|
-
}) : new
|
|
2118
|
-
keyType:
|
|
2119
|
+
}) : new Te({
|
|
2120
|
+
keyType: j.create(),
|
|
2119
2121
|
valueType: e,
|
|
2120
|
-
typeName:
|
|
2122
|
+
typeName: p.ZodRecord,
|
|
2121
2123
|
...v(t)
|
|
2122
2124
|
});
|
|
2123
2125
|
}
|
|
2124
2126
|
}
|
|
2125
|
-
class
|
|
2127
|
+
class ze extends g {
|
|
2126
2128
|
get keySchema() {
|
|
2127
2129
|
return this._def.keyType;
|
|
2128
2130
|
}
|
|
@@ -2136,41 +2138,41 @@ class je extends _ {
|
|
|
2136
2138
|
code: c.invalid_type,
|
|
2137
2139
|
expected: f.map,
|
|
2138
2140
|
received: n.parsedType
|
|
2139
|
-
}),
|
|
2141
|
+
}), y;
|
|
2140
2142
|
const s = this._def.keyType, a = this._def.valueType, i = [...n.data.entries()].map(([o, u], d) => ({
|
|
2141
|
-
key: s._parse(new
|
|
2142
|
-
value: a._parse(new
|
|
2143
|
+
key: s._parse(new U(n, o, n.path, [d, "key"])),
|
|
2144
|
+
value: a._parse(new U(n, u, n.path, [d, "value"]))
|
|
2143
2145
|
}));
|
|
2144
2146
|
if (n.common.async) {
|
|
2145
2147
|
const o = /* @__PURE__ */ new Map();
|
|
2146
2148
|
return Promise.resolve().then(async () => {
|
|
2147
2149
|
for (const u of i) {
|
|
2148
|
-
const d = await u.key,
|
|
2149
|
-
if (d.status === "aborted" ||
|
|
2150
|
-
return
|
|
2151
|
-
(d.status === "dirty" ||
|
|
2150
|
+
const d = await u.key, m = await u.value;
|
|
2151
|
+
if (d.status === "aborted" || m.status === "aborted")
|
|
2152
|
+
return y;
|
|
2153
|
+
(d.status === "dirty" || m.status === "dirty") && t.dirty(), o.set(d.value, m.value);
|
|
2152
2154
|
}
|
|
2153
2155
|
return { status: t.value, value: o };
|
|
2154
2156
|
});
|
|
2155
2157
|
} else {
|
|
2156
2158
|
const o = /* @__PURE__ */ new Map();
|
|
2157
2159
|
for (const u of i) {
|
|
2158
|
-
const d = u.key,
|
|
2159
|
-
if (d.status === "aborted" ||
|
|
2160
|
-
return
|
|
2161
|
-
(d.status === "dirty" ||
|
|
2160
|
+
const d = u.key, m = u.value;
|
|
2161
|
+
if (d.status === "aborted" || m.status === "aborted")
|
|
2162
|
+
return y;
|
|
2163
|
+
(d.status === "dirty" || m.status === "dirty") && t.dirty(), o.set(d.value, m.value);
|
|
2162
2164
|
}
|
|
2163
2165
|
return { status: t.value, value: o };
|
|
2164
2166
|
}
|
|
2165
2167
|
}
|
|
2166
2168
|
}
|
|
2167
|
-
|
|
2169
|
+
ze.create = (r, e, t) => new ze({
|
|
2168
2170
|
valueType: e,
|
|
2169
2171
|
keyType: r,
|
|
2170
|
-
typeName:
|
|
2172
|
+
typeName: p.ZodMap,
|
|
2171
2173
|
...v(t)
|
|
2172
2174
|
});
|
|
2173
|
-
class
|
|
2175
|
+
class ee extends g {
|
|
2174
2176
|
_parse(e) {
|
|
2175
2177
|
const { status: t, ctx: n } = this._processInputParams(e);
|
|
2176
2178
|
if (n.parsedType !== f.set)
|
|
@@ -2178,7 +2180,7 @@ class Q extends _ {
|
|
|
2178
2180
|
code: c.invalid_type,
|
|
2179
2181
|
expected: f.set,
|
|
2180
2182
|
received: n.parsedType
|
|
2181
|
-
}),
|
|
2183
|
+
}), y;
|
|
2182
2184
|
const s = this._def;
|
|
2183
2185
|
s.minSize !== null && n.data.size < s.minSize.value && (l(n, {
|
|
2184
2186
|
code: c.too_small,
|
|
@@ -2198,24 +2200,24 @@ class Q extends _ {
|
|
|
2198
2200
|
const a = this._def.valueType;
|
|
2199
2201
|
function i(u) {
|
|
2200
2202
|
const d = /* @__PURE__ */ new Set();
|
|
2201
|
-
for (const
|
|
2202
|
-
if (
|
|
2203
|
-
return
|
|
2204
|
-
|
|
2203
|
+
for (const m of u) {
|
|
2204
|
+
if (m.status === "aborted")
|
|
2205
|
+
return y;
|
|
2206
|
+
m.status === "dirty" && t.dirty(), d.add(m.value);
|
|
2205
2207
|
}
|
|
2206
2208
|
return { status: t.value, value: d };
|
|
2207
2209
|
}
|
|
2208
|
-
const o = [...n.data.values()].map((u, d) => a._parse(new
|
|
2210
|
+
const o = [...n.data.values()].map((u, d) => a._parse(new U(n, u, n.path, d)));
|
|
2209
2211
|
return n.common.async ? Promise.all(o).then((u) => i(u)) : i(o);
|
|
2210
2212
|
}
|
|
2211
2213
|
min(e, t) {
|
|
2212
|
-
return new
|
|
2214
|
+
return new ee({
|
|
2213
2215
|
...this._def,
|
|
2214
2216
|
minSize: { value: e, message: h.toString(t) }
|
|
2215
2217
|
});
|
|
2216
2218
|
}
|
|
2217
2219
|
max(e, t) {
|
|
2218
|
-
return new
|
|
2220
|
+
return new ee({
|
|
2219
2221
|
...this._def,
|
|
2220
2222
|
maxSize: { value: e, message: h.toString(t) }
|
|
2221
2223
|
});
|
|
@@ -2227,14 +2229,14 @@ class Q extends _ {
|
|
|
2227
2229
|
return this.min(1, e);
|
|
2228
2230
|
}
|
|
2229
2231
|
}
|
|
2230
|
-
|
|
2232
|
+
ee.create = (r, e) => new ee({
|
|
2231
2233
|
valueType: r,
|
|
2232
2234
|
minSize: null,
|
|
2233
2235
|
maxSize: null,
|
|
2234
|
-
typeName:
|
|
2236
|
+
typeName: p.ZodSet,
|
|
2235
2237
|
...v(e)
|
|
2236
2238
|
});
|
|
2237
|
-
class
|
|
2239
|
+
class de extends g {
|
|
2238
2240
|
constructor() {
|
|
2239
2241
|
super(...arguments), this.validate = this.implement;
|
|
2240
2242
|
}
|
|
@@ -2245,16 +2247,16 @@ class ne extends _ {
|
|
|
2245
2247
|
code: c.invalid_type,
|
|
2246
2248
|
expected: f.function,
|
|
2247
2249
|
received: t.parsedType
|
|
2248
|
-
}),
|
|
2250
|
+
}), y;
|
|
2249
2251
|
function n(o, u) {
|
|
2250
|
-
return
|
|
2252
|
+
return Ue({
|
|
2251
2253
|
data: o,
|
|
2252
2254
|
path: t.path,
|
|
2253
2255
|
errorMaps: [
|
|
2254
2256
|
t.common.contextualErrorMap,
|
|
2255
2257
|
t.schemaErrorMap,
|
|
2256
|
-
|
|
2257
|
-
|
|
2258
|
+
Me(),
|
|
2259
|
+
ue
|
|
2258
2260
|
].filter((d) => !!d),
|
|
2259
2261
|
issueData: {
|
|
2260
2262
|
code: c.invalid_arguments,
|
|
@@ -2263,14 +2265,14 @@ class ne extends _ {
|
|
|
2263
2265
|
});
|
|
2264
2266
|
}
|
|
2265
2267
|
function s(o, u) {
|
|
2266
|
-
return
|
|
2268
|
+
return Ue({
|
|
2267
2269
|
data: o,
|
|
2268
2270
|
path: t.path,
|
|
2269
2271
|
errorMaps: [
|
|
2270
2272
|
t.common.contextualErrorMap,
|
|
2271
2273
|
t.schemaErrorMap,
|
|
2272
|
-
|
|
2273
|
-
|
|
2274
|
+
Me(),
|
|
2275
|
+
ue
|
|
2274
2276
|
].filter((d) => !!d),
|
|
2275
2277
|
issueData: {
|
|
2276
2278
|
code: c.invalid_return_type,
|
|
@@ -2279,14 +2281,14 @@ class ne extends _ {
|
|
|
2279
2281
|
});
|
|
2280
2282
|
}
|
|
2281
2283
|
const a = { errorMap: t.common.contextualErrorMap }, i = t.data;
|
|
2282
|
-
if (this._def.returns instanceof
|
|
2284
|
+
if (this._def.returns instanceof fe) {
|
|
2283
2285
|
const o = this;
|
|
2284
2286
|
return S(async function(...u) {
|
|
2285
|
-
const d = new
|
|
2286
|
-
throw d.addIssue(n(u,
|
|
2287
|
-
}),
|
|
2288
|
-
return await o._def.returns._def.type.parseAsync(
|
|
2289
|
-
throw d.addIssue(s(
|
|
2287
|
+
const d = new I([]), m = await o._def.args.parseAsync(u, a).catch((G) => {
|
|
2288
|
+
throw d.addIssue(n(u, G)), d;
|
|
2289
|
+
}), T = await Reflect.apply(i, this, m);
|
|
2290
|
+
return await o._def.returns._def.type.parseAsync(T, a).catch((G) => {
|
|
2291
|
+
throw d.addIssue(s(T, G)), d;
|
|
2290
2292
|
});
|
|
2291
2293
|
});
|
|
2292
2294
|
} else {
|
|
@@ -2294,11 +2296,11 @@ class ne extends _ {
|
|
|
2294
2296
|
return S(function(...u) {
|
|
2295
2297
|
const d = o._def.args.safeParse(u, a);
|
|
2296
2298
|
if (!d.success)
|
|
2297
|
-
throw new
|
|
2298
|
-
const
|
|
2299
|
-
if (!
|
|
2300
|
-
throw new
|
|
2301
|
-
return
|
|
2299
|
+
throw new I([n(u, d.error)]);
|
|
2300
|
+
const m = Reflect.apply(i, this, d.data), T = o._def.returns.safeParse(m, a);
|
|
2301
|
+
if (!T.success)
|
|
2302
|
+
throw new I([s(m, T.error)]);
|
|
2303
|
+
return T.data;
|
|
2302
2304
|
});
|
|
2303
2305
|
}
|
|
2304
2306
|
}
|
|
@@ -2309,13 +2311,13 @@ class ne extends _ {
|
|
|
2309
2311
|
return this._def.returns;
|
|
2310
2312
|
}
|
|
2311
2313
|
args(...e) {
|
|
2312
|
-
return new
|
|
2314
|
+
return new de({
|
|
2313
2315
|
...this._def,
|
|
2314
|
-
args:
|
|
2316
|
+
args: L.create(e).rest(X.create())
|
|
2315
2317
|
});
|
|
2316
2318
|
}
|
|
2317
2319
|
returns(e) {
|
|
2318
|
-
return new
|
|
2320
|
+
return new de({
|
|
2319
2321
|
...this._def,
|
|
2320
2322
|
returns: e
|
|
2321
2323
|
});
|
|
@@ -2327,15 +2329,15 @@ class ne extends _ {
|
|
|
2327
2329
|
return this.parse(e);
|
|
2328
2330
|
}
|
|
2329
2331
|
static create(e, t, n) {
|
|
2330
|
-
return new
|
|
2331
|
-
args: e ||
|
|
2332
|
-
returns: t ||
|
|
2333
|
-
typeName:
|
|
2332
|
+
return new de({
|
|
2333
|
+
args: e || L.create([]).rest(X.create()),
|
|
2334
|
+
returns: t || X.create(),
|
|
2335
|
+
typeName: p.ZodFunction,
|
|
2334
2336
|
...v(n)
|
|
2335
2337
|
});
|
|
2336
2338
|
}
|
|
2337
2339
|
}
|
|
2338
|
-
class
|
|
2340
|
+
class we extends g {
|
|
2339
2341
|
get schema() {
|
|
2340
2342
|
return this._def.getter();
|
|
2341
2343
|
}
|
|
@@ -2344,12 +2346,12 @@ class ve extends _ {
|
|
|
2344
2346
|
return this._def.getter()._parse({ data: t.data, path: t.path, parent: t });
|
|
2345
2347
|
}
|
|
2346
2348
|
}
|
|
2347
|
-
|
|
2349
|
+
we.create = (r, e) => new we({
|
|
2348
2350
|
getter: r,
|
|
2349
|
-
typeName:
|
|
2351
|
+
typeName: p.ZodLazy,
|
|
2350
2352
|
...v(e)
|
|
2351
2353
|
});
|
|
2352
|
-
class
|
|
2354
|
+
class Ee extends g {
|
|
2353
2355
|
_parse(e) {
|
|
2354
2356
|
if (e.data !== this._def.value) {
|
|
2355
2357
|
const t = this._getOrReturnCtx(e);
|
|
@@ -2357,7 +2359,7 @@ class _e extends _ {
|
|
|
2357
2359
|
received: t.data,
|
|
2358
2360
|
code: c.invalid_literal,
|
|
2359
2361
|
expected: this._def.value
|
|
2360
|
-
}),
|
|
2362
|
+
}), y;
|
|
2361
2363
|
}
|
|
2362
2364
|
return { status: "valid", value: e.data };
|
|
2363
2365
|
}
|
|
@@ -2365,38 +2367,38 @@ class _e extends _ {
|
|
|
2365
2367
|
return this._def.value;
|
|
2366
2368
|
}
|
|
2367
2369
|
}
|
|
2368
|
-
|
|
2370
|
+
Ee.create = (r, e) => new Ee({
|
|
2369
2371
|
value: r,
|
|
2370
|
-
typeName:
|
|
2372
|
+
typeName: p.ZodLiteral,
|
|
2371
2373
|
...v(e)
|
|
2372
2374
|
});
|
|
2373
|
-
function
|
|
2375
|
+
function St(r, e) {
|
|
2374
2376
|
return new Y({
|
|
2375
2377
|
values: r,
|
|
2376
|
-
typeName:
|
|
2378
|
+
typeName: p.ZodEnum,
|
|
2377
2379
|
...v(e)
|
|
2378
2380
|
});
|
|
2379
2381
|
}
|
|
2380
|
-
class Y extends
|
|
2382
|
+
class Y extends g {
|
|
2381
2383
|
constructor() {
|
|
2382
|
-
super(...arguments),
|
|
2384
|
+
super(...arguments), me.set(this, void 0);
|
|
2383
2385
|
}
|
|
2384
2386
|
_parse(e) {
|
|
2385
2387
|
if (typeof e.data != "string") {
|
|
2386
2388
|
const t = this._getOrReturnCtx(e), n = this._def.values;
|
|
2387
2389
|
return l(t, {
|
|
2388
|
-
expected:
|
|
2390
|
+
expected: _.joinValues(n),
|
|
2389
2391
|
received: t.parsedType,
|
|
2390
2392
|
code: c.invalid_type
|
|
2391
|
-
}),
|
|
2393
|
+
}), y;
|
|
2392
2394
|
}
|
|
2393
|
-
if (
|
|
2395
|
+
if (Le(this, me) || Tt(this, me, new Set(this._def.values)), !Le(this, me).has(e.data)) {
|
|
2394
2396
|
const t = this._getOrReturnCtx(e), n = this._def.values;
|
|
2395
2397
|
return l(t, {
|
|
2396
2398
|
received: t.data,
|
|
2397
2399
|
code: c.invalid_enum_value,
|
|
2398
2400
|
options: n
|
|
2399
|
-
}),
|
|
2401
|
+
}), y;
|
|
2400
2402
|
}
|
|
2401
2403
|
return S(e.data);
|
|
2402
2404
|
}
|
|
@@ -2434,29 +2436,29 @@ class Y extends _ {
|
|
|
2434
2436
|
});
|
|
2435
2437
|
}
|
|
2436
2438
|
}
|
|
2437
|
-
|
|
2438
|
-
Y.create =
|
|
2439
|
-
class
|
|
2439
|
+
me = /* @__PURE__ */ new WeakMap();
|
|
2440
|
+
Y.create = St;
|
|
2441
|
+
class Ce extends g {
|
|
2440
2442
|
constructor() {
|
|
2441
|
-
super(...arguments),
|
|
2443
|
+
super(...arguments), pe.set(this, void 0);
|
|
2442
2444
|
}
|
|
2443
2445
|
_parse(e) {
|
|
2444
|
-
const t =
|
|
2446
|
+
const t = _.getValidEnumValues(this._def.values), n = this._getOrReturnCtx(e);
|
|
2445
2447
|
if (n.parsedType !== f.string && n.parsedType !== f.number) {
|
|
2446
|
-
const s =
|
|
2448
|
+
const s = _.objectValues(t);
|
|
2447
2449
|
return l(n, {
|
|
2448
|
-
expected:
|
|
2450
|
+
expected: _.joinValues(s),
|
|
2449
2451
|
received: n.parsedType,
|
|
2450
2452
|
code: c.invalid_type
|
|
2451
|
-
}),
|
|
2453
|
+
}), y;
|
|
2452
2454
|
}
|
|
2453
|
-
if (
|
|
2454
|
-
const s =
|
|
2455
|
+
if (Le(this, pe) || Tt(this, pe, new Set(_.getValidEnumValues(this._def.values))), !Le(this, pe).has(e.data)) {
|
|
2456
|
+
const s = _.objectValues(t);
|
|
2455
2457
|
return l(n, {
|
|
2456
2458
|
received: n.data,
|
|
2457
2459
|
code: c.invalid_enum_value,
|
|
2458
2460
|
options: s
|
|
2459
|
-
}),
|
|
2461
|
+
}), y;
|
|
2460
2462
|
}
|
|
2461
2463
|
return S(e.data);
|
|
2462
2464
|
}
|
|
@@ -2464,13 +2466,13 @@ class xe extends _ {
|
|
|
2464
2466
|
return this._def.values;
|
|
2465
2467
|
}
|
|
2466
2468
|
}
|
|
2467
|
-
|
|
2468
|
-
|
|
2469
|
+
pe = /* @__PURE__ */ new WeakMap();
|
|
2470
|
+
Ce.create = (r, e) => new Ce({
|
|
2469
2471
|
values: r,
|
|
2470
|
-
typeName:
|
|
2472
|
+
typeName: p.ZodNativeEnum,
|
|
2471
2473
|
...v(e)
|
|
2472
2474
|
});
|
|
2473
|
-
class
|
|
2475
|
+
class fe extends g {
|
|
2474
2476
|
unwrap() {
|
|
2475
2477
|
return this._def.type;
|
|
2476
2478
|
}
|
|
@@ -2481,7 +2483,7 @@ class ie extends _ {
|
|
|
2481
2483
|
code: c.invalid_type,
|
|
2482
2484
|
expected: f.promise,
|
|
2483
2485
|
received: t.parsedType
|
|
2484
|
-
}),
|
|
2486
|
+
}), y;
|
|
2485
2487
|
const n = t.parsedType === f.promise ? t.data : Promise.resolve(t.data);
|
|
2486
2488
|
return S(n.then((s) => this._def.type.parseAsync(s, {
|
|
2487
2489
|
path: t.path,
|
|
@@ -2489,17 +2491,17 @@ class ie extends _ {
|
|
|
2489
2491
|
})));
|
|
2490
2492
|
}
|
|
2491
2493
|
}
|
|
2492
|
-
|
|
2494
|
+
fe.create = (r, e) => new fe({
|
|
2493
2495
|
type: r,
|
|
2494
|
-
typeName:
|
|
2496
|
+
typeName: p.ZodPromise,
|
|
2495
2497
|
...v(e)
|
|
2496
2498
|
});
|
|
2497
|
-
class
|
|
2499
|
+
class D extends g {
|
|
2498
2500
|
innerType() {
|
|
2499
2501
|
return this._def.schema;
|
|
2500
2502
|
}
|
|
2501
2503
|
sourceType() {
|
|
2502
|
-
return this._def.schema._def.typeName ===
|
|
2504
|
+
return this._def.schema._def.typeName === p.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
|
|
2503
2505
|
}
|
|
2504
2506
|
_parse(e) {
|
|
2505
2507
|
const { status: t, ctx: n } = this._processInputParams(e), s = this._def.effect || null, a = {
|
|
@@ -2515,23 +2517,23 @@ class j extends _ {
|
|
|
2515
2517
|
if (n.common.async)
|
|
2516
2518
|
return Promise.resolve(i).then(async (o) => {
|
|
2517
2519
|
if (t.value === "aborted")
|
|
2518
|
-
return
|
|
2520
|
+
return y;
|
|
2519
2521
|
const u = await this._def.schema._parseAsync({
|
|
2520
2522
|
data: o,
|
|
2521
2523
|
path: n.path,
|
|
2522
2524
|
parent: n
|
|
2523
2525
|
});
|
|
2524
|
-
return u.status === "aborted" ?
|
|
2526
|
+
return u.status === "aborted" ? y : u.status === "dirty" || t.value === "dirty" ? ce(u.value) : u;
|
|
2525
2527
|
});
|
|
2526
2528
|
{
|
|
2527
2529
|
if (t.value === "aborted")
|
|
2528
|
-
return
|
|
2530
|
+
return y;
|
|
2529
2531
|
const o = this._def.schema._parseSync({
|
|
2530
2532
|
data: i,
|
|
2531
2533
|
path: n.path,
|
|
2532
2534
|
parent: n
|
|
2533
2535
|
});
|
|
2534
|
-
return o.status === "aborted" ?
|
|
2536
|
+
return o.status === "aborted" ? y : o.status === "dirty" || t.value === "dirty" ? ce(o.value) : o;
|
|
2535
2537
|
}
|
|
2536
2538
|
}
|
|
2537
2539
|
if (s.type === "refinement") {
|
|
@@ -2549,9 +2551,9 @@ class j extends _ {
|
|
|
2549
2551
|
path: n.path,
|
|
2550
2552
|
parent: n
|
|
2551
2553
|
});
|
|
2552
|
-
return o.status === "aborted" ?
|
|
2554
|
+
return o.status === "aborted" ? y : (o.status === "dirty" && t.dirty(), i(o.value), { status: t.value, value: o.value });
|
|
2553
2555
|
} else
|
|
2554
|
-
return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((o) => o.status === "aborted" ?
|
|
2556
|
+
return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((o) => o.status === "aborted" ? y : (o.status === "dirty" && t.dirty(), i(o.value).then(() => ({ status: t.value, value: o.value }))));
|
|
2555
2557
|
}
|
|
2556
2558
|
if (s.type === "transform")
|
|
2557
2559
|
if (n.common.async === !1) {
|
|
@@ -2560,30 +2562,30 @@ class j extends _ {
|
|
|
2560
2562
|
path: n.path,
|
|
2561
2563
|
parent: n
|
|
2562
2564
|
});
|
|
2563
|
-
if (!
|
|
2565
|
+
if (!ye(i))
|
|
2564
2566
|
return i;
|
|
2565
2567
|
const o = s.transform(i.value, a);
|
|
2566
2568
|
if (o instanceof Promise)
|
|
2567
2569
|
throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
|
|
2568
2570
|
return { status: t.value, value: o };
|
|
2569
2571
|
} else
|
|
2570
|
-
return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((i) =>
|
|
2571
|
-
|
|
2572
|
+
return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((i) => ye(i) ? Promise.resolve(s.transform(i.value, a)).then((o) => ({ status: t.value, value: o })) : i);
|
|
2573
|
+
_.assertNever(s);
|
|
2572
2574
|
}
|
|
2573
2575
|
}
|
|
2574
|
-
|
|
2576
|
+
D.create = (r, e, t) => new D({
|
|
2575
2577
|
schema: r,
|
|
2576
|
-
typeName:
|
|
2578
|
+
typeName: p.ZodEffects,
|
|
2577
2579
|
effect: e,
|
|
2578
2580
|
...v(t)
|
|
2579
2581
|
});
|
|
2580
|
-
|
|
2582
|
+
D.createWithPreprocess = (r, e, t) => new D({
|
|
2581
2583
|
schema: e,
|
|
2582
2584
|
effect: { type: "preprocess", transform: r },
|
|
2583
|
-
typeName:
|
|
2585
|
+
typeName: p.ZodEffects,
|
|
2584
2586
|
...v(t)
|
|
2585
2587
|
});
|
|
2586
|
-
class
|
|
2588
|
+
class M extends g {
|
|
2587
2589
|
_parse(e) {
|
|
2588
2590
|
return this._getType(e) === f.undefined ? S(void 0) : this._def.innerType._parse(e);
|
|
2589
2591
|
}
|
|
@@ -2591,12 +2593,12 @@ class $ extends _ {
|
|
|
2591
2593
|
return this._def.innerType;
|
|
2592
2594
|
}
|
|
2593
2595
|
}
|
|
2594
|
-
|
|
2596
|
+
M.create = (r, e) => new M({
|
|
2595
2597
|
innerType: r,
|
|
2596
|
-
typeName:
|
|
2598
|
+
typeName: p.ZodOptional,
|
|
2597
2599
|
...v(e)
|
|
2598
2600
|
});
|
|
2599
|
-
class
|
|
2601
|
+
class J extends g {
|
|
2600
2602
|
_parse(e) {
|
|
2601
2603
|
return this._getType(e) === f.null ? S(null) : this._def.innerType._parse(e);
|
|
2602
2604
|
}
|
|
@@ -2604,12 +2606,12 @@ class G extends _ {
|
|
|
2604
2606
|
return this._def.innerType;
|
|
2605
2607
|
}
|
|
2606
2608
|
}
|
|
2607
|
-
|
|
2609
|
+
J.create = (r, e) => new J({
|
|
2608
2610
|
innerType: r,
|
|
2609
|
-
typeName:
|
|
2611
|
+
typeName: p.ZodNullable,
|
|
2610
2612
|
...v(e)
|
|
2611
2613
|
});
|
|
2612
|
-
class
|
|
2614
|
+
class Se extends g {
|
|
2613
2615
|
_parse(e) {
|
|
2614
2616
|
const { ctx: t } = this._processInputParams(e);
|
|
2615
2617
|
let n = t.data;
|
|
@@ -2623,13 +2625,13 @@ class ke extends _ {
|
|
|
2623
2625
|
return this._def.innerType;
|
|
2624
2626
|
}
|
|
2625
2627
|
}
|
|
2626
|
-
|
|
2628
|
+
Se.create = (r, e) => new Se({
|
|
2627
2629
|
innerType: r,
|
|
2628
|
-
typeName:
|
|
2630
|
+
typeName: p.ZodDefault,
|
|
2629
2631
|
defaultValue: typeof e.default == "function" ? e.default : () => e.default,
|
|
2630
2632
|
...v(e)
|
|
2631
2633
|
});
|
|
2632
|
-
class
|
|
2634
|
+
class Oe extends g {
|
|
2633
2635
|
_parse(e) {
|
|
2634
2636
|
const { ctx: t } = this._processInputParams(e), n = {
|
|
2635
2637
|
...t,
|
|
@@ -2644,11 +2646,11 @@ class be extends _ {
|
|
|
2644
2646
|
...n
|
|
2645
2647
|
}
|
|
2646
2648
|
});
|
|
2647
|
-
return
|
|
2649
|
+
return ve(s) ? s.then((a) => ({
|
|
2648
2650
|
status: "valid",
|
|
2649
2651
|
value: a.status === "valid" ? a.value : this._def.catchValue({
|
|
2650
2652
|
get error() {
|
|
2651
|
-
return new
|
|
2653
|
+
return new I(n.common.issues);
|
|
2652
2654
|
},
|
|
2653
2655
|
input: n.data
|
|
2654
2656
|
})
|
|
@@ -2656,7 +2658,7 @@ class be extends _ {
|
|
|
2656
2658
|
status: "valid",
|
|
2657
2659
|
value: s.status === "valid" ? s.value : this._def.catchValue({
|
|
2658
2660
|
get error() {
|
|
2659
|
-
return new
|
|
2661
|
+
return new I(n.common.issues);
|
|
2660
2662
|
},
|
|
2661
2663
|
input: n.data
|
|
2662
2664
|
})
|
|
@@ -2666,13 +2668,13 @@ class be extends _ {
|
|
|
2666
2668
|
return this._def.innerType;
|
|
2667
2669
|
}
|
|
2668
2670
|
}
|
|
2669
|
-
|
|
2671
|
+
Oe.create = (r, e) => new Oe({
|
|
2670
2672
|
innerType: r,
|
|
2671
|
-
typeName:
|
|
2673
|
+
typeName: p.ZodCatch,
|
|
2672
2674
|
catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
|
|
2673
2675
|
...v(e)
|
|
2674
2676
|
});
|
|
2675
|
-
class
|
|
2677
|
+
class Be extends g {
|
|
2676
2678
|
_parse(e) {
|
|
2677
2679
|
if (this._getType(e) !== f.nan) {
|
|
2678
2680
|
const n = this._getOrReturnCtx(e);
|
|
@@ -2680,17 +2682,17 @@ class $e extends _ {
|
|
|
2680
2682
|
code: c.invalid_type,
|
|
2681
2683
|
expected: f.nan,
|
|
2682
2684
|
received: n.parsedType
|
|
2683
|
-
}),
|
|
2685
|
+
}), y;
|
|
2684
2686
|
}
|
|
2685
2687
|
return { status: "valid", value: e.data };
|
|
2686
2688
|
}
|
|
2687
2689
|
}
|
|
2688
|
-
|
|
2689
|
-
typeName:
|
|
2690
|
+
Be.create = (r) => new Be({
|
|
2691
|
+
typeName: p.ZodNaN,
|
|
2690
2692
|
...v(r)
|
|
2691
2693
|
});
|
|
2692
|
-
const
|
|
2693
|
-
class
|
|
2694
|
+
const xr = Symbol("zod_brand");
|
|
2695
|
+
class at extends g {
|
|
2694
2696
|
_parse(e) {
|
|
2695
2697
|
const { ctx: t } = this._processInputParams(e), n = t.data;
|
|
2696
2698
|
return this._def.type._parse({
|
|
@@ -2703,7 +2705,7 @@ class Je extends _ {
|
|
|
2703
2705
|
return this._def.type;
|
|
2704
2706
|
}
|
|
2705
2707
|
}
|
|
2706
|
-
class
|
|
2708
|
+
class Ie extends g {
|
|
2707
2709
|
_parse(e) {
|
|
2708
2710
|
const { status: t, ctx: n } = this._processInputParams(e);
|
|
2709
2711
|
if (n.common.async)
|
|
@@ -2713,7 +2715,7 @@ class Te extends _ {
|
|
|
2713
2715
|
path: n.path,
|
|
2714
2716
|
parent: n
|
|
2715
2717
|
});
|
|
2716
|
-
return a.status === "aborted" ?
|
|
2718
|
+
return a.status === "aborted" ? y : a.status === "dirty" ? (t.dirty(), ce(a.value)) : this._def.out._parseAsync({
|
|
2717
2719
|
data: a.value,
|
|
2718
2720
|
path: n.path,
|
|
2719
2721
|
parent: n
|
|
@@ -2725,7 +2727,7 @@ class Te extends _ {
|
|
|
2725
2727
|
path: n.path,
|
|
2726
2728
|
parent: n
|
|
2727
2729
|
});
|
|
2728
|
-
return s.status === "aborted" ?
|
|
2730
|
+
return s.status === "aborted" ? y : s.status === "dirty" ? (t.dirty(), {
|
|
2729
2731
|
status: "dirty",
|
|
2730
2732
|
value: s.value
|
|
2731
2733
|
}) : this._def.out._parseSync({
|
|
@@ -2736,273 +2738,289 @@ class Te extends _ {
|
|
|
2736
2738
|
}
|
|
2737
2739
|
}
|
|
2738
2740
|
static create(e, t) {
|
|
2739
|
-
return new
|
|
2741
|
+
return new Ie({
|
|
2740
2742
|
in: e,
|
|
2741
2743
|
out: t,
|
|
2742
|
-
typeName:
|
|
2744
|
+
typeName: p.ZodPipeline
|
|
2743
2745
|
});
|
|
2744
2746
|
}
|
|
2745
2747
|
}
|
|
2746
|
-
class
|
|
2748
|
+
class Re extends g {
|
|
2747
2749
|
_parse(e) {
|
|
2748
|
-
const t = this._def.innerType._parse(e), n = (s) => (
|
|
2749
|
-
return
|
|
2750
|
+
const t = this._def.innerType._parse(e), n = (s) => (ye(s) && (s.value = Object.freeze(s.value)), s);
|
|
2751
|
+
return ve(t) ? t.then((s) => n(s)) : n(t);
|
|
2750
2752
|
}
|
|
2751
2753
|
unwrap() {
|
|
2752
2754
|
return this._def.innerType;
|
|
2753
2755
|
}
|
|
2754
2756
|
}
|
|
2755
|
-
|
|
2757
|
+
Re.create = (r, e) => new Re({
|
|
2756
2758
|
innerType: r,
|
|
2757
|
-
typeName:
|
|
2759
|
+
typeName: p.ZodReadonly,
|
|
2758
2760
|
...v(e)
|
|
2759
2761
|
});
|
|
2760
|
-
function
|
|
2761
|
-
return r ?
|
|
2762
|
+
function Ot(r, e = {}, t) {
|
|
2763
|
+
return r ? le.create().superRefine((n, s) => {
|
|
2762
2764
|
var a, i;
|
|
2763
2765
|
if (!r(n)) {
|
|
2764
2766
|
const o = typeof e == "function" ? e(n) : typeof e == "string" ? { message: e } : e, u = (i = (a = o.fatal) !== null && a !== void 0 ? a : t) !== null && i !== void 0 ? i : !0, d = typeof o == "string" ? { message: o } : o;
|
|
2765
2767
|
s.addIssue({ code: "custom", ...d, fatal: u });
|
|
2766
2768
|
}
|
|
2767
|
-
}) :
|
|
2769
|
+
}) : le.create();
|
|
2768
2770
|
}
|
|
2769
|
-
const
|
|
2770
|
-
object:
|
|
2771
|
+
const kr = {
|
|
2772
|
+
object: k.lazycreate
|
|
2771
2773
|
};
|
|
2772
|
-
var
|
|
2774
|
+
var p;
|
|
2773
2775
|
(function(r) {
|
|
2774
2776
|
r.ZodString = "ZodString", r.ZodNumber = "ZodNumber", r.ZodNaN = "ZodNaN", r.ZodBigInt = "ZodBigInt", r.ZodBoolean = "ZodBoolean", r.ZodDate = "ZodDate", r.ZodSymbol = "ZodSymbol", r.ZodUndefined = "ZodUndefined", r.ZodNull = "ZodNull", r.ZodAny = "ZodAny", r.ZodUnknown = "ZodUnknown", r.ZodNever = "ZodNever", r.ZodVoid = "ZodVoid", r.ZodArray = "ZodArray", r.ZodObject = "ZodObject", r.ZodUnion = "ZodUnion", r.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", r.ZodIntersection = "ZodIntersection", r.ZodTuple = "ZodTuple", r.ZodRecord = "ZodRecord", r.ZodMap = "ZodMap", r.ZodSet = "ZodSet", r.ZodFunction = "ZodFunction", r.ZodLazy = "ZodLazy", r.ZodLiteral = "ZodLiteral", r.ZodEnum = "ZodEnum", r.ZodEffects = "ZodEffects", r.ZodNativeEnum = "ZodNativeEnum", r.ZodOptional = "ZodOptional", r.ZodNullable = "ZodNullable", r.ZodDefault = "ZodDefault", r.ZodCatch = "ZodCatch", r.ZodPromise = "ZodPromise", r.ZodBranded = "ZodBranded", r.ZodPipeline = "ZodPipeline", r.ZodReadonly = "ZodReadonly";
|
|
2775
|
-
})(
|
|
2776
|
-
const
|
|
2777
|
+
})(p || (p = {}));
|
|
2778
|
+
const br = (r, e = {
|
|
2777
2779
|
message: `Input not instance of ${r.name}`
|
|
2778
|
-
}) =>
|
|
2779
|
-
string: (r) =>
|
|
2780
|
-
number: (r) =>
|
|
2781
|
-
boolean: (r) =>
|
|
2780
|
+
}) => Ot((t) => t instanceof r, e), Rt = j.create, It = K.create, Tr = Be.create, wr = q.create, Zt = ge.create, Er = Q.create, Cr = $e.create, Sr = _e.create, Or = xe.create, Rr = le.create, Ir = X.create, Zr = V.create, Nr = Ve.create, Ar = P.create, jr = k.create, Pr = k.strictCreate, Dr = ke.create, Mr = He.create, Ur = be.create, Lr = L.create, $r = Te.create, Vr = ze.create, zr = ee.create, Br = de.create, Hr = we.create, Wr = Ee.create, Kr = Y.create, qr = Ce.create, Yr = fe.create, vt = D.create, Jr = M.create, Gr = J.create, Fr = D.createWithPreprocess, Xr = Ie.create, Qr = () => Rt().optional(), en = () => It().optional(), tn = () => Zt().optional(), rn = {
|
|
2781
|
+
string: (r) => j.create({ ...r, coerce: !0 }),
|
|
2782
|
+
number: (r) => K.create({ ...r, coerce: !0 }),
|
|
2783
|
+
boolean: (r) => ge.create({
|
|
2782
2784
|
...r,
|
|
2783
2785
|
coerce: !0
|
|
2784
2786
|
}),
|
|
2785
2787
|
bigint: (r) => q.create({ ...r, coerce: !0 }),
|
|
2786
|
-
date: (r) =>
|
|
2787
|
-
},
|
|
2788
|
-
var
|
|
2788
|
+
date: (r) => Q.create({ ...r, coerce: !0 })
|
|
2789
|
+
}, nn = y;
|
|
2790
|
+
var x = /* @__PURE__ */ Object.freeze({
|
|
2789
2791
|
__proto__: null,
|
|
2790
|
-
defaultErrorMap:
|
|
2791
|
-
setErrorMap:
|
|
2792
|
-
getErrorMap:
|
|
2793
|
-
makeIssue:
|
|
2794
|
-
EMPTY_PATH:
|
|
2792
|
+
defaultErrorMap: ue,
|
|
2793
|
+
setErrorMap: nr,
|
|
2794
|
+
getErrorMap: Me,
|
|
2795
|
+
makeIssue: Ue,
|
|
2796
|
+
EMPTY_PATH: sr,
|
|
2795
2797
|
addIssueToContext: l,
|
|
2796
2798
|
ParseStatus: E,
|
|
2797
|
-
INVALID:
|
|
2798
|
-
DIRTY:
|
|
2799
|
+
INVALID: y,
|
|
2800
|
+
DIRTY: ce,
|
|
2799
2801
|
OK: S,
|
|
2800
|
-
isAborted:
|
|
2801
|
-
isDirty:
|
|
2802
|
-
isValid:
|
|
2803
|
-
isAsync:
|
|
2802
|
+
isAborted: tt,
|
|
2803
|
+
isDirty: rt,
|
|
2804
|
+
isValid: ye,
|
|
2805
|
+
isAsync: ve,
|
|
2804
2806
|
get util() {
|
|
2805
|
-
return
|
|
2807
|
+
return _;
|
|
2806
2808
|
},
|
|
2807
2809
|
get objectUtil() {
|
|
2808
|
-
return
|
|
2810
|
+
return et;
|
|
2809
2811
|
},
|
|
2810
2812
|
ZodParsedType: f,
|
|
2811
2813
|
getParsedType: H,
|
|
2812
|
-
ZodType:
|
|
2813
|
-
datetimeRegex:
|
|
2814
|
-
ZodString:
|
|
2815
|
-
ZodNumber:
|
|
2814
|
+
ZodType: g,
|
|
2815
|
+
datetimeRegex: Ct,
|
|
2816
|
+
ZodString: j,
|
|
2817
|
+
ZodNumber: K,
|
|
2816
2818
|
ZodBigInt: q,
|
|
2817
|
-
ZodBoolean:
|
|
2818
|
-
ZodDate:
|
|
2819
|
-
ZodSymbol:
|
|
2820
|
-
ZodUndefined:
|
|
2821
|
-
ZodNull:
|
|
2822
|
-
ZodAny:
|
|
2823
|
-
ZodUnknown:
|
|
2824
|
-
ZodNever:
|
|
2825
|
-
ZodVoid:
|
|
2826
|
-
ZodArray:
|
|
2827
|
-
ZodObject:
|
|
2828
|
-
ZodUnion:
|
|
2829
|
-
ZodDiscriminatedUnion:
|
|
2830
|
-
ZodIntersection:
|
|
2831
|
-
ZodTuple:
|
|
2832
|
-
ZodRecord:
|
|
2833
|
-
ZodMap:
|
|
2834
|
-
ZodSet:
|
|
2835
|
-
ZodFunction:
|
|
2836
|
-
ZodLazy:
|
|
2837
|
-
ZodLiteral:
|
|
2819
|
+
ZodBoolean: ge,
|
|
2820
|
+
ZodDate: Q,
|
|
2821
|
+
ZodSymbol: $e,
|
|
2822
|
+
ZodUndefined: _e,
|
|
2823
|
+
ZodNull: xe,
|
|
2824
|
+
ZodAny: le,
|
|
2825
|
+
ZodUnknown: X,
|
|
2826
|
+
ZodNever: V,
|
|
2827
|
+
ZodVoid: Ve,
|
|
2828
|
+
ZodArray: P,
|
|
2829
|
+
ZodObject: k,
|
|
2830
|
+
ZodUnion: ke,
|
|
2831
|
+
ZodDiscriminatedUnion: He,
|
|
2832
|
+
ZodIntersection: be,
|
|
2833
|
+
ZodTuple: L,
|
|
2834
|
+
ZodRecord: Te,
|
|
2835
|
+
ZodMap: ze,
|
|
2836
|
+
ZodSet: ee,
|
|
2837
|
+
ZodFunction: de,
|
|
2838
|
+
ZodLazy: we,
|
|
2839
|
+
ZodLiteral: Ee,
|
|
2838
2840
|
ZodEnum: Y,
|
|
2839
|
-
ZodNativeEnum:
|
|
2840
|
-
ZodPromise:
|
|
2841
|
-
ZodEffects:
|
|
2842
|
-
ZodTransformer:
|
|
2843
|
-
ZodOptional:
|
|
2844
|
-
ZodNullable:
|
|
2845
|
-
ZodDefault:
|
|
2846
|
-
ZodCatch:
|
|
2847
|
-
ZodNaN:
|
|
2848
|
-
BRAND:
|
|
2849
|
-
ZodBranded:
|
|
2850
|
-
ZodPipeline:
|
|
2851
|
-
ZodReadonly:
|
|
2852
|
-
custom:
|
|
2853
|
-
Schema:
|
|
2854
|
-
ZodSchema:
|
|
2855
|
-
late:
|
|
2841
|
+
ZodNativeEnum: Ce,
|
|
2842
|
+
ZodPromise: fe,
|
|
2843
|
+
ZodEffects: D,
|
|
2844
|
+
ZodTransformer: D,
|
|
2845
|
+
ZodOptional: M,
|
|
2846
|
+
ZodNullable: J,
|
|
2847
|
+
ZodDefault: Se,
|
|
2848
|
+
ZodCatch: Oe,
|
|
2849
|
+
ZodNaN: Be,
|
|
2850
|
+
BRAND: xr,
|
|
2851
|
+
ZodBranded: at,
|
|
2852
|
+
ZodPipeline: Ie,
|
|
2853
|
+
ZodReadonly: Re,
|
|
2854
|
+
custom: Ot,
|
|
2855
|
+
Schema: g,
|
|
2856
|
+
ZodSchema: g,
|
|
2857
|
+
late: kr,
|
|
2856
2858
|
get ZodFirstPartyTypeKind() {
|
|
2857
|
-
return
|
|
2859
|
+
return p;
|
|
2858
2860
|
},
|
|
2859
|
-
coerce:
|
|
2860
|
-
any:
|
|
2861
|
-
array:
|
|
2862
|
-
bigint:
|
|
2863
|
-
boolean:
|
|
2864
|
-
date:
|
|
2865
|
-
discriminatedUnion:
|
|
2866
|
-
effect:
|
|
2867
|
-
enum:
|
|
2868
|
-
function:
|
|
2869
|
-
instanceof:
|
|
2870
|
-
intersection:
|
|
2871
|
-
lazy:
|
|
2872
|
-
literal:
|
|
2873
|
-
map:
|
|
2874
|
-
nan:
|
|
2875
|
-
nativeEnum:
|
|
2876
|
-
never:
|
|
2877
|
-
null:
|
|
2878
|
-
nullable:
|
|
2879
|
-
number:
|
|
2880
|
-
object:
|
|
2881
|
-
oboolean:
|
|
2882
|
-
onumber:
|
|
2883
|
-
optional:
|
|
2884
|
-
ostring:
|
|
2885
|
-
pipeline:
|
|
2886
|
-
preprocess:
|
|
2887
|
-
promise:
|
|
2888
|
-
record:
|
|
2889
|
-
set:
|
|
2890
|
-
strictObject:
|
|
2891
|
-
string:
|
|
2892
|
-
symbol:
|
|
2893
|
-
transformer:
|
|
2894
|
-
tuple:
|
|
2895
|
-
undefined:
|
|
2896
|
-
union:
|
|
2897
|
-
unknown:
|
|
2898
|
-
void:
|
|
2899
|
-
NEVER:
|
|
2861
|
+
coerce: rn,
|
|
2862
|
+
any: Rr,
|
|
2863
|
+
array: Ar,
|
|
2864
|
+
bigint: wr,
|
|
2865
|
+
boolean: Zt,
|
|
2866
|
+
date: Er,
|
|
2867
|
+
discriminatedUnion: Mr,
|
|
2868
|
+
effect: vt,
|
|
2869
|
+
enum: Kr,
|
|
2870
|
+
function: Br,
|
|
2871
|
+
instanceof: br,
|
|
2872
|
+
intersection: Ur,
|
|
2873
|
+
lazy: Hr,
|
|
2874
|
+
literal: Wr,
|
|
2875
|
+
map: Vr,
|
|
2876
|
+
nan: Tr,
|
|
2877
|
+
nativeEnum: qr,
|
|
2878
|
+
never: Zr,
|
|
2879
|
+
null: Or,
|
|
2880
|
+
nullable: Gr,
|
|
2881
|
+
number: It,
|
|
2882
|
+
object: jr,
|
|
2883
|
+
oboolean: tn,
|
|
2884
|
+
onumber: en,
|
|
2885
|
+
optional: Jr,
|
|
2886
|
+
ostring: Qr,
|
|
2887
|
+
pipeline: Xr,
|
|
2888
|
+
preprocess: Fr,
|
|
2889
|
+
promise: Yr,
|
|
2890
|
+
record: $r,
|
|
2891
|
+
set: zr,
|
|
2892
|
+
strictObject: Pr,
|
|
2893
|
+
string: Rt,
|
|
2894
|
+
symbol: Cr,
|
|
2895
|
+
transformer: vt,
|
|
2896
|
+
tuple: Lr,
|
|
2897
|
+
undefined: Sr,
|
|
2898
|
+
union: Dr,
|
|
2899
|
+
unknown: Ir,
|
|
2900
|
+
void: Nr,
|
|
2901
|
+
NEVER: nn,
|
|
2900
2902
|
ZodIssueCode: c,
|
|
2901
|
-
quotelessJson:
|
|
2902
|
-
ZodError:
|
|
2903
|
-
}), Vr = /* @__PURE__ */ ((r) => (r.UNSTYLED = "unstyled", r.LIGHT = "light", r.DARK = "dark", r))(Vr || {});
|
|
2904
|
-
const zr = m.object({
|
|
2905
|
-
colorPrimary: m.string().optional(),
|
|
2906
|
-
colorBackground: m.string().optional(),
|
|
2907
|
-
colorForeground: m.string().optional(),
|
|
2908
|
-
colorText: m.string().optional(),
|
|
2909
|
-
colorDanger: m.string().optional(),
|
|
2910
|
-
fontFamily: m.string().optional(),
|
|
2911
|
-
fontSize: m.string().optional(),
|
|
2912
|
-
spacing: m.string().optional(),
|
|
2913
|
-
borderRadius: m.string().optional(),
|
|
2914
|
-
borderColor: m.string().optional(),
|
|
2915
|
-
borderWidth: m.string().optional(),
|
|
2916
|
-
focusRingColor: m.string().optional(),
|
|
2917
|
-
padding: m.string().optional()
|
|
2918
|
-
}), an = m.object({
|
|
2919
|
-
theme: m.enum([
|
|
2920
|
-
"unstyled",
|
|
2921
|
-
"light",
|
|
2922
|
-
"dark"
|
|
2923
|
-
/* DARK */
|
|
2924
|
-
]),
|
|
2925
|
-
variables: zr.optional()
|
|
2903
|
+
quotelessJson: rr,
|
|
2904
|
+
ZodError: I
|
|
2926
2905
|
});
|
|
2927
|
-
|
|
2928
|
-
|
|
2929
|
-
|
|
2930
|
-
|
|
2931
|
-
|
|
2932
|
-
|
|
2933
|
-
|
|
2934
|
-
|
|
2906
|
+
const N = x.string().trim().min(1, { message: "Cannot be blank" }), B = x.string().trim().optional();
|
|
2907
|
+
var Nt = /* @__PURE__ */ ((r) => (r.FIRST_NAME = "firstName", r.LAST_NAME = "lastName", r.EMAIL = "email", r.ZIP_CODE = "zipCode", r.CITY = "city", r.STATE = "state", r.COUNTRY = "country", r.ADDRESS = "address", r.PHONE = "phone", r))(Nt || {});
|
|
2908
|
+
const At = x.nativeEnum(Nt);
|
|
2909
|
+
var jt = /* @__PURE__ */ ((r) => (r.CARD_NUMBER = "cardNumber", r.CARD_EXPIRY = "cardExpiry", r.CARD_CVC = "cardCvc", r))(jt || {});
|
|
2910
|
+
const Pt = x.nativeEnum(jt), sn = x.union([At, Pt]);
|
|
2911
|
+
x.object({
|
|
2912
|
+
backgroundColor: B,
|
|
2913
|
+
color: B,
|
|
2914
|
+
fontFamily: B,
|
|
2915
|
+
fontSize: B,
|
|
2916
|
+
fontWeight: B,
|
|
2917
|
+
margin: B,
|
|
2918
|
+
padding: B
|
|
2935
2919
|
});
|
|
2936
|
-
|
|
2937
|
-
|
|
2938
|
-
|
|
2939
|
-
|
|
2940
|
-
|
|
2941
|
-
|
|
2942
|
-
|
|
2943
|
-
|
|
2944
|
-
|
|
2945
|
-
|
|
2946
|
-
|
|
2947
|
-
|
|
2948
|
-
|
|
2949
|
-
|
|
2950
|
-
|
|
2951
|
-
|
|
2952
|
-
|
|
2953
|
-
}),
|
|
2954
|
-
type:
|
|
2955
|
-
|
|
2956
|
-
|
|
2957
|
-
|
|
2958
|
-
|
|
2959
|
-
|
|
2960
|
-
|
|
2961
|
-
|
|
2962
|
-
|
|
2963
|
-
|
|
2964
|
-
|
|
2965
|
-
|
|
2966
|
-
|
|
2967
|
-
|
|
2968
|
-
|
|
2969
|
-
|
|
2970
|
-
|
|
2971
|
-
|
|
2972
|
-
|
|
2973
|
-
|
|
2974
|
-
|
|
2975
|
-
|
|
2976
|
-
|
|
2977
|
-
|
|
2978
|
-
|
|
2979
|
-
|
|
2980
|
-
|
|
2981
|
-
|
|
2982
|
-
|
|
2983
|
-
|
|
2984
|
-
|
|
2985
|
-
|
|
2986
|
-
|
|
2920
|
+
const b = x.enum([
|
|
2921
|
+
// Element -> Form
|
|
2922
|
+
"LOADED",
|
|
2923
|
+
"BLUR",
|
|
2924
|
+
"FOCUS",
|
|
2925
|
+
"CHANGE",
|
|
2926
|
+
"TOKENIZE_STARTED",
|
|
2927
|
+
"CHECKOUT_STARTED",
|
|
2928
|
+
"TOKENIZE_SUCCESS",
|
|
2929
|
+
"CHECKOUT_SUCCESS",
|
|
2930
|
+
"LOAD_ERROR",
|
|
2931
|
+
"VALIDATION_ERROR",
|
|
2932
|
+
"TOKENIZE_ERROR",
|
|
2933
|
+
"CHECKOUT_ERROR",
|
|
2934
|
+
// Form -> Element
|
|
2935
|
+
"TOKENIZE",
|
|
2936
|
+
"CHECKOUT"
|
|
2937
|
+
]), an = b.extract(["TOKENIZE_STARTED", "CHECKOUT_STARTED"]), on = x.object({ type: an }), cn = b.extract(["BLUR", "FOCUS", "CHANGE"]), dn = x.object({
|
|
2938
|
+
type: cn,
|
|
2939
|
+
elementType: Pt
|
|
2940
|
+
}), un = b.extract(["LOAD_ERROR", "TOKENIZE_ERROR", "CHECKOUT_ERROR"]), ln = x.object({
|
|
2941
|
+
type: un,
|
|
2942
|
+
message: N
|
|
2943
|
+
}), fn = b.extract(["VALIDATION_ERROR"]), hn = x.object({
|
|
2944
|
+
type: fn,
|
|
2945
|
+
elementType: sn,
|
|
2946
|
+
errors: x.array(x.string())
|
|
2947
|
+
}), mn = x.object({
|
|
2948
|
+
type: x.literal(b.enum.LOADED),
|
|
2949
|
+
sessionId: N,
|
|
2950
|
+
height: N,
|
|
2951
|
+
totalAmountAtoms: x.number(),
|
|
2952
|
+
currency: B
|
|
2953
|
+
}), pn = b.extract(["TOKENIZE", "CHECKOUT"]), Dt = x.object({
|
|
2954
|
+
type: pn,
|
|
2955
|
+
sessionId: N,
|
|
2956
|
+
firstName: N,
|
|
2957
|
+
lastName: N,
|
|
2958
|
+
email: N,
|
|
2959
|
+
zipCode: N,
|
|
2960
|
+
country: N
|
|
2961
|
+
}), yn = x.object({
|
|
2962
|
+
type: x.literal(b.enum.TOKENIZE_SUCCESS),
|
|
2963
|
+
isReadyForCheckout: x.boolean()
|
|
2964
|
+
}), vn = x.object({
|
|
2965
|
+
type: x.literal(b.enum.CHECKOUT_SUCCESS),
|
|
2966
|
+
invoiceUrls: x.array(x.string())
|
|
2967
|
+
}), gn = x.discriminatedUnion("type", [
|
|
2968
|
+
on,
|
|
2969
|
+
dn,
|
|
2970
|
+
ln,
|
|
2971
|
+
hn,
|
|
2972
|
+
mn,
|
|
2973
|
+
Dt,
|
|
2974
|
+
yn,
|
|
2975
|
+
vn
|
|
2976
|
+
]), _n = x.object({
|
|
2977
|
+
payload: gn,
|
|
2978
|
+
nonce: N,
|
|
2979
|
+
formId: N,
|
|
2980
|
+
elementId: N
|
|
2981
|
+
}), xn = (r) => {
|
|
2982
|
+
const e = {};
|
|
2983
|
+
return Object.entries(r).forEach(([t, n]) => {
|
|
2984
|
+
try {
|
|
2985
|
+
const s = At.parse(t);
|
|
2986
|
+
Array.isArray(n) ? e[s] = n : Array.isArray(n._errors) && (e[s] = n._errors);
|
|
2987
|
+
} catch {
|
|
2988
|
+
return;
|
|
2989
|
+
}
|
|
2990
|
+
}), e;
|
|
2991
|
+
}, kn = (r, e, t) => {
|
|
2992
|
+
const s = Array.from(e.querySelectorAll("input[data-opid]") ?? []).reduce(
|
|
2993
|
+
(i, o) => {
|
|
2994
|
+
const u = o.getAttribute("data-opid");
|
|
2995
|
+
return u ? { ...i, [u]: o.value } : i;
|
|
2987
2996
|
},
|
|
2988
|
-
{
|
|
2989
|
-
|
|
2990
|
-
|
|
2991
|
-
}
|
|
2997
|
+
{
|
|
2998
|
+
type: b.enum.TOKENIZE,
|
|
2999
|
+
sessionId: r
|
|
3000
|
+
}
|
|
3001
|
+
), a = Dt.safeParse(s);
|
|
3002
|
+
if (a.success)
|
|
3003
|
+
return a.data;
|
|
3004
|
+
{
|
|
3005
|
+
const i = a.error.format(), o = xn(i);
|
|
3006
|
+
for (const [u, d] of Object.entries(o))
|
|
3007
|
+
t(u, d, u);
|
|
3008
|
+
}
|
|
3009
|
+
}, bn = (r) => {
|
|
2992
3010
|
try {
|
|
2993
|
-
return
|
|
3011
|
+
return _n.parse(r);
|
|
2994
3012
|
} catch (e) {
|
|
2995
3013
|
throw e;
|
|
2996
3014
|
}
|
|
2997
|
-
},
|
|
3015
|
+
}, gt = (r, e, t, n) => {
|
|
2998
3016
|
const s = {
|
|
2999
3017
|
payload: n,
|
|
3000
|
-
nonce:
|
|
3018
|
+
nonce: kt(),
|
|
3001
3019
|
formId: e,
|
|
3002
3020
|
elementId: t
|
|
3003
3021
|
};
|
|
3004
|
-
r.postMessage(JSON.stringify(s),
|
|
3005
|
-
},
|
|
3022
|
+
r.postMessage(JSON.stringify(s), st);
|
|
3023
|
+
}, Sn = (r) => {
|
|
3006
3024
|
const {
|
|
3007
3025
|
children: e,
|
|
3008
3026
|
checkoutSecureToken: t,
|
|
@@ -3013,94 +3031,115 @@ const Hr = m.enum([
|
|
|
3013
3031
|
onLoad: o,
|
|
3014
3032
|
onLoadError: u,
|
|
3015
3033
|
onValidationError: d,
|
|
3016
|
-
onCheckoutStarted:
|
|
3017
|
-
onCheckoutSuccess:
|
|
3018
|
-
onCheckoutError:
|
|
3019
|
-
|
|
3020
|
-
|
|
3021
|
-
|
|
3022
|
-
|
|
3023
|
-
|
|
3024
|
-
const oe = V.source;
|
|
3025
|
-
if (V.origin !== Ge || !oe) return;
|
|
3026
|
-
const Z = tn(JSON.parse(V.data)), Se = Z.elementId;
|
|
3027
|
-
if (Z.formId !== F || !Se || Z.nonce in Xe)
|
|
3034
|
+
onCheckoutStarted: m,
|
|
3035
|
+
onCheckoutSuccess: T,
|
|
3036
|
+
onCheckoutError: z
|
|
3037
|
+
} = r, [G, F] = R(void 0), [it, Mt] = R([]), [Ut, Lt] = R("1px"), [ot, $t] = R(!1), [Ke, ct] = R(void 0), [dt, Ze] = R(!1), [te, Vt] = R([]), [re, zt] = R({}), [ut, lt] = R(0), [ft, ht] = R(!1), [ne, Bt] = R(void 0), [mt, Ht] = R(void 0), [qe, Wt] = R(void 0), se = Pe(() => `opjs-form-${kt()}`, []), he = _t(null), Ye = Ae(
|
|
3038
|
+
(O) => {
|
|
3039
|
+
if (O.origin !== st || !O.source) return;
|
|
3040
|
+
const ae = O.source, C = bn(JSON.parse(O.data)), Ne = C.elementId;
|
|
3041
|
+
if (C.formId !== se || !Ne || C.nonce in it)
|
|
3028
3042
|
return;
|
|
3029
|
-
|
|
3030
|
-
const
|
|
3031
|
-
if (
|
|
3032
|
-
s(
|
|
3033
|
-
else if (
|
|
3034
|
-
a(
|
|
3035
|
-
else if (
|
|
3036
|
-
i(
|
|
3037
|
-
else if (
|
|
3038
|
-
|
|
3039
|
-
|
|
3040
|
-
|
|
3041
|
-
|
|
3043
|
+
Mt((ie) => [...ie, C.nonce]);
|
|
3044
|
+
const Z = C.payload, A = Z.type;
|
|
3045
|
+
if (A === b.enum.FOCUS && s)
|
|
3046
|
+
s(C.elementId);
|
|
3047
|
+
else if (A === b.enum.BLUR && a)
|
|
3048
|
+
a(C.elementId);
|
|
3049
|
+
else if (A === b.enum.CHANGE && i)
|
|
3050
|
+
i(C.elementId);
|
|
3051
|
+
else if (A === b.enum.LOADED) {
|
|
3052
|
+
const ie = te.find((Fe) => Fe.contentWindow === ae);
|
|
3053
|
+
if (Ze(!1), !ie)
|
|
3054
|
+
return;
|
|
3055
|
+
zt((Fe) => ({ ...Fe, [Ne]: ae }));
|
|
3056
|
+
const Ge = Z.height ? `${Z.height}px` : "100%";
|
|
3057
|
+
Lt(Ge), Wt(Z.totalAmountAtoms), Ht(Z.currency), ne || Bt(Z.sessionId);
|
|
3058
|
+
} else if (A === b.enum.TOKENIZE_STARTED)
|
|
3059
|
+
Ze(!0), m && m();
|
|
3060
|
+
else if (A === b.enum.TOKENIZE_SUCCESS && Ke) {
|
|
3061
|
+
const ie = ut + 1, Ge = ie === Object.keys(re).length;
|
|
3062
|
+
!ft && (Ge || Z.isReadyForCheckout) ? (gt(ae, se, Ne, Ke), ht(!0), ct(void 0)) : lt(ie);
|
|
3063
|
+
} else A === b.enum.CHECKOUT_SUCCESS ? (Ze(!1), lt(0), ht(!1), T && T(Z.invoiceUrls)) : A === b.enum.LOAD_ERROR ? u && u(Z.message) : A === b.enum.VALIDATION_ERROR ? d && d(Z.elementType, Z.errors, Ne) : (A === b.enum.TOKENIZE_ERROR || A === b.enum.CHECKOUT_ERROR) && (Ze(!1), z && z(Z.message));
|
|
3042
3064
|
},
|
|
3043
3065
|
[
|
|
3044
|
-
|
|
3045
|
-
|
|
3046
|
-
|
|
3066
|
+
se,
|
|
3067
|
+
ne,
|
|
3068
|
+
it,
|
|
3069
|
+
Ke,
|
|
3070
|
+
te,
|
|
3071
|
+
re,
|
|
3072
|
+
ut,
|
|
3073
|
+
ft,
|
|
3047
3074
|
a,
|
|
3048
3075
|
i,
|
|
3049
3076
|
s,
|
|
3050
3077
|
u,
|
|
3051
|
-
|
|
3052
|
-
|
|
3053
|
-
|
|
3078
|
+
m,
|
|
3079
|
+
T,
|
|
3080
|
+
z,
|
|
3054
3081
|
d
|
|
3055
3082
|
]
|
|
3056
|
-
),
|
|
3057
|
-
if (!
|
|
3058
|
-
const
|
|
3059
|
-
|
|
3060
|
-
|
|
3061
|
-
|
|
3062
|
-
|
|
3063
|
-
|
|
3064
|
-
|
|
3065
|
-
|
|
3066
|
-
|
|
3067
|
-
|
|
3068
|
-
|
|
3069
|
-
|
|
3070
|
-
|
|
3083
|
+
), Kt = Ae(() => {
|
|
3084
|
+
if (!he.current || !d || !ne) return;
|
|
3085
|
+
const O = kn(ne, he.current, d);
|
|
3086
|
+
if (O) {
|
|
3087
|
+
for (const [ae, C] of Object.entries(re))
|
|
3088
|
+
C && gt(C, se, ae, O);
|
|
3089
|
+
O.type = b.enum.CHECKOUT, ct(O);
|
|
3090
|
+
}
|
|
3091
|
+
}, [he, re, se, d, ne]), Je = Ae(
|
|
3092
|
+
(O) => {
|
|
3093
|
+
dt && O.preventDefault();
|
|
3094
|
+
},
|
|
3095
|
+
[dt]
|
|
3096
|
+
);
|
|
3097
|
+
De(() => {
|
|
3098
|
+
ot || !he.current || !qe || te.length === Object.keys(re).length && ($t(!0), o && o(qe, mt));
|
|
3099
|
+
}, [te, re, ot, o, qe, mt]), De(() => (F(window.location.origin), window.addEventListener("message", Ye), window.addEventListener("beforeunload", Je), () => {
|
|
3100
|
+
window.removeEventListener("beforeunload", Je), window.removeEventListener("message", Ye);
|
|
3101
|
+
}), [ne, Ye, Je]);
|
|
3102
|
+
const qt = Ae(
|
|
3103
|
+
(O) => {
|
|
3104
|
+
te.find((C) => C.contentWindow === O.contentWindow) || Vt((C) => [...C, O]);
|
|
3105
|
+
},
|
|
3106
|
+
[te]
|
|
3107
|
+
), Yt = {
|
|
3108
|
+
formId: se,
|
|
3109
|
+
formHeight: Ut,
|
|
3110
|
+
referer: G,
|
|
3071
3111
|
checkoutSecureToken: t,
|
|
3072
|
-
|
|
3112
|
+
registerIframe: qt
|
|
3073
3113
|
};
|
|
3074
|
-
return /* @__PURE__ */
|
|
3075
|
-
},
|
|
3076
|
-
const { subPath: e, styles: t } = r, {
|
|
3114
|
+
return /* @__PURE__ */ W(xt.Provider, { value: Yt, children: /* @__PURE__ */ W("div", { className: n, ref: he, children: e({ submit: Kt }) }) });
|
|
3115
|
+
}, Tn = (r) => `styles=${encodeURIComponent(JSON.stringify(r))}`, We = (r) => {
|
|
3116
|
+
const { subPath: e, styles: t } = r, { formId: n, referer: s, formHeight: a, checkoutSecureToken: i, registerIframe: o } = Ft(), [u, d] = R(!1), m = _t(null), T = Pe(() => t ? Tn(t) : "", [t]), z = Pe(() => ({
|
|
3077
3117
|
border: "none",
|
|
3078
3118
|
width: "100%",
|
|
3079
3119
|
height: a
|
|
3080
|
-
}), [a]),
|
|
3120
|
+
}), [a]), G = Pe(() => {
|
|
3081
3121
|
if (!i || !s) return "";
|
|
3082
|
-
const
|
|
3083
|
-
return
|
|
3084
|
-
}, [
|
|
3085
|
-
return
|
|
3122
|
+
const F = new URLSearchParams();
|
|
3123
|
+
return F.append("referer", s), F.append("styles", T), F.append("formId", n), F.append("secureToken", i), F.toString();
|
|
3124
|
+
}, [T, n, s, i]);
|
|
3125
|
+
return De(() => d(!0), []), De(() => {
|
|
3126
|
+
!m.current || !u || o(m.current);
|
|
3127
|
+
}, [u]), i ? /* @__PURE__ */ W(
|
|
3086
3128
|
"iframe",
|
|
3087
3129
|
{
|
|
3088
3130
|
name: `${e}-element`,
|
|
3089
|
-
src: `${
|
|
3090
|
-
style:
|
|
3091
|
-
ref:
|
|
3131
|
+
src: `${st}/app/v1/${e}-element/?${G}`,
|
|
3132
|
+
style: z,
|
|
3133
|
+
ref: m
|
|
3092
3134
|
}
|
|
3093
|
-
) : /* @__PURE__ */
|
|
3094
|
-
},
|
|
3135
|
+
) : /* @__PURE__ */ W("div", {});
|
|
3136
|
+
}, On = ({ styles: r }) => /* @__PURE__ */ W(We, { styles: r, subPath: "card-cvc" }), Rn = ({ styles: r }) => /* @__PURE__ */ W(We, { styles: r, subPath: "card" }), In = ({ styles: r }) => /* @__PURE__ */ W(We, { styles: r, subPath: "card-expiry" }), Zn = ({ styles: r }) => /* @__PURE__ */ W(We, { styles: r, subPath: "card-number" });
|
|
3095
3137
|
export {
|
|
3096
|
-
|
|
3097
|
-
|
|
3098
|
-
|
|
3099
|
-
|
|
3100
|
-
|
|
3101
|
-
|
|
3102
|
-
|
|
3103
|
-
on as ElementsForm,
|
|
3104
|
-
Br as FieldName,
|
|
3105
|
-
At as useOpenPayElements
|
|
3138
|
+
On as CardCvcElement,
|
|
3139
|
+
Rn as CardElement,
|
|
3140
|
+
In as CardExpiryElement,
|
|
3141
|
+
Zn as CardNumberElement,
|
|
3142
|
+
Sn as ElementsForm,
|
|
3143
|
+
Nt as FieldName,
|
|
3144
|
+
Ft as useOpenPayElements
|
|
3106
3145
|
};
|