esmtk 0.5.13 → 0.6.0

package/.vscode/launch.json

@@ -0,0 +1,44 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "CopyFileToFile",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/esmtk.js",
+            "cwd": "${workspaceFolder}",
+            "args": ["cp", "./test/cp/test1.txt", "./test/cp2/test1.txt"],
+            "console": "integratedTerminal",
+        },
+        {
+            "name": "CopyFileToFolder",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/esmtk.js",
+            "cwd": "${workspaceFolder}",
+            "args": ["cp", "./test/cp/test1.txt", "./test/cp2"],
+            "console": "integratedTerminal",
+        },
+        {
+            "name": "CopyFolderRecursively",
+            "type": "node",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/esmtk.js",
+            "cwd": "${workspaceFolder}",
+            "args": ["cp", "-r", "./test/cp/", "./test/cp2"],
+            "console": "integratedTerminal",
+        }
+    ]
+}

package/bin/commands/cp.js

@@ -1,159 +1,97 @@
-import fs from 'fs'
-import path from 'path'
-import os from 'os'
-import glob from 'glob'
+import { basename, dirname } from 'node:path'
+import { access, constants, cp as nodeCp, stat } from 'node:fs/promises'
 
-export async function cp (opt) {
-  const self = this
-  const options = {}
-  options.noclobber = opt.force === true ? false : opt.noclobber
-  options.recursive = opt.R === true ? true : opt.recursive
-
-  const dest = opt.args.pop()
+export async function cp (source, target, options) {
+  if (!options.recursive) {
+    await copyAsync(source, target, options.force)
+  }
 
-  let sources = opt.args
-  const exists = fs.existsSync(dest)
-  const stats = exists && fs.statSync(dest)
+  if (options.recursive) {
+    await copyRecursiveAsync(source, target, options.force)
+  }
+}
 
-  // Dest is not existing dir, but multiple sources given
-  if ((!exists || !stats.isDirectory()) && sources.length > 1) {
-    console.error(`cp: target ${dest} is not a directory`)
+// 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)
   }
-
-  // Dest is an existing file, but no -f given
-  if (exists && stats.isFile() && options.noclobber) {
-    process.exit(0)
+  const sStats = await stat(source)
+  if (sStats.isSymbolicLink()) {
+    console.error(`cp: source ${source} is a sybolic link`)
+    process.exit(1)
   }
 
-  if (options.recursive) {
-    sources = sources.reduce((acc, src) => {
-      if (src.endsWith('/')) {
-        return [...acc, `${src}*`]
-      }
-      if (fs.statSync(src).isDirectory() && !exists) {
-        return [...acc, `${src}/*`]
-      }
-      return [...acc, src]
-    }, [])
-
-    try {
-      fs.mkdirSync(dest, parseInt('0777', 8))
-    } catch (e) {
-      // like Unix's cp, keep going even if we can't create dest dir
-    }
+  const tDir = dirname(target)
+  const tDirExists = await fileExists(tDir)
+  if (!tDirExists) {
+    console.error(`cp: target directory ${tDir} does not exist`)
+    process.exit(1)
   }
-  sources = sources.reduce((acc, curr) => {
-    return [...acc, ...glob.sync(curr)]
-  }, [])
 
-  sources.forEach(function (src) {
-    if (!fs.existsSync(src)) {
-      console.error(`cp: cannot stat ${src}: No such file or directory`)
-      return
+  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 (fs.statSync(src).isDirectory()) {
-      if (!options.recursive) {
-        console.log(`cp: -r not specified; omitting directory ${src}`)
-      } else {
-        // 'cp /a/source dest' should create 'source' in 'dest'
-        const newDest = path.join(dest, path.basename(src))
-        const checkDir = fs.statSync(src)
-        try {
-          fs.mkdirSync(newDest, checkDir.mode)
-        } catch (e) {
-          if (e.code !== 'EEXIST') {
-            throw new Error()
-          }
-        }
-        cpdirSyncRecursive.call(self, src, newDest, options)
-      }
-      return
-    }
-
-    // If here, src is a file
-    // When copying to '/path/dir', iDest = '/path/dir/file1'
-    let iDest = dest
-    if (fs.existsSync(dest) && fs.statSync(dest).isDirectory()) {
-      iDest = path.normalize(`${dest}/${path.basename(src)}`)
+    if (tStats.isDirectory()) {
+      const sourceFile = basename(source)
+      target = target.endsWith('/') ? target.slice(0, -1) : target
+      target = `${target}/${sourceFile}`
     }
-
-    if (fs.existsSync(iDest) && options.no_force) {
-      return
-    }
-
-    copyFileSync.call(self, src, iDest)
-  })
-}
-
-function cpdirSyncRecursive (sourceDir, destDir, options) {
-  const self = this
-  if (!options) {
-    options = {}
   }
-  const checkDir = fs.statSync(sourceDir)
+
   try {
-    fs.mkdirSync(destDir, checkDir.mode)
-  } catch (e) {
-    if (e.code !== 'EEXIST') {
-      throw e
-    }
-  }
-  const files = fs.readdirSync(sourceDir)
-  for (let i = 0; i < files.length; i++) {
-    const srcFile = `${sourceDir}/${files[i]}`
-    const destFile = `${destDir}/${files[i]}`
-    const srcFileStat = fs.lstatSync(srcFile)
-    if (srcFileStat.isDirectory()) {
-      // recursion this thing right on back.
-      cpdirSyncRecursive.call(self, srcFile, destFile, options)
-    } else if (srcFileStat.isSymbolicLink()) {
-      const symlinkFull = fs.readlinkSync(srcFile)
-      fs.symlinkSync(symlinkFull, destFile, os.platform() === 'win32' ? 'junction' : null)
-      // At this point, we've hit a file actually worth copying... so copy it on over.
-    } else if (fs.existsSync(destFile) && options.noclobber) {
-      // be silent
-    } else {
-      copyFileSync.call(self, srcFile, destFile)
-    }
+    await nodeCp(source, target, { force })
+  } catch (err) {
+    console.error(`cp: error ${err.message}`)
   }
 }
 
-function copyFileSync (src, dest) {
-  if (!fs.existsSync(src)) {
-    console.error(`cp: cannot stat ${src}: No such file or directory`)
-    return
+// 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 BUF_LENGTH = 64 * 1024
-  const buf = Buffer.alloc(BUF_LENGTH)
-  let bytesRead = BUF_LENGTH
-  let pos = 0
-  let fdr = null
-  let fdw = null
-
-  try {
-    fdr = fs.openSync(src, 'r')
-  } catch (e) {
-    console.error(`cp: cannot open ${src}: ${e.code}`)
-    return
+  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 {
-    fdw = fs.openSync(dest, 'w')
-  } catch (e) {
-    console.error(`cp: cannot write to destination file ${dest}: ${e.code}`)
-    return
+    await nodeCp(source, target, { force, recursive: true })
+  } catch (err) {
+    console.error(`cp": error ${err.message}`)
   }
+}
 
-  while (bytesRead === BUF_LENGTH) {
-    bytesRead = fs.readSync(fdr, buf, 0, BUF_LENGTH, pos)
-    fs.writeSync(fdw, buf, 0, bytesRead)
-    pos += bytesRead
+async function fileExists (file) {
+  try {
+    await access(file, constants.F_OK)
+    return true
+  } catch (error) {
+    return false
   }
-
-  fs.closeSync(fdr)
-  fs.closeSync(fdw)
-  fs.chmodSync(dest, fs.statSync(src).mode)
 }

package/bin/esmtk.js

@@ -1,39 +1,46 @@
 #!/usr/bin/env node
-import cli from 'commander'
 import { bundle, cp, commonjs, lint, minify } from './commands/index.js'
+import { Command } from 'commander'
 import { createRequire } from 'module'
+const program = new Command()
 const require = createRequire(import.meta.url)
 const pkg = require('../package.json')
 
-cli.version(pkg.version, '-v, --version')
-cli.command('lint')
-  .description('Lint the package using StandardJS')
+program.version(pkg.version, '-v, --version')
+
+program.command('lint')
+  .description('Lint the source using StandardJS')
   .option('--fix', 'Automatically fix problems')
-  .action(opt => {
-    const flags = opt.fix ? ['--fix'] : []
+  .action(options => {
+    const flags = options.fix ? ['--fix'] : []
     lint(flags)
   })
-cli.command('bundle <input> <output>')
+
+program.command('bundle <input> <output>')
   .description('Bundle the source using ESBuild')
   .action((input, output) => {
     bundle(input, output)
   })
-cli.command('commonjs <input> <output>')
+
+program.command('commonjs <input> <output>')
   .description('Transpile the source to CommonJS using ESBuild')
   .action((input, output) => {
     commonjs(input, output)
   })
-cli.command('minify <input> <output>')
+
+program.command('minify <input> <output>')
   .description('Minify the source using ESBuild')
   .action((input, output) => {
     minify(input, output)
   })
-cli.command('cp')
-  .description('Copy files from the source to the destination')
-  .usage('[options] [source] [destination]')
+
+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')
-  .action((opt) => {
-    cp(opt)
+  .action((source, target, options) => {
+    cp(source, target, options)
   })
-cli.parse(process.argv)
+
+program.parse(process.argv)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esmtk",
-  "version": "0.5.13",
+  "version": "0.6.0",
   "description": "ES Module Toolkit",
   "keywords": [
     "esm",
@@ -17,17 +17,17 @@
     "esmtk": "bin/esmtk.js"
   },
   "scripts": {
-    "lint": "standard",
+    "lint": "./bin/esmtk.js lint",
     "preversion": "npm run lint",
     "postversion": "git push --follow-tags"
   },
   "dependencies": {
-    "commander": "^8.3.0",
+    "commander": "^14.0.3",
     "esbuild": "^0.13.13",
-    "glob": "^7.2.0",
-    "standard": "^16.0.4"
+    "glob": "^13.0.6",
+    "standard": "^17.1.2"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=17"
   }
 }