feat(util): unassert

Signed-off-by: Lexus Drumgold <[email protected]>

Author: unicornware

.commitlintrc.ts

@@ -21,6 +21,7 @@ const config: UserConfig = {
     'scope-enum': [Severity.Error, 'always', scopes([
       'chore',
       'handlers',
+      'util',
       'visitors'
     ])]
   }

.dictionary.txt

@@ -32,5 +32,6 @@ shfmt
 unassert
 unstub
 vates
+vfile
 vitest
 yarnrc

.eslintignore

@@ -16,6 +16,7 @@
 **/node_modules/
 **/tsconfig*temp.json
 Brewfile
+__fixtures__/modules/*.cjs
 yarn.lock
 
 # NEGATED PATTERNS

.eslintrc.cjs

@@ -10,7 +10,27 @@
  */
 const config = {
   extends: ['./.eslintrc.base.cjs'],
-  overrides: [...require('./.eslintrc.base.cjs').overrides],
+  overrides: [
+    ...require('./.eslintrc.base.cjs').overrides,
+    {
+      files: ['__fixtures__/modules/*.mjs'],
+      rules: {
+        '@typescript-eslint/no-confusing-void-expression': 0,
+        '@typescript-eslint/no-unsafe-argument': 0,
+        '@typescript-eslint/no-unsafe-call': 0,
+        '@typescript-eslint/no-unsafe-member-access': 0,
+        '@typescript-eslint/no-unsafe-return': 0,
+        '@typescript-eslint/require-await': 0,
+        '@typescript-eslint/restrict-plus-operands': 0,
+        '@typescript-eslint/restrict-template-expressions': 0,
+        '@typescript-eslint/strict-boolean-expressions': 0,
+        'jsdoc/require-file-overview': 0,
+        'jsdoc/require-jsdoc': 0,
+        'unicorn/prefer-math-trunc': 0,
+        'unicorn/prefer-node-protocol': 0
+      }
+    }
+  ],
   root: true
 }
 

.lintstagedrc.json

@@ -9,6 +9,6 @@
   "src/**/*.ts": [
     "vitest run --changed --coverage",
     "yarn build",
-    "bash -c tsc -p tsconfig.build.json"
+    "bash -c tsc -p tsconfig.json"
   ]
 }

__fixtures__/modules/add.mjs

@@ -0,0 +1,18 @@
+import { deprecate, equal, ok } from 'devlop'
+
+function add(a, b) {
+  ok(typeof a === 'number', 'expected `a` to be a number')
+  ok(typeof b === 'number', 'expected `b` to be a number')
+
+  if (process.env.NODE_ENV !== 'production') {
+    equal(Number.isNaN(a), false, 'expected `a` not to equal NaN')
+    equal(Number.isNaN(b), false, 'expected `b` not to equal NaN')
+  } else {
+    ok(!Number.isNaN(a), 'expected `a` not to be NaN')
+    ok(!Number.isNaN(b), 'expected `b` not to be NaN')
+  }
+
+  return a + b
+}
+
+export default deprecate(add)

__fixtures__/modules/assert.mjs

@@ -0,0 +1,5 @@
+function assert(value, message, ...params) {
+  return void console.assert(value, message, ...params)
+}
+
+export default assert

__fixtures__/modules/call-expression.mjs

@@ -0,0 +1,97 @@
+import {
+  DOT,
+  at,
+  define,
+  set
+} from '@flex-development/tutils'
+import { ok, unreachable } from 'devlop'
+import { CONTINUE } from 'estree-util-visit'
+import { is } from 'unist-util-is'
+
+function CallExpression(node, key, index) {
+  if (
+    (
+      is(node.callee, 'Identifier') &&
+      this.identifiers.has(node.callee.name)
+    ) ||
+    (
+      is(node.callee, 'MemberExpression') &&
+      is(node.callee.object, 'Identifier') &&
+      this.identifiers.has(node.callee.object.name)
+    ) ||
+    (
+      is(node.callee, 'MemberExpression') &&
+      is(node.callee.object, 'Identifier') &&
+      is(node.callee.property, 'Identifier') &&
+      node.callee.object.name === 'console' &&
+      node.callee.property.name === 'assert'
+    )
+  ) {
+    ok(this.parent, 'expected `parent`')
+    ok(key, 'expected `key`')
+    ok(key in this.parent, `expected \`parent.${key}\``)
+    const zero = { raw: '0', type: 'Literal', value: 0 }
+    const void0 = {
+      argument: zero,
+      operator: 'void',
+      prefix: true,
+      type: 'UnaryExpression'
+    }
+    switch (this.parent.type) {
+      case 'ArrayExpression':
+      case 'CallExpression':
+        ok(typeof index === 'number', 'expected `index` to be a number')
+        set(this.parent, key + DOT + index, void0)
+        break
+      case 'AssignmentExpression':
+        if (is(this.grandparent, 'ExpressionStatement')) {
+          this.trash.add(this.grandparent)
+        } else {
+          define(this.parent, key, { value: void0 })
+        }
+        break
+      case 'ArrowFunctionExpression':
+      case 'AssignmentPattern':
+      case 'ConditionalExpression':
+      case 'LogicalExpression':
+      case 'Property':
+        define(this.parent, key, { value: void0 })
+        break
+      case 'AwaitExpression':
+        if (is(this.grandparent, 'ExpressionStatement')) {
+          this.trash.add(this.grandparent)
+        } else {
+          define(this.parent, key, { value: void0 })
+        }
+        break
+      case 'ExpressionStatement':
+        this.trash.add(this.parent)
+        break
+      case 'ExportDefaultDeclaration':
+        define(this.parent, key, { value: at(node.arguments, 0, void0) })
+        break
+      case 'ReturnStatement':
+      case 'YieldExpression':
+        define(this.parent, key, { value: null })
+        break
+      case 'UnaryExpression':
+        if (is(this.grandparent, 'ExpressionStatement')) {
+          this.trash.add(this.grandparent)
+        } else {
+          define(this.parent, key, {
+            value: this.parent.operator === 'void' ? zero : void0
+          })
+        }
+        break
+      default:
+        console.dir(this.parent, { depth: 10 })
+        void unreachable(`unexpected parent: ${this.parent.type}`)
+    }
+  }
+  return CONTINUE
+}
+
+var call_expression_default = CallExpression
+export {
+  call_expression_default as default
+}

__fixtures__/modules/century-from-year.mjs

@@ -0,0 +1,10 @@
+const { ok } = await import('devlop')
+const assert = await import('node:assert/strict')
+
+const centuryFromYear = year => {
+  ok(typeof year === 'number', 'expected `year` to be a number')
+  assert.notEqual(Number.isNaN(year), true, 'expected `year` not to be NaN')
+  return Math.ceil(year / 100)
+}
+
+export default centuryFromYear

__fixtures__/modules/digitize.mjs

@@ -0,0 +1,17 @@
+import { ok } from 'devlop'
+import * as assert from 'node:assert/strict'
+
+function digitize(n) {
+  ok(typeof n === 'number', 'expected `n` to be a number')
+
+  if (process.env.NODE_ENV !== 'production') {
+    assert.notEqual(Number.isNaN(n), true, 'expected `n` not to be NaN')
+  } else ok(n >= 0, 'expected `n` to be a non-negative number')
+
+  if (n <= 9) return [n]
+  const digits = []
+  while (n > 0) digits.push(n % 10 | 0) && (n = n / 10 | 0)
+  return digits
+}
+
+export default digitize