Join Helper methods for fs and path (Most likely one of a millions other similar helper libs!!)
Ex:
import { x } from "node-x-path"
const c = await x.load("path/to/file.txt")Code:
// (... Class version ...)
export const x = {
fromPath: NodeXPath.fromPath,
fromPathWithContent: NodeXPath.fromPathWithContent,
fromRelPath: NodeXPath.fromRelPath,
fromRelPathWithContent: NodeXPath.fromRelPathWithContent,
sep: nodePath.sep,
processCwd,
standardGlobIngorePattern,
async glob(
pattern: string,
{ ignore = standardGlobIngorePattern, cwd = processCwd, nocase = true, dot = true } = {}
) {
return await glob(pattern, {
ignore,
cwd,
nocase,
dot,
})
},
/** Wrap on glob search. Creates a glob pattern: '**./*<searchTerm>*' */
async searchFileName(
options: constructGlobPatternOptions & {
ignore?: string[]
cwd?: string
nocase?: boolean
dot?: boolean
} = {}
) {
const { ignore, cwd, nocase, dot, ...searchOptions } = options
const pattern = constructGlobPattern({ ...searchOptions })
return await glob(pattern, {
ignore,
cwd,
nocase,
dot,
})
},
filename(fullPath: string) {
return nodePath.basename(fullPath)
},
dir(fullPath: string) {
return nodePath.dirname(fullPath)
},
join(...paths: string[]) {
let fullPath = nodePath.join(...paths)
return fullPath
},
lines(content: string) {
return content.split("\n")
},
trimEmptyLines(content: string) {
return content.replace(/^(\s*\n)+/, "").replace(/(\n\s*)+$/, "") // remove empty lines from start and end
},
removeEmptyLines(content: string) {
// remove each empty line
return content.replace(/^\s*\n/gm, "")
},
addIndent: (content: string, indent = _indent) => {
return content.replace(/(^|\n)/g, `$1${indent}`)
},
removeIndent: (content: string, indent = _indent) => {
return content.replace(new RegExp(`(^|\n)${indent}`, "g"), "$1")
},
minIndent(content: string, max = " ") {
let baseIndent = max
let lines = content.split("\n")
for (const line of lines) {
if (line.length === 0 || emptyLineRegex.test(line)) continue // exclude empty lines
let indent = line.match(indentRegex)
if (!indent) continue
if (indent[0].length === 0) return ""
if (indent[0].length < baseIndent.length) {
baseIndent = indent[0]
}
}
return baseIndent
},
async load(fullPath: string, stripReturnFeed = true) {
const content = await fs.readFile(fullPath, { encoding: "utf8" })
if (stripReturnFeed) {
return content.replace(/\r\n/g, "\n")
}
return content
},
loadSync(fullPath: string, stripReturnFeed = true) {
const content = fs.readFileSync(fullPath, { encoding: "utf8" })
if (stripReturnFeed) {
return content.replace(/\r\n/g, "\n")
}
return content
},
async loadJson<TJson>(fullPath: string, stripReturnFeed = true) {
let c = await x.load(fullPath, stripReturnFeed)
try {
return JSON.parse(c) as TJson
} catch (e) {
console.log?.("NodeXPath - loadJson SyntaxError:", e)
}
},
loadJsonSync<TJson>(fullPath: string, stripReturnFeed = true) {
let c = x.loadSync(fullPath, stripReturnFeed)
try {
return JSON.parse(c) as TJson
} catch (e) {
console.log?.("NodeXPath - loadJson SyntaxError:", e)
}
},
async save(fullPath: string, content: string, encoding: BufferEncoding = "utf8") {
await fs.ensureDir(nodePath.dirname(fullPath))
await fs.writeFile(fullPath, content, { encoding })
},
saveSync(fullPath: string, content: string, encoding: BufferEncoding = "utf8") {
fs.ensureDirSync(nodePath.dirname(fullPath))
fs.writeFileSync(fullPath, content, { encoding })
},
async delete(fullPath: string) {
if (await fs.pathExists(fullPath)) {
await fs.remove(fullPath)
}
},
deleteSync(fullPath: string) {
if (fs.pathExistsSync(fullPath)) {
fs.removeSync(fullPath)
}
},
async exists(fullPath: string) {
return await fs.pathExists(fullPath)
},
existsSync(fullPath: string) {
return fs.pathExistsSync(fullPath)
},
async ensureDir(fullPath: string) {
let exists = await fs.pathExists(fullPath)
let dir = fullPath
if (exists) {
let stat = await fs.stat(fullPath)
let isFile = stat.isFile()
if (isFile) {
dir = nodePath.dirname(fullPath)
}
await fs.ensureDir(dir)
return
}
let p = nodePath.parse(fullPath)
if (p.ext) {
dir = nodePath.dirname(fullPath)
}
await fs.ensureDir(dir)
},
ensureDirSync(fullPath: string) {
let exists = fs.pathExistsSync(fullPath)
let dir = fullPath
if (exists) {
let stat = fs.statSync(fullPath)
let isFile = stat.isFile()
if (isFile) {
dir = nodePath.dirname(fullPath)
}
fs.ensureDirSync(dir)
return
}
let p = nodePath.parse(fullPath)
if (p.ext) {
dir = nodePath.dirname(fullPath)
}
fs.ensureDirSync(dir)
},
async isFile(fullPath: string) {
let exists = await fs.pathExists(fullPath)
if (!exists) return false
let stat = await fs.stat(fullPath)
return stat.isFile()
},
isFileSync(fullPath: string) {
let exists = fs.pathExistsSync(fullPath)
if (!exists) return false
let stat = fs.statSync(fullPath)
return stat.isFile()
},
async isDir(fullPath: string) {
let exists = await fs.pathExists(fullPath)
if (!exists) return false
let stat = await fs.stat(fullPath)
return stat.isDirectory()
},
isDirSync(fullPath: string) {
let exists = fs.pathExistsSync(fullPath)
if (!exists) return false
let stat = fs.statSync(fullPath)
return stat.isDirectory()
},
async children(fullPath: string) {
let exists = await fs.pathExists(fullPath)
if (!exists) return []
let children = await fs.readdir(fullPath, { withFileTypes: true })
return children
},
async childDirs(fullPath: string) {
let exists = await fs.pathExists(fullPath)
if (!exists) return []
let children = await fs.readdir(fullPath, { withFileTypes: true })
let dirs = children.filter((item) => item.isDirectory())
return dirs
},
async childFiles(fullPath: string) {
let exists = await fs.pathExists(fullPath)
if (!exists) return []
let children = await fs.readdir(fullPath, { withFileTypes: true })
let files = children.filter((item) => item.isFile())
return files
},
relativeTo: (from: string, to: string) => {
return nodePath.relative(from, to)
},
}