@cabloy/zod-query 2.0.3 → 2.1.1

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.
Files changed (7) hide show
  1. package/LICENSE +0 -0
  2. package/dist/index.js +318 -1
  3. package/package.json +22 -20
  4. package/dist/lib/metadata.js +0 -31
  5. package/dist/lib/query.js +0 -223
  6. package/dist/lib/utils.js +0 -2
  7. package/dist/lib/zod-is-type.js +0 -58
package/LICENSE CHANGED
File without changes
package/dist/index.js CHANGED
@@ -1 +1,318 @@
1
- export * from "./lib/query.js";
1
+ import { z } from 'zod';
2
+
3
+ const ZodTypeKeys = {
4
+ ZodAny: 'any',
5
+ ZodArray: 'array',
6
+ ZodBigInt: 'bigint',
7
+ ZodBoolean: 'boolean',
8
+ ZodDefault: 'default',
9
+ ZodTransform: 'transform',
10
+ ZodEnum: 'enum',
11
+ ZodIntersection: 'intersection',
12
+ ZodLiteral: 'literal',
13
+ ZodNever: 'never',
14
+ ZodNull: 'null',
15
+ ZodNullable: 'nullable',
16
+ ZodNumber: 'number',
17
+ ZodNonOptional: 'nonoptional',
18
+ ZodObject: 'object',
19
+ ZodOptional: 'optional',
20
+ ZodPipe: 'pipe',
21
+ ZodReadonly: 'readonly',
22
+ ZodRecord: 'record',
23
+ ZodString: 'string',
24
+ ZodTuple: 'tuple',
25
+ ZodType: 'type',
26
+ ZodUnion: 'union',
27
+ ZodDiscriminatedUnion: 'union',
28
+ ZodUnknown: 'unknown',
29
+ ZodVoid: 'void',
30
+ ZodDate: 'date'
31
+ };
32
+ function isZodType(schema, typeNames) {
33
+ const typeNamesArray = Array.isArray(typeNames) ? typeNames : [typeNames];
34
+ return typeNamesArray.some(typeName => {
35
+ const typeNameMatch = schema?.def?.type === ZodTypeKeys[typeName];
36
+ if (typeName === 'ZodDiscriminatedUnion') {
37
+ return typeNameMatch && 'discriminator' in schema.def;
38
+ }
39
+ return typeNameMatch;
40
+ });
41
+ }
42
+ function isAnyZodType(schema) {
43
+ return 'def' in schema;
44
+ }
45
+
46
+ class Metadata {
47
+ static unwrapUntil(schema, typeName) {
48
+ if (typeName && isZodType(schema, typeName)) {
49
+ return schema;
50
+ }
51
+ if (isZodType(schema, ['ZodOptional', 'ZodNullable', 'ZodDefault', 'ZodReadonly', 'ZodNonOptional']) && isAnyZodType(schema._zod.def.innerType)) {
52
+ return this.unwrapUntil(schema._zod.def.innerType, typeName);
53
+ }
54
+ if (isZodType(schema, 'ZodPipe')) {
55
+ const inSchema = schema._zod.def.in;
56
+ const outSchema = schema._zod.def.out;
57
+
58
+ // meaning preprocess
59
+ if (isZodType(inSchema, 'ZodTransform') && isAnyZodType(outSchema)) {
60
+ return this.unwrapUntil(outSchema, typeName);
61
+ }
62
+
63
+ // meaning transform
64
+ if (isAnyZodType(inSchema)) {
65
+ return this.unwrapUntil(inSchema, typeName);
66
+ }
67
+ }
68
+ return typeName ? undefined : schema;
69
+ }
70
+ }
71
+
72
+ const isUndefined = obj => typeof obj === 'undefined';
73
+ const isNil = val => isUndefined(val) || val === null;
74
+
75
+ let ZodMetadata;
76
+ function setParseAdapter(zodMetadata) {
77
+ ZodMetadata = zodMetadata;
78
+ z.core.setParseAdapter(__parseAdapter);
79
+ }
80
+ function __parseAdapter(inst, parse) {
81
+ return (payload, _) => {
82
+ const type = inst.type;
83
+ switch (type) {
84
+ case 'string':
85
+ return __parseString(inst, parse, payload, _);
86
+ case 'number':
87
+ return __parseNumber(inst, parse, payload, _);
88
+ case 'bigint':
89
+ return __parseBigInt(inst, parse, payload, _);
90
+ case 'boolean':
91
+ return __parseBoolean(inst, parse, payload, _);
92
+ case 'date':
93
+ return __parseDate(inst, parse, payload, _);
94
+ case 'object':
95
+ return __parseObject(inst, parse, payload, _);
96
+ case 'array':
97
+ return __parseArray(inst, parse, payload, _);
98
+ case 'optional':
99
+ return __parseOptional(inst, parse, payload, _);
100
+ case 'default':
101
+ return __parseDefault(inst, parse, payload, _);
102
+ }
103
+ return parse(payload, _);
104
+ };
105
+ }
106
+
107
+ /////////////////////////////////////////
108
+ /////////////////////////////////////////
109
+ /// /////// /////////
110
+ /// /////// ZodString /////////
111
+ /// /////// /////////
112
+ /////////////////////////////////////////
113
+ /////////////////////////////////////////
114
+
115
+ function __parseString(inst, parse, payload, _) {
116
+ const metadata = ZodMetadata?.getOpenapiMetadata(inst);
117
+ if (metadata?.format === 'binary' && !isNil(payload.value)) {
118
+ // ignore upload file
119
+ return payload;
120
+ }
121
+ _coerceString(payload);
122
+ return parse(payload, _);
123
+ }
124
+
125
+ /////////////////////////////////////////
126
+ /////////////////////////////////////////
127
+ /// /////// /////////
128
+ /// /////// ZodNumber /////////
129
+ /// /////// /////////
130
+ /////////////////////////////////////////
131
+ /////////////////////////////////////////
132
+
133
+ function __parseNumber(_inst, parse, payload, _) {
134
+ _coerceWithNil(payload, () => {
135
+ payload.value = Number(payload.value);
136
+ });
137
+ return parse(payload, _);
138
+ }
139
+
140
+ /////////////////////////////////////////
141
+ /////////////////////////////////////////
142
+ /// /////// /////////
143
+ /// /////// ZodBigInt /////////
144
+ /// /////// /////////
145
+ /////////////////////////////////////////
146
+ /////////////////////////////////////////
147
+
148
+ function __parseBigInt(_inst, parse, payload, _) {
149
+ _coerceWithNil(payload, () => {
150
+ payload.value = BigInt(payload.value);
151
+ });
152
+ return parse(payload, _);
153
+ }
154
+
155
+ //////////////////////////////////////////
156
+ //////////////////////////////////////////
157
+ /// /////// //////////
158
+ /// /////// ZodBoolean /////////
159
+ /// /////// //////////
160
+ //////////////////////////////////////////
161
+ //////////////////////////////////////////
162
+
163
+ function __parseBoolean(_inst, parse, payload, _) {
164
+ _coerceWithNil(payload, () => {
165
+ if (payload.value === 'false' || payload.value === '0') {
166
+ payload.value = false;
167
+ } else {
168
+ payload.value = Boolean(payload.value);
169
+ }
170
+ });
171
+ return parse(payload, _);
172
+ }
173
+
174
+ ///////////////////////////////////////
175
+ ///////////////////////////////////////
176
+ /// /////// ///////
177
+ /// /////// ZodDate ///////
178
+ /// /////// ///////
179
+ ///////////////////////////////////////
180
+ ///////////////////////////////////////
181
+
182
+ function __parseDate(_inst, parse, payload, _) {
183
+ _coerceWithNil(payload, () => {
184
+ payload.value = new Date(payload.value);
185
+ });
186
+ return parse(payload, _);
187
+ }
188
+
189
+ /////////////////////////////////////////
190
+ /////////////////////////////////////////
191
+ /// /////// /////////
192
+ /// /////// ZodObject /////////
193
+ /// /////// /////////
194
+ /////////////////////////////////////////
195
+ /////////////////////////////////////////
196
+
197
+ function __parseObject(_inst, parse, payload, _) {
198
+ _coerceWithNil(payload, () => {
199
+ if (typeof payload.value === 'string') {
200
+ payload.value = JSON.parse(payload.value);
201
+ }
202
+ });
203
+ return parse(payload, _);
204
+ }
205
+
206
+ ////////////////////////////////////////
207
+ ////////////////////////////////////////
208
+ /// /////// /////////
209
+ /// /////// ZodArray /////////
210
+ /// /////// /////////
211
+ ////////////////////////////////////////
212
+ ////////////////////////////////////////
213
+
214
+ function __parseArray(_inst, parse, payload, _) {
215
+ _coerceWithNil(payload, () => {
216
+ if (typeof payload.value === 'string') {
217
+ if (payload.value.startsWith('[') && payload.value.endsWith(']')) {
218
+ payload.value = JSON.parse(payload.value);
219
+ } else {
220
+ payload.value = payload.value.split(',');
221
+ }
222
+ }
223
+ });
224
+ return parse(payload, _);
225
+ }
226
+
227
+ ///////////////////////////////////////////
228
+ ///////////////////////////////////////////
229
+ /// /////// /////////
230
+ /// /////// ZodOptional /////////
231
+ /// /////// /////////
232
+ ///////////////////////////////////////////
233
+ ///////////////////////////////////////////
234
+
235
+ function __parseOptional(_inst, parse, payload, _) {
236
+ if (isZodType(Metadata.unwrapUntil(_inst), 'ZodString')) {
237
+ _coerceString(payload);
238
+ } else {
239
+ _coerceWithNil(payload);
240
+ }
241
+ if (payload.value === null) {
242
+ payload.value = undefined;
243
+ }
244
+ return parse(payload, _);
245
+ }
246
+
247
+ ////////////////////////////////////////////
248
+ ////////////////////////////////////////////
249
+ /// /////// /////////
250
+ /// /////// ZodDefault /////////
251
+ /// /////// /////////
252
+ ////////////////////////////////////////////
253
+ ////////////////////////////////////////////
254
+
255
+ function __parseDefault(_inst, parse, payload, _) {
256
+ if (isZodType(Metadata.unwrapUntil(_inst), 'ZodString')) {
257
+ _coerceString(payload);
258
+ } else {
259
+ _coerceWithNil(payload);
260
+ }
261
+ return parse(payload, _);
262
+ }
263
+
264
+ ///////////////////////////////////////
265
+ ///////////////////////////////////////
266
+ /// /////// ///////
267
+ /// /////// coerce ///////
268
+ /// /////// ///////
269
+ ///////////////////////////////////////
270
+ ///////////////////////////////////////
271
+
272
+ // function _coerce(payload: IParsePayload, fn?: Function) {
273
+ // if (!isNil(payload.value)) {
274
+ // fn?.(payload);
275
+ // }
276
+ // }
277
+
278
+ function _coerceString(payload, fn) {
279
+ if (!isNil(payload.value)) {
280
+ if (payload.value === '') {
281
+ payload.value = undefined;
282
+ } else if (typeof payload.value !== 'string') {
283
+ payload.value = String(payload.value);
284
+ } else ;
285
+ }
286
+ }
287
+ function _coerceWithNil(payload, fn) {
288
+ if (!isNil(payload.value)) {
289
+ if (payload.value === 'undefined' || payload.value === '') {
290
+ payload.value = undefined;
291
+ } else if (payload.value === 'null') {
292
+ payload.value = null;
293
+ } else {
294
+ fn?.(payload);
295
+ }
296
+ }
297
+ }
298
+ function coerceWithNil(value, fn) {
299
+ const payload = {
300
+ value,
301
+ issues: []
302
+ };
303
+ _coerceWithNil(payload, fn);
304
+ return payload.value;
305
+ }
306
+ function getInnerTypeName(schema) {
307
+ return Metadata.unwrapUntil(schema).type;
308
+ }
309
+ // function _coerce(instance, input, fn) {
310
+ // if (instance._def.coerce !== false) {
311
+ // if (instance._def.coerce === true) instance._def.coerce = undefined as any;
312
+ // if (!isNil(payload.value)) {
313
+ // fn();
314
+ // }
315
+ // }
316
+ // }
317
+
318
+ export { coerceWithNil, getInnerTypeName, setParseAdapter };
package/package.json CHANGED
@@ -1,26 +1,27 @@
1
1
  {
2
2
  "name": "@cabloy/zod-query",
3
- "type": "module",
4
- "version": "2.0.3",
3
+ "version": "2.1.1",
4
+ "gitHead": "991189da4443b789fcf77872990b901ccf43bccb",
5
5
  "description": "zod-query",
6
- "publishConfig": {
7
- "access": "public"
6
+ "keywords": [
7
+ "ioc",
8
+ "vue3",
9
+ "zova"
10
+ ],
11
+ "homepage": "https://github.com/cabloy/zova#readme",
12
+ "bugs": {
13
+ "url": "https://github.com/cabloy/zova/issues"
8
14
  },
9
- "author": "zhennann",
10
15
  "license": "MIT",
11
- "homepage": "https://github.com/cabloy/zova#readme",
16
+ "author": "zhennann",
12
17
  "repository": {
13
18
  "type": "git",
14
19
  "url": "git+https://github.com/cabloy/zova.git"
15
20
  },
16
- "bugs": {
17
- "url": "https://github.com/cabloy/zova/issues"
18
- },
19
- "keywords": [
20
- "vue3",
21
- "ioc",
22
- "zova"
21
+ "files": [
22
+ "dist"
23
23
  ],
24
+ "type": "module",
24
25
  "exports": {
25
26
  ".": {
26
27
  "types": [
@@ -31,13 +32,14 @@
31
32
  },
32
33
  "./package.json": "./package.json"
33
34
  },
34
- "files": [
35
- "dist"
36
- ],
37
- "gitHead": "0eab9dc4a5622caffe89e7b1b3f02c08ccbc4c4b",
35
+ "publishConfig": {
36
+ "access": "public"
37
+ },
38
38
  "scripts": {
39
- "lint": "eslint .",
40
39
  "clean": "rimraf dist tsconfig.tsbuildinfo",
41
- "tsc:publish": "npm run clean && tsc"
40
+ "tsc:publish": "npm run clean && vona :bin:buildGeneral && tsc",
41
+ "prepublishOnly": "npm run tsc:publish",
42
+ "prepack": "clean-package",
43
+ "postpack": "clean-package restore"
42
44
  }
43
- }
45
+ }
package/dist/lib/metadata.js DELETED
@@ -1,31 +0,0 @@
1
- import { isAnyZodType, isZodType } from "./zod-is-type.js";
2
- export class Metadata {
3
- static unwrapUntil(schema, typeName) {
4
- if (typeName && isZodType(schema, typeName)) {
5
- return schema;
6
- }
7
- if (isZodType(schema, [
8
- 'ZodOptional',
9
- 'ZodNullable',
10
- 'ZodDefault',
11
- 'ZodReadonly',
12
- 'ZodNonOptional',
13
- ]) &&
14
- isAnyZodType(schema._zod.def.innerType)) {
15
- return this.unwrapUntil(schema._zod.def.innerType, typeName);
16
- }
17
- if (isZodType(schema, 'ZodPipe')) {
18
- const inSchema = schema._zod.def.in;
19
- const outSchema = schema._zod.def.out;
20
- // meaning preprocess
21
- if (isZodType(inSchema, 'ZodTransform') && isAnyZodType(outSchema)) {
22
- return this.unwrapUntil(outSchema, typeName);
23
- }
24
- // meaning transform
25
- if (isAnyZodType(inSchema)) {
26
- return this.unwrapUntil(inSchema, typeName);
27
- }
28
- }
29
- return typeName ? undefined : schema;
30
- }
31
- }
package/dist/lib/query.js DELETED
@@ -1,223 +0,0 @@
1
- import { z } from 'zod';
2
- import { Metadata } from "./metadata.js";
3
- import { isNil } from "./utils.js";
4
- import { isZodType } from "./zod-is-type.js";
5
- let ZodMetadata;
6
- export function setParseAdapter(zodMetadata) {
7
- ZodMetadata = zodMetadata;
8
- (z.core).setParseAdapter(__parseAdapter);
9
- }
10
- function __parseAdapter(inst, parse) {
11
- return (payload, _) => {
12
- const type = inst.type;
13
- switch (type) {
14
- case 'string': return __parseString(inst, parse, payload, _);
15
- case 'number': return __parseNumber(inst, parse, payload, _);
16
- case 'bigint': return __parseBigInt(inst, parse, payload, _);
17
- case 'boolean': return __parseBoolean(inst, parse, payload, _);
18
- case 'date': return __parseDate(inst, parse, payload, _);
19
- case 'object': return __parseObject(inst, parse, payload, _);
20
- case 'array': return __parseArray(inst, parse, payload, _);
21
- case 'optional': return __parseOptional(inst, parse, payload, _);
22
- case 'default': return __parseDefault(inst, parse, payload, _);
23
- }
24
- return parse(payload, _);
25
- };
26
- }
27
- /////////////////////////////////////////
28
- /////////////////////////////////////////
29
- /// /////// /////////
30
- /// /////// ZodString /////////
31
- /// /////// /////////
32
- /////////////////////////////////////////
33
- /////////////////////////////////////////
34
- function __parseString(inst, parse, payload, _) {
35
- const metadata = ZodMetadata?.getOpenapiMetadata(inst);
36
- if (metadata?.format === 'binary' && !isNil(payload.value)) {
37
- // ignore upload file
38
- return payload;
39
- }
40
- _coerceString(payload);
41
- return parse(payload, _);
42
- }
43
- /////////////////////////////////////////
44
- /////////////////////////////////////////
45
- /// /////// /////////
46
- /// /////// ZodNumber /////////
47
- /// /////// /////////
48
- /////////////////////////////////////////
49
- /////////////////////////////////////////
50
- function __parseNumber(_inst, parse, payload, _) {
51
- _coerceWithNil(payload, () => {
52
- payload.value = Number(payload.value);
53
- });
54
- return parse(payload, _);
55
- }
56
- /////////////////////////////////////////
57
- /////////////////////////////////////////
58
- /// /////// /////////
59
- /// /////// ZodBigInt /////////
60
- /// /////// /////////
61
- /////////////////////////////////////////
62
- /////////////////////////////////////////
63
- function __parseBigInt(_inst, parse, payload, _) {
64
- _coerceWithNil(payload, () => {
65
- payload.value = BigInt(payload.value);
66
- });
67
- return parse(payload, _);
68
- }
69
- //////////////////////////////////////////
70
- //////////////////////////////////////////
71
- /// /////// //////////
72
- /// /////// ZodBoolean /////////
73
- /// /////// //////////
74
- //////////////////////////////////////////
75
- //////////////////////////////////////////
76
- function __parseBoolean(_inst, parse, payload, _) {
77
- _coerceWithNil(payload, () => {
78
- if (payload.value === 'false' || payload.value === '0') {
79
- payload.value = false;
80
- }
81
- else {
82
- payload.value = Boolean(payload.value);
83
- }
84
- });
85
- return parse(payload, _);
86
- }
87
- ///////////////////////////////////////
88
- ///////////////////////////////////////
89
- /// /////// ///////
90
- /// /////// ZodDate ///////
91
- /// /////// ///////
92
- ///////////////////////////////////////
93
- ///////////////////////////////////////
94
- function __parseDate(_inst, parse, payload, _) {
95
- _coerceWithNil(payload, () => {
96
- payload.value = new Date(payload.value);
97
- });
98
- return parse(payload, _);
99
- }
100
- /////////////////////////////////////////
101
- /////////////////////////////////////////
102
- /// /////// /////////
103
- /// /////// ZodObject /////////
104
- /// /////// /////////
105
- /////////////////////////////////////////
106
- /////////////////////////////////////////
107
- function __parseObject(_inst, parse, payload, _) {
108
- _coerceWithNil(payload, () => {
109
- if (typeof payload.value === 'string') {
110
- payload.value = JSON.parse(payload.value);
111
- }
112
- });
113
- return parse(payload, _);
114
- }
115
- ////////////////////////////////////////
116
- ////////////////////////////////////////
117
- /// /////// /////////
118
- /// /////// ZodArray /////////
119
- /// /////// /////////
120
- ////////////////////////////////////////
121
- ////////////////////////////////////////
122
- function __parseArray(_inst, parse, payload, _) {
123
- _coerceWithNil(payload, () => {
124
- if (typeof payload.value === 'string') {
125
- if (payload.value.startsWith('[') && payload.value.endsWith(']')) {
126
- payload.value = JSON.parse(payload.value);
127
- }
128
- else {
129
- payload.value = payload.value.split(',');
130
- }
131
- }
132
- });
133
- return parse(payload, _);
134
- }
135
- ///////////////////////////////////////////
136
- ///////////////////////////////////////////
137
- /// /////// /////////
138
- /// /////// ZodOptional /////////
139
- /// /////// /////////
140
- ///////////////////////////////////////////
141
- ///////////////////////////////////////////
142
- function __parseOptional(_inst, parse, payload, _) {
143
- if (isZodType(Metadata.unwrapUntil(_inst), 'ZodString')) {
144
- _coerceString(payload);
145
- }
146
- else {
147
- _coerceWithNil(payload);
148
- }
149
- if (payload.value === null) {
150
- payload.value = undefined;
151
- }
152
- return parse(payload, _);
153
- }
154
- ////////////////////////////////////////////
155
- ////////////////////////////////////////////
156
- /// /////// /////////
157
- /// /////// ZodDefault /////////
158
- /// /////// /////////
159
- ////////////////////////////////////////////
160
- ////////////////////////////////////////////
161
- function __parseDefault(_inst, parse, payload, _) {
162
- if (isZodType(Metadata.unwrapUntil(_inst), 'ZodString')) {
163
- _coerceString(payload);
164
- }
165
- else {
166
- _coerceWithNil(payload);
167
- }
168
- return parse(payload, _);
169
- }
170
- ///////////////////////////////////////
171
- ///////////////////////////////////////
172
- /// /////// ///////
173
- /// /////// coerce ///////
174
- /// /////// ///////
175
- ///////////////////////////////////////
176
- ///////////////////////////////////////
177
- // function _coerce(payload: IParsePayload, fn?: Function) {
178
- // if (!isNil(payload.value)) {
179
- // fn?.(payload);
180
- // }
181
- // }
182
- function _coerceString(payload, fn) {
183
- if (!isNil(payload.value)) {
184
- if (payload.value === '') {
185
- payload.value = undefined;
186
- }
187
- else if (typeof payload.value !== 'string') {
188
- payload.value = String(payload.value);
189
- }
190
- else {
191
- fn?.(payload);
192
- }
193
- }
194
- }
195
- function _coerceWithNil(payload, fn) {
196
- if (!isNil(payload.value)) {
197
- if (payload.value === 'undefined' || payload.value === '') {
198
- payload.value = undefined;
199
- }
200
- else if (payload.value === 'null') {
201
- payload.value = null;
202
- }
203
- else {
204
- fn?.(payload);
205
- }
206
- }
207
- }
208
- export function coerceWithNil(value, fn) {
209
- const payload = { value, issues: [] };
210
- _coerceWithNil(payload, fn);
211
- return payload.value;
212
- }
213
- export function getInnerTypeName(schema) {
214
- return Metadata.unwrapUntil(schema).type;
215
- }
216
- // function _coerce(instance, input, fn) {
217
- // if (instance._def.coerce !== false) {
218
- // if (instance._def.coerce === true) instance._def.coerce = undefined as any;
219
- // if (!isNil(payload.value)) {
220
- // fn();
221
- // }
222
- // }
223
- // }
package/dist/lib/utils.js DELETED
@@ -1,2 +0,0 @@
1
- export const isUndefined = (obj) => typeof obj === 'undefined';
2
- export const isNil = (val) => isUndefined(val) || val === null;
package/dist/lib/zod-is-type.js DELETED
@@ -1,58 +0,0 @@
1
- ;
2
- const ZodTypeKeys = {
3
- ZodAny: 'any',
4
- ZodArray: 'array',
5
- ZodBigInt: 'bigint',
6
- ZodBoolean: 'boolean',
7
- ZodDefault: 'default',
8
- ZodTransform: 'transform',
9
- ZodEnum: 'enum',
10
- ZodIntersection: 'intersection',
11
- ZodLiteral: 'literal',
12
- ZodNever: 'never',
13
- ZodNull: 'null',
14
- ZodNullable: 'nullable',
15
- ZodNumber: 'number',
16
- ZodNonOptional: 'nonoptional',
17
- ZodObject: 'object',
18
- ZodOptional: 'optional',
19
- ZodPipe: 'pipe',
20
- ZodReadonly: 'readonly',
21
- ZodRecord: 'record',
22
- ZodString: 'string',
23
- ZodTuple: 'tuple',
24
- ZodType: 'type',
25
- ZodUnion: 'union',
26
- ZodDiscriminatedUnion: 'union',
27
- ZodUnknown: 'unknown',
28
- ZodVoid: 'void',
29
- ZodDate: 'date',
30
- };
31
- export function isZodType(schema, typeNames) {
32
- const typeNamesArray = Array.isArray(typeNames) ? typeNames : [typeNames];
33
- return typeNamesArray.some(typeName => {
34
- const typeNameMatch = schema?.def?.type === ZodTypeKeys[typeName];
35
- if (typeName === 'ZodDiscriminatedUnion') {
36
- return (typeNameMatch &&
37
- 'discriminator' in schema.def);
38
- }
39
- return typeNameMatch;
40
- });
41
- }
42
- export function isAnyZodType(schema) {
43
- return 'def' in schema;
44
- }
45
- /**
46
- * The schema.isNullable() is deprecated. This is the suggested replacement
47
- * as this was how isNullable operated beforehand.
48
- */
49
- export function isNullableSchema(schema) {
50
- return schema.safeParse(null).success;
51
- }
52
- /**
53
- * The schema.isOptional() is deprecated. This is the suggested replacement
54
- * as this was how isOptional operated beforehand.
55
- */
56
- export function isOptionalSchema(schema) {
57
- return schema.safeParse(undefined).success;
58
- }