@sinclair/typebox 0.24.0 → 0.24.1

package/compiler/compiler.d.ts

@@ -1,11 +1,5 @@
 import * as Types from '../typebox';
-export declare type CheckFunction = (value: unknown) => CheckOk | CheckFail;
-export interface CheckOk {
-    ok: true;
-}
-export interface CheckFail {
-    ok: false;
-}
+export declare type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheckAssertError extends Error {
     readonly schema: Types.TSchema;
     readonly value: unknown;

package/compiler/compiler.js

@@ -51,16 +51,14 @@ class TypeCheck {
     }
     /** Returns true if the value is valid. */
     Check(value) {
-        const result = this.checkFunc(value);
-        return result.ok;
+        return this.checkFunc(value);
     }
     /** Asserts the given value and throws a TypeCheckAssertError if invalid. */
     Assert(value) {
         // The return type for this function should be 'asserts value is Static<T>' but due
         // to a limitation in TypeScript, this currently isn't possible. See issue below.
         // https://github.com/microsoft/TypeScript/issues/36931
-        const result = this.checkFunc(value);
-        if (!result.ok)
+        if (!this.checkFunc(value))
             throw new TypeCheckAssertError(this.schema, value);
     }
 }
@@ -187,11 +185,11 @@ var TypeCompiler;
             PushLocal(body);
         }
         const func = CreateFunctionName(schema.$ref);
-        yield CreateCondition(schema, path, `(${func}(${path}).ok)`);
+        yield CreateCondition(schema, path, `(${func}(${path}))`);
     }
     function* Self(schema, path) {
         const func = CreateFunctionName(schema.$ref);
-        yield CreateCondition(schema, path, `(${func}(${path}).ok)`);
+        yield CreateCondition(schema, path, `(${func}(${path}))`);
     }
     function* String(schema, path) {
         yield CreateCondition(schema, path, `(typeof ${path} === 'string')`);
@@ -240,7 +238,7 @@ var TypeCompiler;
             const name = CreateFunctionName(schema.$id);
             const body = CreateFunction(name, conditions);
             PushLocal(body);
-            yield CreateCondition(schema, path, `(${name}(${path}).ok)`);
+            yield CreateCondition(schema, path, `(${name}(${path}))`);
             return;
         }
         const anySchema = schema;
@@ -326,8 +324,8 @@ var TypeCompiler;
         return `check_${$id.replace(/-/g, '_')}`;
     }
     function CreateFunction(name, conditions) {
-        const statements = conditions.map((condition, index) => `  if(!${condition.expr}) { return { ok: false } }`);
-        return `function ${name}(value) {\n${statements.join('\n')}\n  return { ok: true }\n}`;
+        const statements = conditions.map((condition, index) => `  if(!${condition.expr}) { return false }`);
+        return `function ${name}(value) {\n${statements.join('\n')}\n  return true\n}`;
     }
     // -------------------------------------------------------------------
     // Compiler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.0",
+  "version": "0.24.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",

package/typebox.d.ts

@@ -84,15 +84,6 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<string | number>[];
 }
-export interface TExclude<T extends TUnion, U extends TUnion> extends TUnion {
-    [Kind]: 'Union';
-    static: Exclude<Static<T, this['params']>, Static<U, this['params']>>;
-}
-export interface TExtract<T extends TSchema, U extends TUnion> extends TUnion {
-    [Kind]: 'Union';
-    static: Extract<Static<T, this['params']>, Static<U, this['params']>>;
-}
-export declare type TExtends<T extends TSchema, U extends TSchema, X extends TSchema, Y extends TSchema> = T extends TAny ? (U extends TUnknown ? X : U extends TAny ? X : TUnion<[X, Y]>) : T extends U ? X : Y;
 export declare type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];