fix: remove old deps

Author: brianleroux

.github/workflows/build.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        node-version: [ 14.x ]
+        node-version: [ 22.x, 24.x ]
         os: [ ubuntu-latest ]
 
     # Go

changelog.md

@@ -2,6 +2,12 @@
 
 ---
 
+## [3.0.0] 2025-12-03
+
+- Added `nodejs24.x`, `python3.14`; thanks again @lpsinger!
+- Removed eslint (overkill, and frankly annoying)
+- Removed tape,etc for the native node test runner
+
 ## [2.0.4 - 2.0.5] 2025-01-17
 
 ### Changed

cjs/index.js

@@ -40,21 +40,21 @@ let runtimeVersions = {
     major:    '24',
     minor:    null,
     patch:    null,
-    wildcard: '24.*.*'
+    wildcard: '24.*.*',
   },
   'nodejs22.x': {
     runtime:  'node',
     major:    '22',
     minor:    null,
     patch:    null,
-    wildcard: '22.*.*'
+    wildcard: '22.*.*',
   },
   'nodejs20.x': {
     runtime:  'node',
     major:    '20',
     minor:    null,
     patch:    null,
-    wildcard: '20.*.*'
+    wildcard: '20.*.*',
   },
   'python3.14': {
     runtime:  'python',

esm/.eslintrc.cjs

@@ -15,25 +15,14 @@
   },
   "license": "Apache-2.0",
   "scripts": {
-    "lint": "eslint . --fix",
-    "test": "npm run lint && npm run test:unit",
-    "test:unit": "tape 'test/unit/**/*-test.js' | tap-arc",
+    "test": "node --test 'test/unit/**/*-test.js'",
     "rc": "npm version prerelease --preid RC"
   },
   "engines": {
-    "node": ">=14"
-  },
-  "devDependencies": {
-    "@architect/eslint-config": "^2.1.2",
-    "eslint": "^8.56.0",
-    "tap-arc": "^1.2.2",
-    "tape": "~5.7.5"
+    "node": ">=22"
   },
   "files": [
     "cjs/*",
     "esm/*.js"
-  ],
-  "eslintConfig": {
-    "extends": "@architect/eslint-config"
-  }
+  ]
 }

package.json

@@ -1,13 +1,12 @@
-import test from 'tape'
+import { test } from 'node:test'
+import assert from 'node:assert'
 import lambdaRuntimes from '../../../esm/index.js'
 
-test('Set up env', t => {
-  t.plan(1)
-  t.ok(lambdaRuntimes, 'lambdaRuntimes is present')
+test('Set up env', () => {
+  assert.ok(lambdaRuntimes, 'lambdaRuntimes is present')
 })
 
-test('Exports', t => {
-  t.plan(8)
+test('Exports', () => {
   let {
     runtimes,
     runtimeVersions,
@@ -17,75 +16,62 @@ test('Exports', t => {
     aliases,
     retiredRuntimes,
   } = lambdaRuntimes
-  t.ok(runtimes, 'Got runtimes')
-  t.ok(runtimeVersions, 'Got runtimeVersions')
-  t.ok(runtimeList, 'Got runtimeList')
-  t.ok(runtimesByArchitecture, 'Got runtimesByArchitecture')
-  t.ok(architecturesByRuntime, 'Got architecturesByRuntime')
-  t.ok(aliases, 'Got aliases')
-  t.ok(retiredRuntimes, 'Got retiredRuntimes')
-  t.equal(Object.keys(lambdaRuntimes).length, 7, 'Got all properties')
+  assert.ok(runtimes, 'Got runtimes')
+  assert.ok(runtimeVersions, 'Got runtimeVersions')
+  assert.ok(runtimeList, 'Got runtimeList')
+  assert.ok(runtimesByArchitecture, 'Got runtimesByArchitecture')
+  assert.ok(architecturesByRuntime, 'Got architecturesByRuntime')
+  assert.ok(aliases, 'Got aliases')
+  assert.ok(retiredRuntimes, 'Got retiredRuntimes')
+  assert.equal(Object.keys(lambdaRuntimes).length, 7, 'Got all properties')
   console.dir(lambdaRuntimes, { depth: null })
 })
 
-test('runtimes semantics', t => {
-  t.plan(1)
+test('runtimes semantics', () => {
   let { runtimes } = lambdaRuntimes
   Object.values(runtimes).forEach(v => {
-    if (!Array.isArray(v)) t.fail(`Expected an array: ${v}`)
+    assert.ok(Array.isArray(v), `Expected an array: ${v}`)
   })
-  t.pass('All runtimes values are arrays')
 })
 
-test('runtimeVersions semantics', t => {
-  t.plan(2)
+test('runtimeVersions semantics', () => {
   let { runtimeList, runtimeVersions } = lambdaRuntimes
   let list = runtimeList.filter(r => !r.startsWith('provided'))
   list.forEach(runtime => {
-    if (!runtimeVersions[runtime]) t.fail(`${runtime} not found in runtimeVersions`)
+    assert.ok(runtimeVersions[runtime], `${runtime} not found in runtimeVersions`)
   })
-  t.pass('Found all runtimeVersions')
-  t.equal(list.length, Object.keys(runtimeVersions).length, 'Correct number of runtimeVersions found')
+  assert.equal(list.length, Object.keys(runtimeVersions).length, 'Correct number of runtimeVersions found')
 })
 
-test('runtimeList semantics', t => {
-  t.plan(1)
+test('runtimeList semantics', () => {
   let { runtimeList } = lambdaRuntimes
-  t.ok(Array.isArray(runtimeList), 'runtimeList is an array')
+  assert.ok(Array.isArray(runtimeList), 'runtimeList is an array')
 })
 
-test('runtimesByArchitecture semantics', t => {
-  t.plan(1)
+test('runtimesByArchitecture semantics', () => {
   let { runtimesByArchitecture } = lambdaRuntimes
   Object.values(runtimesByArchitecture).forEach(v => {
-    if (!Array.isArray(v)) t.fail(`Expected an array: ${v}`)
+    assert.ok(Array.isArray(v), `Expected an array: ${v}`)
   })
-  t.pass('All runtimesByArchitecture are arrays')
 })
 
-test('architecturesByRuntime semantics', t => {
-  t.plan(1)
+test('architecturesByRuntime semantics', () => {
   let { architecturesByRuntime } = lambdaRuntimes
   Object.values(architecturesByRuntime).forEach(v => {
-    if (!Array.isArray(v)) t.fail(`Expected an array: ${v}`)
+    assert.ok(Array.isArray(v), `Expected an array: ${v}`)
   })
-  t.pass('All architecturesByRuntime are arrays')
 })
 
-test('aliases semantics', t => {
-  t.plan(1)
+test('aliases semantics', () => {
   let { aliases } = lambdaRuntimes
   Object.values(aliases).forEach(v => {
-    if (typeof v !== 'string') t.fail(`Expected a string: ${v}`)
+    assert.equal(typeof v, 'string', `Expected a string: ${v}`)
   })
-  t.pass('All aliases are strings')
 })
 
-test('retiredRuntimes semantics', t => {
-  t.plan(1)
+test('retiredRuntimes semantics', () => {
   let { retiredRuntimes } = lambdaRuntimes
   Object.values(retiredRuntimes).forEach(v => {
-    if (!Array.isArray(v)) t.fail(`Expected an array: ${v}`)
+    assert.ok(Array.isArray(v), `Expected an array: ${v}`)
   })
-  t.pass('All retiredRuntimes are arrays')
 })