@sinclair/typebox 0.31.1 → 0.31.3

package/compiler/compiler.js

@@ -145,6 +145,16 @@ var Identifier;
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
 // -------------------------------------------------------------------
+// LiteralString
+// -------------------------------------------------------------------
+var LiteralString;
+(function (LiteralString) {
+    function Escape(content) {
+        return content.replace(/'/g, "\\'");
+    }
+    LiteralString.Escape = Escape;
+})(LiteralString || (LiteralString = {}));
+// -------------------------------------------------------------------
 // Errors
 // -------------------------------------------------------------------
 class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
@@ -303,7 +313,7 @@ var TypeCompiler;
             yield `(${value} === ${schema.const})`;
         }
         else {
-            yield `(${value} === '${schema.const}')`;
+            yield `(${value} === '${LiteralString.Escape(schema.const)}')`;
         }
     }
     function* TNever(schema, references, value) {
@@ -374,7 +384,7 @@ var TypeCompiler;
         if ((0, guard_1.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
-        const variable = CreateVariable(`new RegExp(/${patternKey}/)`);
+        const variable = CreateVariable(`${new RegExp(patternKey)}`);
         const check1 = CreateExpression(patternSchema, references, 'value');
         const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true';
         const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.1",
+  "version": "0.31.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -59,6 +59,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.1.6"
+    "typescript": "^5.2.2"
   }
 }

package/readme.md

@@ -60,7 +60,9 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime checked using standard Json Schema validation.
 
-TypeBox is designed to be a runtime type system based on industry standard specifications. It offers serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, a high performance runtime validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. It can either be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
+TypeBox types are designed to express industry standard schematics as TypeScript types. All types are runtime reflectable, serializable and publishable by default. It includes an extensible type system able to represent type safe schematics for multiple schema specifications. It also provides a high performance validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. 
+
+TypeBox can be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
 
 License MIT
 
@@ -947,7 +949,7 @@ const U = Type.Union(R)                              // const U = {
 
 ### Transform Types
 
-TypeBox supports bi-directional decode and encode with Transform types. These types are designed to operate with the Value and TypeCompiler Encode and Decode functions. Transform types are useful to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to convert between Date and number using the Value module.
+TypeBox supports value decoding and encoding with Transform types. These types work in tandem with the Encode and Decode functions available on the Value and TypeCompiler modules. Transform types can be used to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to decode numbers into Dates using the Value module.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -1167,9 +1169,9 @@ const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }
 Use the Decode function to decode a value from a type, or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
 
 ```typescript
-const A = Type.Decode(Type.String(), 'hello')        // const A = 'hello'
+const A = Value.Decode(Type.String(), 'hello')        // const A = 'hello'
 
-const B = Type.Decode(Type.String(), 42)             // throw
+const B = Value.Decode(Type.String(), 42)             // throw
 ```
 <a name='values-decode'></a>
 
@@ -1178,9 +1180,9 @@ const B = Type.Decode(Type.String(), 42)             // throw
 Use the Encode function to encode a value to a type, or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
 
 ```typescript
-const A = Type.Encode(Type.String(), 'hello')        // const A = 'hello'
+const A = Value.Encode(Type.String(), 'hello')        // const A = 'hello'
 
-const B = Type.Encode(Type.String(), 42)             // throw
+const B = Value.Encode(Type.String(), 42)             // throw
 ```
 
 <a name='values-equal'></a>
@@ -1602,13 +1604,16 @@ The following is a list of community packages that offer general tooling, extend
 
 | Package   |  Description |
 | ------------- | ------------- |
