@fullstackunicorn/filesystem 1.0.8 → 1.0.10

package/modules/fsa.js

@@ -1,83 +1,109 @@
 import { fsAsync, constants, path } from '#@/index.dep.js'
 
-export const fsa = {
-    chmod: fsAsync.chmod,
-    exists: async (path) => {
-        try { await fsAsync.access(path, constants.F_OK); return true }
-        catch { return false }
-    },
-    readFile: async (path) => await fsa.exists(path) ? await fsAsync.readFile(path) : null,
-    readText: async (path) => await fsa.exists(path) ? await fsAsync.readFile(path, 'utf8') : null,
-    readJSON: async (path) => {
-        try { return await fsa.exists(path) ? JSON.parse(await fsAsync.readFile(path, 'utf8')) : {} }
-        catch { return {} }
-    },
-    writeJSON: async (path, json) => await fsAsync.writeFile(path, JSON.stringify(json, null, 4)),
-    readDir: async (path, opts) => await fsa.exists(path) ? await fsAsync.readdir(path, opts) : [],
-    readDirVisible: async (path) => (await fsa.readDir(path, { withFileTypes: true }))
-        .filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name),
-    isDir: async (path) => {
-        try { return (await fsAsync.stat(path)).isDirectory() }
-        catch { return false }
-    },
-    ensureDir: async (path) => { if (!await fsa.exists(path)) await fsAsync.mkdir(path, { recursive: true }) },
-    ensureFileDir: async (filePath) => {
-        const dirPath = path.dirname(filePath)
-        if (!await fsa.exists(dirPath)) await fsAsync.mkdir(dirPath, { recursive: true })
-    },
-    writeText: async (path, text) => await fsAsync.writeFile(path, text),
-    listFiles: async (path, ext = null) => (await fsa.readDir(path)).filter(f => !ext || f.endsWith(ext)),
-    safeUnlink: async (path) => { if (await fsa.exists(path)) await fsAsync.unlink(path) },
-    safeRemove: async (path) => { if (await fsa.exists(path)) await fsAsync.rm(path, { recursive: true, force: true }) },
-    append: async (path, buffer) => await fsAsync.appendFile(path, buffer),
-    copyFile: fsAsync.copyFile,
-    remove: fsAsync.rm,
-    writeDir: fsAsync.mkdir,
-    unlink: fsAsync.unlink,
-    stat: fsAsync.stat,
-    writeFile: fsAsync.writeFile,
-    writeBuffer: async (filePath, file) => {
-        let buffer
-        if (Buffer.isBuffer(file?.buffer)) buffer = file?.buffer
-        else if (file?.buffer instanceof ArrayBuffer) buffer = Buffer.from(file.buffer)
-        else throw new Error('buffer-error')
-        await fsAsync.writeFile(filePath, buffer)
-    },
-    isJunk: name => {
-        if (!name) return true
-        const lower = name.toLowerCase()
-        if (lower.endsWith('~') || lower.endsWith('.tmp') || lower.endsWith('.temp')) return true
-        return [
-            '.ds_store', '._', '.spotlight-v100', '.trashes', '.fseventsd', '.temporaryitems', '.apdisk', '.volumeicon.icns',
-            'thumbs.db', 'ehthumbs.db', 'desktop.ini', '$recycle.bin', 'system volume information',
-            'lost+found', '__macosx', '.swp', '.swo', '.#', '.cache'
-        ].some(bad => lower === bad || lower.startsWith(bad))
-    },
-    copyFile: fsAsync.copyFile,
-    copyDir: async (src, dest) => {
-        await fsa.ensureDir(dest)
-        const entries = await fsa.readDir(src)
+const fsa = {}
+
+fsa.chmod = fsAsync.chmod
+
+fsa.exists = async (path) => {
+    try { await fsAsync.access(path, constants.F_OK); return true }
+    catch { return false }
+}
+
+fsa.readFile = async (path) => await fsa.exists(path) ? await fsAsync.readFile(path) : null
+
+fsa.readText = async (path) => await fsa.exists(path) ? await fsAsync.readFile(path, 'utf8') : null
+
+fsa.readJSON = async (path) => {
+    try { return await fsa.exists(path) ? JSON.parse(await fsAsync.readFile(path, 'utf8')) : {} }
+    catch { return {} }
+}
+
+fsa.writeJSON = async (path, json) => await fsAsync.writeFile(path, JSON.stringify(json, null, 4))
+
+fsa.readDir = async (path, opts) => await fsa.exists(path) ? await fsAsync.readdir(path, opts) : []
+
+fsa.readDirVisible = async (path) => (await fsa.readDir(path, { withFileTypes: true }))
+    .filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name)
+
+fsa.isDir = async (path) => {
+    try { return (await fsAsync.stat(path)).isDirectory() }
+    catch { return false }
+}
+
+fsa.ensureDir = async (path) => { if (!await fsa.exists(path)) await fsAsync.mkdir(path, { recursive: true }) }
+
+fsa.ensureFileDir = async (filePath) => {
+    const dirPath = path.dirname(filePath)
+    if (!await fsa.exists(dirPath)) await fsAsync.mkdir(dirPath, { recursive: true })
+}
+
+fsa.writeText = async (path, text) => await fsAsync.writeFile(path, text)
+
+fsa.listFiles = async (path, ext = null) => (await fsa.readDir(path)).filter(f => !ext || f.endsWith(ext))
+
+fsa.safeUnlink = async (path) => { if (await fsa.exists(path)) await fsAsync.unlink(path) }
+
+fsa.safeRemove = async (path) => { if (await fsa.exists(path)) await fsAsync.rm(path, { recursive: true, force: true }) }
+
+fsa.append = async (path, buffer) => await fsAsync.appendFile(path, buffer)
+
+fsa.copyFile = fsAsync.copyFile
+
+fsa.remove = fsAsync.rm
+
+fsa.writeDir = fsAsync.mkdir
+
+fsa.unlink = fsAsync.unlink
+
+fsa.stat = fsAsync.stat
+
+fsa.writeFile = fsAsync.writeFile
+
+fsa.writeBuffer = async (filePath, file) => {
+    let buffer
+    if (Buffer.isBuffer(file?.buffer)) buffer = file?.buffer
+    else if (file?.buffer instanceof ArrayBuffer) buffer = Buffer.from(file.buffer)
+    else throw new Error('buffer-error')
+    await fsAsync.writeFile(filePath, buffer)
+}
+
+fsa.isJunk = name => {
+    if (!name) return true
+    const lower = name.toLowerCase()
+    if (lower.endsWith('~') || lower.endsWith('.tmp') || lower.endsWith('.temp')) return true
+    return [
+        '.ds_store', '._', '.spotlight-v100', '.trashes', '.fseventsd', '.temporaryitems', '.apdisk', '.volumeicon.icns',
+        'thumbs.db', 'ehthumbs.db', 'desktop.ini', '$recycle.bin', 'system volume information',
+        'lost+found', '__macosx', '.swp', '.swo', '.#', '.cache'
+    ].some(bad => lower === bad || lower.startsWith(bad))
+}
+
+fsa.copyDir = async (src, dest) => {
+    await fsa.ensureDir(dest)
+    const entries = await fsa.readDir(src)
+    for (const entry of entries) {
+        const srcPath = `${src}/${entry}`
+        const destPath = `${dest}/${entry}`
+        const stat = await fsa.stat(srcPath)
+        if (stat.isDirectory()) await fsa.copyDir(srcPath, destPath)
+        else await fsAsync.copyFile(srcPath, destPath)
+    }
+}
+
+fsa.getDirPaths = async (basePath) => {
+    const files = []
+    const scan = async dir => {
+        const entries = await fsa.readDir(dir)
         for (const entry of entries) {
-            const srcPath = `${src}/${entry}`
-            const destPath = `${dest}/${entry}`
-            const stat = await fsa.stat(srcPath)
-            if (stat.isDirectory()) await fsa.copyDir(srcPath, destPath)
-            else await fsAsync.copyFile(srcPath, destPath)
-        }
-    },
-    getDirPaths: async (basePath) => {
-        const files = []
-        const scan = async dir => {
-            const entries = await fsa.readDir(dir)
-            for (const entry of entries) {
-                if (fsa.isJunk(entry)) continue
-                const fullPath = path.join(dir, entry)
-                const stat = await fsa.stat(fullPath)
-                if (stat.isDirectory()) await scan(fullPath)
-                else files.push(path.relative(basePath, fullPath))
-            }
+            if (fsa.isJunk(entry)) continue
+            const fullPath = path.join(dir, entry)
+            const stat = await fsa.stat(fullPath)
+            if (stat.isDirectory()) await scan(fullPath)
+            else files.push(path.relative(basePath, fullPath))
         }
-        await scan(basePath)
-        return files
-    },
-}
+    }
+    await scan(basePath)
+    return files
+}
+
+export { fsa }

