@vanillaes/esmtk 0.20.0 → 0.21.0

package/.vscode/launch.json

@@ -37,6 +37,18 @@
             "args": ["test"],
             "console": "integratedTerminal",
         },
+        {
+            "name": "Test - --ignore",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/esmtk.js",
+            "cwd": "${workspaceFolder}",
+            "args": ["test", "--ignore", "node_modules/**,src/util.spec.js"],
+            "console": "integratedTerminal",
+        },
         {
             "name": "Lint",
             "type": "node",
@@ -445,5 +457,16 @@
             "args": ["clean", "--custom", "**/*.min.js"],
             "console": "integratedTerminal",
         },
+        {
+            "name": "Tape - Current File",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${file}",
+            "cwd": "${workspaceFolder}",
+             "console": "integratedTerminal",
+        }
     ]
 }

package/README.md

@@ -3,7 +3,7 @@
 ESMTK, essential tools for ECMAScript module development
 
 <div align="center">
-  <a href="https://github.com/vanillaes/esmtk/releases"><img src="https://badgen.net/github/tag/vanillaes/esmtk" alt="GitHub Release"></a>
+  <a href="https://github.com/vanillaes/esmtk/releases"><img src="https://badgen.net/github/tag/vanillaes/esmtk?cache-control=no-cache" alt="GitHub Release"></a>
   <a href="https://www.npmjs.com/package/@vanillaes/esmtk"><img src="https://badgen.net/npm/v/@vanillaes/esmtk?icon=npm" alt="NPM Version"></a>
   <a href="https://www.npmjs.com/package/@vanillaes/esmtk"><img src="https://badgen.net/npm/dm/@vanillaes/esmtk?icon=npm" alt="NPM Downloads"></a>
   <a href="https://github.com/vanillaes/esmtk/actions"><img src="https://github.com/vanillaes/esmtk/workflows/Latest/badge.svg" alt="Latest Status"></a>
