@sinclair/typebox 0.26.0-dev.4 → 0.26.0-dev.5

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 (18) hide show
  1. package/compiler/compiler.d.ts +9 -4
  2. package/compiler/compiler.js +121 -97
  3. package/errors/errors.d.ts +5 -1
  4. package/errors/errors.js +173 -157
  5. package/package.json +1 -1
  6. package/readme.md +70 -71
  7. package/typebox.d.ts +16 -27
  8. package/typebox.js +104 -163
  9. package/value/cast.d.ts +6 -2
  10. package/value/cast.js +130 -111
  11. package/value/check.d.ts +5 -1
  12. package/value/check.js +168 -154
  13. package/value/convert.d.ts +6 -6
  14. package/value/convert.js +83 -74
  15. package/value/create.d.ts +6 -2
  16. package/value/create.js +102 -77
  17. package/value/value.d.ts +13 -3
  18. package/value/value.js +15 -15
package/value/check.js CHANGED
@@ -27,10 +27,13 @@ THE SOFTWARE.
27
27
 
28
28
  ---------------------------------------------------------------------------*/
29
29
  Object.defineProperty(exports, "__esModule", { value: true });
30
- exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
30
+ exports.ValueCheck = exports.ValueCheckDereferenceError = exports.ValueCheckUnknownTypeError = void 0;
31
31
  const Types = require("../typebox");
32
32
  const index_1 = require("../system/index");
33
33
  const hash_1 = require("./hash");
34
+ // -------------------------------------------------------------------------
35
+ // Errors
36
+ // -------------------------------------------------------------------------
34
37
  class ValueCheckUnknownTypeError extends Error {
35
38
  constructor(schema) {
36
39
  super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
@@ -38,31 +41,59 @@ class ValueCheckUnknownTypeError extends Error {
38
41
  }
39
42
  }
40
43
  exports.ValueCheckUnknownTypeError = ValueCheckUnknownTypeError;
44
+ class ValueCheckDereferenceError extends Error {
45
+ constructor(schema) {
46
+ super(`ValueCheck: Unable to dereference schema with $id '${schema.$ref}'`);
47
+ this.schema = schema;
48
+ }
49
+ }
50
+ exports.ValueCheckDereferenceError = ValueCheckDereferenceError;
41
51
  var ValueCheck;
42
52
  (function (ValueCheck) {
43
- // --------------------------------------------------------
53
+ // ----------------------------------------------------------------------
44
54
  // Guards
45
- // --------------------------------------------------------
55
+ // ----------------------------------------------------------------------
56
+ function IsObject(value) {
57
+ const result = typeof value === 'object' && value !== null;
58
+ return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
59
+ }
60
+ function IsRecordObject(value) {
61
+ return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
62
+ }
46
63
  function IsBigInt(value) {
47
64
  return typeof value === 'bigint';
48
65
  }
49
66
  function IsNumber(value) {
50
- return typeof value === 'number' && globalThis.Number.isFinite(value);
67
+ const result = typeof value === 'number';
68
+ return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
51
69
  }
52
- // --------------------------------------------------------
53
- // Guards
54
- // --------------------------------------------------------
55
- function Any(schema, value) {
70
+ function IsInteger(value) {
71
+ return globalThis.Number.isInteger(value);
72
+ }
73
+ function IsString(value) {
74
+ return typeof value === 'string';
75
+ }
76
+ function IsVoid(value) {
77
+ const result = value === undefined;
78
+ return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
79
+ }
80
+ function IsDefined(value) {
81
+ return value !== undefined;
82
+ }
83
+ // ----------------------------------------------------------------------
84
+ // Types
85
+ // ----------------------------------------------------------------------
86
+ function Any(schema, references, value) {
56
87
  return true;
57
88
  }
58
- function Array(schema, value) {
89
+ function Array(schema, references, value) {
59
90
  if (!globalThis.Array.isArray(value)) {
60
91
  return false;
61
92
  }
62
- if (IsNumber(schema.minItems) && !(value.length >= schema.minItems)) {
93
+ if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
63
94
  return false;
64
95
  }
65
- if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
96
+ if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) {
66
97
  return false;
67
98
  }
68
99
  // prettier-ignore
@@ -77,82 +108,82 @@ var ValueCheck;
77
108
  } return true; })())) {
78
109
  return false;
79
110
  }
80
- return value.every((value) => Visit(schema.items, value));
111
+ return value.every((value) => Visit(schema.items, references, value));
81
112
  }
