Add way to declare custom/project-based type validations (#66)

* add custom validations

* refactor out customTypes into customTypes.mjs, remove PC specific code

* Asserter: add @ignoreRTI tag for skipping runtype type assertion generation

* add two tests

Author: kungfooman

src-runtime/customTypes.mjs

@@ -0,0 +1,5 @@
+/**
+ * @type {Record<string, (value: any) => boolean>}
+ */
+const customTypes = {};
+export {customTypes};

src-runtime/customValidations.mjs

@@ -0,0 +1,5 @@
+/**
+ * @type {Function[]}
+ */
+const customValidations = [];
+export {customValidations};

src-runtime/index.mjs

@@ -1,5 +1,7 @@
 export * from './assertType.mjs';
 export * from './createDiv.mjs';
+export * from './customTypes.mjs';
+export * from './customValidations.mjs';
 export * from './makeJSDoc.mjs';
 export * from './registerClass.mjs';
 export * from './registerTypedef.mjs';

src-runtime/typecheckOptions.mjs

@@ -11,38 +11,6 @@ const typecheckOptions = {
    */
   warned: {},
   logSuperfluousProperty: false,
-  /**
-   * @todo integrate PC/Transformers Examples browser + custom config for each project
-   */
-  customTypes: {
-    AnimSetter(value) {
-      //console.log("@todo Is AnimSetter?", value);
-      return true;
-    },
-    AnimBinder(value) {
-      //console.log("@todo Is AnimBinder?", value);
-      return true;
-    },
-    AnimCurvePath(value) {
-      //console.log("@todo Is AnimCurvePath?", value);
-      return true;
-    },
-    ComponentData(value) {
-      //console.log("@todo Is ComponentData?", value);
-      return true;
-    },
-    Renderer(value) {
-      // E.g. instance of `ForwardRenderer`
-      //debugger;
-      return value?.constructor?.name?.endsWith("Renderer");
-    },
-    IArguments(value) {
-      //console.log("@todo Is IArguments?", value);
-      return true;
-    },
-    // @todo validate textures having width != 0 and height != 0
-    // @todo validate integers
-  },
   count: 0,
 };
 function typecheckReport() {

src-runtime/validateType.mjs

@@ -1,22 +1,24 @@
-import {classes         } from "./registerClass.mjs";
-import {typedefs        } from "./registerTypedef.mjs";
-import {typecheckOptions} from "./typecheckOptions.mjs";
-import {typecheckWarn   } from "./typecheckWarn.mjs";
-import {validateArray   } from "./validateArray.mjs";
-import {validateMap     } from "./validateMap.mjs";
-import {validateNumber  } from "./validateNumber.mjs";
-import {validateObject  } from "./validateObject.mjs";
-import {validateRecord  } from "./validateRecord.mjs";
-import {validateSet     } from "./validateSet.mjs";
-import {validateTuple   } from "./validateTuple.mjs";
-import {validateTypedef } from "./validateTypedef.mjs";
-import {validateUnion   } from "./validateUnion.mjs";
-// For quickly checking props of Vec2/Vec3/Vec4/Quat/Mat3/Mat4 without GC
-const propsXY   = ['x', 'y'];
-const propsXYZ  = ['x', 'y', 'z'];
-const propsXYZW = ['x', 'y', 'z', 'w'];
-const props9    = [0, 1, 2, 3, 4, 5, 6, 7, 8];
-const props16   = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+import {customTypes      } from "./customTypes.mjs";
+import {customValidations} from "./customValidations.mjs";
+import {classes          } from "./registerClass.mjs";
+import {typedefs         } from "./registerTypedef.mjs";
+import {typecheckWarn    } from "./typecheckWarn.mjs";
+import {validateArray    } from "./validateArray.mjs";
+import {validateMap      } from "./validateMap.mjs";
+import {validateNumber   } from "./validateNumber.mjs";
+import {validateObject   } from "./validateObject.mjs";
+import {validateRecord   } from "./validateRecord.mjs";
+import {validateSet      } from "./validateSet.mjs";
+import {validateTuple    } from "./validateTuple.mjs";
+import {validateTypedef  } from "./validateTypedef.mjs";
+import {validateUnion    } from "./validateUnion.mjs";
+let enabled = true;
+export function disableTypeChecking() {
+  enabled = false;
+}
+export function enableTypeChecking() {
+  enabled = true;
+}
 /**
  * @param {*} value - The actual value which we need to check.
  * @param {object} expect - Can also be a string, but string|object is unsupported in VSCode
@@ -36,6 +38,9 @@ const props16   = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  * @returns {boolean} Returns wether `value` is in the shape of `expect`.
  */
 function validateType(value, expect, loc, name, critical = true) {
+  if (!enabled) {
+    return true;
+  }
   if (typeof expect === 'string') {
     expect = {
       type: expect,
@@ -59,7 +64,7 @@ function validateType(value, expect, loc, name, critical = true) {
       return true;
     }
   }
-  const customCheck = typecheckOptions.customTypes[type];
+  const customCheck = customTypes[type];
   if (customCheck) {
     return customCheck(value);
   }
@@ -76,34 +81,13 @@ function validateType(value, expect, loc, name, critical = true) {
       return false;
     }
   }
-  if (typeof window !== 'undefined' && window.pc) {
-    const {pc} = window;
-    /**
-     * @param {string|number} prop - Something like 'x', 'y', 'z', 'w', 0, 1, 2, 3, 4 etc.
-     * @returns {boolean} Wether prop is a valid number.
-     */
-    const checkProp = (prop) => {
-      return validateNumber(value, prop);
-    };
-    // In a bundle pc can be defined while pc is not filled with all classes yet,
-    // therefore we need to check if class is added already.
-    if (pc.Vec2 && value instanceof pc.Vec2) {
-      return propsXY.every(checkProp);
-    }
-    if (pc.Vec3 && value instanceof pc.Vec3) {
-      return propsXYZ.every(checkProp);
-    }
-    if ((pc.Vec4 && value instanceof pc.Vec4) || (pc.Quat && value instanceof pc.Quat)) {
-      return propsXYZW.every(checkProp);
-    }
-    if (pc.Mat3 && value instanceof pc.Mat3) {
-      return props9.every(prop => validateNumber(value.data, prop));
-    }
-    if (pc.Mat4 && value instanceof pc.Mat4) {
-      return props16.every(prop => validateNumber(value.data, prop));
+  for (const customValidation of customValidations) {
+    const ret = customValidation(value, expect, loc, name, critical);
+    if (!ret) {
+      typecheckWarn(`${loc}> customValidation failed`);
+      return false;
     }
   }
-  // todo: either switch or object lookup for custom hooks
   if (type === "object") {
     return validateObject(value, properties, loc, name, critical);
   }

src-transpiler/Asserter.mjs

@@ -223,6 +223,9 @@ class Asserter extends Stringifier {
             [paramName]: parseJSDocSetter(lastComment.value, this.expandType)
           };
         }
+        if (lastComment.value.includes('@ignoreRTI')) {
+          return;
+        }
         return parseJSDoc(lastComment.value, this.expandType);
       }
     }

test/typechecking/customTypes-for-prime-types.mjs

@@ -0,0 +1,56 @@
+import {customTypes, disableTypeChecking, enableTypeChecking} from '@runtime-type-inspector/runtime';
+/**
+ * @ignoreRTI
+ * @param {*} value - The value.
+ * @returns {boolean} Whether "value" if of type  "expect".
+ */
+function validatePrime(value) {
+  if (typeof value !== 'number') {
+    return false;
+  }
+  // Preventation for: Uncaught RangeError: Maximum call stack size exceeded
+  disableTypeChecking();
+  const ret = isPrime(value);
+  enableTypeChecking();
+  return ret;
+}
+customTypes.prime = validatePrime;
+/**
+ * @typedef {number} prime
+ */
+/**
+ * @param {prime} a - 1st prime addend.
+ * @param {prime} b - 2nd prime addend.
+ * @returns {number} The sum.
+ */
+function addPrimesOnly(a, b) {
+  return a + b;
+}
+/**
+ * @param {number} x - The number to test.
+ * @returns {boolean} Whether number is a prime.
+ */
+function isPrime(x) {
+  if (x > 2 && x % 2 === 0) {
+    return false;
+  }
+  const n = Math.ceil(Math.sqrt(x));
+  for (let i = 3; i <= n; i += 2) {
+    if (x % i === 0) {
+      return false;
+    }
+  }
+  return x > 1;
+}
+// Tests:
+addPrimesOnly(11, 13); // works, both prime
+addPrimesOnly(1, 13); // fails, 1 isn't prime
+addPrimesOnly(11, undefined); // not even a number
+const primes = [];
+for (let i = 0; i < 200; i++) {
+  const prime = isPrime(i);
+  if (prime) {
+    primes.push(i);
+  }
+}
+console.log("Primes:", primes);

test/typechecking/customValidations-for-entity.mjs

@@ -0,0 +1,31 @@
+import {customValidations, typecheckWarn} from '@runtime-type-inspector/runtime';
+class Vec3 {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+}
+class Entity {
+  /**
+   * @param {string} [name] - The name.
+   */
+  constructor(name = "Untitled") {
+    this.name = name;
+  }
+}
+console.log("customValidations", customValidations);
+customValidations.length = 0;
+customValidations.push(value => {
+  if (value instanceof Vec3) {
+    if (isNaN(value.x)) {
+      typecheckWarn("x is NaN");
+      return false;
+    }
+  }
+  return true;
+});
+const entity1 = new Entity("test");
+console.log("entity1", entity1);
+const entity2 = new Entity(new Vec3(NaN, 2, 3));
+console.log("entity2", entity2);