@@ -19,7 +19,7 @@ ESMTK, essential tools for ECMAScript module development
 - [bundle](#bundle) - Bundle the source code to an ECMAScript module (using ESBuild)
 - [minify](#minify) - Bundle and Minify the source code to an ECMAScript module (using ESBuild)
 - [commonjs](#commonjs) - Bundle the source code to a CommonJS module (using ESBuild)
-- [typeings](#typings) - Generate Type Declarations (.d.ts) from JSDoc (using Typescript)
+- [typings](#typings) - Generate Type Declarations (.d.ts) from JSDoc (using Typescript)
 - [clean](#clean) - Clean up build artifacts
 - [cp](#cp) - A cross-platform clone of the `cp` command in Linux
 - [rm](#rm) - A cross-platform clone of the `rm` command in Linux
@@ -50,6 +50,7 @@ Run tests (using Tape-ES)
 `esmtk test [glob]`
 
 - `[glob]` - the glob used to locate test files (default: `**/*.spec.js`)
+- `-i` | `--ignore` - the ignore matcher pattern (default `**/node_modules/**`)
 - `--watch` - watch for changes to the tests
 
 ### Usage
@@ -61,6 +62,9 @@ npx @vanillaes/esmtk test
 # run the tests (using a different naming scheme)
 npx @vanillaes/esmtk test **/*.test.js
 
+# run the tests (ignore tests)
+npx @vanillaes/esmtk test **/*.test.js --ignore **/node_modules/**,src/rm.spec.js
+
 # run the tests (watch for changes)
 npx @vanillaes/esmtk test --watch
 ```

package/bin/commands/test.js

@@ -12,6 +12,10 @@ export async function test (glob, options) {
   if (options?.watch) {
     args.push('--watch')
   }
+  if (options?.ignore) {
+    args.push('--ignore')
+    args.push(options.ignore)
+  }
 
   spawn('node', args, {
     cwd: process.cwd(),

package/bin/esmtk.js

@@ -17,6 +17,7 @@ program.command('init')
 program.command('test')
   .description('Run tests using Tape-ES')
   .argument('[glob]', 'The glob pattern used to find test files', '**/*.spec.js')
+  .option('-i, --ignore <ignore>', 'the ignore matcher pattern')
   .option('--watch', 'Watch the files for changes')
   .action((glob, options) => {
     test(glob, options)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillaes/esmtk",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "ES Module Toolkit",
   "keywords": [
     "ecmascript",
@@ -37,20 +37,21 @@
     }
   },
   "scripts": {
+    "test": "./bin/esmtk.js test",
     "lint": "./bin/esmtk.js lint",
     "types": "./bin/esmtk.js types src/index.js",
     "bundle": "./bin/esmtk.js bundle --platform=node src/index.js src/index.esm.js",
     "minify": "./bin/esmtk.js minify --platform=node src/index.js src/index.min.js",
     "typings": "./bin/esmtk.js typings src/index.js",
     "clean": "./bin/esmtk.js clean --typings",
-    "preversion": "npm run lint && npm run types",
+    "preversion": "npm run test && npm run lint && npm run types",
     "postversion": "git push --follow-tags"
   },
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
-    "@vanillaes/tape-es": "^2.0.2",
+    "@vanillaes/tape-es": "^3.0.3",
     "commander": "^14.0.3",
     "standard": "^17.1.2"
   },

package/src/__test__/rm.json

@@ -0,0 +1,35 @@
+{
+  "removeAsync": {
+    "test1.txt": "test 1 text",
+    "test2.txt": "test 2 text"
+  },
+  "removeAsyncExpect": {
+    "test2.txt": "test 2 text"
+  },
+  "removeMultipleAsync": {
+    "test1.txt": "test 1 text",
+    "test2.txt": "test 2 text",
+    "test1.js": "test 1 javascript",
+    "test2.js": "test 2 javascript"
+  },
+  "removeMultipleAsyncExpect": {
+    "test2.txt": "test 2 text",
+    "test2.js": "test 2 javascript"
+  },
+  "removeRecursiveAsync": {
+    "directory1": {
+      "test1.txt": "test 1 text",
+      "test1.js": "test 1 javascript"
+    },
+    "directory2": {
+      "test2.txt": "test 2 text",
+      "test2.js": "test 2 javascript"
+    }
+  },
+  "removeRecursiveAsyncExpect": {
+    "directory2": {
+      "test2.txt": "test 2 text",
+      "test2.js": "test 2 javascript"
+    }
+  }
+}

package/src/__test__/test.js

@@ -0,0 +1,96 @@
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import tapeTest from 'tape'
+
+export async function setup (fn) {
+  tapeTest('Setup', function (t) {
+    fn(t)
+  })
+}
+
+export const skip = () => tapeTest.skip()
+
+export async function teardown (fn) {
+  tapeTest('Teardown', function (t) {
+    fn(t)
+  })
+}
+
+export async function test (description, files = [], fn) {
+  if (!files) {
+    tapeTest(description, function (t) {
+      fn(t)
+    })
+    return
+  }
+
+  tapeTest(description, function (t) {
+    mkdirSync('test', { recursive: true })
+    process.chdir('test')
+
+    objectsλFiles(files)
+
+    const oldEnd = t.end
+    t.end = function () {
+      oldEnd()
+      process.chdir('..')
+      rmSync('test', { recursive: true, force: true })
+    }
+
+    fn(t)
+  })
+}
+
+export function objectsλFiles (obj, path = process.cwd()) {
+  if (obj !== null && typeof obj === 'object') {
+    Object.entries(obj).forEach(([key, value]) => {
+      if (typeof value === 'object' && value !== null) {
+        mkdirSync(join(path, key), { recursive: true })
+        objectsλFiles(value, join(path, key))
+      } else {
+        writeFileSync(join(path, key), value)
+      }
+    })
+  }
+}
+
+export function filesλobjects (dir = '.') {
+  function walk (dir, fileList = []) {
+    const files = readdirSync(dir)
+    for (const file of files) {
+      const filePath = join(dir, file)
+      const stat = statSync(filePath)
+      if (stat.isDirectory()) {
+        walk(filePath, fileList)
+      } else if (stat.isFile()) {
+        fileList.push(filePath)
+      }
+    }
+    return fileList
+  }
+
+  function treeify (files) {
+    const tree = {}
+    for (const path of files) {
+      const parts = path.split('/')
+      let currentLevel = tree
+      parts.forEach((part, index, array) => {
+        if (index === array.length - 1) {
+          const contents = readFileSync(path, 'utf8')
+          currentLevel[part] = contents
+        } else {
+          if (!currentLevel[part]) {
+            currentLevel[part] = {}
+          }
+          currentLevel = currentLevel[part]
+        }
+      })
+    }
+    return tree
+  }
+
+  const files = walk(dir).reverse()
+  const tree = treeify(files)
+
+  return tree
+}

package/src/__test__/util.json

@@ -0,0 +1,17 @@
+{
+  "expand": {
+    "test1.txt": "test 1",
+    "test2.txt": "test 2",
+    "test1.js": "test 1 javascript",
+    "test2.js": "test 2 javascript"
+  },
+  "fileExists": {
+    "test1.txt": "test 1"
+  },
+  "match": {
+    "test1.txt": "test 1",
+    "test2.txt": "test 2",
+    "test1.js": "test 1 javascript",
+    "test2.js": "test 2 javascript"
+  }
+}

package/src/rm.spec.js

@@ -0,0 +1,75 @@
+import { filesλobjects, setup, teardown, test } from './__test__/test.js'
+import { removeAsync, removeMultipleAsync, removeRecursiveAsync } from '@vanillaes/esmtk'
+import { rmSync } from 'node:fs'
+
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+const files = require('./__test__/rm.json')
+const processExit = process.exit
+
+setup(async (t) => {
+  process.exit = function () {
+    throw new Error('process.exit(1)')
+  }
+  process.chdir(process.cwd())
+  rmSync('test', { recursive: true, force: true })
+
+  t.end()
+})
+
+test('removeAsync - remove a file', files.removeAsync, async (t) => {
+  await removeAsync('test1.txt')
+
+  const actual = filesλobjects()
+  const expect = files.removeAsyncExpect
+
+  t.deepEqual(actual, expect)
+  t.end()
+})
+
+test('removeAsync - ERROR: no such file or directory', files.removeAsync, async (t) => {
+  try {
+    await removeAsync('test1.ts')
+  } catch (err) {
+    t.ok(err, 'Error was thrown as expected')
+  }
+  t.end()
+})
+
+test('removeAsync - ERROR: file is a directory', files.removeAsync, async (t) => {
+  try {
+    await removeAsync('directory/')
+    t.fail('Expected error was not thrown')
+  } catch (err) {
+    t.ok(err, 'Error was thrown as expected')
+  }
+  t.end()
+})
+
+test('removeMultipleAsync - remove multiple files', files.removeMultipleAsync, async (t) => {
+  await removeMultipleAsync(['test1.txt', 'test1.js'])
+
+  const actual = filesλobjects()
+  const expect = files.removeMultipleAsyncExpect
+
+  t.deepEqual(actual, expect)
+  t.end()
+})
+
+test('removeRecursiveAsync - ', files.removeRecursiveAsync, async (t) => {
+  await removeRecursiveAsync('directory1')
+
+  const actual = filesλobjects()
+  const expect = files.removeRecursiveAsyncExpect
+
+  t.deepEqual(actual, expect)
+  t.end()
+})
+
+teardown(async (t) => {
+  process.exit = processExit
+  process.chdir(process.cwd())
+  rmSync('test', { recursive: true, force: true })
+
+  t.end()
+})

package/src/util.js

@@ -64,9 +64,12 @@ export async function installed (pkg) {
  * @param {string} ignore glob of pattern(s) to ignore
  * @returns {Promise<string[]>} an array of paths
  */
-export async function match (pattern, root = process.cwd(), ignore = '') {
-  const ignores = ignore.includes(',') ? [ignore] : ignore.split(',')
-  return await Array.fromAsync(glob(pattern, { cwd: root, exclude: ignores }))
+export async function match (pattern, root = process.cwd(), ignore = null) {
+  if (ignore) {
+    const ignores = ignore.includes(',') ? ignore.split(',') : [ignore]
+    return await Array.fromAsync(glob(pattern, { cwd: root, exclude: ignores }))
+  }
+  return await Array.fromAsync(glob(pattern, { cwd: root }))
 }
 
 /**

package/src/util.spec.js

@@ -0,0 +1,55 @@
+import { setup, teardown, test } from './__test__/test.js'
+import { expand, fileExists, match } from '@vanillaes/esmtk'
+import { rmSync } from 'node:fs'
+
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+const files = require('./__test__/util.json')
+
+setup(async (t) => {
+  process.chdir(process.cwd())
+  rmSync('test', { recursive: true, force: true })
+
+  t.end()
+})
+
+test('expand #1 - match glob', files.expand, async (t) => {
+  const actual = await expand('*.txt')
+  const expect = ['test1.txt', 'test2.txt']
+
+  t.deepEqual(actual, expect)
+  t.end()
+})
+
+test('fileExists #1 - test to see if a file exists', files.fileExists, async (t) => {
+  const actual = await fileExists('test1.txt')
+  const expect = true
+
+  t.equal(actual, expect)
+
+  t.end()
+})
+
+test('fileExists #2 - test to see if a file does not exist', files.fileExists, async (t) => {
+  const actual = await fileExists('test1.ts')
+  const expect = false
+
+  t.equal(actual, expect)
+
+  t.end()
+})
+
+test('match #1 - match a file', files.match, async (t) => {
+  const expect = ['test1.txt', 'test2.txt']
+  const actual = await match('*.txt')
+
+  t.deepEqual(actual, expect)
+  t.end()
+})
+
+teardown(async (t) => {
+  process.chdir(process.cwd())
+  rmSync('test', { recursive: true, force: true })
+
+  t.end()
+})