added a better incremental recursive rename fn

Author: elliotberry

eslint.config.js

@@ -15,7 +15,7 @@ export default [
             sourceType: 'module',
         },
         plugins: {
-            import: pluginImport,
+        
 
             'simple-import-sort': is,
         },

lib/process-one-file.js

@@ -1,24 +1,16 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
-
+import returnSafeFilepath from './return-safe-filepath.js'
 import exists from './exists.js'
 
 const processOneFile = async (fileObject, rename = true) => {
     try {
-        // !global.silent && console.log(`${f.old} -> ${f.new}`)
+       
 
         if (await exists(fileObject.new)) {
             if (rename === true) {
-                //ambiguous !global.silent && console.log(`file will be renamed: ${fileObj.new}`)
-                let index = 1
-                let parsed = path.parse(fileObject.new)
-                let newName = `${parsed.name}-${index}${parsed.ext}`
-                while (await exists(path.join(parsed.dir, newName))) {
-                    index++
-                    newName = `${parsed.name}-${index}${parsed.ext}`
-                }
-                fileObject.new = path.resolve(path.join(parsed.dir, newName))
-                await fs.rename(fileObject.old, fileObject.new)
+                let newPath = await returnSafeFilepath(fileObject.new)
+                await fs.rename(fileObject.old, newPath)
             } else {
                 console.warn(
                     `file already exists, doing nothing: ${fileObject.new}`

lib/return-safe-filepath.js

@@ -0,0 +1,74 @@
+import exists from "./exists.js"
+import fs from "node:fs/promises"
+import path from "node:path"
+
+const isDirectoryWithCatch = async (destination) => {
+  let isDir = false
+  try {
+    let ii = await fs.stat(destination)
+    isDir = ii.isDirectory()
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      isDir = false
+    } else {
+      throw error
+    }
+  }
+  return isDir
+}
+
+
+function getBasenameAndSuffix(str) {
+  let theName
+  let theSuffix = ""
+  let theDashed = str.split("-")
+  if (theDashed.length === 1) {
+    theName = str
+    return { name: theName, suffix: theSuffix }
+  } else {
+    let possibleSuffix = theDashed[theDashed.length - 1]
+    let possibleSuffixNumber = parseInt(possibleSuffix)
+    if (isNaN(possibleSuffixNumber)) {
+      theName = str
+      return { name: theName, suffix: theSuffix }
+    } else {
+      theName = theDashed.slice(0, -1).join("-")
+      theSuffix = possibleSuffix
+      return { basename: theName, suffix: theSuffix }
+    }
+  }
+}
+
+const splitFileIntoThePartsINeed = (file, directory) => {
+  let [originalBasename, extension] = file.split(".")
+  let { basename, suffix } = getBasenameAndSuffix(originalBasename)
+  return { basename, suffix, extension, directory }
+}
+
+const returnSafeFilePath = async (destination) => {
+  if (await isDirectoryWithCatch(destination)) {
+    throw new Error("destination is a directory")
+  }
+  destination = path.resolve(destination)
+  let file = path.basename(destination)
+  let directory = path.dirname(destination)
+  if ((await exists(destination)) === false) {
+    return destination
+  }
+
+  let { basename, suffix, extension } = splitFileIntoThePartsINeed(
+    file,
+    directory
+  )
+
+  let count = suffix
+  while ((await exists(destination)) === true) {
+    let currentSuffix = `-${count}`
+    file = `${basename}${currentSuffix}.${extension}`
+    destination = path.join(directory, file)
+    count++
+  }
+  return destination
+}
+
+export default returnSafeFilePath