@sinclair/typebox 0.32.11 → 0.32.13

package/build/import/compiler/compiler.mjs

@@ -387,6 +387,10 @@ export var TypeCompiler;
     function* FromRegExp(schema, references, value) {
         const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
         yield `(typeof ${value} === 'string')`;
+        if (IsNumber(schema.maxLength))
+            yield `${value}.length <= ${schema.maxLength}`;
+        if (IsNumber(schema.minLength))
+            yield `${value}.length >= ${schema.minLength}`;
         yield `${variable}.test(${value})`;
     }
     function* FromString(schema, references, value) {

package/build/import/errors/errors.mjs

@@ -393,6 +393,14 @@ function* FromRef(schema, references, path, value) {
     yield* Visit(Deref(schema, references), references, path, value);
 }
 function* FromRegExp(schema, references, path, value) {
+    if (!IsString(value))
+        return yield Create(ValueErrorType.String, schema, path, value);
+    if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
+        yield Create(ValueErrorType.StringMinLength, schema, path, value);
+    }
+    if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
+        yield Create(ValueErrorType.StringMaxLength, schema, path, value);
+    }
     const regex = new RegExp(schema.source, schema.flags);
     if (!regex.test(value)) {
         return yield Create(ValueErrorType.RegExp, schema, path, value);

package/build/import/index.d.mts

@@ -48,7 +48,7 @@ export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-option
 export { Record, type TRecord, type TRecordOrObject } from './type/record/index.mjs';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index.mjs';
 export { Ref, type TRef } from './type/ref/index.mjs';
-export { RegExp, type TRegExp } from './type/regexp/index.mjs';
+export { RegExp, type TRegExp, type RegExpOptions } from './type/regexp/index.mjs';
 export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index.mjs';
 export { Rest, type TRest } from './type/rest/index.mjs';
 export { ReturnType, type TReturnType } from './type/return-type/index.mjs';

package/build/import/type/array/array.d.mts

@@ -1,4 +1,5 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Ensure } from '../helpers/index.mjs';
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 export interface ArrayOptions extends SchemaOptions {
@@ -15,11 +16,13 @@ export interface ArrayOptions extends SchemaOptions {
     /** A maximum number of contains schema matches */
     maxContains?: number;
 }
+type ArrayStatic<T extends TSchema, P extends unknown[]> = Ensure<Static<T, P>[]>;
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
     [Kind]: 'Array';
-    static: Array<Static<T, this['params']>>;
+    static: ArrayStatic<T, this['params']>;
     type: 'array';
     items: T;
 }
 /** `[Json]` Creates an Array type */
 export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+export {};

package/build/import/type/array/array.mjs

@@ -1,5 +1,5 @@
-import { Kind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates an Array type */
 export function Array(schema, options = {}) {
     return {

package/build/import/type/guard/type.mjs

@@ -331,7 +331,9 @@ export function IsRegExp(value) {
     return (IsKindOf(value, 'RegExp') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.source) &&
-        ValueGuard.IsString(value.flags));
+        ValueGuard.IsString(value.flags) &&
+        IsOptionalNumber(value.maxLength) &&
+        IsOptionalNumber(value.minLength));
 }
 /** Returns true if the given value is TString */
 export function IsString(value) {

package/build/import/type/record/record.d.mts

@@ -35,7 +35,9 @@ type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TReg
 type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
 type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<Record<Assert<Static<K>, PropertyKey>, Static<T, P>>>);
+type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<{
+    [_ in Assert<Static<K>, PropertyKey>]: Static<T, P>;
+}>);
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: RecordStatic<K, T, this['params']>;

package/build/import/type/regexp/regexp.d.mts

@@ -1,6 +1,12 @@
 import type { SchemaOptions } from '../schema/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
 import { Kind } from '../symbols/index.mjs';