82
- function BigInt(schema, value) {
83
- if (typeof value !== 'bigint') {
113
+ function BigInt(schema, references, value) {
114
+ if (!IsBigInt(value)) {
84
115
  return false;
85
116
  }
86
- if (IsBigInt(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
117
+ if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
87
118
  return false;
88
119
  }
89
- if (IsBigInt(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
120
+ if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
90
121
  return false;
91
122
  }
92
- if (IsBigInt(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
123
+ if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
93
124
  return false;
94
125
  }
95
- if (IsBigInt(schema.minimum) && !(value >= schema.minimum)) {
126
+ if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
96
127
  return false;
97
128
  }
98
- if (IsBigInt(schema.maximum) && !(value <= schema.maximum)) {
129
+ if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
99
130
  return false;
100
131
  }
101
132
  return true;
102
133
  }
103
- function Boolean(schema, value) {
134
+ function Boolean(schema, references, value) {
104
135
  return typeof value === 'boolean';
105
136
  }
106
- function Constructor(schema, value) {
107
- return Visit(schema.returns, value.prototype);
137
+ function Constructor(schema, references, value) {
138
+ return Visit(schema.returns, references, value.prototype);
108
139
  }
109
- function Date(schema, value) {
140
+ function Date(schema, references, value) {
110
141
  if (!(value instanceof globalThis.Date)) {
111
142
  return false;
112
143
  }
113
- if (!globalThis.Number.isFinite(value.getTime())) {
144
+ if (!IsNumber(value.getTime())) {
114
145
  return false;
115
146
  }
116
- if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
147
+ if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
117
148
  return false;
118
149
  }
119
- if (IsNumber(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
150
+ if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
120
151
  return false;
121
152
  }
122
- if (IsNumber(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
153
+ if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
123
154
  return false;
124
155
  }
125
- if (IsNumber(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
156
+ if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
126
157
  return false;
127
158
  }
128
159
  return true;
129
160
  }
130
- function Function(schema, value) {
161
+ function Function(schema, references, value) {
131
162
  return typeof value === 'function';
132
163
  }
133
- function Integer(schema, value) {
134
- if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
164
+ function Integer(schema, references, value) {
165
+ if (!IsInteger(value)) {
135
166
  return false;
136
167
  }
137
- if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
168
+ if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
138
169
  return false;
139
170
  }
140
- if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
171
+ if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
141
172
  return false;
142
173
  }
143
- if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
174
+ if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
144
175
  return false;
145
176
  }
146
- if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
177
+ if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
147
178
  return false;
148
179
  }
149
- if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
180
+ if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
150
181
  return false;
151
182
  }
152
183
  return true;
153
184
  }
154
- function Intersect(schema, value) {
155
- if (!schema.allOf.every((schema) => Visit(schema, value))) {
185
+ function Intersect(schema, references, value) {
186
+ if (!schema.allOf.every((schema) => Visit(schema, references, value))) {
156
187
  return false;
157
188
  }
158
189
  else if (schema.unevaluatedProperties === false) {
@@ -163,62 +194,48 @@ var ValueCheck;
163
194
  else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
164
195
  const schemaKeys = Types.KeyResolver.Resolve(schema);
165
196
  const valueKeys = globalThis.Object.getOwnPropertyNames(value);
166
- return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.unevaluatedProperties, value[key]));
197
+ return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.unevaluatedProperties, references, value[key]));
167
198
  }
168
199
  else {
169
200
  return true;
170
201
  }
171
202
  }
172
- function Literal(schema, value) {
203
+ function Literal(schema, references, value) {
173
204
  return value === schema.const;
174
205
  }
175
- function Never(schema, value) {
206
+ function Never(schema, references, value) {
176
207
  return false;
177
208
  }
178
- function Not(schema, value) {
179
- return !Visit(schema.allOf[0].not, value) && Visit(schema.allOf[1], value);
209
+ function Not(schema, references, value) {
210
+ return !Visit(schema.allOf[0].not, references, value) && Visit(schema.allOf[1], references, value);
180
211
  }
181
- function Null(schema, value) {
212
+ function Null(schema, references, value) {
182
213
  return value === null;
183
214
  }
184
- function Number(schema, value) {
185
- if (index_1.TypeSystem.AllowNaN) {
186
- if (!(typeof value === 'number')) {
187
- return false;
188
- }
189
- }
190
- else {
191
- if (!(typeof value === 'number' && globalThis.Number.isFinite(value))) {
192
- return false;
193
- }
215
+ function Number(schema, references, value) {
216
+ if (!IsNumber(value)) {
217
+ return false;
194
218
  }
195
- if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
219
+ if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
196
220
  return false;
197
221
  }
198
- if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
222
+ if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
199
223
  return false;
200
224
  }
201
- if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
225
+ if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
202
226
  return false;
203
227
  }
204
- if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
228
+ if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
205
229
  return false;
206
230
  }
207
- if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
231
+ if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
208
232
  return false;
209
233
  }
210
234
  return true;
211
235
  }
212
- function Object(schema, value) {
213
- if (index_1.TypeSystem.AllowArrayObjects) {
214
- if (!(typeof value === 'object' && value !== null)) {
215
- return false;
216
- }
217
- }
218
- else {
219
- if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
220
- return false;
221
- }
236
+ function Object(schema, references, value) {
237
+ if (!IsObject(value)) {
238
+ return false;
222
239
  }
223
240
  if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
224
241
  return false;
@@ -226,19 +243,19 @@ var ValueCheck;
226
243
  if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
227
244
  return false;
228
245
  }
229
- const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
230
- for (const schemaKey of schemaKeys) {
231
- const property = schema.properties[schemaKey];
232
- if (schema.required && schema.required.includes(schemaKey)) {
233
- if (!Visit(property, value[schemaKey])) {
246
+ const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
247
+ for (const knownKey of knownKeys) {
248
+ const property = schema.properties[knownKey];
249
+ if (schema.required && schema.required.includes(knownKey)) {
250
+ if (!Visit(property, references, value[knownKey])) {
234
251
  return false;
235
252
  }
236
253
  if (Types.ExtendsUndefined.Check(property)) {
237
- return schemaKey in value;
254
+ return knownKey in value;
238
255
  }
239
256
  }
240
257
  else {
241
- if (schemaKey in value && !Visit(property, value[schemaKey])) {
258
+ if (knownKey in value && !Visit(property, references, value[knownKey])) {
242
259
  return false;
243
260
  }
244
261
  }
@@ -246,34 +263,27 @@ var ValueCheck;
246
263
  if (schema.additionalProperties === false) {
247
264
  const valueKeys = globalThis.Object.getOwnPropertyNames(value);
248
265
  // optimization: value is valid if schemaKey length matches the valueKey length
249
- if (schema.required && schema.required.length === schemaKeys.length && valueKeys.length === schemaKeys.length) {
266
+ if (schema.required && schema.required.length === knownKeys.length && valueKeys.length === knownKeys.length) {
250
267
  return true;
251
268
  }
252
269
  else {
253
- return valueKeys.every((valueKey) => schemaKeys.includes(valueKey));
270
+ return valueKeys.every((valueKey) => knownKeys.includes(valueKey));
254
271
  }
255
272
  }
256
273
  else if (typeof schema.additionalProperties === 'object') {
257
274
  const valueKeys = globalThis.Object.getOwnPropertyNames(value);
258
- return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.additionalProperties, value[key]));
275
+ return valueKeys.every((key) => knownKeys.includes(key) || Visit(schema.additionalProperties, references, value[key]));
259
276
  }
260
277
  else {
261
278
  return true;
262
279
  }
263
280
  }
264
- function Promise(schema, value) {
281
+ function Promise(schema, references, value) {
265
282
  return typeof value === 'object' && typeof value.then === 'function';
266
283
  }
267
- function Record(schema, value) {
268
- if (index_1.TypeSystem.AllowArrayObjects) {
269
- if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
270
- return false;
271
- }
272
- }
273
- else {
274
- if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
275
- return false;
276
- }
284
+ function Record(schema, references, value) {
285
+ if (!IsRecordObject(value)) {
286
+ return false;
277
287
  }
278
288
  const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
279
289
  const regex = new RegExp(keyPattern);
@@ -281,35 +291,43 @@ var ValueCheck;
281
291
  return false;
282
292
  }
283
293
  for (const propValue of globalThis.Object.values(value)) {
284
- if (!Visit(valueSchema, propValue))
294
+ if (!Visit(valueSchema, references, propValue))
285
295
  return false;
286
296
  }
287
297
  return true;
288
298
  }
289
- function Ref(schema, value) {
290
- return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
299
+ function Ref(schema, references, value) {
300
+ const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
301
+ if (index === -1)
302
+ throw new ValueCheckDereferenceError(schema);
303
+ const target = references[index];
304
+ return Visit(target, references, value);
291
305
  }
292
- function Self(schema, value) {
293
- return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
306
+ function Self(schema, references, value) {
307
+ const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
308
+ if (index === -1)
309
+ throw new ValueCheckDereferenceError(schema);
310
+ const target = references[index];
311
+ return Visit(target, references, value);
294
312
  }
295
- function String(schema, value) {
296
- if (!(typeof value === 'string')) {
313
+ function String(schema, references, value) {
314
+ if (!IsString(value)) {
297
315
  return false;
298
316
  }
299
- if (IsNumber(schema.minLength)) {
317
+ if (IsDefined(schema.minLength)) {
300
318
  if (!(value.length >= schema.minLength))
301
319
  return false;
302
320
  }
303
- if (IsNumber(schema.maxLength)) {
321
+ if (IsDefined(schema.maxLength)) {
304
322
  if (!(value.length <= schema.maxLength))
305
323
  return false;
306
324
  }
307
- if (schema.pattern !== undefined) {
325
+ if (IsDefined(schema.pattern)) {
308
326
  const regex = new RegExp(schema.pattern);
309
327
  if (!regex.test(value))
310
328
  return false;
311
329
  }
312
- if (schema.format !== undefined) {
330
+ if (IsDefined(schema.format)) {
313
331
  if (!Types.FormatRegistry.Has(schema.format))
314
332
  return false;
315
333
  const func = Types.FormatRegistry.Get(schema.format);
@@ -317,13 +335,13 @@ var ValueCheck;
317
335
  }
318
336
  return true;
319
337
  }
320
- function Symbol(schema, value) {
338
+ function Symbol(schema, references, value) {
321
339
  if (!(typeof value === 'symbol')) {
322
340
  return false;
323
341
  }
324
342
  return true;
325
343
  }
326
- function Tuple(schema, value) {
344
+ function Tuple(schema, references, value) {
327
345
  if (!globalThis.Array.isArray(value)) {
328
346
  return false;
329
347
  }
@@ -337,114 +355,110 @@ var ValueCheck;
337
355
  return true;
338
356
  }
339
357
  for (let i = 0; i < schema.items.length; i++) {
340
- if (!Visit(schema.items[i], value[i]))
358
+ if (!Visit(schema.items[i], references, value[i]))
341
359
  return false;
342
360
  }
343
361
  return true;
344
362
  }
345
- function Undefined(schema, value) {
363
+ function Undefined(schema, references, value) {
346
364
  return value === undefined;
347
365
  }
348
- function Union(schema, value) {
349
- return schema.anyOf.some((inner) => Visit(inner, value));
366
+ function Union(schema, references, value) {
367
+ return schema.anyOf.some((inner) => Visit(inner, references, value));
350
368
  }
351
- function Uint8Array(schema, value) {
369
+ function Uint8Array(schema, references, value) {
352
370
  if (!(value instanceof globalThis.Uint8Array)) {
353
371
  return false;
354
372
  }
355
- if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
373
+ if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
356
374
  return false;
357
375
  }
358
- if (IsNumber(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
376
+ if (IsDefined(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
359
377
  return false;
360
378
  }
361
379
  return true;
362
380
  }
363
- function Unknown(schema, value) {
381
+ function Unknown(schema, references, value) {
364
382
  return true;
365
383
  }
366
- function Void(schema, value) {
367
- if (index_1.TypeSystem.AllowVoidNull) {
368
- return value === undefined || value === null;
369
- }
370
- else {
371
- return value === undefined;
372
- }
384
+ function Void(schema, references, value) {
385
+ return IsVoid(value);
373
386
  }
374
- function UserDefined(schema, value) {
387
+ function UserDefined(schema, references, value) {
375
388
  if (!Types.TypeRegistry.Has(schema[Types.Kind]))
376
389
  return false;
377
390
  const func = Types.TypeRegistry.Get(schema[Types.Kind]);
378
391
  return func(schema, value);
379
392
  }
380
- function Visit(schema, value) {
381
- const anySchema = schema;
382
- switch (anySchema[Types.Kind]) {
393
+ function Visit(schema, references, value) {
394
+ const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
395
+ const schema_ = schema;
396
+ switch (schema_[Types.Kind]) {
383
397
  case 'Any':
384
- return Any(anySchema, value);
398
+ return Any(schema_, references_, value);
385
399
  case 'Array':
386
- return Array(anySchema, value);
400
+ return Array(schema_, references_, value);
387
401
  case 'BigInt':
388
- return BigInt(anySchema, value);
402
+ return BigInt(schema_, references_, value);
389
403
  case 'Boolean':
390
- return Boolean(anySchema, value);
404
+ return Boolean(schema_, references_, value);
391
405
  case 'Constructor':
392
- return Constructor(anySchema, value);
406
+ return Constructor(schema_, references_, value);
393
407
  case 'Date':
394
- return Date(anySchema, value);
408
+ return Date(schema_, references_, value);
395
409
  case 'Function':
396
- return Function(anySchema, value);
410
+ return Function(schema_, references_, value);
397
411
  case 'Integer':
398
- return Integer(anySchema, value);
412
+ return Integer(schema_, references_, value);
399
413
  case 'Intersect':
400
- return Intersect(anySchema, value);
414
+ return Intersect(schema_, references_, value);
401
415
  case 'Literal':
402
- return Literal(anySchema, value);
416
+ return Literal(schema_, references_, value);
403
417
  case 'Never':
404
- return Never(anySchema, value);
418
+ return Never(schema_, references_, value);
405
419
  case 'Not':
406
- return Not(anySchema, value);
420
+ return Not(schema_, references_, value);
407
421
  case 'Null':
408
- return Null(anySchema, value);
422
+ return Null(schema_, references_, value);
409
423
  case 'Number':
410
- return Number(anySchema, value);
424
+ return Number(schema_, references_, value);
411
425
  case 'Object':
412
- return Object(anySchema, value);
426
+ return Object(schema_, references_, value);
413
427
  case 'Promise':
414
- return Promise(anySchema, value);
428
+ return Promise(schema_, references_, value);
415
429
  case 'Record':
416
- return Record(anySchema, value);
430
+ return Record(schema_, references_, value);
417
431
  case 'Ref':
418
- return Ref(anySchema, value);
432
+ return Ref(schema_, references_, value);
419
433
  case 'Self':
420
- return Self(anySchema, value);
434
+ return Self(schema_, references_, value);
421
435
  case 'String':
422
- return String(anySchema, value);
436
+ return String(schema_, references_, value);
423
437
  case 'Symbol':
424
- return Symbol(anySchema, value);
438
+ return Symbol(schema_, references_, value);
425
439
  case 'Tuple':
426
- return Tuple(anySchema, value);
440
+ return Tuple(schema_, references_, value);
427
441
  case 'Undefined':
428
- return Undefined(anySchema, value);
442
+ return Undefined(schema_, references_, value);
429
443
  case 'Union':
430
- return Union(anySchema, value);
444
+ return Union(schema_, references_, value);
431
445
  case 'Uint8Array':
432
- return Uint8Array(anySchema, value);
446
+ return Uint8Array(schema_, references_, value);
433
447
  case 'Unknown':
434
- return Unknown(anySchema, value);
448
+ return Unknown(schema_, references_, value);
435
449
  case 'Void':
436
- return Void(anySchema, value);
450
+ return Void(schema_, references_, value);
437
451
  default:
438
- if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
439
- throw new ValueCheckUnknownTypeError(anySchema);
440
- return UserDefined(anySchema, value);
452
+ if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
453
+ throw new ValueCheckUnknownTypeError(schema_);
454
+ return UserDefined(schema_, references_, value);
441
455
  }
442
456
  }
443
457
  // -------------------------------------------------------------------------
444
458
  // Check
445
459
  // -------------------------------------------------------------------------
446
- function Check(schema, value) {
447
- return Visit(schema, value);
460
+ function Check(schema, references, value) {
461
+ return Visit(schema, references, value);
448
462
  }
449
463
  ValueCheck.Check = Check;
450
464
  })(ValueCheck = exports.ValueCheck || (exports.ValueCheck = {}));
package/value/convert.d.ts CHANGED
@@ -1,13 +1,13 @@
1
1
  import * as Types from '../typebox';
2
- export declare class ValueConvertReferenceTypeError extends Error {
3
- readonly schema: Types.TRef | Types.TSelf;
4
- constructor(schema: Types.TRef | Types.TSelf);
5
- }
6
2
  export declare class ValueConvertUnknownTypeError extends Error {
7
3
  readonly schema: Types.TSchema;
8
4
  constructor(schema: Types.TSchema);
9
5
  }
6
+ export declare class ValueConvertDereferenceError extends Error {
7
+ readonly schema: Types.TRef | Types.TSelf;
8
+ constructor(schema: Types.TRef | Types.TSelf);
9
+ }
10
10
  export declare namespace ValueConvert {
11
- function Visit(schema: Types.TSchema, value: any): unknown;
12
- function Convert<T extends Types.TSchema>(schema: T, value: any): unknown;
11
+ function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown;
12
+ function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): unknown;
13
13
  }