@vanillaes/esmtk 0.6.4 → 0.6.6

package/.vscode/launch.json

@@ -36,6 +36,42 @@
             "cwd": "${workspaceFolder}",
             "args": ["cp", "-r", "./test/cp/", "./test/cp2"],
             "console": "integratedTerminal",
+        },
+        {
+            "name": "Lint",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/esmtk.js",
+            "cwd": "${workspaceFolder}",
+            "args": ["lint"],
+            "console": "integratedTerminal",
+        },
+        {
+            "name": "RemoveFile",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/esmtk.js",
+            "cwd": "${workspaceFolder}",
+            "args": ["rm", "./test/cp2/test1.txt"],
+            "console": "integratedTerminal",
+        },
+                {
+            "name": "RemoveDirectory",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/esmtk.js",
+            "cwd": "${workspaceFolder}",
+            "args": ["rm", "-r", "./test/cp2/"],
+            "console": "integratedTerminal",
         }
     ]
 }

package/README.md

@@ -78,7 +78,7 @@ esmtk commonjs src/sample.js bundle.cjs
 
 ## Copy
 
-Copy us a cross-platform clone of the `cp` command in Linux
+Copy is a cross-platform clone of the `cp` command in Linux
 
 ### Arguments
 
@@ -86,11 +86,29 @@ Copy us a cross-platform clone of the `cp` command in Linux
 
 - `[source]` - the source file/glob
 - `[destination]` - the destination file/directory
+- `-f --force` - ignore exceptions if the file doesn't exist
 - `-r, --recursive` - copy files/directories recursively
-- `-f --force` - force overwrite existing files
 
 ### Usage
 
 ```sh
 esmtk cp -r src/ dest/
 ```
+
+## Remove
+
+Remove is a cross-platform clone of the `rm` command in Linux
+
+### Arguments
+
+`esmtk rm [-rf] [file|directory]`
+
+- `[file|directory]` - the source file/glob
+- `-f --force` - force remove existing file(s)
+- `-r, --recursive` - remove files/directories recursively
+
+### Usage
+
+```sh
+esmtk rm -r src/
+```

package/bin/commands/cp.js