+| [drizzle-typebox](https://www.npmjs.com/package/drizzle-typebox) | Generates TypeBox types from Drizzle ORM schemas |
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
 | [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
+| [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |
+| [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 
 <a name='benchmark'></a>

package/typebox.d.ts

@@ -6,9 +6,9 @@ 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 PatternBooleanExact: string;
-export declare const PatternNumberExact: string;
-export declare const PatternStringExact: string;
+export declare const PatternBooleanExact = "^(true|false)$";
+export declare const PatternNumberExact = "^(0|[1-9][0-9]*)$";
+export declare const PatternStringExact = "^(.*)$";
 export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
 export type TupleToUnion<T extends any[]> = {
     [K in keyof T]: T[K];
@@ -436,11 +436,12 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     type: 'string';
     pattern: string;
 }
-export type DecodeStaticProperties<T extends TProperties> = {
-    [K in keyof T]: DecodeStaticType<T[K]>;
+export type DecodeModifier<D extends TSchema, T extends TSchema> = T extends TReadonly<T> & TOptional<T> ? TReadonly<TOptional<D>> : T extends TReadonly<T> ? TReadonly<D> : T extends TOptional<T> ? TOptional<D> : D;
+export type DecodeProperties<T extends TProperties> = {
+    [K in keyof T]: DecodeType<T[K]>;
 };
-export type DecodeStaticRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? [DecodeStaticType<AssertType<L>>, ...DecodeStaticRest<AssertRest<R>>] : [];
-export type DecodeStaticType<T extends TSchema> = T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S> ? TArray<DecodeStaticType<S>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<DecodeStaticType<S>> : T extends TConstructor<infer P, infer R> ? TConstructor<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> : T extends TFunction<infer P, infer R> ? TFunction<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> : T extends TIntersect<infer S> ? TIntersect<AssertRest<DecodeStaticRest<S>>> : T extends TIterator<infer S> ? TIterator<DecodeStaticType<S>> : T extends TNot<infer S> ? TNot<DecodeStaticType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeStaticProperties<S>>> : T extends TPromise<infer S> ? TPromise<DecodeStaticType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeStaticType<S>> : T extends TRecursive<infer S> ? TRecursive<DecodeStaticType<S>> : T extends TRef<infer S> ? TRef<DecodeStaticType<S>> : T extends TTuple<infer S> ? TTuple<AssertRest<DecodeStaticRest<S>>> : T extends TUnion<infer S> ? TUnion<AssertRest<DecodeStaticRest<S>>> : T;
+export type DecodeRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? [DecodeType<AssertType<L>>, ...DecodeRest<AssertRest<R>>] : [];
+export type DecodeType<T extends TSchema> = T extends TTransform<infer _, infer R> ? DecodeModifier<TUnsafe<R>, T> : T extends TArray<infer S> ? DecodeModifier<TArray<DecodeType<S>>, T> : T extends TAsyncIterator<infer S> ? DecodeModifier<TAsyncIterator<DecodeType<S>>, T> : T extends TConstructor<infer P, infer R> ? DecodeModifier<TConstructor<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> : T extends TFunction<infer P, infer R> ? DecodeModifier<TFunction<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> : T extends TIntersect<infer S> ? DecodeModifier<TIntersect<AssertRest<DecodeRest<S>>>, T> : T extends TIterator<infer S> ? DecodeModifier<TIterator<DecodeType<S>>, T> : T extends TNot<infer S> ? DecodeModifier<TNot<DecodeType<S>>, T> : T extends TObject<infer S> ? DecodeModifier<TObject<Evaluate<DecodeProperties<S>>>, T> : T extends TPromise<infer S> ? DecodeModifier<TPromise<DecodeType<S>>, T> : T extends TRecord<infer K, infer S> ? DecodeModifier<TRecord<K, DecodeType<S>>, T> : T extends TRecursive<infer S> ? DecodeModifier<TRecursive<DecodeType<S>>, T> : T extends TRef<infer S> ? DecodeModifier<TRef<DecodeType<S>>, T> : T extends TTuple<infer S> ? DecodeModifier<TTuple<AssertRest<DecodeRest<S>>>, T> : T extends TUnion<infer S> ? DecodeModifier<TUnion<AssertRest<DecodeRest<S>>>, T> : T;
 export type TransformFunction<T = any, U = any> = (value: T) => U;
 export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
     Decode: TransformFunction<StaticDecode<I>, O>;
@@ -507,7 +508,7 @@ export interface TVoid extends TSchema {
     type: 'void';
 }
 /** Creates the decoded static form for a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeStaticType<T>, P>;
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>;
 /** Creates the encoded static form for a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
 /** Creates the static type for a TypeBox type */