@sinclair/typebox 0.32.12 → 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/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/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/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/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/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/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.12",
+  "version": "0.32.13",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",