ESLint: add/fix src/runtime + some other ESLint fixes

Author: kungfooman

package.json

@@ -11,7 +11,7 @@
     "build:types": "npm run build:dts && rollup -c --environment target:types",
     "test": "npm run test:update && node test.mjs",
     "test:update": "node gen_tests.mjs > test/typechecking.json",
-    "lint": "eslint --ext .js,.mjs,.cjs src-transpiler",
+    "lint": "eslint --ext .js,.mjs,.cjs src-transpiler src-runtime",
     "docs": "echo todo docs using jsdoc"
   },
   "repository": {

plugin-parcel1/index.cjs

@@ -1,4 +1,4 @@
-const { addTypeChecks } = require('runtime-type-inspector');
+const {addTypeChecks} = require('runtime-type-inspector');
 const JSAsset = require('parcel-bundler/src/assets/JSAsset.js');
 class JSAssetPlayCanvas extends JSAsset {
   /**

repl/babel-core.mjs

@@ -1,5 +1,5 @@
 // Instead of loading this as UMD module, we will soon integrate Babel 8, which
 // finally ships as proper ESM modules. But it requires a bit more work (tm).
 await import("../unpkg.com_@babel_standalone@7.22.17_babel.js");
-const { parseSync } = Babel._babel;
-export { parseSync };
+const {parseSync} = Babel._babel;
+export {parseSync};

repl/index.html

@@ -26,7 +26,7 @@
     Right: <input id="right" type="checkbox" checked></input>
     <script type="module">
       import * as Index from "./index.mjs";
-      Object.assign(window, { ...Index });
+      Object.assign(window, {...Index});
     </script>
   </body>
 </html>

repl/index.mjs

@@ -33,7 +33,7 @@ if (!(inputRight instanceof HTMLInputElement)) {
   throw 'This module requires a <input id="right" ...';
 }
 inputLeft.onchange = (event) => {
-  const { checked } = event.target;
+  const {checked} = event.target;
   if (checked) {
     // Unhide right editor and resize right one to half size again
     aceDivLeft.style.display = "";
@@ -52,7 +52,7 @@ inputLeft.onchange = (event) => {
   }
 }
 inputRight.onchange = (event) => {
-  const { checked } = event.target;
+  const {checked} = event.target;
   if (checked) {
     // Unhide left editor and resize right one to half size again
     aceDivRight.style.display = "";

rollup.config.mjs

@@ -1,19 +1,19 @@
-import { execSync } from 'child_process';
+import {execSync} from 'child_process';
 import fs from 'fs';
 import path from 'path';
 // 1st party Rollup plugins
-import { createFilter } from '@rollup/pluginutils';
-import { babel } from '@rollup/plugin-babel';
-import { nodeResolve } from '@rollup/plugin-node-resolve';
+import {createFilter} from '@rollup/pluginutils';
+import {babel       } from '@rollup/plugin-babel';
+import {nodeResolve } from '@rollup/plugin-node-resolve';
 import terser from '@rollup/plugin-terser';
 // 3rd party Rollup plugins
 import dts from 'rollup-plugin-dts';
-import { visualizer } from 'rollup-plugin-visualizer';
+import {visualizer} from 'rollup-plugin-visualizer';
 import json from '@rollup/plugin-json';
-//import { addTypeChecks } from "./src-transpiler/typeInserter.mjs";
-//const { addTypeChecks } = await import("runtime-type-inspector/src-transpiler/typeInserter.mjs");
+//import {addTypeChecks} from "./src-transpiler/typeInserter.mjs";
+//const {addTypeChecks} = await import("runtime-type-inspector/src-transpiler/typeInserter.mjs");
 import commonjs from '@rollup/plugin-commonjs';
-//import { runtimeTypeInspector } from './plugin-rollup/index.mjs';
+//import {runtimeTypeInspector} from './plugin-rollup/index.mjs';
 /** @typedef {import('rollup').RollupOptions} RollupOptions */
 /** @typedef {import('rollup').Plugin} Plugin */
 /** @typedef {import('rollup').OutputOptions} OutputOptions */
@@ -169,7 +169,7 @@ export default (args) => {
   const envTarget = process.env.target ? process.env.target.toLowerCase() : null;
   if ((envTarget === null) && fs.existsSync('build')) {
     // no targets specified, clean build directory
-    fs.rmSync('build', { recursive: true });
+    fs.rmSync('build', {recursive: true});
   }
   if (envTarget === 'types') {
     targets.push(target_types);

src-runtime/assertType.mjs

@@ -24,7 +24,7 @@ export function assertType(value, expect, loc, name, critical = true) {
     }
     expectStr = '';
     const msg = `${loc}> type of '${name}' is invalid${expectStr}`;
-    typecheckWarn(msg, { expect, value });
+    typecheckWarn(msg, {expect, value});
     const warnObj = typecheckOptions.warned[msg];
     if (!warnObj.tr) {
       const tr = document.createElement('tr');
@@ -33,7 +33,7 @@ export function assertType(value, expect, loc, name, critical = true) {
       dbgInput.type = "checkbox";
       dbgInput.onchange = () => {
         warnObj.dbg = dbgInput.checked;
-      }
+      };
       const count = document.createElement('td');
       const desc = document.createElement('td');
       desc.innerText = msg;

src-runtime/makeJSDoc.mjs

@@ -1,6 +1,4 @@
-/**
- * @type {Record<string, string>}
- */
+/** @type {Record<string, string>} */
 const jsdocCache = {};
 /**
  * @todo
@@ -24,11 +22,11 @@ function makeJSDoc(loc, names, values) {
     } else if (value instanceof Object) {
       type = value.constructor.name;
     }
-    if (type !== 'string' && pc[type]) {
+    if (type !== 'string' && window.pc[type]) {
       type = 'pc.' + type;
     }
     //debugger;
-    jsdoc += `     * @param {${type}} ${name} - todo/jsdoc\n`
+    jsdoc += `     * @param {${type}} ${name} - todo/jsdoc\n`;
   }
   jsdoc += '     */';
   if (!jsdocCache[loc]) {

src-runtime/typecheckEvery.mjs

@@ -3,7 +3,7 @@
  * @example
  * const a = [];
  * a.length = 10;
- * typecheckEvery(a, (e, i) => { console.log(e); return true; }
+ * typecheckEvery(a, (e, i) => {console.log(e); return true;}
  * @param {*[]} arr - The array to test.
  * @param {Function} fn - The callback function to test each element with.
  * @returns {boolean} True if every callback call is true aswell.

src-runtime/typecheckOptions.mjs

@@ -1,15 +1,3 @@
-function typecheckReport() {
-  console.table(typecheckOptions.warned);
-}
-/**
- * @param {Object<string, any>} obj - The object to clear.
- */
-function clearObject(obj) {
-  Object.keys(obj).forEach(_ => delete obj[_]);
-}
-function typecheckReset() {
-  clearObject(typecheckOptions.warned);
-}
 const typecheckOptions = {
   /**
    * @type {'spam'|'once'|'never'} - In spam-mode every message is printed. In once-mode a cache is
@@ -57,4 +45,16 @@ const typecheckOptions = {
   },
   count: 0,
 };
+function typecheckReport() {
+  console.table(typecheckOptions.warned);
+}
+/**
+ * @param {Object<string, any>} obj - The object to clear.
+ */
+function clearObject(obj) {
+  Object.keys(obj).forEach(_ => delete obj[_]);
+}
+function typecheckReset() {
+  clearObject(typecheckOptions.warned);
+}
 export {typecheckReport, clearObject, typecheckReset, typecheckOptions};

src-runtime/typecheckWarn.mjs

@@ -4,8 +4,8 @@ import {typecheckOptions} from "./typecheckOptions.mjs";
  * @param {...any} extra - Extra strings or objects etc.
  */
 function typecheckWarn(msg, ...extra) {
-  const { mode, warned } = typecheckOptions;
-  warned[msg] = warned[msg] || { hits: 0 };
+  const {mode, warned} = typecheckOptions;
+  warned[msg] = warned[msg] || {hits: 0};
   warned[msg].hits++;
   switch (mode) {
     case 'spam':

src-runtime/validateArray.mjs

@@ -1,16 +1,16 @@
 import {assertType    } from "./assertType.mjs";
 import {typecheckEvery} from "./typecheckEvery.mjs";
 /**
- * @param {*} value 
- * @param {*} expect 
- * @param {*} loc 
- * @param {*} name 
- * @param {*} critical 
- * @returns {boolean}
+ * @param {*} value - The actual value that we need to validate.
+ * @param {*} expect - The supposed type information of said value.
+ * @param {string} loc - String like `BoundingBox#compute`
+ * @param {string} name - Name of the argument
+ * @param {boolean} critical - Only `false` for unions.
+ * @returns {boolean} - Boolean indicating if a type is correct.
  */
 function validateArray(value, expect, loc, name, critical) {
   if (value && value instanceof Array) {
-    const { elementType } = expect;
+    const {elementType} = expect;
     // some that not validate -> type error
     return typecheckEvery(value, (_, i) => assertType(
       _,

src-runtime/validateDivision.mjs

@@ -6,25 +6,25 @@ import {typecheckWarn} from "./typecheckWarn.mjs";
  * validateDivision( 1 ,  2 ); // Outputs: 0.5
  * validateDivision( 1 , "2"); // Warns: validateDivision> incompatible type pair
  * validateDivision(10n,  2n); // Outputs: 5n
- * @returns {number}
+ * @returns {number} The division result.
  */
 function validateDivision(lhs, rhs) {
   const ret = lhs / rhs;
   const twoNumbers = typeof lhs === 'number' && typeof rhs === 'number';
   const twoBigInts = typeof lhs === 'bigint' && typeof rhs === 'bigint';
   const valid = twoNumbers || twoBigInts;
   if (!valid) {
-    typecheckWarn(`validateDivision> incompatible type pair`, { lhs, rhs, twoNumbers, twoBigInts });
+    typecheckWarn(`validateDivision> incompatible type pair`, {lhs, rhs, twoNumbers, twoBigInts});
   }
   // If we got two bigint's, we are done, as isNaN and isFinite is only for "normal" numbers.
   if (twoBigInts) {
     return ret;
   }
   if (isNaN(ret)) {
-    typecheckWarn(`validateDivision> NaN`, { lhs, rhs });
+    typecheckWarn(`validateDivision> NaN`, {lhs, rhs});
   }
   if (!isFinite(ret)) {
-    typecheckWarn(`validateDivision> +-Infinity`, { lhs, rhs });
+    typecheckWarn(`validateDivision> +-Infinity`, {lhs, rhs});
   }
   return ret;
 }

src-runtime/validateMap.mjs

@@ -2,15 +2,15 @@ import {assertType   } from "./assertType.mjs";
 import {typecheckWarn} from "./typecheckWarn.mjs";
 /**
  * @todo Implement checking all possible key/val types
- * @param {*} value 
- * @param {*} expect 
- * @param {*} loc 
- * @param {*} name 
- * @param {*} critical 
- * @returns {boolean}
+ * @param {*} value - The actual value that we need to validate.
+ * @param {*} expect - The supposed type information of said value.
+ * @param {string} loc - String like `BoundingBox#compute`
+ * @param {string} name - Name of the argument
+ * @param {boolean} critical - Only `false` for unions.
+ * @returns {boolean} - Boolean indicating if a type is correct.
  */
 function validateMap(value, expect, loc, name, critical) {
-  const { key, val } = expect;
+  const {key, val} = expect;
   if (key !== 'string') {
     typecheckWarn(`${loc}> validateType> map> unhandled key '${key}'`);
     return false;

src-runtime/validateNumber.mjs

@@ -9,19 +9,19 @@ function validateNumber(obj, prop) {
   const val = obj[prop];
   const type = typeof obj;
   if (val === null) {
-    typecheckWarn(`${type}#${prop} null`, { obj });
+    typecheckWarn(`${type}#${prop} null`, {obj});
     return false;
   }
   if (val === undefined) {
-    typecheckWarn(`${type}#${prop} undefined`, { obj });
+    typecheckWarn(`${type}#${prop} undefined`, {obj});
     return false;
   }
   if (isNaN(val)) {
-    typecheckWarn(`${type}#${prop} NaN`, { obj });
+    typecheckWarn(`${type}#${prop} NaN`, {obj});
     return false;
   }
   if (!isFinite(val)) {
-    typecheckWarn(`${type}#${prop} +-Infinity`, { obj });
+    typecheckWarn(`${type}#${prop} +-Infinity`, {obj});
     return false;
   }
   return true;

src-runtime/validateObject.mjs

@@ -2,12 +2,12 @@ import {assertType      } from "./assertType.mjs";
 import {typecheckOptions} from "./typecheckOptions.mjs";
 import {typecheckWarn   } from "./typecheckWarn.mjs";
 /**
- * @param {*} value 
- * @param {*} properties 
- * @param {*} loc 
- * @param {*} name 
- * @param {*} critical 
- * @returns {boolean}
+ * @param {*} value - The actual value that we need to validate.
+ * @param {*} properties - The properties.
+ * @param {string} loc - String like `BoundingBox#compute`
+ * @param {string} name - Name of the argument
+ * @param {boolean} critical - Only `false` for unions.
+ * @returns {boolean} - Boolean indicating if a type is correct.
  */
 function validateObject(value, properties, loc, name, critical) {
   if (!(value instanceof Object)) {
@@ -21,7 +21,7 @@ function validateObject(value, properties, loc, name, critical) {
         }
         if (!properties[key]) {
           if (typecheckOptions.logSuperfluousProperty) {
-            typecheckWarn(`${loc}> superfluous property> ${name}.${key}`, { properties, value });
+            typecheckWarn(`${loc}> superfluous property> ${name}.${key}`, {properties, value});
           }
         }
       });

src-runtime/validateRecord.mjs

@@ -1,12 +1,12 @@
 import {assertType   } from "./assertType.mjs";
 import {typecheckWarn} from "./typecheckWarn.mjs";
 /**
- * @param {*} value 
- * @param {*} expect 
- * @param {*} loc 
- * @param {*} name 
- * @param {*} critical 
- * @returns {boolean}
+ * @param {*} value - The actual value that we need to validate.
+ * @param {*} expect - The supposed type information of said value.
+ * @param {string} loc - String like `BoundingBox#compute`
+ * @param {string} name - Name of the argument
+ * @param {boolean} critical - Only `false` for unions.
+ * @returns {boolean} - Boolean indicating if a type is correct.
  */
 function validateRecord(value, expect, loc, name, critical) {
   const {key, val} = expect;

src-runtime/validateSet.mjs

@@ -1,12 +1,12 @@
 import {assertType   } from "./assertType.mjs";
 import {typecheckWarn} from "./typecheckWarn.mjs";
 /**
- * @param {*} value 
- * @param {*} expect 
- * @param {*} loc 
- * @param {*} name 
- * @param {*} critical 
- * @return {boolean}
+ * @param {*} value - The actual value that we need to validate.
+ * @param {*} expect - The supposed type information of said value.
+ * @param {string} loc - String like `BoundingBox#compute`
+ * @param {string} name - Name of the argument
+ * @param {boolean} critical - Only `false` for unions.
+ * @returns {boolean} - Boolean indicating if a type is correct.
  */
 function validateSet(value, expect, loc, name, critical) {
   if (!(value instanceof Set)) {

src-runtime/validateTuple.mjs

@@ -1,11 +1,11 @@
 import {assertType} from "./assertType.mjs";
 /**
- * @param {*} value 
- * @param {*} expect 
- * @param {*} loc 
- * @param {*} name 
- * @param {*} critical 
- * @returns {boolean}
+ * @param {*} value - The actual value that we need to validate.
+ * @param {*} expect - The supposed type information of said value.
+ * @param {string} loc - String like `BoundingBox#compute`
+ * @param {string} name - Name of the argument
+ * @param {boolean} critical - Only `false` for unions.
+ * @returns {boolean} - Boolean indicating if a type is correct.
  */
 function validateTuple(value, expect, loc, name, critical) {
   if (!value) {
@@ -14,7 +14,7 @@ function validateTuple(value, expect, loc, name, critical) {
   if (!(value instanceof Array)) {
     return false;
   }
-  const { elements } = expect;
+  const {elements} = expect;
   return elements.every((element, i) => {
     return assertType(
       value[i],