@webergency-utils/typechecker 0.2.2 → 0.2.3

package/dist/transformer.js

@@ -5,6 +5,7 @@ import { hoistRegistrations } from './engine/hoister.js';
 import { installStaticConstraintDiagnostics } from './engine/staticAsserts.js';
 const TYPE_FUNCTIONS = ['is', 'assert', 'assertGuard', 'validate', 'jsonSchema'];
 const SCHEMA_FUNCTIONS = ['isSchema', 'assertSchema', 'assertGuardSchema', 'validateSchema'];
+const VALIDATION_FUNCTIONS = ['is', 'assert', 'assertGuard', 'validate'];
 function metadataCall(method, args) {
     return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), method), undefined, args);
 }
@@ -19,13 +20,62 @@ export default function transformer(program) {
             const validatorCache = new Map();
             const schemasCache = new Map();
             const requiredUtils = new Set();
+            const helperBindings = new Map();
+            const helperNamespaces = new Set();
+            const hashByTypeId = new Map();
+            const getTypeHash = (type) => {
+                const typeId = type.id;
+                if (typeof typeId === 'number') {
+                    const cached = hashByTypeId.get(typeId);
+                    if (cached) {
+                        return cached;
+                    }
+                    const hash = generateHash(type, checker);
+                    hashByTypeId.set(typeId, hash);
+                    return hash;
+                }
+                return generateHash(type, checker);
+            };
+            for (const statement of sourceFile.statements) {
+                if (!ts.isImportDeclaration(statement)) {
+                    continue;
+                }
+                const moduleName = ts.isStringLiteral(statement.moduleSpecifier)
+                    ? statement.moduleSpecifier.text
+                    : '';
+                const isTypecheckerImport = moduleName === '@webergency-utils/typechecker' ||
+                    /(?:^|\/)(?:src\/)?index\.(?:js|ts)$/.test(moduleName);
+                if (!isTypecheckerImport) {
+                    continue;
+                }
+                const bindings = statement.importClause?.namedBindings;
+                if (bindings && ts.isNamedImports(bindings)) {
+                    for (const element of bindings.elements) {
+                        const importedName = element.propertyName?.text || element.name.text;
+                        if (TYPE_FUNCTIONS.includes(importedName) || SCHEMA_FUNCTIONS.includes(importedName)) {
+                            helperBindings.set(element.name.text, importedName);
+                        }
+                    }
+                }
+                else if (bindings && ts.isNamespaceImport(bindings)) {
+                    helperNamespaces.add(bindings.name.text);
+                }
+            }
             const visitor = (node) => {
                 if (ts.isImportDeclaration(node)) {
                     return node;
                 }
-                if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-                    const fnName = node.expression.text;
-                    if (SCHEMA_FUNCTIONS.includes(fnName)) {
+                if (ts.isCallExpression(node)) {
+                    let fnName;
+                    if (ts.isIdentifier(node.expression)) {
+                        fnName = helperBindings.get(node.expression.text);
+                    }
+                    else if (ts.isPropertyAccessExpression(node.expression) &&
+                        ts.isIdentifier(node.expression.expression) &&
+                        helperNamespaces.has(node.expression.expression.text)) {
+                        fnName = node.expression.name.text;
+                    }
+                    if (fnName && SCHEMA_FUNCTIONS.includes(fnName)) {
                         requiredUtils.add('MetadataStore');
                         const schemaArg = argOrUndefined(node.arguments, 0);
                         const inputArg = argOrUndefined(node.arguments, 1);
@@ -42,34 +92,37 @@ export default function transformer(program) {
                         }
                         return metadataCall('assertGuard', [compiled, inputArg, optionsArg]);
                     }
-                    if (TYPE_FUNCTIONS.includes(fnName)) {
+                    if (fnName && TYPE_FUNCTIONS.includes(fnName)) {
                         const typeArg = node.typeArguments?.[0];
                         if (typeArg) {
                             const type = checker.getTypeFromTypeNode(typeArg);
-                            const hash = generateHash(type, checker);
-                            if (!validatorCache.has(hash)) {
-                                buildValidator(type, checker, validatorCache, requiredUtils);
-                            }
-                            if (!schemasCache.has(hash)) {
-                                const schemaObj = buildJsonSchema(type, checker);
-                                schemasCache.set(hash, objectToAst(schemaObj));
-                            }
-                            const inputArg = argOrUndefined(node.arguments, 0);
-                            const optionsArg = argOrUndefined(node.arguments, 1);
-                            const getValidator = metadataCall('getValidator', [ts.factory.createStringLiteral(hash)]);
+                            const hash = getTypeHash(type);
                             if (fnName === 'jsonSchema') {
+                                requiredUtils.add('MetadataStore');
+                                if (!schemasCache.has(hash)) {
+                                    const schemaObj = buildJsonSchema(type, checker);
+                                    schemasCache.set(hash, objectToAst(schemaObj));
+                                }
                                 return metadataCall('getSchema', [ts.factory.createStringLiteral(hash)]);
                             }
-                            if (fnName === 'validate') {
-                                return metadataCall('validate', [getValidator, inputArg, optionsArg]);
-                            }
-                            if (fnName === 'is') {
-                                return metadataCall('is', [getValidator, inputArg, optionsArg]);
-                            }
-                            if (fnName === 'assert') {
-                                return metadataCall('assert', [getValidator, inputArg, optionsArg]);
+                            if (VALIDATION_FUNCTIONS.includes(fnName)) {
+                                if (!validatorCache.has(hash)) {
+                                    buildValidator(type, checker, validatorCache, requiredUtils, hash);
+                                }
+                                const inputArg = argOrUndefined(node.arguments, 0);
+                                const optionsArg = argOrUndefined(node.arguments, 1);
+                                const getValidator = metadataCall('getValidator', [ts.factory.createStringLiteral(hash)]);
+                                if (fnName === 'validate') {
+                                    return metadataCall('validate', [getValidator, inputArg, optionsArg]);
+                                }
+                                if (fnName === 'is') {
+                                    return metadataCall('is', [getValidator, inputArg, optionsArg]);
+                                }
+                                if (fnName === 'assert') {
+                                    return metadataCall('assert', [getValidator, inputArg, optionsArg]);
+                                }
+                                return metadataCall('assertGuard', [getValidator, inputArg, optionsArg]);
                             }
-                            return metadataCall('assertGuard', [getValidator, inputArg, optionsArg]);
                         }
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webergency-utils/typechecker",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "description": "TypeScript compiler plugin for runtime validation",
   "author": "radixxko",
@@ -42,6 +42,7 @@
   "scripts": {
     "lint": "eslint .",
     "test": "vitest run",
+    "bench": "npm run build && node scripts/perf-microbench.mjs",
     "fuzz": "npm run build:fuzz && jazzer fuzz_typechecker.cjs",
     "coverage": "vitest run --coverage",
     "clean": "rm -rf ./dist ./dist-fuzz",