@sinclair/typebox 0.28.11 → 0.28.13

package/compiler/compiler.js

@@ -194,13 +194,13 @@ var TypeCompiler;
     }
     function* Array(schema, references, value) {
         const expression = CreateExpression(schema.items, references, 'value');
-        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
         if (IsNumber(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         if (IsNumber(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
         if (schema.uniqueItems === true)
             yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
+        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
     }
     function* BigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.11",
+  "version": "0.28.13",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -42,6 +42,6 @@
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.0.2"
+    "typescript": "^5.0.4"
   }
 }

package/readme.md

@@ -109,6 +109,7 @@ License MIT
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
 - [Workbench](#workbench)
+- [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -1277,7 +1278,7 @@ The TypeCompiler is provided as an optional import.
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 ```
 
-Use the `Compile(...)` function to compile a type.
+Use the `Compile(...)` function to compile a type. Note that compilation is an expensive operation that should typically be performed once per type during application start up. TypeBox does not cache previously compiled types, so applications are expected to hold references to each compiled type for the lifetime of the application.
 
 ```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
@@ -1419,16 +1420,29 @@ TypeSystem.AllowNaN = true
 
 ## Workbench
 
-TypeBox offers a web based code generation tool that can be used to create TypeBox types from TypeScript type definitions. This tool is written to prototype new TypeBox features, but can be used to rapidly convert TypeScript type definitions in to TypeBox types as well as raw JSON Schema.
+TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox type definitions as well as a variety of other formats.
 
 [Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
 
 <div align='center'>
-	
+
 <a href="https://sinclairzx81.github.io/typebox-workbench/"><img src="https://github.com/sinclairzx81/typebox/blob/master/workbench.png?raw=true" /></a>
 
 </div>
 
+<a name='ecosystem'></a>
+
+## Ecosystem
+
+The following is a list of community packages that provide general tooling and framework support for TypeBox.
+
+| Package   |  Description |
+| ------------- | ------------- |
+| [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 |
+| [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
+| [ts2typebox](https://github.com/xddq/ts2typebox)  | Cli tool to generate TypeBox JSON schemas based on your Typescript types |
+
 <a name='benchmark'></a>
 
 ## Benchmark

package/typebox.d.ts

@@ -132,7 +132,7 @@ export interface TEnumOption<T> {
 export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
     [Kind]: 'Union';
     static: T[keyof T];
-    anyOf: TLiteral<string | number>[];
+    anyOf: TLiteral<T[keyof T]>[];
 }
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertType<X>, AssertType<Y>]> : AssertType<O> : never;
 export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{