package/modules/fss.js

@@ -1,80 +1,105 @@
 import { fsSync, path } from '#@/index.dep.js'
 
-export const fss = {
-    exists: (...args) => fsSync.existsSync(...args),
-    readFile: (...args) => fss.exists(...args) ? fsSync.readFileSync(...args) : null,
-    readText: (path) => fss.exists(path) ? fsSync.readFileSync(path, 'utf8') : null,
-    readJSON: (path) => {
-        try { return fss.exists(path) ? JSON.parse(fsSync.readFileSync(path, 'utf8')) : {} }
-        catch { return {} }
-    },
-    writeJSON: (path, json) => fsSync.writeFileSync(path, JSON.stringify(json, null, 4)),
-    readDir: (...args) => fss.exists(...args) ? fsSync.readdirSync(...args) : [],
-    readDirVisible: (path) => (
-        fss.readDir(path, { withFileTypes: true }) || []
-    ).filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name),
-    isDir: (path) => {
-        try { return fsSync.statSync(path).isDirectory() }
-        catch { return false }
-    },
-    ensureDir: (path) => { if (!fss.exists(path)) fsSync.mkdirSync(path, { recursive: true }) },
-    ensureFileDir: (filePath) => {
-        const dirPath = path.dirname(filePath)
-        if (!fss.exists(dirPath)) fsSync.mkdirSync(dirPath, { recursive: true })
-    },
-    writeText: (path, text) => fsSync.writeFileSync(path, text),
-    listFiles: (path, ext = null) => fss.readDir(path).filter(f => !ext || f.endsWith(ext)),
-    safeUnlink: (path) => { if (fss.exists(path)) fsSync.unlinkSync(path) },
-    safeRemove: (path) => { if (fss.exists(path)) fsSync.rmSync(path, { recursive: true, force: true }) },
-    copyFile: fsSync.copyFileSync,
-    remove: fsSync.rmSync,
-    writeDir: fsSync.mkdirSync,
-    unlink: fsSync.unlinkSync,
-    stat: fsSync.statSync,
-    writeFile: fsSync.writeFileSync,
-    writeStream: (...args) => fsSync.createWriteStream(...args),
-    writeBuffer: (filePath, file) => {
-        let buffer
-        if (Buffer.isBuffer(file?.buffer)) buffer = file?.buffer
-        else if (file?.buffer instanceof ArrayBuffer) buffer = Buffer.from(file.buffer)
-        else throw new Error('buffer-error')
-        fsSync.writeFileSync(filePath, buffer)
-    },
-    isJunk: name => {
-        if (!name) return true
-        const lower = name.toLowerCase()
-        if (lower.endsWith('~') || lower.endsWith('.tmp') || lower.endsWith('.temp')) return true
-        return [
-            '.ds_store', '._', '.spotlight-v100', '.trashes', '.fseventsd', '.temporaryitems', '.apdisk', '.volumeicon.icns',
-            'thumbs.db', 'ehthumbs.db', 'desktop.ini', '$recycle.bin', 'system volume information',
-            'lost+found', '__macosx', '.swp', '.swo', '.#', '.cache'
-        ].some(bad => lower === bad || lower.startsWith(bad))
-    },
-    copyFile: fsSync.copyFileSync,
-    copyDir: (src, dest) => {
-        fss.ensureDir(dest)
-        const entries = fss.readDir(src)
+const fss = {}
+
+fss.exists = (...args) => fsSync.existsSync(...args)
+
+fss.readFile = (...args) => fss.exists(...args) ? fsSync.readFileSync(...args) : null
+
+fss.readText = (path) => fss.exists(path) ? fsSync.readFileSync(path, 'utf8') : null
+
+fss.readJSON = (path) => {
+    try { return fss.exists(path) ? JSON.parse(fsSync.readFileSync(path, 'utf8')) : {} }
+    catch { return {} }
+}
+
+fss.writeJSON = (path, json) => fsSync.writeFileSync(path, JSON.stringify(json, null, 4))
+
+fss.readDir = (...args) => fss.exists(...args) ? fsSync.readdirSync(...args) : []
+
+fss.readDirVisible = (path) => (
+    fss.readDir(path, { withFileTypes: true }) || []
+).filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name)
+
+fss.isDir = (path) => {
+    try { return fsSync.statSync(path).isDirectory() }
+    catch { return false }
+}
+
+fss.ensureDir = (path) => { if (!fss.exists(path)) fsSync.mkdirSync(path, { recursive: true }) }
+
+fss.ensureFileDir = (filePath) => {
+    const dirPath = path.dirname(filePath)
+    if (!fss.exists(dirPath)) fsSync.mkdirSync(dirPath, { recursive: true })
+}
+
+fss.writeText = (path, text) => fsSync.writeFileSync(path, text)
+
+fss.listFiles = (path, ext = null) => fss.readDir(path).filter(f => !ext || f.endsWith(ext))
+
+fss.safeUnlink = (path) => { if (fss.exists(path)) fsSync.unlinkSync(path) }
+
+fss.safeRemove = (path) => { if (fss.exists(path)) fsSync.rmSync(path, { recursive: true, force: true }) }
+
+fss.copyFile = fsSync.copyFileSync
+
+fss.remove = fsSync.rmSync
+
+fss.writeDir = fsSync.mkdirSync
+
+fss.unlink = fsSync.unlinkSync
+
+fss.stat = fsSync.statSync
+
+fss.writeFile = fsSync.writeFileSync
+
+fss.writeStream = (...args) => fsSync.createWriteStream(...args)
+
+fss.writeBuffer = (filePath, file) => {
+    let buffer
+    if (Buffer.isBuffer(file?.buffer)) buffer = file?.buffer
+    else if (file?.buffer instanceof ArrayBuffer) buffer = Buffer.from(file.buffer)
+    else throw new Error('buffer-error')
+    fsSync.writeFileSync(filePath, buffer)
+}
+
+fss.isJunk = name => {
+    if (!name) return true
+    const lower = name.toLowerCase()
+    if (lower.endsWith('~') || lower.endsWith('.tmp') || lower.endsWith('.temp')) return true
+    return [
+        '.ds_store', '._', '.spotlight-v100', '.trashes', '.fseventsd', '.temporaryitems', '.apdisk', '.volumeicon.icns',
+        'thumbs.db', 'ehthumbs.db', 'desktop.ini', '$recycle.bin', 'system volume information',
+        'lost+found', '__macosx', '.swp', '.swo', '.#', '.cache'
+    ].some(bad => lower === bad || lower.startsWith(bad))
+}
+
+fss.copyDir = (src, dest) => {
+    fss.ensureDir(dest)
+    const entries = fss.readDir(src)
+    for (const entry of entries) {
+        const srcPath = `${src}/${entry}`
+        const destPath = `${dest}/${entry}`
+        const stat = fss.stat(srcPath)
+        if (stat.isDirectory()) fss.copyDir(srcPath, destPath)
+        else fsSync.copyFileSync(srcPath, destPath)
+    }
+}
+
+fss.getDirPaths = (basePath) => {
+    const files = []
+    const scan = dir => {
+        const entries = fss.readDir(dir)
         for (const entry of entries) {
-            const srcPath = `${src}/${entry}`
-            const destPath = `${dest}/${entry}`
-            const stat = fss.stat(srcPath)
-            if (stat.isDirectory()) fss.copyDir(srcPath, destPath)
-            else fsSync.copyFileSync(srcPath, destPath)
-        }
-    },
-    getDirPaths: (basePath) => {
-        const files = []
-        const scan = dir => {
-            const entries = fss.readDir(dir)
-            for (const entry of entries) {
-                if (fss.isJunk(entry)) continue
-                const fullPath = path.join(dir, entry)
-                const stat = fss.stat(fullPath)
-                if (stat.isDirectory()) scan(fullPath)
-                else files.push(path.relative(basePath, fullPath))
-            }
+            if (fss.isJunk(entry)) continue
+            const fullPath = path.join(dir, entry)
+            const stat = fss.stat(fullPath)
+            if (stat.isDirectory()) scan(fullPath)
+            else files.push(path.relative(basePath, fullPath))
         }
-        scan(basePath)
-        return files
     }
-}
+    scan(basePath)
+    return files
+}
+
+export { fss }

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "1.0.8",
+    "version": "1.0.10",
     "name": "@fullstackunicorn/filesystem",
     "author": "lucanigido (https://fullstackunicorn.dev/author/lucanigido)",
     "description": "A simple sync/async file system wrapper for Node.js",