@@ -1,97 +1,11 @@
-import { basename, dirname } from 'node:path'
-import { access, constants, cp as nodeCp, stat } from 'node:fs/promises'
+import { copyAsync, copyRecursiveAsync } from '../../src/cp.js'
 
 export async function cp (source, target, options) {
-  if (!options.recursive) {
-    await copyAsync(source, target, options.force)
+  if (!options?.recursive) {
+    await copyAsync(source, target, options?.force)
   }
 
-  if (options.recursive) {
-    await copyRecursiveAsync(source, target, options.force)
-  }
-}
-
-// copy a single file
-async function copyAsync (source, target, force = false) {
-  const sExists = await fileExists(source)
-  if (!sExists) {
-    console.error(`cp: source ${source} does not exist`)
-    process.exit(1)
-  }
-  const sStats = await stat(source)
-  if (sStats.isSymbolicLink()) {
-    console.error(`cp: source ${source} is a sybolic link`)
-    process.exit(1)
-  }
-
-  const tDir = dirname(target)
-  const tDirExists = await fileExists(tDir)
-  if (!tDirExists) {
-    console.error(`cp: target directory ${tDir} does not exist`)
-    process.exit(1)
-  }
-
-  const tExists = await fileExists(target)
-  if (tExists) {
-    const tStats = await stat(target)
-    if (tStats.isSymbolicLink()) {
-      console.error(`cp: target ${target} is a sybolic link`)
-      process.exit(1)
-    }
-    if (tStats.isDirectory()) {
-      const sourceFile = basename(source)
-      target = target.endsWith('/') ? target.slice(0, -1) : target
-      target = `${target}/${sourceFile}`
-    }
-  }
-
-  try {
-    await nodeCp(source, target, { force })
-  } catch (err) {
-    console.error(`cp: error ${err.message}`)
-  }
-}
-
-// copy a directory recursively
-async function copyRecursiveAsync (source, target, force = false) {
-  const sExists = await fileExists(source)
-  if (!sExists) {
-    console.error(`cp: source ${source} does not exist`)
-    process.exit(1)
-  }
-  const sStats = await stat(source)
-  if (sStats.isSymbolicLink()) {
-    console.error(`cp: source ${source} is a sybolic link`)
-    process.exit(1)
-  }
-
-  const tExists = await fileExists(target)
-  if (!tExists) {
-    console.error(`cp: target directory ${target} does not exist`)
-    process.exit(1)
-  }
-  const tStats = await stat(target)
-  if (tStats.isSymbolicLink()) {
-    console.error(`cp: target ${target} is a sybolic link`)
-    process.exit(1)
-  }
-  if (!tStats.isDirectory()) {
-    console.error(`cp: target ${target} is not a directory`)
-    process.exit(1)
-  }
-
-  try {
-    await nodeCp(source, target, { force, recursive: true })
-  } catch (err) {
-    console.error(`cp": error ${err.message}`)
-  }
-}
-
-async function fileExists (file) {
-  try {
-    await access(file, constants.F_OK)
-    return true
-  } catch (error) {
-    return false
+  if (options?.recursive) {
+    await copyRecursiveAsync(source, target, options?.force)
   }
 }

package/bin/commands/index.js

@@ -3,3 +3,4 @@ export { commonjs } from './commonjs.js'
 export { cp } from './cp.js'
 export { lint } from './lint.js'
 export { minify } from './minify.js'
+export { rm } from './rm.js'

package/bin/commands/lint.js

@@ -4,10 +4,22 @@ import { join } from 'path'
 const BIN_PATH = join(process.cwd(), 'node_modules', '.bin', 'standard')
 
 export async function lint (flags) {
-  spawn(BIN_PATH, flags, {
+  const child = spawn(BIN_PATH, flags, {
     cwd: process.cwd(),
-    stdio: ['pipe', process.stdout, process.stderr]
+    stdio: ['pipe', 'pipe', 'pipe']
   }).on('error', err => {
-    console.error(err)
+    console.error(`test${err}`)
+  })
+
+  child.stdout.on('data', (data) => {
+    process.stdout.write(`${data}`)
+  })
+
+  child.stderr.on('data', (data) => {
+    if (data.toString() === 'standard: Run `standard --fix` to automatically fix some problems.\n') {
+      process.stderr.write('standard: Run `esmtk lint --fix` to automatically fix some problems.\n')
+    } else {
+      process.stderr.write(`${data}`)
+    }
   })
 }

package/bin/commands/rm.js

@@ -0,0 +1,11 @@
+import { removeAsync, removeRecursiveAsync } from '../../src/rm.js'
+
+export async function rm (path, options) {
+  if (!options?.recursive) {
+    await removeAsync(path, options?.force)
+  }
+
+  if (options?.recursive) {
+    await removeRecursiveAsync(path, options?.force)
+  }
+}

package/bin/esmtk.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { bundle, cp, commonjs, lint, minify } from './commands/index.js'
+import { bundle, cp, commonjs, lint, minify, rm } from './commands/index.js'
 import { Command } from 'commander'
 import { createRequire } from 'module'
 const program = new Command()
@@ -37,10 +37,19 @@ program.command('minify <input> <output>')
 program.command('cp <source> <target>')
   .usage('[-rf] source target')
   .description('Copy files from the source to the target')
-  .option('-f, --force', 'do not prompt before overwriting')
-  .option('-r, --recursive', 'copy directories recursively')
+  .option('-f, --force', 'do not prompt before overwriting', false)
+  .option('-r, --recursive', 'copy directories recursively', false)
   .action((source, target, options) => {
     cp(source, target, options)
   })
 
+program.command('rm <path>')
+  .usage('[-rf] file|directory')
+  .description('Remove a file|directory')
+  .option('-f, --force', 'do not prompt before overwriting', false)
+  .option('-r, --recursive', 'remove directories recursively', false)
+  .action((path, options) => {
+    rm(path, options)
+  })
+
 program.parse(process.argv)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillaes/esmtk",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "ES Module Toolkit",
   "keywords": [
     "esm",
@@ -13,6 +13,11 @@
   "author": "Evan Plaice <evanplaice@gmail.com> (https://evanplaice.com/)",
   "license": "MIT",
   "type": "module",
+  "exports": {
+    ".": "./src/index.js",
+    "./cp": "./src/cp.js",
+    "./rm": "./src/rm.js"
+  },
   "bin": {
     "esmtk": "bin/esmtk.js"
   },

package/src/cp.js

@@ -0,0 +1,97 @@
+import { basename, dirname } from 'node:path'
+import { access, constants, cp, stat } from 'node:fs/promises'
+
+/**
+ * Copy a single file asynchronously
+ * @param {string} source The source file
+ * @param {string} target The target file
+ * @param {boolean} force If the file already exists, overwrite it (default false)
+ */
+export async function copyAsync (source, target, force = false) {
+  const sExists = await fileExists(source)
+  if (!sExists) {
+    console.error(`cp: source ${source} does not exist`)
+    process.exit(1)
+  }
+  const sStats = await stat(source)
+  if (sStats.isSymbolicLink()) {
+    console.error(`cp: source ${source} is a sybolic link`)
+    process.exit(1)
+  }
+
+  const tDir = dirname(target)
+  const tDirExists = await fileExists(tDir)
+  if (!tDirExists) {
+    console.error(`cp: target directory ${tDir} does not exist`)
+    process.exit(1)
+  }
+
+  const tExists = await fileExists(target)
+  if (tExists) {
+    const tStats = await stat(target)
+    if (tStats.isSymbolicLink()) {
+      console.error(`cp: target ${target} is a sybolic link`)
+      process.exit(1)
+    }
+    if (tStats.isDirectory()) {
+      const sourceFile = basename(source)
+      target = target.endsWith('/') ? target.slice(0, -1) : target
+      target = `${target}/${sourceFile}`
+    }
+  }
+
+  try {
+    await cp(source, target, { force })
+  } catch (err) {
+    console.error(`cp: error ${err.message}`)
+  }
+}
+
+/**
+ * Recursively copy a directory asynchronously
+ * @param {string} source The source directory
+ * @param {string} target The target directory
+ * @param {bool} force If the file already exists, overwrite it (default false)
+ */
+export async function copyRecursiveAsync (source, target, force = false) {
+  const sExists = await fileExists(source)
+  if (!sExists) {
+    console.error(`cp: source ${source} does not exist`)
+    process.exit(1)
+  }
+  const sStats = await stat(source)
+  if (sStats.isSymbolicLink()) {
+    console.error(`cp: source ${source} is a sybolic link`)
+    process.exit(1)
+  }
+
+  const tExists = await fileExists(target)
+  if (!tExists) {
+    console.error(`cp: target directory ${target} does not exist`)
+    process.exit(1)
+  }
+  const tStats = await stat(target)
+  if (tStats.isSymbolicLink()) {
+    console.error(`cp: target ${target} is a sybolic link`)
+    process.exit(1)
+  }
+  if (!tStats.isDirectory()) {
+    console.error(`cp: target ${target} is not a directory`)
+    process.exit(1)
+  }
+
+  try {
+    await cp(source, target, { force, recursive: true })
+  } catch (err) {
+    console.error(`cp": error ${err.message}`)
+  }
+}
+
+async function fileExists (file) {
+  try {
+    await access(file, constants.F_OK)
+    return true
+  } catch (error) {
+    return false
+  }
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export { copyAsync, copyRecursiveAsync } from './cp.js'
+export { removeAsync, removeRecursiveAsync } from './rm.js'

package/src/rm.js

@@ -0,0 +1,58 @@
+import { access, constants, rm, stat } from 'node:fs/promises'
+
+/**
+ * Remove a file asynchronously
+ * @param {string} path The file to delete
+ * @param {boolean} force Ignore exceptions if the file doesn't exist (default false)
+ */
+export async function removeAsync (path, force = false) {
+  const exists = await fileExists(path)
+  if (!exists) {
+    console.error(`rm: path ${path} does not exist`)
+    process.exit(1)
+  }
+  const stats = await stat(path)
+  if (stats.isSymbolicLink()) {
+    console.error(`rm: path ${path} is a sybolic link`)
+    process.exit(1)
+  }
+
+  try {
+    await rm(path, { force })
+  } catch (err) {
+    console.error(`rm: error ${err.message}`)
+  }
+}
+
+/**
+ * Recursively remove a file|directory asynchronously
+ * @param {string} path The file|directory to remove
+ * @param {bool} force Ignore exceptions if the file|directory doesn't exist (default false)
+ */
+export async function removeRecursiveAsync (path, force = false) {
+  const exists = await fileExists(path)
+  if (!exists) {
+    console.error(`rm: path ${path} does not exist`)
+    process.exit(1)
+  }
+  const stats = await stat(path)
+  if (stats.isSymbolicLink()) {
+    console.error(`rm: path ${path} is a sybolic link`)
+    process.exit(1)
+  }
+
+  try {
+    await rm(path, { force, recursive: true })
+  } catch (err) {
+    console.error(`rm": error ${err.message}`)
+  }
+}
+
+async function fileExists (file) {
+  try {
+    await access(file, constants.F_OK)
+    return true
+  } catch (error) {
+    return false
+  }
+}