@sinclair/typebox 0.27.4 → 0.27.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.4",
+  "version": "0.27.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -101,7 +101,7 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
-- [TypeSystem](#typecheck)
+- [TypeSystem](#typesystem)
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
@@ -402,7 +402,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
 │   Type.String(),               │   string,                   │   type: 'object',              │
-│   Type.Number()                │   number,                   │   patternProperties: {         │
+│   Type.Number()                │   number                    │   patternProperties: {         │
 │ )                              │ >                           │     '^.*$': {                  │
 │                                │                             │       type: 'number'           │
 │                                │                             │     }                          │

package/typebox.d.ts

@@ -3,7 +3,7 @@ export declare const Hint: unique symbol;
 export declare const Kind: unique symbol;
 export declare const PatternBoolean = "(true|false)";
 export declare const PatternNumber = "(0|[1-9][0-9]*)";
-export declare const PatternString = ".*";
+export declare const PatternString = "(.*)";
 export declare const PatternBooleanExact: string;
 export declare const PatternNumberExact: string;
 export declare const PatternStringExact: string;
@@ -183,7 +183,7 @@ export type TKeyOfTuple<T extends TSchema> = {
 } extends infer U ? UnionToTuple<Exclude<{
     [K in keyof U]: U[K];
 }[keyof U], undefined>> : never;
-export type TKeyOf<T extends TSchema = TSchema> = (T extends TComposite ? TKeyOfTuple<T> : T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : T extends TRecord<infer K> ? [K] : [
+export type TKeyOf<T extends TSchema = TSchema> = (T extends TComposite ? TKeyOfTuple<T> : T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : T extends TRecursive<infer S> ? TKeyOfTuple<S> : T extends TRecord<infer K> ? [K] : [
 ]) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
 export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
@@ -248,7 +248,7 @@ export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
     [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
 }, TSchema[]>;
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
-export type TOmit<T extends TSchema, K extends keyof any> = T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
+export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
 export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
 export type TPartialObjectArray<T extends TObject[]> = Assert<{
     [K in keyof T]: TPartial<Assert<T[K], TObject>>;
@@ -266,7 +266,7 @@ export type TPickArray<T extends TSchema[], K extends keyof any> = {
 export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
     [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
 }) : never;
-export type TPick<T extends TSchema, K extends keyof any> = T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
+export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
     static: Promise<Static<T, this['params']>>;
@@ -277,7 +277,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{
     [_ in Static<K>]: T;
 }>>>;
-export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<TString, T>;
+export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<K, T>;
 export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{
     [X in Static<K>]: T;
 }>> : never;

package/typebox.js

@@ -39,7 +39,7 @@ exports.Kind = Symbol.for('TypeBox.Kind');
 // --------------------------------------------------------------------------
 exports.PatternBoolean = '(true|false)';
 exports.PatternNumber = '(0|[1-9][0-9]*)';
-exports.PatternString = '.*';
+exports.PatternString = '(.*)';
 exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
 exports.PatternNumberExact = `^${exports.PatternNumber}$`;
 exports.PatternStringExact = `^${exports.PatternString}$`;
@@ -1520,9 +1520,6 @@ class TemplateLiteralParserError extends Error {
 exports.TemplateLiteralParserError = TemplateLiteralParserError;
 var TemplateLiteralParser;
 (function (TemplateLiteralParser) {
-    function Unescape(value) {
-        return value.replace(/\\/g, '');
-    }
     function IsNonEscaped(pattern, index, char) {
         return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
     }
@@ -1647,7 +1644,7 @@ var TemplateLiteralParser;
             return Or(pattern);
         if (IsPrecedenceAnd(pattern))
             return And(pattern);
-        return { type: 'const', const: Unescape(pattern) };
+        return { type: 'const', const: pattern };
     }
     TemplateLiteralParser.Parse = Parse;
     /** Parses a pattern and strips forward and trailing ^ and $ */
@@ -1662,10 +1659,22 @@ var TemplateLiteralParser;
 var TemplateLiteralFinite;
 (function (TemplateLiteralFinite) {
     function IsNumber(expression) {
-        return expression.type === 'or' && expression.expr.length === 2 && expression.expr[0].type === 'const' && expression.expr[0].const === '0' && expression.expr[1].type === 'const' && expression.expr[1].const === '[1-9][0-9]*';
+        // prettier-ignore
+        return (expression.type === 'or' &&
+            expression.expr.length === 2 &&
+            expression.expr[0].type === 'const' &&
+            expression.expr[0].const === '0' &&
+            expression.expr[1].type === 'const' &&
+            expression.expr[1].const === '[1-9][0-9]*');
     }
     function IsBoolean(expression) {
-        return expression.type === 'or' && expression.expr.length === 2 && expression.expr[0].type === 'const' && expression.expr[0].const === 'true' && expression.expr[1].type === 'const' && expression.expr[1].const === 'false';
+        // prettier-ignore
+        return (expression.type === 'or' &&
+            expression.expr.length === 2 &&
+            expression.expr[0].type === 'const' &&
+            expression.expr[0].const === 'true' &&
+            expression.expr[1].type === 'const' &&
+            expression.expr[1].const === 'false');
     }
     function IsString(expression) {
         return expression.type === 'const' && expression.const === '.*';

package/value/create.js

@@ -49,7 +49,7 @@ class ValueCreateNeverTypeError extends Error {
 exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
 class ValueCreateIntersectTypeError extends Error {
     constructor(schema) {
-        super('ValueCreate: Can only create values for intersected objects and non-varying primitive types. Consider using a default value.');
+        super('ValueCreate: Intersect produced invalid value. Consider using a default value.');
         this.schema = schema;
     }
 }
@@ -179,7 +179,13 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            const value = schema.type === 'object' ? schema.allOf.reduce((acc, schema) => ({ ...acc, ...Visit(schema, references) }), {}) : schema.allOf.reduce((_, schema) => Visit(schema, references), undefined);
+            // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
+            // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
+            // be a consequence of an illogical intersection.
+            const value = schema.allOf.reduce((acc, schema) => {
+                const next = Visit(schema, references);
+                return typeof next === 'object' ? { ...acc, ...next } : next;
+            }, {});
             if (!check_1.ValueCheck.Check(schema, references, value))
                 throw new ValueCreateIntersectTypeError(schema);
             return value;