+export interface RegExpOptions extends SchemaOptions {
+    /** The maximum length of the string */
+    maxLength?: number;
+    /** The minimum length of the string */
+    minLength?: number;
+}
 export interface TRegExp extends TSchema {
     [Kind]: 'RegExp';
     static: `${string}`;
@@ -9,6 +15,6 @@ export interface TRegExp extends TSchema {
     flags: string;
 }
 /** `[JavaScript]` Creates a RegExp type */
-export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+export declare function RegExp(pattern: string, options?: RegExpOptions): TRegExp;
 /** `[JavaScript]` Creates a RegExp type */
-export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+export declare function RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;

package/build/import/type/type/javascript.d.mts

@@ -10,7 +10,7 @@ import { type TInstanceType } from '../instance-type/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
 import { type TParameters } from '../parameters/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
-import { type TRegExp } from '../regexp/index.mjs';
+import { type TRegExp, RegExpOptions } from '../regexp/index.mjs';
 import { type TReturnType } from '../return-type/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
 import { type TSymbol } from '../symbol/index.mjs';
@@ -42,9 +42,9 @@ export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
     /** `[JavaScript]` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+    RegExp(pattern: string, options?: RegExpOptions): TRegExp;
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+    RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
     /** `[JavaScript]` Creates a Symbol type */

package/build/import/type/type/json.mjs

@@ -172,7 +172,7 @@ export class JsonTypeBuilder {
     }
     /** `[Json]` Creates a Record type */
     Record(key, schema, options = {}) {
-        return Record(key, schema);
+        return Record(key, schema, options);
     }
     /** `[Json]` Creates a Recursive type */
     Recursive(callback, options = {}) {

package/build/import/value/check/check.mjs

@@ -287,6 +287,14 @@ function FromRef(schema, references, value) {
 }
 function FromRegExp(schema, references, value) {
     const regex = new RegExp(schema.source, schema.flags);
+    if (IsDefined(schema.minLength)) {
+        if (!(value.length >= schema.minLength))
+            return false;
+    }
+    if (IsDefined(schema.maxLength)) {
+        if (!(value.length <= schema.maxLength))
+            return false;
+    }
     return regex.test(value);
 }
 function FromString(schema, references, value) {

package/build/require/compiler/compiler.js

@@ -387,6 +387,10 @@ var TypeCompiler;
     function* FromRegExp(schema, references, value) {
         const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
         yield `(typeof ${value} === 'string')`;
+        if ((0, index_11.IsNumber)(schema.maxLength))
+            yield `${value}.length <= ${schema.maxLength}`;
+        if ((0, index_11.IsNumber)(schema.minLength))
+            yield `${value}.length >= ${schema.minLength}`;
         yield `${variable}.test(${value})`;
     }
     function* FromString(schema, references, value) {

package/build/require/errors/errors.js

@@ -397,6 +397,14 @@ function* FromRef(schema, references, path, value) {
     yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
 function* FromRegExp(schema, references, path, value) {
+    if (!(0, index_9.IsString)(value))
+        return yield Create(ValueErrorType.String, schema, path, value);
+    if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
+        yield Create(ValueErrorType.StringMinLength, schema, path, value);
+    }
+    if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
+        yield Create(ValueErrorType.StringMaxLength, schema, path, value);
+    }
     const regex = new RegExp(schema.source, schema.flags);
     if (!regex.test(value)) {
         return yield Create(ValueErrorType.RegExp, schema, path, value);

package/build/require/index.d.ts

@@ -48,7 +48,7 @@ export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-option
 export { Record, type TRecord, type TRecordOrObject } from './type/record/index';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index';
 export { Ref, type TRef } from './type/ref/index';
-export { RegExp, type TRegExp } from './type/regexp/index';
+export { RegExp, type TRegExp, type RegExpOptions } from './type/regexp/index';
 export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index';
 export { Rest, type TRest } from './type/rest/index';
 export { ReturnType, type TReturnType } from './type/return-type/index';

package/build/require/type/array/array.d.ts

@@ -1,4 +1,5 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
+import { Ensure } from '../helpers/index';
+import type { SchemaOptions, TSchema } from '../schema/index';
 import type { Static } from '../static/index';
 import { Kind } from '../symbols/index';
 export interface ArrayOptions extends SchemaOptions {
@@ -15,11 +16,13 @@ export interface ArrayOptions extends SchemaOptions {
     /** A maximum number of contains schema matches */
     maxContains?: number;
 }
+type ArrayStatic<T extends TSchema, P extends unknown[]> = Ensure<Static<T, P>[]>;
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
     [Kind]: 'Array';
-    static: Array<Static<T, this['params']>>;
+    static: ArrayStatic<T, this['params']>;
     type: 'array';
     items: T;
 }
 /** `[Json]` Creates an Array type */
 export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+export {};

package/build/require/type/array/array.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Array = void 0;
-const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
 /** `[Json]` Creates an Array type */
 function Array(schema, options = {}) {
     return {

package/build/require/type/guard/type.js

@@ -367,7 +367,9 @@ function IsRegExp(value) {
     return (IsKindOf(value, 'RegExp') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.source) &&
-        ValueGuard.IsString(value.flags));
+        ValueGuard.IsString(value.flags) &&
+        IsOptionalNumber(value.maxLength) &&
+        IsOptionalNumber(value.minLength));
 }
 exports.IsRegExp = IsRegExp;
 /** Returns true if the given value is TString */

package/build/require/type/record/record.d.ts

@@ -35,7 +35,9 @@ type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TReg
 type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
 type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<Record<Assert<Static<K>, PropertyKey>, Static<T, P>>>);
+type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<{
+    [_ in Assert<Static<K>, PropertyKey>]: Static<T, P>;
+}>);
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: RecordStatic<K, T, this['params']>;

package/build/require/type/regexp/regexp.d.ts

@@ -1,6 +1,12 @@
 import type { SchemaOptions } from '../schema/index';
 import type { TSchema } from '../schema/index';
 import { Kind } from '../symbols/index';
+export interface RegExpOptions extends SchemaOptions {
+    /** The maximum length of the string */
+    maxLength?: number;
+    /** The minimum length of the string */
+    minLength?: number;
+}
 export interface TRegExp extends TSchema {
     [Kind]: 'RegExp';
     static: `${string}`;
@@ -9,6 +15,6 @@ export interface TRegExp extends TSchema {
     flags: string;
 }
 /** `[JavaScript]` Creates a RegExp type */
-export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+export declare function RegExp(pattern: string, options?: RegExpOptions): TRegExp;
 /** `[JavaScript]` Creates a RegExp type */
-export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+export declare function RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;

package/build/require/type/type/javascript.d.ts

@@ -10,7 +10,7 @@ import { type TInstanceType } from '../instance-type/index';
 import { type TIterator } from '../iterator/index';
 import { type TParameters } from '../parameters/index';
 import { type TPromise } from '../promise/index';
-import { type TRegExp } from '../regexp/index';
+import { type TRegExp, RegExpOptions } from '../regexp/index';
 import { type TReturnType } from '../return-type/index';
 import { type TSchema, type SchemaOptions } from '../schema/index';
 import { type TSymbol } from '../symbol/index';
@@ -42,9 +42,9 @@ export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
     /** `[JavaScript]` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+    RegExp(pattern: string, options?: RegExpOptions): TRegExp;
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+    RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
     /** `[JavaScript]` Creates a Symbol type */

package/build/require/type/type/json.js

@@ -176,7 +176,7 @@ class JsonTypeBuilder {
     }
     /** `[Json]` Creates a Record type */
     Record(key, schema, options = {}) {
-        return (0, index_29.Record)(key, schema);
+        return (0, index_29.Record)(key, schema, options);
     }
     /** `[Json]` Creates a Recursive type */
     Recursive(callback, options = {}) {

package/build/require/value/check/check.js

@@ -291,6 +291,14 @@ function FromRef(schema, references, value) {
 }
 function FromRegExp(schema, references, value) {
     const regex = new RegExp(schema.source, schema.flags);
+    if (IsDefined(schema.minLength)) {
+        if (!(value.length >= schema.minLength))
+            return false;
+    }
+    if (IsDefined(schema.maxLength)) {
+        if (!(value.length <= schema.maxLength))
+            return false;
+    }
     return regex.test(value);
 }
 function FromString(schema, references, value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.11",
+  "version": "0.32.13",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",