@sinclair/typebox 0.31.2 → 0.31.4

package/compiler/compiler.js

@@ -384,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.2",
+  "version": "0.31.4",
   "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,7 @@ 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 built upon industry standard specifications. It offers reflectable, serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, includes a high performance validation compiler, offers various tools for working with dynamic data and provides detailed structured error reporting. 
+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.
 
@@ -949,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'
@@ -1604,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/system/index.d.ts

@@ -1 +1,2 @@
+export { ValueErrorType } from '../errors/errors';
 export * from './system';

package/system/index.js

@@ -41,4 +41,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrorType = void 0;
+var errors_1 = require("../errors/errors");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
 __exportStar(require("./system"), exports);

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 */
@@ -799,7 +800,7 @@ export declare class JsonTypeBuilder extends TypeBuilder {
     /** `[Json]` Creates a Composite object type */
     Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[Json]` Creates a Enum type */
-    Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
+    Enum<V extends string | number, T extends Record<string, V>>(item: T, options?: SchemaOptions): TEnum<T>;
     /** `[Json]` Creates a Conditional type */
     Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */