@webergency-utils/typechecker 0.1.9 → 0.2.1

package/dist/engine/generators.d.ts

@@ -11,7 +11,7 @@ export declare function createLiteralCheck(value: string | number | boolean | ts
 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 createObjectCheck(props: any[], requiredUtils: Set<string>, expected?: string, indexValidator?: ts.Expression): 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;
@@ -21,3 +21,4 @@ export declare function createUndefinedCheck(requiredUtils: Set<string>): ts.Exp
 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;
+export declare function createInstanceOfCheck(typeName: string, requiredUtils: Set<string>): ts.Expression;

package/dist/engine/generators.js

@@ -79,7 +79,7 @@ export function createConstrainedPrimitiveCheck(baseType, constraints, requiredU
             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})`;
+            return `v = validators.format(v, path, ctx, ${JSON.stringify(c.value)}${msgArg})`;
         }
         if (c.type === 'minItems') {
             return `validators.minItems(v, path, ctx, ${valStr}${msgArg})`;
@@ -118,13 +118,13 @@ export function createConstrainedPrimitiveCheck(baseType, constraints, requiredU
                 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)';
+                return 'v = validators.coerceQueryNumber(v)';
             }
             if (tc.type === 'transform' && tc.value === 'toboolean') {
-                return 'v = (v === \'true\' || v === \'1\' || v === true || v === 1)';
+                return 'v = validators.coerceQueryBoolean(v)';
             }
             if (tc.type === 'transform' && tc.value === 'todate') {
-                return 'v = new Date(v)';
+                return 'v = validators.coerceQueryDate(v)';
             }
             if (tc.type === 'transform_custom') {
                 return `v = ${tc.value}(v)`;
@@ -188,19 +188,39 @@ export function createUnionCheck(checks, requiredUtils, expected = 'Type<Union>'
         ts.factory.createStringLiteral(expected)
     ]));
 }
-export function createObjectCheck(props, requiredUtils, expected = 'object') {
+export function createObjectCheck(props, requiredUtils, expected = 'object', indexValidator) {
     requiredUtils.add('validators');
-    const propDefinitions = props.map((p, i) => ts.factory.createArrayLiteralExpression([
+    const propDefinitions = props.map((p) => 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));
+    if (indexValidator) {
+        const tpl = `
+        (v, path, ctx) => {
+            const obj = validators.object(v, path, ctx, undefined, __EXPECTED__);
+            if (obj === false) return v;
+            const data = validators.objectShell(obj, ctx);
+            validators.props(obj, data, path, ctx, __PROPS__);
+            validators.additionalProps(obj, data, path, ctx, __KEYS__, __INDEX__);
+            return data;
+        }
+        `;
+        return injectNodes(templateToAst(tpl), {
+            '__KEYS__': ts.factory.createArrayLiteralExpression(allowedKeys),
+            '__EXPECTED__': ts.factory.createStringLiteral(expected),
+            '__PROPS__': ts.factory.createArrayLiteralExpression(propDefinitions, true),
+            '__INDEX__': indexValidator
+        });
+    }
     const tpl = `
     (v, path, ctx) => {
-        if (!validators.object(v, path, ctx, __KEYS__, __EXPECTED__)) return v;
-        const data = ctx.mode === 'strip' ? {} : v;
-        validators.props(v, data, path, ctx, __PROPS__);
+        const obj = validators.object(v, path, ctx, __KEYS__, __EXPECTED__);
+        if (obj === false) return v;
+        const data = validators.objectShell(obj, ctx);
+        validators.props(obj, data, path, ctx, __PROPS__);
+        validators.stripExtras(data, ctx, __KEYS__);
         return data;
     }
     `;
@@ -243,10 +263,11 @@ 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;
+        let data = validators.objectShell(v, ctx);
         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);
+            if (typeof val === "object" && val !== null && !Array.isArray(val) && typeof data === "object" && data !== null && !Array.isArray(data)) Object.assign(data, val);
+            else data = val;
         }
         return data;
     }
@@ -265,3 +286,8 @@ export function createMapCheck(keyValidator, valueValidator, requiredUtils) {
     const tpl = '(v, path, ctx) => validators.map(v, path, ctx, __KEY__, __VALUE__)';
     return injectNodes(templateToAst(tpl), { '__KEY__': keyValidator, '__VALUE__': valueValidator });
 }
+export function createInstanceOfCheck(typeName, requiredUtils) {
+    requiredUtils.add('validators');
+    const tpl = `(v, path, ctx) => validators.instanceOf(v, path, ctx, ${JSON.stringify(typeName)})`;
+    return templateToAst(tpl);
+}

package/dist/engine/resolver.js

@@ -1,5 +1,5 @@
 import ts from '../ts.js';
-import { createPrimitiveCheck, createLiteralCheck, createArrayCheck, createUnionCheck, createObjectCheck, createDateCheck, createNullCheck, createUndefinedCheck, createIntersectionCheck, createTupleCheck, createRecordCheck, createRegExpCheck, createTemplateLiteralCheck, createConstrainedPrimitiveCheck, createSetCheck, createMapCheck } from './generators.js';
+import { createPrimitiveCheck, createLiteralCheck, createArrayCheck, createUnionCheck, createObjectCheck, createDateCheck, createNullCheck, createUndefinedCheck, createIntersectionCheck, createTupleCheck, createRecordCheck, createRegExpCheck, createTemplateLiteralCheck, createConstrainedPrimitiveCheck, createSetCheck, createMapCheck, createInstanceOfCheck } from './generators.js';
 import { createHash } from 'crypto';
 function getStringLiteralValue(type) {
     if (type.isStringLiteral()) {
@@ -48,6 +48,87 @@ function minifyTypeString(str) {
         .replace(/:\s+/g, ':')
         .replace(/\s+\|\s+/g, '|');
 }
+function isNativeEnumType(type) {
+    const flags = type.getFlags();
+    if (flags & ts.TypeFlags.Enum) {
+        return true;
+    }
+    const symbol = type.getSymbol();
+    if (!symbol) {
+        return false;
+    }
+    return (symbol.flags & (ts.SymbolFlags.RegularEnum | ts.SymbolFlags.ConstEnum)) !== 0;
+}
+function buildEnumValidator(type, checker, validatorsMap, requiredUtils) {
+    const symbol = type.getSymbol();
+    const checks = [];
+    if (symbol?.exports) {
+        symbol.exports.forEach(member => {
+            if (!(member.flags & ts.SymbolFlags.EnumMember)) {
+                return;
+            }
+            const declaration = member.valueDeclaration || member.declarations?.[0];
+            if (!declaration) {
+                return;
+            }
+            const memberType = checker.getTypeOfSymbolAtLocation(member, declaration);
+            checks.push(buildValidator(memberType, checker, validatorsMap, requiredUtils));
+        });
+    }
+    if (checks.length === 0 && type.isUnion()) {
+        const unionChecks = type.types.map(t => buildValidator(t, checker, validatorsMap, requiredUtils));
+        return createUnionCheck(unionChecks, requiredUtils, `Type<${minifyTypeString(checker.typeToString(type))}>`);
+    }
+    if (checks.length === 0) {
+        return createPrimitiveCheck('any', requiredUtils);
+    }
+    if (checks.length === 1) {
+        return checks[0];
+    }
+    return createUnionCheck(checks, requiredUtils, `Type<${minifyTypeString(checker.typeToString(type))}>`);
+}
+function isConstraintOnlyType(type, checker) {
+    const props = checker.getPropertiesOfType(type);
+    return props.length > 0 && props.every(p => p.getName().startsWith('__'));
+}
+function tryMergeObjectIntersection(types, checker, validatorsMap, requiredUtils, expected) {
+    const objectTypes = types.filter(t => {
+        if (isConstraintOnlyType(t, checker)) {
+            return false;
+        }
+        const flags = t.getFlags();
+        return ((flags & ts.TypeFlags.Object) !== 0) || t.isClassOrInterface();
+    });
+    if (objectTypes.length < 2) {
+        return undefined;
+    }
+    const others = types.filter(t => !isConstraintOnlyType(t, checker) && !objectTypes.includes(t));
+    if (others.length > 0) {
+        return undefined;
+    }
+    const propMap = new Map();
+    let indexValidator;
+    for (const t of objectTypes) {
+        const stringIndexInfo = checker.getIndexInfoOfType(t, ts.IndexKind.String);
+        if (stringIndexInfo) {
+            indexValidator = buildValidator(stringIndexInfo.type, checker, validatorsMap, requiredUtils);
+        }
+        for (const prop of checker.getPropertiesOfType(t)) {
+            const name = prop.getName();
+            if (name.startsWith('__')) {
+                continue;
+            }
+            const declaration = prop.valueDeclaration || prop.declarations?.[0];
+            const propType = declaration ? checker.getTypeOfSymbolAtLocation(prop, declaration) : checker.getAnyType();
+            propMap.set(name, {
+                name,
+                isOptional: (prop.getFlags() & ts.SymbolFlags.Optional) !== 0,
+                validator: buildValidator(propType, checker, validatorsMap, requiredUtils)
+            });
+        }
+    }
+    return createObjectCheck([...propMap.values()], requiredUtils, expected, indexValidator);
+}
 export function buildValidator(type, checker, validatorsMap, requiredUtils) {
     const hash = generateHash(type, checker);
     if (validatorsMap.has(hash)) {
@@ -159,7 +240,7 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                             }
                         }
                         if (fnName === '__function' || !fnName) {
-                            throw new Error('[Webergency] Custom validator must reference a named function via typeof (e.g. tag.Custom<typeof myFunc>).');
+                            throw new Error('[Webergency] Custom transform must reference a named function via typeof (e.g. transform.Custom<typeof myFunc>).');
                         }
                         if (filePath) {
                             requiredUtils.add(`custom:${fnName}:${filePath}`);
@@ -199,7 +280,7 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                             }
                         }
                         if (fnName === '__function' || !fnName) {
-                            throw new Error('[Webergency] Custom validator must reference a named function via typeof (e.g. tag.Custom<typeof myFunc>).');
+                            throw new Error('[Webergency] Custom validator must reference a named function via typeof (e.g. constraint.Custom<typeof myFunc>).');
                         }
                         if (filePath) {
                             requiredUtils.add(`custom:${fnName}:${filePath}`);
@@ -306,21 +387,27 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                     baseValidator = buildValidator(nonConstraintTypes[0], checker, validatorsMap, requiredUtils);
                 }
                 else if (nonConstraintTypes.length > 1) {
-                    const checks = nonConstraintTypes.map(t => buildValidator(t, checker, validatorsMap, requiredUtils));
-                    baseValidator = createIntersectionCheck(checks, requiredUtils);
+                    const merged = tryMergeObjectIntersection(nonConstraintTypes, checker, validatorsMap, requiredUtils, minifyTypeString(checker.typeToString(type)));
+                    baseValidator = merged || createIntersectionCheck(nonConstraintTypes.map(t => buildValidator(t, checker, validatorsMap, requiredUtils)), requiredUtils);
                 }
                 if (baseValidator) {
                     result = createConstrainedPrimitiveCheck('any', constraints, requiredUtils, baseValidator);
                 }
                 else {
-                    const checks = type.types.map(t => buildValidator(t, checker, validatorsMap, requiredUtils));
-                    result = createIntersectionCheck(checks, requiredUtils);
+                    const merged = tryMergeObjectIntersection(types, checker, validatorsMap, requiredUtils, minifyTypeString(checker.typeToString(type)));
+                    result = merged || createIntersectionCheck(type.types.map(t => buildValidator(t, checker, validatorsMap, requiredUtils)), requiredUtils);
                 }
             }
         }
         else {
-            const checks = type.types.map(t => buildValidator(t, checker, validatorsMap, requiredUtils));
-            result = createIntersectionCheck(checks, requiredUtils);
+            const merged = tryMergeObjectIntersection(types, checker, validatorsMap, requiredUtils, minifyTypeString(checker.typeToString(type)));
+            if (merged) {
+                result = merged;
+            }
+            else {
+                const checks = type.types.map(t => buildValidator(t, checker, validatorsMap, requiredUtils));
+                result = createIntersectionCheck(checks, requiredUtils);
+            }
         }
     }
     else if (type.getSymbol()?.name === 'Date') {
@@ -338,6 +425,15 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
         const valueType = type.typeArguments?.[1] || checker.getAnyType();
         result = createMapCheck(buildValidator(keyType, checker, validatorsMap, requiredUtils), buildValidator(valueType, checker, validatorsMap, requiredUtils), requiredUtils);
     }
+    else if (type.getSymbol()?.name === 'Promise') {
+        result = createInstanceOfCheck('Promise', requiredUtils);
+    }
+    else if (type.getSymbol()?.name && [
+        'Uint8Array', 'Uint16Array', 'Uint32Array', 'Int8Array', 'Int16Array', 'Int32Array',
+        'Float32Array', 'Float64Array', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView', 'Buffer'
+    ].includes(type.getSymbol().name)) {
+        result = createInstanceOfCheck(type.getSymbol().name, requiredUtils);
+    }
     else if (flags & ts.TypeFlags.Null) {
         result = createNullCheck(requiredUtils);
     }
@@ -356,6 +452,12 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
     else if (flags & ts.TypeFlags.Boolean) {
         result = createPrimitiveCheck('boolean', requiredUtils);
     }
+    else if (flags & ts.TypeFlags.Never) {
+        result = createPrimitiveCheck('never', requiredUtils);
+    }
+    else if (flags & ts.TypeFlags.ESSymbol || flags & ts.TypeFlags.UniqueESSymbol || type.intrinsicName === 'symbol') {
+        result = createPrimitiveCheck('symbol', requiredUtils);
+    }
     else if (flags & ts.TypeFlags.TemplateLiteral) {
         const templateType = type;
         let regexStr = '^';
@@ -404,23 +506,32 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
         const elementType = type.typeArguments?.[0] || checker.getAnyType();
         result = createArrayCheck(buildValidator(elementType, checker, validatorsMap, requiredUtils), requiredUtils);
     }
+    else if (type.getCallSignatures().length > 0 && type.getConstructSignatures().length === 0) {
+        result = createPrimitiveCheck('function', requiredUtils);
+    }
+    else if (isNativeEnumType(type)) {
+        result = buildEnumValidator(type, checker, validatorsMap, requiredUtils);
+    }
     else {
         const stringIndexInfo = checker.getIndexInfoOfType(type, ts.IndexKind.String);
-        if (stringIndexInfo) {
+        const props = checker.getPropertiesOfType(type).map(prop => {
+            const declaration = prop.valueDeclaration || prop.declarations?.[0];
+            const propType = declaration ? checker.getTypeOfSymbolAtLocation(prop, declaration) : checker.getAnyType();
+            return {
+                name: prop.getName(),
+                isOptional: (prop.getFlags() & ts.SymbolFlags.Optional) !== 0,
+                validator: buildValidator(propType, checker, validatorsMap, requiredUtils)
+            };
+        });
+        if (stringIndexInfo && props.length === 0) {
             result = createRecordCheck(buildValidator(stringIndexInfo.type, checker, validatorsMap, requiredUtils), requiredUtils);
         }
-        else if (flags & ts.TypeFlags.Object || type.isClassOrInterface() || type.isTypeParameter()) {
-            const props = checker.getPropertiesOfType(type).map(prop => {
-                const declaration = prop.valueDeclaration || prop.declarations?.[0];
-                const propType = declaration ? checker.getTypeOfSymbolAtLocation(prop, declaration) : checker.getAnyType();
-                return {
-                    name: prop.getName(),
-                    isOptional: (prop.getFlags() & ts.SymbolFlags.Optional) !== 0,
-                    validator: buildValidator(propType, checker, validatorsMap, requiredUtils)
-                };
-            });
+        else if (flags & ts.TypeFlags.Object || type.isClassOrInterface() || type.isTypeParameter() || stringIndexInfo) {
             const typeName = checker.typeToString(type);
-            result = createObjectCheck(props, requiredUtils, typeName);
+            const indexValidator = stringIndexInfo
+                ? buildValidator(stringIndexInfo.type, checker, validatorsMap, requiredUtils)
+                : undefined;
+            result = createObjectCheck(props, requiredUtils, typeName, indexValidator);
         }
         else {
             result = createPrimitiveCheck('any', requiredUtils);
@@ -475,6 +586,38 @@ function buildStructuralSignature(type, checker, visited = new Set()) {
     if (flags & ts.TypeFlags.Undefined || flags & ts.TypeFlags.Void) {
         return 'undefined';
     }
+    if (flags & ts.TypeFlags.Never) {
+        return 'never';
+    }
+    if (flags & ts.TypeFlags.Unknown) {
+        return 'unknown';
+    }
+    if (flags & ts.TypeFlags.Any) {
+        return 'any';
+    }
+    if (flags & ts.TypeFlags.ESSymbol || flags & ts.TypeFlags.UniqueESSymbol || type.intrinsicName === 'symbol') {
+        return 'symbol';
+    }
+    if (type.getCallSignatures().length > 0 && type.getConstructSignatures().length === 0) {
+        return 'function';
+    }
+    if (isNativeEnumType(type)) {
+        const symbol = type.getSymbol();
+        const members = [];
+        if (symbol?.exports) {
+            symbol.exports.forEach(member => {
+                if (!(member.flags & ts.SymbolFlags.EnumMember)) {
+                    return;
+                }
+                const declaration = member.valueDeclaration || member.declarations?.[0];
+                if (!declaration) {
+                    return;
+                }
+                members.push(buildStructuralSignature(checker.getTypeOfSymbolAtLocation(member, declaration), checker, visited));
+            });
+        }
+        return `Enum<${symbol?.name || 'anonymous'}:${members.sort().join(',')}>`;
+    }
     if (flags & ts.TypeFlags.TemplateLiteral) {
         const templateType = type;
         return `TemplateLiteral<${templateType.texts.join(',')}|${templateType.types.map(t => buildStructuralSignature(t, checker, visited)).join(',')}>`;
@@ -483,11 +626,37 @@ function buildStructuralSignature(type, checker, visited = new Set()) {
         const elementType = type.typeArguments?.[0] || checker.getAnyType();
         return `Array<${buildStructuralSignature(elementType, checker, visited)}>`;
     }
+    const typeSymbolName = type.getSymbol()?.name || type.aliasSymbol?.getName();
+    if (typeSymbolName === 'Date') {
+        return 'Date';
+    }
+    if (typeSymbolName === 'RegExp') {
+        return 'RegExp';
+    }
+    if (typeSymbolName === 'Promise') {
+        const valueType = type.typeArguments?.[0] || checker.getAnyType();
+        return `Promise<${buildStructuralSignature(valueType, checker, visited)}>`;
+    }
+    if (typeSymbolName === 'Set') {
+        const elementType = type.typeArguments?.[0] || checker.getAnyType();
+        return `Set<${buildStructuralSignature(elementType, checker, visited)}>`;
+    }
+    if (typeSymbolName === 'Map') {
+        const keyType = type.typeArguments?.[0] || checker.getAnyType();
+        const valueType = type.typeArguments?.[1] || checker.getAnyType();
+        return `Map<${buildStructuralSignature(keyType, checker, visited)},${buildStructuralSignature(valueType, checker, visited)}>`;
+    }
+    if (typeSymbolName && [
+        'Uint8Array', 'Uint16Array', 'Uint32Array', 'Int8Array', 'Int16Array', 'Int32Array',
+        'Float32Array', 'Float64Array', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView', 'Buffer'
+    ].includes(typeSymbolName)) {
+        return typeSymbolName;
+    }
     if (flags & ts.TypeFlags.Object || type.isClassOrInterface()) {
         const props = checker.getPropertiesOfType(type);
+        const stringIndexInfo = checker.getIndexInfoOfType(type, ts.IndexKind.String);
         if (props.length === 0) {
             // Handle Record or empty object
-            const stringIndexInfo = checker.getIndexInfoOfType(type, ts.IndexKind.String);
             if (stringIndexInfo) {
                 return `Record<${buildStructuralSignature(stringIndexInfo.type, checker, visited)}>`;
             }
@@ -498,7 +667,10 @@ function buildStructuralSignature(type, checker, visited = new Set()) {
             const isOptional = (prop.getFlags() & ts.SymbolFlags.Optional) !== 0;
             return `${prop.getName()}${isOptional ? '?' : ''}:${buildStructuralSignature(propType, checker, visited)}`;
         }).sort();
-        return `Object{${propSigs.join(';')}}`;
+        const indexSig = stringIndexInfo
+            ? `;[string]:${buildStructuralSignature(stringIndexInfo.type, checker, visited)}`
+            : '';
+        return `Object{${propSigs.join(';')}${indexSig}}`;
     }
     return 'any';
 }
@@ -679,42 +851,14 @@ function buildJsonSchemaInternal(type, checker, defs, visited, counts, circularH
         const types = type.types;
         let baseSchema = {};
         const constraints = {};
+        const memberSchemas = [];
         for (const sub of types) {
             const sFlags = sub.getFlags();
-            if (sFlags & ts.TypeFlags.String || sFlags & ts.TypeFlags.TemplateLiteral) {
-                baseSchema = { type: 'string' };
-            }
-            else if (sFlags & ts.TypeFlags.Number) {
-                baseSchema = { type: 'number' };
-            }
-            else if (sFlags & ts.TypeFlags.BigInt) {
-                baseSchema = { type: 'integer' };
-            }
-            else if (sFlags & ts.TypeFlags.Boolean || sub.intrinsicName === 'boolean') {
-                baseSchema = { type: 'boolean' };
-            }
-            else if (sub.getSymbol()?.name === 'Date') {
-                baseSchema = { type: 'string', format: 'date-time' };
-            }
-            else if (sub.getSymbol()?.name === 'RegExp') {
-                baseSchema = { type: 'string', format: 'regex' };
-            }
-            else if (sub.getSymbol()?.name === 'Set') {
-                const elementType = sub.typeArguments?.[0] || checker.getAnyType();
-                baseSchema = { type: 'array', items: buildJsonSchemaInternal(elementType, checker, defs, visited, counts, circularHashes), uniqueItems: true };
-            }
-            else if (sub.getSymbol()?.name === 'Map') {
-                const valueType = sub.typeArguments?.[1] || checker.getAnyType();
-                baseSchema = { type: 'object', additionalProperties: buildJsonSchemaInternal(valueType, checker, defs, visited, counts, circularHashes) };
-            }
-            else if (checker.isArrayType(sub)) {
-                const elementType = sub.typeArguments?.[0] || checker.getAnyType();
-                baseSchema = { type: 'array', items: buildJsonSchemaInternal(elementType, checker, defs, visited, counts, circularHashes) };
-            }
-            const props = checker.getPropertiesOfType(sub);
-            for (const prop of props) {
-                const pName = prop.getName();
-                if (pName.startsWith('__')) {
+            const subProps = checker.getPropertiesOfType(sub);
+            const isConstraintPhantom = subProps.length > 0 && subProps.every(p => p.getName().startsWith('__'));
+            if (isConstraintPhantom) {
+                for (const prop of subProps) {
+                    const pName = prop.getName();
                     const pType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0]);
                     const actualType = stripUndefinedFromType(pType);
                     const val = getTagPropertyValue(pType);
@@ -775,36 +919,97 @@ function buildJsonSchemaInternal(type, checker, defs, visited, counts, circularH
                         constraints.requires = reqVal;
                     }
                 }
+                continue;
+            }
+            if (sFlags & ts.TypeFlags.String || sFlags & ts.TypeFlags.TemplateLiteral) {
+                baseSchema = { type: 'string' };
+            }
+            else if (sFlags & ts.TypeFlags.Number) {
+                baseSchema = { type: 'number' };
+            }
+            else if (sFlags & ts.TypeFlags.BigInt) {
+                baseSchema = { 'x-typescript-type': 'bigint' };
             }
+            else if (sFlags & ts.TypeFlags.Boolean || sub.intrinsicName === 'boolean') {
+                baseSchema = { type: 'boolean' };
+            }
+            else if (sub.getSymbol()?.name === 'Date') {
+                baseSchema = { 'x-typescript-type': 'Date' };
+            }
+            else if (sub.getSymbol()?.name === 'RegExp') {
+                baseSchema = { 'x-typescript-type': 'RegExp' };
+            }
+            else if (sub.getSymbol()?.name === 'Set') {
+                const elementType = sub.typeArguments?.[0] || checker.getAnyType();
+                baseSchema = {
+                    'x-typescript-type': 'Set',
+                    items: buildJsonSchemaInternal(elementType, checker, defs, visited, counts, circularHashes)
+                };
+            }
+            else if (sub.getSymbol()?.name === 'Map') {
+                const keyType = sub.typeArguments?.[0] || checker.getAnyType();
+                const valueType = sub.typeArguments?.[1] || checker.getAnyType();
+                baseSchema = {
+                    'x-typescript-type': 'Map',
+                    key: buildJsonSchemaInternal(keyType, checker, defs, visited, counts, circularHashes),
+                    value: buildJsonSchemaInternal(valueType, checker, defs, visited, counts, circularHashes)
+                };
+            }
+            else if (checker.isArrayType(sub)) {
+                const elementType = sub.typeArguments?.[0] || checker.getAnyType();
+                baseSchema = { type: 'array', items: buildJsonSchemaInternal(elementType, checker, defs, visited, counts, circularHashes) };
+            }
+            else if ((sFlags & ts.TypeFlags.Object) || sub.isClassOrInterface()) {
+                memberSchemas.push(buildJsonSchemaInternal(sub, checker, defs, visited, counts, circularHashes));
+            }
+        }
+        if (memberSchemas.length > 1) {
+            return { allOf: memberSchemas, ...constraints };
+        }
+        if (memberSchemas.length === 1) {
+            return { ...memberSchemas[0], ...constraints };
         }
         return { ...baseSchema, ...constraints };
     }
     if (type.getSymbol()?.name === 'Date') {
-        return { type: 'string', format: 'date-time' };
+        return { 'x-typescript-type': 'Date' };
     }
     if (type.getSymbol()?.name === 'RegExp') {
-        return { type: 'string', format: 'regex' };
+        return { 'x-typescript-type': 'RegExp' };
+    }
+    if (type.getSymbol()?.name === 'Promise') {
+        return { 'x-typescript-type': 'Promise' };
+    }
+    {
+        const typedName = type.getSymbol()?.name;
+        if (typedName && [
+            'Uint8Array', 'Uint16Array', 'Uint32Array', 'Int8Array', 'Int16Array', 'Int32Array',
+            'Float32Array', 'Float64Array', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView', 'Buffer'
+        ].includes(typedName)) {
+            return { 'x-typescript-type': typedName };
+        }
     }
     if (type.getSymbol()?.name === 'Set') {
         const elementType = type.typeArguments?.[0] || checker.getAnyType();
         return {
-            type: 'array',
-            items: buildJsonSchemaInternal(elementType, checker, defs, visited, counts, circularHashes),
-            uniqueItems: true
+            'x-typescript-type': 'Set',
+            items: buildJsonSchemaInternal(elementType, checker, defs, visited, counts, circularHashes)
         };
     }
     if (type.getSymbol()?.name === 'Map') {
+        const keyType = type.typeArguments?.[0] || checker.getAnyType();
         const valueType = type.typeArguments?.[1] || checker.getAnyType();
         return {
-            type: 'object',
-            additionalProperties: buildJsonSchemaInternal(valueType, checker, defs, visited, counts, circularHashes)
+            'x-typescript-type': 'Map',
+            key: buildJsonSchemaInternal(keyType, checker, defs, visited, counts, circularHashes),
+            value: buildJsonSchemaInternal(valueType, checker, defs, visited, counts, circularHashes)
         };
     }
     if (flags & ts.TypeFlags.Null) {
         return { type: 'null' };
     }
     if (flags & ts.TypeFlags.Undefined || flags & ts.TypeFlags.Void) {
-        return { type: 'null', description: 'undefined' };
+        return { 'x-typescript-type': 'undefined' };
     }
     if (flags & ts.TypeFlags.String) {
         return { type: 'string' };
@@ -813,7 +1018,7 @@ function buildJsonSchemaInternal(type, checker, defs, visited, counts, circularH
         return { type: 'number' };
     }
     if (flags & ts.TypeFlags.BigInt) {
-        return { type: 'integer' };
+        return { 'x-typescript-type': 'bigint' };
     }
     if (flags & ts.TypeFlags.Boolean || type.intrinsicName === 'boolean') {
         return { type: 'boolean' };
@@ -848,6 +1053,7 @@ function buildJsonSchemaInternal(type, checker, defs, visited, counts, circularH
     }
     // Object types
     if (flags & ts.TypeFlags.Object || type.isClassOrInterface()) {
+        const stringIndexInfo = checker.getIndexInfoOfType(type, ts.IndexKind.String);
         const symbol = type.getSymbol() || type.aliasSymbol;
         const name = symbol ? symbol.getName() : 'Object';
         const typeHash = generateHash(type, checker);
@@ -875,9 +1081,14 @@ function buildJsonSchemaInternal(type, checker, defs, visited, counts, circularH
         }
         const schemaObj = {
             type: 'object',
-            properties,
-            additionalProperties: false
+            properties
         };
+        if (stringIndexInfo) {
+            schemaObj.additionalProperties = buildJsonSchemaInternal(stringIndexInfo.type, checker, defs, visited, counts, circularHashes);
+        }
+        else {
+            schemaObj.additionalProperties = false;
+        }
         if (required.length > 0) {
             schemaObj.required = required;
         }

package/dist/engine/staticAsserts.js

@@ -168,12 +168,13 @@ export function evaluateStaticConstraints(constant, constraints) {
         else if (c.type === 'multipleOf' && constant.kind === 'number') {
             const v = constant.value;
             const n = c.value;
-            let ok = true;
+            let ok;
             if (typeof v === 'bigint' || typeof n === 'bigint') {
                 ok = BigInt(v) % BigInt(n) === 0n;
             }
             else {
-                ok = v % n === 0;
+                const q = v / n;
+                ok = Math.abs(q - Math.round(q)) <= 1e-8 * Math.max(1, Math.abs(q));
             }
             if (!ok) {
                 errors.push(c.message || `Value ${String(v)} does not satisfy MultipleOf<${n}>`);

package/dist/index.d.ts

@@ -1,21 +1,27 @@
 import { ResolveDefaults } from './runtime/tags.js';
+import type { IValidationError } from './runtime/validators.js';
 export interface IValidation<T> {
     success: boolean;
     data?: T;
-    errors?: any[];
+    errors?: IValidationError[];
 }
 export type ValidationMode = 'strict' | 'relaxed' | 'strip';
 export interface ValidationOptions {
     mode?: ValidationMode;
-    tryConvert?: boolean;
+    from?: 'json' | 'query' | ((key: string, value: any, type: 'string' | 'number' | 'boolean' | 'bigint' | 'function' | 'symbol' | 'never' | 'Date' | 'RegExp' | 'Set' | 'Map' | 'Array' | 'Object' | 'instance' | 'null' | 'undefined' | 'tuple' | 'literal') => any);
     wrapArrays?: boolean;
+    /** When true, write validated/coerced values onto the input. Default false: always return new containers. */
+    mutate?: boolean;
     schema?: any;
     errorFactory?: (errors: any[]) => Error;
 }
-export declare function is<T>(input: unknown, options?: ValidationMode | ValidationOptions): input is ResolveDefaults<T>;
-export declare function assert<T>(input: unknown, options?: ValidationMode | ValidationOptions): ResolveDefaults<T>;
-export declare function assertGuard<T>(input: unknown, options?: ValidationMode | ValidationOptions): asserts input is ResolveDefaults<T>;
-export declare function validate<T>(input: unknown, options?: ValidationMode | ValidationOptions): IValidation<ResolveDefaults<T>>;
+/** Returns whether `input` already matches `T`. Does not coerce; `from` is ignored. */
+export declare function is<T>(_input: unknown, _options?: ValidationMode | ValidationOptions): _input is ResolveDefaults<T>;
+/** Validates and returns the (possibly coerced) value. Use `from` when conversion is needed. */
+export declare function assert<T>(_input: unknown, _options?: ValidationMode | ValidationOptions): ResolveDefaults<T>;
+/** Asserts `input` already matches `T`. Does not coerce; `from` is ignored. */
+export declare function assertGuard<T>(_input: unknown, _options?: ValidationMode | ValidationOptions): asserts _input is ResolveDefaults<T>;
+export declare function validate<T>(_input: unknown, _options?: ValidationMode | ValidationOptions): IValidation<ResolveDefaults<T>>;
 export declare function jsonSchema<T>(): any;
 export * from './runtime/validators.js';
 export * from './runtime/tags.js';