@webergency-utils/typechecker 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 webergency-utils
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,263 @@
+# @webergency-utils/typechecker
+
+`@webergency-utils/typechecker` is a high-performance, zero-runtime-dependency TypeScript compiler plugin (transformer) that converts your static TypeScript types into optimized, hashed, and hoisted runtime validators.
+
+It is designed to work seamlessly with the `@webergency-utils/server` library, automatically enforcing strict data validation at compile time, and provides standard validation API wrappers matching `typia` with extended options for coercion and array handling.
+
+---
+
+## Features
+
+- **⚡ Blazing Fast**: No runtime schema parsing or generic reflection. Code is generated at compile time as highly optimized JavaScript pipelines.
+- **📦 Zero Dependency**: The generated code has absolutely zero external dependencies.
+- **🔄 Advanced Type Checking**: Full support for Unions, Intersections, Nested Objects, Tuples, and Optional Properties.
+- **🏷️ Tag-Based Validation**: Custom JSON-Schema validation tags directly inside your TypeScript types (e.g. `MinLength<8>`, `Format<'email'>`).
+- **🛡️ Multiple Validation Modes**: Easily switch between `'strict'`, `'relaxed'`, and `'strip'` modes.
+- **📈 Coercion & Coalescing**: Extended options for type conversion and single-value array wrapping (highly useful for HTTP Query parameters!).
+
+---
+
+## Installation
+
+Since this library is a TypeScript compiler plugin, you will need a tool like `ts-patch` or `ts-node` to hook into the compilation process.
+
+```bash
+npm install @webergency-utils/typechecker
+npm install -D ts-patch
+```
+
+Run `ts-patch install` to patch your local TypeScript installation.
+
+---
+
+## Configuration
+
+Update your `tsconfig.json` to include the transformer in the `compilerOptions.plugins` array:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "plugins": [
+      { "transform": "@webergency-utils/typechecker" }
+    ]
+  }
+}
+```
+
+---
+
+## Usage
+
+### 1. Decorator-Based Validation (Server Endpoints)
+
+The transformer automatically intercepts decorators imported from `@webergency-utils/server` (`@Body`, `@Query`, `@Param`). It hashes the underlying TypeScript type, generates a highly optimized validation function, and hoists it to the top of the file using the `MetadataStore`.
+
+```typescript
+import { Controller, Post, Body } from '@webergency-utils/server';
+
+interface UserDTO {
+  id: string;
+  name: string;
+  age?: number;
+}
+
+@Controller('/users')
+export class UserController {
+  // @webergency-utils/typechecker automatically generates a validator for UserDTO,
+  // registers it, and transforms this to @Body("hash_id", "strict")
+  @Post('/')
+  createUser(@Body() user: UserDTO) {
+    return { success: true, user };
+  }
+}
+```
+
+---
+
+### 2. Manual Runtime Validation APIs
+
+You can manually validate unknown data anywhere in your code. The transformer intercepts these calls and replaces them with direct, optimized validation functions.
+
+```typescript
+import { is, assert, assertGuard, validate } from '@webergency-utils/typechecker';
+
+interface Payload {
+  id: string;
+  active: boolean;
+}
+
+const data: unknown = JSON.parse('{"id": "123", "active": true}');
+
+// 1. is() - returns a boolean (type guard)
+if (is<Payload>(data)) {
+  console.log(data.id); // Narrowed to 'Payload'
+}
+
+// 2. assert() - returns the narrowed value or throws an error
+const validData = assert<Payload>(data);
+
+// 3. assertGuard() - asserts the type for the current scope in-place
+assertGuard<Payload>(data);
+console.log(data.id); // Narrowed in-place
+
+// 4. validate() - returns a structured validation result with errors
+const result = validate<Payload>(data);
+if (result.success) {
+  console.log(result.data);
+} else {
+  console.error(result.errors); // Array of formatted errors
+}
+```
+
+---
+
+### 3. Extended Options & Validation Modes
+
+All validation APIs accept either a string `ValidationMode` or a custom `ValidationOptions` object:
+
+```typescript
+export type ValidationMode = 'strict' | 'relaxed' | 'strip';
+
+export interface ValidationOptions {
+  mode?: ValidationMode;    // default: 'strict'
+  tryConvert?: boolean;     // Converts string numbers, booleans, and dates (ideal for query parameters)
+  wrapArrays?: boolean;     // Wraps a single value into an array if the type expects an array
+}
+```
+
+#### Examples:
+```typescript
+// Relaxed Mode (ignores additional properties)
+const user = assert<User>(data, 'relaxed');
+
+// Strip Mode (strips out any unknown properties from returned object)
+const cleanUser = assert<User>(data, 'strip');
+
+// Query-String Coercion
+const query = assert<SearchQuery>(rawQuery, {
+  mode: 'strip',
+  tryConvert: true, // Coerces "18" -> 18, "true" -> true, etc.
+  wrapArrays: true  // Coerces "tag" -> ["tag"] if tags: string[] is expected
+});
+```
+
+---
+
+### 4. Error Reporting & Grouping
+
+When validation fails using `validate<T>()`, you receive a highly structured array of errors. To make this easy to consume for humans, LLMs, and UI libraries (like React Hook Form), the library provides a `groupErrorsByPath` helper that organizes these errors by their exact JSON path.
+
+The error strings follow a deterministic, parser-friendly `Constraint<Value>` format.
+
+```typescript
+import { validate, groupErrorsByPath, Minimum } from '@webergency-utils/typechecker';
+
+interface Payload {
+  id: string;
+  role: "admin" | "user";
+  age: number & Minimum<18>;
+  metadata: { tag: string } | { priority: number };
+}
+
+const data = {
+  id: 123,           // Error: expected string, got number
+  role: "guest",     // Error: literal union mismatch
+  age: 15,           // Error: minimum constraint failed
+  metadata: { }      // Error: complex union mismatch
+};
+
+const result = validate<Payload>(data);
+if (!result.success) {
+  const grouped = groupErrorsByPath(result.errors);
+  console.log(JSON.stringify(grouped, null, 2));
+}
+```
+
+**Output:**
+```json
+{
+  "id": {
+    "value": 123,
+    "errors": ["Type<string>"]
+  },
+  "role": {
+    "value": "guest",
+    "errors": [
+      "Literal<'admin'>",
+      "Literal<'user'>"
+    ]
+  },
+  "age": {
+    "value": 15,
+    "errors": ["Minimum<18>"]
+  },
+  "metadata": {
+    "value": {},
+    "errors": ["Type<{tag:string}|{priority:number}>"]
+  },
+  "metadata.tag": {
+    "value": undefined,
+    "errors": ["Type<string>"]
+  },
+  "metadata.priority": {
+    "value": undefined,
+    "errors": ["Type<number>"]
+  }
+}
+```
+
+This flattened, grouped output is incredibly powerful—it tells the developer (or an AI agent) exactly *why* a complex union or object failed down to the very specific branch and missing property constraint.
+
+---
+
+## Supported JSON-Schema Validation Tags
+
+Add strict runtime metadata to your TypeScript primitives using standard intersection types:
+
+### String Tags
+- `MinLength<N>`: Minimum string length.
+- `MaxLength<N>`: Maximum string length.
+- `Pattern<RegExp>`: Regular expression validation.
+- `Format<T>`: Structural formats: `'email'`, `'uuid'`, `'date'`, `'date-time'`, `'url'`, `'ipv4'`, `'ipv6'`.
+
+### Number Tags
+- `Minimum<N>`: Minimum numeric value (inclusive).
+- `Maximum<N>`: Maximum numeric value (inclusive).
+- `ExclusiveMinimum<N>`: Greater than `N`.
+- `ExclusiveMaximum<N>`: Less than `N`.
+- `MultipleOf<N>`: Must be a multiple of `N`.
+
+### Array Tags
+- `MinItems<N>`: Minimum array items count.
+- `MaxItems<N>`: Maximum array items count.
+- `UniqueItems`: Enforces all elements in the array to be deeply unique.
+
+#### Example:
+```typescript
+import { MinLength, Minimum, Format, UniqueItems } from '@webergency-utils/typechecker';
+
+interface Profile {
+  email: string & Format<'email'>;
+  password: string & MinLength<8>;
+  age: number & Minimum<18>;
+  luckyNumbers: number[] & UniqueItems;
+}
+```
+
+---
+
+## How it Works
+
+1. **AST Analysis**: The transformer scans compile-time type signatures and generates highly nested, direct runtime checks.
+2. **Circular References**: Safely handles recursive and circular types by generating self-referencing lazy functions.
+3. **Hoisting & Deduping**: Identical type validations are hoisted to top-level constants and shared, minimizing footprint.
+4. **Clean Emitted JS**: The output compiles into vanilla JS, utilizing direct, blazing-fast validation logic.
+
+---
+
+## License
+
+MIT © radixxko / [webergency-utils](https://github.com/webergency-utils)

package/dist/engine/generators.d.ts

@@ -0,0 +1,23 @@
+import * as ts from 'typescript';
+export interface IValidationRegistry {
+    validators: Map<string, ts.Expression>;
+}
+export declare function createRegistry(): IValidationRegistry;
+export declare function templateToAst(template: string): ts.Expression;
+export declare function injectNodes(expr: ts.Expression, replacements: Record<string, ts.Expression>): ts.Expression;
+export declare function createPrimitiveCheck(type: string, requiredUtils: Set<string>): ts.Expression;
+export declare function createConstrainedPrimitiveCheck(baseType: string, constraints: any[], requiredUtils: Set<string>, baseValidator?: ts.Expression): ts.Expression;
+export declare function createLiteralCheck(value: string | number | boolean | ts.PseudoBigInt, requiredUtils: Set<string>): ts.Expression;
+export declare function createArrayCheck(elementValidator: ts.Expression, requiredUtils: Set<string>): ts.Expression;
+export declare function createTemplateLiteralCheck(regexStr: string, expected: string, requiredUtils: Set<string>): ts.Expression;
+export declare function createUnionCheck(checks: ts.Expression[], requiredUtils: Set<string>, expected?: string): ts.Expression;
+export declare function createObjectCheck(props: any[], requiredUtils: Set<string>, expected?: string): ts.Expression;
+export declare function createRecordCheck(valueValidator: ts.Expression, requiredUtils: Set<string>): ts.Expression;
+export declare function createTupleCheck(checks: ts.Expression[], requiredUtils: Set<string>): ts.Expression;
+export declare function createDateCheck(requiredUtils: Set<string>): ts.Expression;
+export declare function createRegExpCheck(requiredUtils: Set<string>): ts.Expression;
+export declare function createNullCheck(requiredUtils: Set<string>): ts.Expression;
+export declare function createUndefinedCheck(requiredUtils: Set<string>): ts.Expression;
+export declare function createIntersectionCheck(checks: ts.Expression[], requiredUtils: Set<string>): ts.Expression;
+export declare function createSetCheck(elementValidator: ts.Expression, requiredUtils: Set<string>): ts.Expression;
+export declare function createMapCheck(keyValidator: ts.Expression, valueValidator: ts.Expression, requiredUtils: Set<string>): ts.Expression;

package/dist/engine/generators.js

@@ -0,0 +1,283 @@
+import * as ts from 'typescript';
+export function createRegistry() {
+    return {
+        validators: new Map()
+    };
+}
+export function templateToAst(template) {
+    const source = ts.createSourceFile('template.ts', `const x = ${template};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const statement = source.statements[0];
+    if (ts.isVariableStatement(statement)) {
+        return statement.declarationList.declarations[0].initializer;
+    }
+    if (ts.isExpressionStatement(statement)) {
+        return statement.expression;
+    }
+    throw new Error('Template must be an expression or variable declaration');
+}
+function stripPositions(node) {
+    const visitor = (n) => {
+        const cloned = ts.visitEachChild(n, visitor, undefined);
+        const res = { ...cloned, pos: -1, end: -1 };
+        Object.setPrototypeOf(res, Object.getPrototypeOf(cloned));
+        return res;
+    };
+    return ts.visitNode(node, visitor);
+}
+export function injectNodes(expr, replacements) {
+    const transformer = (context) => {
+        return (rootNode) => {
+            function visit(node) {
+                if (ts.isIdentifier(node) && replacements[node.text]) {
+                    return stripPositions(replacements[node.text]);
+                }
+                return ts.visitEachChild(node, visit, context);
+            }
+            return ts.visitNode(rootNode, visit);
+        };
+    };
+    const result = ts.transform(expr, [transformer]);
+    return stripPositions(result.transformed[0]);
+}
+export function createPrimitiveCheck(type, requiredUtils) {
+    requiredUtils.add('validators');
+    return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier(type));
+}
+export function createConstrainedPrimitiveCheck(baseType, constraints, requiredUtils, baseValidator) {
+    requiredUtils.add('validators');
+    const defaultConstraint = constraints.find(c => c.type === 'default');
+    const transformConstraints = constraints.filter(c => c.type === 'transform' || c.type === 'transform_custom');
+    const messageConstraint = constraints.find(c => c.type === 'message');
+    const remainingConstraints = constraints.filter(c => c.type !== 'default' && c.type !== 'transform' && c.type !== 'transform_custom' && c.type !== 'message');
+    const fallbackMsg = messageConstraint?.value;
+    const constraintCode = remainingConstraints.map(c => {
+        const valStr = typeof c.value === 'bigint' ? `${c.value}n` : (typeof c.value === 'string' ? `"${c.value}"` : `${c.value}`);
+        const activeMsg = c.message !== undefined ? c.message : fallbackMsg;
+        const msgArg = activeMsg !== undefined ? `, ${JSON.stringify(activeMsg)}` : '';
+        if (c.type === 'minLength') {
+            return `validators.minLength(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'maxLength') {
+            return `validators.maxLength(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'minimum') {
+            return `validators.minimum(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'maximum') {
+            return `validators.maximum(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'exclusiveMinimum') {
+            return `validators.exclusiveMinimum(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'exclusiveMaximum') {
+            return `validators.exclusiveMaximum(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'multipleOf') {
+            return `validators.multipleOf(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'pattern') {
+            return `validators.pattern(v, path, ctx, new RegExp(${JSON.stringify(c.value)}), ${JSON.stringify('Pattern<' + c.value + '>')}${msgArg})`;
+        }
+        if (c.type === 'format') {
+            return `validators.format(v, path, ctx, ${JSON.stringify(c.value)}${msgArg})`;
+        }
+        if (c.type === 'minItems') {
+            return `validators.minItems(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'maxItems') {
+            return `validators.maxItems(v, path, ctx, ${valStr}${msgArg})`;
+        }
+        if (c.type === 'uniqueItems') {
+            return `validators.uniqueItems(v, path, ctx${msgArg})`;
+        }
+        if (c.type === 'custom') {
+            return `validators.custom(v, path, ctx, ${c.value}${msgArg})`;
+        }
+        if (c.type === 'requires') {
+            return `validators.requires(v, path, ctx, ${JSON.stringify(Array.isArray(c.value) ? c.value : [c.value])}${msgArg})`;
+        }
+        return '';
+    }).filter(c => c !== '').join(';\n            ');
+    let defaultInit = '';
+    if (defaultConstraint) {
+        defaultInit = `if (v === undefined) v = ${JSON.stringify(defaultConstraint.value)};\n        `;
+    }
+    let transformInit = '';
+    if (transformConstraints.length > 0) {
+        const statements = transformConstraints.map(tc => {
+            if (tc.type === 'transform' && tc.value === 'lowercase') {
+                return 'if (typeof v === \'string\') v = v.toLowerCase()';
+            }
+            if (tc.type === 'transform' && tc.value === 'uppercase') {
+                return 'if (typeof v === \'string\') v = v.toUpperCase()';
+            }
+            if (tc.type === 'transform' && tc.value === 'trim') {
+                return 'if (typeof v === \'string\') v = v.trim()';
+            }
+            if (tc.type === 'transform' && tc.value === 'capitalize') {
+                return 'if (typeof v === \'string\' && v.length > 0) v = v.charAt(0).toUpperCase() + v.slice(1)';
+            }
+            if (tc.type === 'transform' && tc.value === 'tonumber') {
+                return 'v = Number(v)';
+            }
+            if (tc.type === 'transform' && tc.value === 'toboolean') {
+                return 'v = (v === \'true\' || v === \'1\' || v === true || v === 1)';
+            }
+            if (tc.type === 'transform' && tc.value === 'todate') {
+                return 'v = new Date(v)';
+            }
+            if (tc.type === 'transform_custom') {
+                return `v = ${tc.value}(v)`;
+            }
+            return '';
+        }).filter(s => s !== '').join(';\n            ');
+        transformInit = `if (v !== undefined && v !== null) {\n            ${statements};\n        }\n        `;
+    }
+    const tpl = `
+    (v, path, ctx) => {
+        const _s = ctx.success;
+        ctx.success = true;
+        ${defaultInit}${transformInit}v = __BASE_CHECK__;
+        if (ctx.success && v !== undefined && v !== null) {
+            ${constraintCode};
+        }
+        if (_s === false) ctx.success = false;
+        return v;
+    }
+    `;
+    const baseCheck = baseValidator ? ts.factory.createCallExpression(baseValidator, undefined, [ts.factory.createIdentifier('v'), ts.factory.createIdentifier('path'), ts.factory.createIdentifier('ctx')]) : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier(baseType)), undefined, [ts.factory.createIdentifier('v'), ts.factory.createIdentifier('path'), ts.factory.createIdentifier('ctx')]);
+    return injectNodes(templateToAst(tpl), { '__BASE_CHECK__': baseCheck });
+}
+export function createLiteralCheck(value, requiredUtils) {
+    requiredUtils.add('validators');
+    return ts.factory.createArrowFunction(undefined, undefined, [
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('v')),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('path')),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('ctx'))
+    ], undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier('literal')), undefined, [
+        ts.factory.createIdentifier('v'),
+        ts.factory.createIdentifier('path'),
+        ts.factory.createIdentifier('ctx'),
+        typeof value === 'string' ? ts.factory.createStringLiteral(value) :
+            typeof value === 'number' ? ts.factory.createNumericLiteral(value.toString()) :
+                typeof value === 'boolean' ? (value ? ts.factory.createTrue() : ts.factory.createFalse()) :
+                    ts.factory.createBigIntLiteral(value.base10Value + 'n')
+    ]));
+}
+export function createArrayCheck(elementValidator, requiredUtils) {
+    requiredUtils.add('validators');
+    const tpl = '(v, path, ctx) => validators.array(v, path, ctx, __CHILD__)';
+    return injectNodes(templateToAst(tpl), { '__CHILD__': elementValidator });
+}
+export function createTemplateLiteralCheck(regexStr, expected, requiredUtils) {
+    requiredUtils.add('validators');
+    const tpl = `(v, path, ctx) => validators.templateLiteral(v, path, ctx, new RegExp(${JSON.stringify(regexStr)}), ${JSON.stringify(expected)})`;
+    return stripPositions(templateToAst(tpl));
+}
+export function createUnionCheck(checks, requiredUtils, expected = 'Type<Union>') {
+    requiredUtils.add('validators');
+    return ts.factory.createArrowFunction(undefined, undefined, [
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('v')),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('path')),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('ctx'))
+    ], undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier('union')), undefined, [
+        ts.factory.createIdentifier('v'),
+        ts.factory.createIdentifier('path'),
+        ts.factory.createIdentifier('ctx'),
+        ts.factory.createArrayLiteralExpression(checks),
+        ts.factory.createStringLiteral(expected)
+    ]));
+}
+export function createObjectCheck(props, requiredUtils, expected = 'object') {
+    requiredUtils.add('validators');
+    const propDefinitions = props.map((p, i) => ts.factory.createArrayLiteralExpression([
+        ts.factory.createStringLiteral(p.name),
+        p.isOptional ? ts.factory.createTrue() : ts.factory.createFalse(),
+        p.validator
+    ]));
+    const allowedKeys = props.map(p => ts.factory.createStringLiteral(p.name));
+    const tpl = `
+    (v, path, ctx) => {
+        if (!validators.object(v, path, ctx, __KEYS__, __EXPECTED__)) return v;
+        let data = v;
+        if (ctx.mode === 'strip') {
+            let hasAdditional = false;
+            const keys = Object.keys(v);
+            const allowed = __KEYS__;
+            if (keys.length > allowed.length) {
+                hasAdditional = true;
+            } else {
+                for (let i = 0; i < keys.length; i++) {
+                    if (!allowed.includes(keys[i])) {
+                        hasAdditional = true;
+                        break;
+                    }
+                }
+            }
+            if (hasAdditional) data = {};
+        }
+        validators.props(v, data, path, ctx, __PROPS__);
+        return data;
+    }
+    `;
+    return injectNodes(templateToAst(tpl), {
+        '__KEYS__': ts.factory.createArrayLiteralExpression(allowedKeys),
+        '__EXPECTED__': ts.factory.createStringLiteral(expected),
+        '__PROPS__': ts.factory.createArrayLiteralExpression(propDefinitions, true)
+    });
+}
+export function createRecordCheck(valueValidator, requiredUtils) {
+    requiredUtils.add('validators');
+    const tpl = '(v, path, ctx) => validators.record(v, path, ctx, __CHILD__)';
+    return injectNodes(templateToAst(tpl), { '__CHILD__': valueValidator });
+}
+export function createTupleCheck(checks, requiredUtils) {
+    requiredUtils.add('validators');
+    const arrayElements = checks.map((_, i) => `__CHECK_${i}__`).join(', ');
+    const tpl = `(v, path, ctx) => validators.tuple(v, path, ctx, [${arrayElements}])`;
+    const replacements = {};
+    checks.forEach((c, i) => replacements[`__CHECK_${i}__`] = c);
+    return injectNodes(templateToAst(tpl), replacements);
+}
+export function createDateCheck(requiredUtils) {
+    requiredUtils.add('validators');
+    return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier('date'));
+}
+export function createRegExpCheck(requiredUtils) {
+    requiredUtils.add('validators');
+    return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier('regexp'));
+}
+export function createNullCheck(requiredUtils) {
+    requiredUtils.add('validators');
+    return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier('null'));
+}
+export function createUndefinedCheck(requiredUtils) {
+    requiredUtils.add('validators');
+    return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('validators'), ts.factory.createIdentifier('undefined'));
+}
+export function createIntersectionCheck(checks, requiredUtils) {
+    const tpl = `
+    (v, path, ctx) => {
+        const checks = __CHECKS__;
+        let data = ctx.mode === "strip" ? (typeof v === "object" && v !== null && !Array.isArray(v) ? {} : v) : v;
+        for (let i = 0; i < checks.length; i++) {
+            const val = checks[i](v, path, ctx);
+            if (ctx.mode === "strip" && typeof val === "object" && val !== null) Object.assign(data, val);
+        }
+        return data;
+    }
+    `;
+    return injectNodes(templateToAst(tpl), {
+        '__CHECKS__': ts.factory.createArrayLiteralExpression(checks)
+    });
+}
+export function createSetCheck(elementValidator, requiredUtils) {
+    requiredUtils.add('validators');
+    const tpl = '(v, path, ctx) => validators.set(v, path, ctx, __CHILD__)';
+    return injectNodes(templateToAst(tpl), { '__CHILD__': elementValidator });
+}
+export function createMapCheck(keyValidator, valueValidator, requiredUtils) {
+    requiredUtils.add('validators');
+    const tpl = '(v, path, ctx) => validators.map(v, path, ctx, __KEY__, __VALUE__)';
+    return injectNodes(templateToAst(tpl), { '__KEY__': keyValidator, '__VALUE__': valueValidator });
+}

package/dist/engine/hoister.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function hoistRegistrations(sourceFile: ts.SourceFile, cache: Map<string, ts.Expression>, requiredUtils: Set<string>, schemasMap?: Map<string, ts.Expression>): ts.SourceFile;