markdown-magic 2.6.0 → 3.0.0

package/lib/transforms/toc.js

@@ -1,10 +1,19 @@
 const { transform } = require('@technote-space/doctoc')
-const { removeLeadingAndTrailingLineBreaks } = require('../utils/regex')
+const { removeLeadingAndTrailingLineBreaks, escapeRegexString } = require('../utils/regex')
+const { findMinIndent } = require('../utils/text')
 
-module.exports = async function TOC(content, options, config) {
+module.exports = async function TOC(api) {
+  // console.log("TOC API", api)
+  const { options, fileContent, originalFileContent } = api
+  //const currentBlock = api.getCurrentBlock()
+  const originalBlock = api.getOriginalBlock()
+  const { block } = originalBlock
+  // console.log('originalBlock', originalBlock)
+  const originalContents = originalFileContent
   const opts = options || {}
+  const isSub = opts.sub
   opts.firsth1 = (opts.firsth1) ? true : false
-  let contents = config.outputContent
+  let contents = fileContent
   // console.log('contents', contents)
 
   let debugFileMatch
@@ -12,13 +21,13 @@ module.exports = async function TOC(content, options, config) {
   // debugFileMatch = config.originalPath.match(/packages\/analytics\/README\.md/)
 
   // https://www.npmjs.com/package/@technote-space/toc-generator
-  const t = await transform(contents, {
+  const tocOptions = {
     // mode: 'github.com', // github.com | bitbucket.org | gitlab.com | nodejs.org | ghost.org (default: github.com)
     isNotitle: true,
     //isCustomMode: true,
     openingComment: '',
     closingComment: '', 
-    maxHeaderLevel: (opts.maxDepth) ? Number(opts.maxDepth) : 4
+    maxHeaderLevel: (opts.maxDepth) ? Number(opts.maxDepth) : 4,
     // maxHeaderLevel: 2, // default: 4
     // title: '**Table of Contents**',
     // isNotitle: true,
@@ -34,18 +43,19 @@ module.exports = async function TOC(content, options, config) {
     // customTemplate: '<p align="center">${ITEMS}</p>',
     // itemTemplate: '<a href="${LINK}">${TEXT}</a>',
     // separator: '<span>|</span>',
-    // footer: '',
-  })
-  let output = t.wrappedToc || ''
+    // footer: 'end',
+  }
+  const t = await transform(contents, tocOptions)
+  let outputText = t.wrappedToc || ''
 
   if (debugFileMatch) {
-    console.log('before firsth1 removal', output)
+    console.log('before firsth1 removal', outputText)
   }
 
   /* remove first h1 */
   if (!opts.firsth1) {
-    // console.log('output', output)
-    const lines = output.split('\n')
+    // console.log('outputText', outputText)
+    const lines = outputText.split('\n')
     let firstH1
     let firstLine
     const countOfH1s = lines.reduce((acc, line, index) => {
@@ -65,23 +75,25 @@ module.exports = async function TOC(content, options, config) {
     const firstHeadingData =  (firstH1 && Array.isArray(firstH1)) ? firstH1 : []
     const [ lineText, lineIndex, isFirst, matchText ] = firstHeadingData
     
-    // verify its h1
-    const matchTextEscaped = escapeStringRegexp(matchText)
-    // console.log('matchTextEscaped', matchTextEscaped)
-    // /^#{1}\s+(.*)/
-    const FIRST_H1_REGEX = new RegExp(`^#\\s*\\[?${matchTextEscaped}\\]?(?:.*)?`, 'gim')
-    // /^<h1\b[^>]*>([\s\S]*?)<\/h1>/
-    const FIRST_HTML_H1_REGEX = new RegExp(`^<h1\\b[^>]*>[\\s]*?(${matchTextEscaped})[\\s]*?<\\/h1>`, 'gim')
-    // /^(.*)\n={3,}/
-    const FIRST_UNDERSCORE_H1 = new RegExp(`^(${matchTextEscaped})\n={3,}`, 'gim')
-    
     let docHasHeading = false
-    if (contents.match(FIRST_H1_REGEX)) {
-      docHasHeading = matchText
-    } else if (contents.match(FIRST_HTML_H1_REGEX)) {
-      docHasHeading = matchText
-    } else if (contents.match(FIRST_UNDERSCORE_H1)) {
-      docHasHeading = matchText
+    if (matchText) {
+      // verify its h1
+      const matchTextEscaped = escapeRegexString(matchText)
+      // console.log('matchTextEscaped', matchTextEscaped)
+      // /^#{1}\s+(.*)/
+      const FIRST_H1_REGEX = new RegExp(`^#\\s*\\[?${matchTextEscaped}\\]?(?:.*)?`, 'gim')
+      // /^<h1\b[^>]*>([\s\S]*?)<\/h1>/
+      const FIRST_HTML_H1_REGEX = new RegExp(`^<h1\\b[^>]*>[\\s]*?(${matchTextEscaped})[\\s]*?<\\/h1>`, 'gim')
+      // /^(.*)\n={3,}/
+      const FIRST_UNDERSCORE_H1 = new RegExp(`^(${matchTextEscaped})\n={3,}`, 'gim')
+  
+      if (contents.match(FIRST_H1_REGEX)) {
+        docHasHeading = matchText
+      } else if (contents.match(FIRST_HTML_H1_REGEX)) {
+        docHasHeading = matchText
+      } else if (contents.match(FIRST_UNDERSCORE_H1)) {
+        docHasHeading = matchText
+      }
     }
   
     if (debugFileMatch) {
@@ -103,7 +115,7 @@ module.exports = async function TOC(content, options, config) {
     let foundFirstH1
 
     if (docHasHeading) {
-      output = lines.reduce((acc, line, i) => {
+      outputText = lines.reduce((acc, line, i) => {
         const isLineEmpty = line === ''
         if (!isLineEmpty && !firstItemWithContent) {
           firstItemWithContent = i
@@ -127,14 +139,14 @@ module.exports = async function TOC(content, options, config) {
       }, []).join('\n')
     }
  
-    // console.log('output', output)
+    // console.log('outputText', outputText)
     if (debugFileMatch) {
-      console.log('after firsth1 removal', output)
+      console.log('after firsth1 removal', outputText)
     }
   }
   // console.log(t)
   // Fix <h1> with multiple lines
-  const spaces = output.match(/\[\n([\s\S]*?)\]/gm)
+  const spaces = outputText.match(/\[\n([\s\S]*?)\]/gm)
   if (spaces) {
     const fixed = spaces[0]
       // all new lines
@@ -142,33 +154,76 @@ module.exports = async function TOC(content, options, config) {
       // leading spaces
       .replace(/\[\s+/, '[')
       .trim()
-    output = output.replace(spaces[0], fixed)
+    outputText = outputText.replace(spaces[0], fixed)
   }
-  // console.log(output)
-  output = output
+  // console.log(outputText)
+  outputText = outputText
     .replace(/(.*)\[Table of Contents\]\(.*\)\n?/i, '')
     .replace(/(.*)\[toc\]\(.*\)\n?/i, '')
 
 
   if (opts.excludeText) {
-    // (\s+)?-(.*)\[Usage\]\(.*\)
-    const regex = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)`, 'i')
-    // /(\s+)?-(.*)\[Usage\]\(.*\)(\n\s+(.*))+/im
-    const nestedRegex = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)\(\\n\\s+\(.*\)\)+`, 'i')
+
+    outputText = excludeTocItem(outputText, opts.excludeText)
+    // // (\s+)?-(.*)\[Usage\]\(.*\)
+    // const regex = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)`, 'i')
+    // // /(\s+)?-(.*)\[Usage\]\(.*\)(\n\s+(.*))+/im
+    // const nestedRegex = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)\(\\n\\s+\(.*\)\)+`, 'i')
     
-    const hasNested = nestedRegex.exec(output)
-    if (hasNested) {
-      // Count indentation of spaces
-      const numberOfSpaces = hasNested[1].replace(/\n/g, '').length
-      const subItems = numberOfSpaces + 1
-      // Update regex to only remove sub items
-      const nestedRegexSpaces = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)\(\\n\\s{${subItems},}\(.*\)\)+`, 'i')
-      // console.log('nestedRegexSpaces', nestedRegexSpaces)
-      // If exclude value has nested sections remove them as well.
-      output = output.replace(nestedRegexSpaces, '')
-      output = output.replace(regex, '')
-    } else {
-      output = output.replace(regex, '')
+    // const hasNested = nestedRegex.exec(outputText)
+    // if (hasNested) {
+    //   // Count indentation of spaces
+    //   const numberOfSpaces = hasNested[1].replace(/\n/g, '').length
+    //   const subItems = numberOfSpaces + 1
+    //   // Update regex to only remove sub items
+    //   const nestedRegexSpaces = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)\(\\n\\s{${subItems},}\(.*\)\)+`, 'i')
+    //   // console.log('nestedRegexSpaces', nestedRegexSpaces)
+    //   // If exclude value has nested sections remove them as well.
+    //   outputText = outputText.replace(nestedRegexSpaces, '')
+    //   outputText = outputText.replace(regex, '')
+    // } else {
+    //   outputText = outputText.replace(regex, '')
+    // }
+  }
+
+  /* Sub table of contents */
+  if (isSub) {
+    // const start = fileContent.indexOf(open.value)
+    // const linesBefore = fileContent.substr(0, start).split('\n')
+    // const closestHeading = linesBefore.reverse().find((line) => {
+    //   return line.match((/^#+/))
+    // })
+    const linesBefore = originalContents.substr(0, block.start).split('\n')
+    const closestHeading = linesBefore.reverse().find((line) => {
+      return line.match((/^#+/))
+    })
+
+    if (closestHeading) {
+      const headingText = closestHeading.replace(/^#*\s*/, '')
+      // console.log('BEFORE', linesBefore)
+      // console.log('closest parent heading', closestHeading)
+      // console.log('headingText', headingText)
+      // https://regex101.com/r/MB85zm/1
+
+      const findSubToc = new RegExp(`^\(\\s+\)?-(.*)\\[${headingText}\\]\\(.*\\)(\\n\\s.*)+`, 'gm')
+      // console.log('findSubToc', findSubToc)
+      const single = singleLinePattern(headingText)
+      // console.log('single', single)
+      const subItems = outputText.match(findSubToc)
+      if (subItems) {
+        const items = subItems[0].replace(single, '').split('\n')
+          .filter(Boolean)
+        // console.log('items', items)
+        const finalItems = items // .slice(1, items.length)
+        if (finalItems) {
+          const indent = findMinIndent(finalItems.join('\n'))
+          // console.log('min indent', indent)
+          // console.log('finalItems', finalItems)
+          outputText = finalItems.map((thing) => thing.substring(indent)).join('\n')
+        } else {
+          // console.log('No sub items')
+        }
+      }
     }
   }
 
@@ -177,7 +232,7 @@ module.exports = async function TOC(content, options, config) {
     const text = (opts.collapseText) ? opts.collapseText : 'Table of Contents'
     return `<details>
 <summary>${text}</summary>
-${output   
+${outputText   
   // Replace leading double spaces
   .replace(/^\n\n/, '\n')
   // Replace trailing double spaces
@@ -185,7 +240,7 @@ ${output
 </details>`
   }
 
-  return output.replace(removeLeadingAndTrailingLineBreaks, '')
+  return outputText.replace(removeLeadingAndTrailingLineBreaks, '')
 }
 
 const HTML_TAG = /<([a-zA-Z1-6]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)/gim
@@ -246,21 +301,38 @@ function parseHtmlProps(mdContents) {
   return tags
 }
 
-function escapeStringRegexp(string) {
-	if (typeof string !== 'string') {
-		throw new TypeError('Expected a string');
-	}
+function singleLinePattern(text) {
+  /* (\s+)?-(.*)\[Usage\]\(.*\) */
+  return new RegExp(`\(\\s+\)?-(.*)\\[${text}\\]\\(.*\\)`, 'i')
+}
 
-	// Escape characters with special meaning either inside or outside character sets.
-	// Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
-	return string
-		.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
-		.replace(/-/g, '\\x2d');
+function excludeTocItem(str, excludeText) {
+  const matchTextEscaped = escapeRegexString(excludeText)
+  /* (\s+)?-(.*)\[Usage\]\(.*\) */
+  const regex = singleLinePattern(matchTextEscaped) // new RegExp(`\(\\s+\)?-(.*)\\[${matchTextEscaped}\\]\\(.*\\)`, 'i')
+  /* /(\s+)?-(.*)\[Usage\]\(.*\)(\n\s+(.*))+/im */
+  const nestedRegex = new RegExp(`\(\\s+\)?-(.*)\\[${matchTextEscaped}\\]\\(.*\\)\(\\n\\s+\(.*\)\)+`, 'i')
+  
+  const hasNested = nestedRegex.exec(str)
+  if (hasNested) {
+    // Count indentation of spaces
+    const numberOfSpaces = (hasNested[1] || '').replace(/\n/g, '').length
+    const subItems = numberOfSpaces + 1
+    // Update regex to only remove sub items
+    const nestedRegexSpaces = new RegExp(`\(\\s+\)?-(.*)\\[${matchTextEscaped}\\]\\(.*\\)\(\\n\\s{${subItems},}\(.*\)\)+`, 'i')
+    // console.log('nestedRegexSpaces', nestedRegexSpaces)
+    // If exclude value has nested sections remove them as well.
+    str = str.replace(nestedRegexSpaces, '')
+    str = str.replace(regex, '')
+  } else {
+    str = str.replace(regex, '')
+  }
+  return str
 }
 
-function removeUndefined(output) {
+function removeUndefined(outputText) {
   // remove undefined from new line and start of string if first H1 is missing
-  return output.replace(/\nundefined/g, '\n-').replace(/^undefined/g, '-')
+  return outputText.replace(/\nundefined/g, '\n-').replace(/^undefined/g, '-')
 }
 
 // Alt https://github.com/thlorenz/doctoc

package/lib/transforms/wordCount.js

@@ -0,0 +1,5 @@
+const { getWordCount } = require('../utils/text')
+
+module.exports = function wordCount({ fileContent }) {
+  return getWordCount(fileContent)
+}

package/lib/utils/fs.js

@@ -0,0 +1,340 @@
+const fs = require('fs').promises
+const path = require('path')
+const globrex = require('globrex')
+const isGlob = require('is-glob')
+const isLocalPath = require('is-local-path')
+const { REGEX_REGEX, escapeRegexString } = require('./regex') 
+const { dirname, resolve, join } = require('path')
+const { readdir, stat, readFile } = fs
+
+const IS_HIDDEN_FILE = /(^|[\\\/])\.[^\\\/\.]/g
+
+// https://github.com/lukeed/escalade
+async function escalade(start, callback) {
+	let dir = resolve('.', start)
+	let tmp, stats = await stat(dir)
+
+	if (!stats.isDirectory()) {
+		dir = dirname(dir)
+	}
+
+	while (true) {
+		tmp = await callback(dir, await readdir(dir))
+		if (tmp) return resolve(dir, tmp)
+		dir = dirname(tmp = dir)
+		if (tmp === dir) break;
+	}
+}
+
+function isRegex(thing) {
+  return (thing instanceof RegExp)
+}
+
+async function writeFile(filePath, content) {
+  try {
+    await fs.writeFile(filePath, content)
+  } catch(e) {
+    const dirName = path.dirname(filePath)
+    await fs.mkdir(dirName, { recursive: true })
+    await fs.writeFile(filePath, content)
+  }
+}
+
+async function findUp(start, fileName) {
+  const file = await escalade(start, (dir, relativePaths) => {
+    // console.log('~> dir:', dir);
+    // console.log('~> relativePaths:', relativePaths);
+    // console.log('---')
+    if (typeof fileName === 'string' && relativePaths.includes(fileName)) {
+      // will be resolved into absolute
+      return fileName
+    }
+    if (fileName instanceof RegExp) {
+      const found = relativePaths.find((relativePath) => relativePath.match(fileName))
+      if (found) return found
+    }
+  })
+  return file
+}
+
+// https://github.com/lukeed/totalist
+async function totalist(dir, callback, pre='') {
+	dir = resolve('.', dir)
+	await readdir(dir).then(arr => {
+		return Promise.all(arr.map((str) => {
+      let abs = join(dir, str)
+      return stat(abs).then(stats => {
+        return stats.isDirectory() ? totalist(abs, callback, join(pre, str)) : callback(join(pre, str), abs, stats)
+      })
+    }))
+	})
+}
+
+function combineRegexes(patterns = []) {
+  const string = patterns.map((pat) => {
+    if (isRegex(pat)) {
+      return pat.source
+    } else if (typeof pat === 'string' && REGEX_REGEX.test(pat)) {
+      const regexInfo = pat.match(REGEX_REGEX)
+      console.log('regexInfo', regexInfo)
+      // escapeRegexString
+      return regexInfo[1]
+    } else if (isGlob(pat)) {
+      console.log('pat', pat)
+      const result = globrex(pat, { globstar: true, extended: true })
+      console.log('result', result)
+      return result.regex.source
+    }
+    return pat
+  }).join('|')
+  console.log('xxxstring', string)
+  return new RegExp(string)
+}
+
+// alt https://github.com/duniul/clean-modules/blob/33b66bcfb7825e1fa1eb1e296e523ddba374f1ae/src/utils/filesystem.ts#L92
+// Alt https://github.com/AvianFlu/ncp
+async function getFilePaths(dirName, {
+  patterns = [],
+  ignore = [],
+  excludeGitIgnore = false,
+  excludeHidden = false
+}) {
+  let findPattern
+  let ignorePattern
+  let filePaths = []
+  let gitIgnoreFiles = []
+  let gitIgnoreGlobs = []
+
+  if (patterns && patterns.length) {
+    findPattern = combineRegexes(patterns)
+    console.log('findPatternfindPatternfindPattern', patterns)
+  }
+  if (ignore && ignore.length) {
+    ignorePattern = combineRegexes(ignore)
+  }
+
+  if (excludeGitIgnore) {
+    const gitIgnoreContents = await getGitignoreContents()
+    for (let index = 0; index < gitIgnoreContents.length; index++) {
+      const ignoreItem = gitIgnoreContents[index]
+      // console.log('ignoreItem', ignoreItem)
+      if (isGlob(ignoreItem)) {
+        gitIgnoreGlobs.push(ignoreItem)
+      } else {
+        gitIgnoreFiles.push(
+          ignoreItem.replace(/^\.\//, '') // normalize relative paths
+        )
+      }
+    }
+  }
+  
+  //*
+  console.log('findPattern', findPattern)
+  console.log('ignorePattern', ignorePattern)
+  console.log('gitIgnoreFiles', gitIgnoreFiles)
+  console.log('gitIgnoreGlobs', gitIgnoreGlobs)
+  // process.exit(1)
+  /** */
+
+  await totalist(dirName, (relativePath, abs, stats) => {
+    const absolutePath = `${dirName}/${relativePath}`
+    const topLevelDir = relativePath.substring(0, relativePath.indexOf('/'))
+    //console.log('absolutePath', absolutePath)
+    // console.log('relativePath', relativePath)
+    // console.log('topLevelDir', topLevelDir)
+
+    /* Remove hidden files */
+    if (excludeHidden && IS_HIDDEN_FILE.test(relativePath)) {
+      return
+    }
+
+    /* Remove files in git ignore */
+    if (excludeGitIgnore && gitIgnoreFiles.length) {
+      if (gitIgnoreFiles.includes(relativePath)) return
+      if (gitIgnoreFiles.includes(path.basename(relativePath))) return
+      //* // slow
+      if (gitIgnoreFiles.some((ignore) => {
+        // console.log('ignore', ignore)
+        // return relativePath.indexOf(ignore) > -1
+        // return relativePath.split('/')[0] === ignore
+        return topLevelDir === ignore || relativePath === ignore
+      })) {
+        return
+      }
+      /** */
+    }
+
+    /* Remove files in ignore array */
+    if (ignorePattern && ignorePattern.test(relativePath)) {
+      // Alt checker https://github.com/axtgr/wildcard-match
+      return
+    }
+
+    /* If no patterns supplied add all files */
+    if (!findPattern) {
+      filePaths.push(absolutePath)
+      return
+    }
+
+    /* If pattern match add file! */
+    // Alt match https://github.com/micromatch/picomatch
+    if (findPattern.test(absolutePath)) {
+      // console.log('Match absolutePath', absolutePath)
+      filePaths.push(absolutePath)
+      return
+    }
+
+    /* If pattern match add file! */
+    if (findPattern.test(relativePath)) {
+      // console.log('Match relativePath', relativePath)
+      filePaths.push(absolutePath)
+      return
+    }
+
+    /*
+    let ignored = false
+    for (let index = 0; index < ignore.length; index++) {
+      const pattern = ignore[index]
+      if (pattern.test(absolutePath)) {
+        ignored = true
+      }
+    }
+    if (!ignored) {
+      filePaths.push(absolutePath)
+    }
+    /** */
+	})
+
+  if (gitIgnoreGlobs && gitIgnoreGlobs.length) {
+    console.log('gitIgnoreGlobs', gitIgnoreGlobs)
+    let removeFiles = []
+    for (let index = 0; index < gitIgnoreGlobs.length; index++) {
+      const glob = gitIgnoreGlobs[index]
+      const result = globrex(glob) // alt lib https://github.com/axtgr/wildcard-match
+      // console.log('result', result)
+      for (let n = 0; n < filePaths.length; n++) {
+        const file = filePaths[n]
+        if (result.regex.test(file)) {
+          removeFiles.push(file)
+        }
+      }
+    }
+    /* Remove files that match glob pattern */
+    if (removeFiles.length) {
+      filePaths = filePaths.filter(function(el) {
+        return removeFiles.indexOf(el) < 0
+      })
+    }
+  }
+
+  return filePaths
+}
+
+function convertToRelativePath(file, cwd) {
+  return file.replace(cwd, '').replace(/^\//, '')
+}
+
+async function getGitignoreContents(filePath = '.gitignore') {
+  try {
+    const gitIgnoreContent = await readFile(filePath, { encoding: 'utf8' })
+    return gitIgnoreContent
+      .split(/\r?\n/)
+      .filter((line) => !/^\s*$/.test(line) && !/^\s*#/.test(line))
+      .map((line) => line.trim().replace(/^\/+|\/+$/g, ''))
+  } catch (_a) {
+    return []
+  }
+}
+
+// slash at the beginning of a filename
+const leadingPathSeparator = new RegExp(`^${escapeRegexString(path.sep)}`)
+const windowsLeadingPathSeparator = new RegExp('^/')
+
+// all slashes in the filename. path.sep is OS agnostic (windows, mac, etc)
+const pathSeparator = new RegExp(escapeRegexString(path.sep), 'g')
+const windowsPathSeparator = new RegExp('/', 'g')
+
+// handle MS Windows style double-backslashed filenames
+const windowsDoubleSlashSeparator = new RegExp('\\\\', 'g')
+
+// derive `foo.bar.baz` object key from `foo/bar/baz.yml` filename
+function fileNameToKey(filename) {
+  // const extension = new RegExp(`${path.extname(filename)}$`)
+  const key = filename
+    // .replace(extension, '')
+    .replace(leadingPathSeparator, '')
+    .replace(windowsLeadingPathSeparator, '')
+    .replace(pathSeparator, '.')
+    .replace(windowsPathSeparator, '.')
+    .replace(windowsDoubleSlashSeparator, '.')
+
+  return key
+}
+
+// https://github.com/regexhq/unc-path-regex/blob/master/index.js
+function isUncPath(filepath) {
+  return /^[\\\/]{2,}[^\\\/]+[\\\/]+[^\\\/]+/.test(filepath)
+}
+function isRelative(filepath) {
+  const isRel = !isUncPath(filepath) && !/^([a-z]:)?[\\\/]/i.test(filepath)
+  // console.log(`isRel ${filepath}`, isRel)
+  return isRel
+}
+/* Find common parts of 2 paths */
+function resolveCommonParent(mainDir = '', fileDir = '') {
+  const parts = mainDir.split('/')
+  let acc = ''
+  let value = ''
+  for (let i = 0; i < parts.length; i++) {
+    const element = parts[i];
+    acc+= ((i) ? '/' : '') + element
+    if (fileDir.startsWith(acc)) {
+      value = acc
+    }
+  }
+  return value
+}
+
+function resolveOutputPath(cwd, outputDir, file) {
+  // console.log('file', file)
+  const fileCommon = resolveCommonParent(cwd, file)
+  // console.log('fileCommon', fileCommon)
+  const remove = resolveCommonParent(outputDir, file)
+  const fileName = file.replace(remove, '').replace(fileCommon, '')
+  let outputFilePath = path.join(outputDir, fileName)
+  if (isRelative(outputDir)) {
+    outputFilePath = path.join(cwd, outputDir, fileName)
+  }
+  // console.log('isRelative(outputDir)', isRelative(outputDir))
+  // console.log('outputDir', outputDir)
+  // console.log('fileName', fileName)
+  // console.log('remove', remove)
+  return outputFilePath
+}
+
+function resolveFlatPath(cwd, outputDir, file) {
+  /* old setup */
+  const fileName = path.basename(file)
+  let outputFilePath = path.join(outputDir, fileName)
+  if (isRelative(outputDir)) {
+    outputFilePath = path.join(cwd, outputDir, fileName)
+  }
+  return outputFilePath
+}
+
+function depth(string) {
+  return path.normalize(string).split(path.sep).length - 1;
+}
+
+module.exports = {
+  isLocalPath,
+  writeFile,
+  readFile, 
+  findUp,
+  getFilePaths,
+  resolveOutputPath,
+  resolveFlatPath,
+  resolveCommonParent,
+  getGitignoreContents,
+  convertToRelativePath
+}