@webergency-utils/typechecker 0.1.10 → 0.2.1

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

@@ -173,7 +173,8 @@ export function evaluateStaticConstraints(constant, constraints) {
                 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';

package/dist/index.js

@@ -1,3 +1,22 @@
+const TRANSFORMER_MISSING = 'Typechecker transformer was not applied. Register { "transform": "@webergency-utils/typechecker/transformer" } in tsconfig plugins (requires ts-patch).';
+/** Returns whether `input` already matches `T`. Does not coerce; `from` is ignored. */
+export function is(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+/** Validates and returns the (possibly coerced) value. Use `from` when conversion is needed. */
+export function assert(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+/** Asserts `input` already matches `T`. Does not coerce; `from` is ignored. */
+export function assertGuard(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+export function validate(_input, _options) {
+    throw new Error(TRANSFORMER_MISSING);
+}
+export function jsonSchema() {
+    throw new Error(TRANSFORMER_MISSING);
+}
 export * from './runtime/validators.js';
 export * from './runtime/tags.js';
 export * from './runtime/casing.js';

package/dist/runtime/tags/format.d.ts

@@ -1,5 +1,6 @@
 import type { Format } from './constraint.js';
 export type Email = Format<'email'>;
+export type IdnEmail = Format<'idn-email'>;
 export type UUID = Format<'uuid'>;
 export type URL = Format<'url'>;
 export type IPv4 = Format<'ipv4'>;
@@ -10,6 +11,12 @@ export type Byte = Format<'byte'>;
 export type Password = Format<'password'>;
 export type Regex = Format<'regex'>;
 export type Hostname = Format<'hostname'>;
+export type IdnHostname = Format<'idn-hostname'>;
+export type URI = Format<'uri'>;
+export type UriReference = Format<'uri-reference'>;
+export type IRI = Format<'iri'>;
+export type IriReference = Format<'iri-reference'>;
+export type UriTemplate = Format<'uri-template'>;
 export type Time = Format<'time'>;
 export type Duration = Format<'duration'>;
 export type ObjectId = Format<'objectId'>;

package/dist/runtime/tags/tag.d.ts

@@ -1,3 +1,3 @@
-export type Default<V extends string | number | boolean | null> = {
+export type Default<V = any> = {
     readonly __default?: V;
 };

package/dist/runtime/tags.d.ts

@@ -47,7 +47,7 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
  * Recursively resolves object properties, removing the optional `?` modifier
  * from any properties that have a `tag.Default` applied.
  */
-export type ResolveDefaults<T> = T extends Date | symbol | string | number | boolean | bigint | null | undefined | Function ? T : T extends Array<infer U> ? Array<ResolveDefaults<U>> : T extends object ? {
+export type ResolveDefaults<T> = T extends Date | RegExp | Promise<any> | Map<any, any> | Set<any> | ArrayBuffer | SharedArrayBuffer | DataView | Buffer | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | symbol | string | number | boolean | bigint | null | undefined | Function ? T : T extends Array<infer U> ? Array<ResolveDefaults<U>> : T extends object ? {
     [K in keyof T as IsAny<T[K]> extends true ? never : '__default' extends keyof NonNullable<T[K]> ? K : never]-?: ResolveDefaults<Exclude<T[K], undefined>>;
 } & {
     [K in keyof T as IsAny<T[K]> extends true ? K : '__default' extends keyof NonNullable<T[K]> ? never : K]: ResolveDefaults<T[K]>;