@stacksjs/storage 0.59.11 → 0.61.1

package/dist/index.js

@@ -11,9 +11,9 @@ var __export = (target, all) => {
 };
 
 // src/files.ts
-import {detectIndent, detectNewline} from "@stacksjs/strings";
-import {dirname, join as join2, path as p} from "@stacksjs/path";
 import {contains} from "@stacksjs/arrays";
+import {dirname, join, path as p} from "@stacksjs/path";
+import {detectIndent, detectNewline} from "@stacksjs/strings";
 
 // src/fs.ts
 import * as fs from "fs-extra";
@@ -53,7 +53,7 @@ function readTextFile(name, cwd) {
   return new Promise((resolve, reject) => {
     let filePath;
     if (cwd)
-      filePath = join2(cwd, name);
+      filePath = join(cwd, name);
     else
       filePath = name;
     fs.readFile(filePath, "utf8", (err, text) => {
@@ -96,7 +96,7 @@ function hasFunctions() {
 function deleteFiles(dir, exclude = []) {
   if (fs.existsSync(dir)) {
     fs.readdirSync(dir).forEach((file) => {
-      const p2 = join2(dir, file);
+      const p2 = join(dir, file);
       if (fs.statSync(p2).isDirectory()) {
         if (fs.readdirSync(p2).length === 0)
           fs.rmSync(p2, { recursive: true, force: true });
@@ -112,9 +112,9 @@ function getFiles(dir, exclude = []) {
   let results = [];
   const list = fs.readdirSync(dir);
   list.forEach((file) => {
-    file = join2(dir, file);
+    file = join(dir, file);
     const stat = fs.statSync(file);
-    if (stat && stat.isDirectory())
+    if (stat.isDirectory())
       results = results.concat(getFiles(file, exclude));
     else if (!contains(file, exclude))
       results.push(file);
@@ -146,8 +146,8 @@ var files = {
   get
 };
 // src/folders.ts
-import {join as join3} from "@stacksjs/path";
-function isFolder2(path3) {
+import {join as join2} from "@stacksjs/path";
+function isFolder(path3) {
   try {
     return fs.statSync(path3).isDirectory();
   } catch {
@@ -155,15 +155,15 @@ function isFolder2(path3) {
   }
 }
 function isDirectory(path3) {
-  return isFolder2(path3);
+  return isFolder(path3);
 }
 function isDir(path3) {
-  return isFolder2(path3);
+  return isFolder(path3);
 }
 function doesFolderExist(path3) {
   return fs.existsSync(path3);
 }
-function createFolder2(dir) {
+function createFolder(dir) {
   return new Promise((resolve, reject) => {
     fs.mkdirs(dir, (err) => {
       if (err)
@@ -175,13 +175,13 @@ function createFolder2(dir) {
 }
 function getFolders(dir) {
   return fs.readdirSync(dir).filter((file) => {
-    return fs.statSync(join3(dir, file)).isDirectory();
+    return fs.statSync(join2(dir, file)).isDirectory();
   });
 }
 var folders = {
-  isFolder: isFolder2,
+  isFolder,
   doesFolderExist,
-  createFolder: createFolder2,
+  createFolder,
   getFolders
 };
 // src/hash.ts
@@ -243,7 +243,7 @@ var helpers = {
 };
 // src/copy.ts
 import {contains as contains2} from "@stacksjs/arrays";
-import {join as join4} from "@stacksjs/path";
+import {join as join3} from "@stacksjs/path";
 function copy(src, dest, exclude = []) {
   if (Array.isArray(src)) {
     src.forEach((file) => {
@@ -264,9 +264,9 @@ function copyFolder(src, dest, exclude = []) {
     fs.mkdirSync(dest, { recursive: true });
   if (fs.existsSync(src)) {
     fs.readdirSync(src).forEach((file) => {
-      if (!contains2(join4(src, file), exclude)) {
-        const srcPath = join4(src, file);
-        const destPath = join4(dest, file);
+      if (!contains2(join3(src, file), exclude)) {
+        const srcPath = join3(src, file);
+        const destPath = join3(dest, file);
         if (fs.statSync(srcPath).isDirectory())
           copyFolder(srcPath, destPath, exclude);
         else
@@ -278,29 +278,29 @@ function copyFolder(src, dest, exclude = []) {
 // src/glob.ts
 import {default as default2} from "fast-glob";
 // src/delete.ts
-import {err, ok} from "@stacksjs/error-handling";
 import {italic, log} from "@stacksjs/cli";
-function deleteFolder(path6) {
+import {err, handleError, ok} from "@stacksjs/error-handling";
+import {join as join4} from "@stacksjs/path";
+function deleteFolder(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (isFolder2(path6)) {
-        fs.rmSync(path6, { recursive: true, force: true });
-        return resolve(ok(`Deleted ${path6}`));
+      if (isFolder(path7)) {
+        fs.rmSync(path7, { recursive: true, force: true });
+        return resolve(ok(`Deleted ${path7}`));
       }
-      return resolve(ok(`Path ${path6} was not a directory`));
+      return resolve(ok(`Path ${path7} was not a directory`));
     } catch (error) {
       return reject(err(error));
     }
   });
 }
-async function isDirectoryEmpty(path6) {
+async function isDirectoryEmpty(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (fs.statSync(path6).isDirectory()) {
-        if (fs.readdirSync(path6).length === 0)
+      if (fs.statSync(path7).isDirectory()) {
+        if (fs.readdirSync(path7).length === 0)
           return resolve(ok(true));
-        else
-          return resolve(ok(false));
+        return resolve(ok(false));
       }
       return resolve(ok(false));
     } catch (error) {
@@ -308,18 +308,17 @@ async function isDirectoryEmpty(path6) {
     }
   });
 }
-async function deleteEmptyFolder(path6) {
+async function deleteEmptyFolder(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (fs.statSync(path6).isDirectory()) {
-        if (fs.readdirSync(path6).length === 0) {
-          fs.rmSync(path6, { recursive: true, force: true });
-          return resolve(ok(`Deleted ${path6}`));
-        } else {
-          return resolve(ok(`Path ${path6} was not empty`));
+      if (fs.statSync(path7).isDirectory()) {
+        if (fs.readdirSync(path7).length === 0) {
+          fs.rmSync(path7, { recursive: true, force: true });
+          return resolve(ok(`Deleted ${path7}`));
         }
+        return resolve(ok(`Path ${path7} was not empty`));
       }
-      return resolve(ok(`Path ${path6} was not a directory`));
+      return resolve(ok(`Path ${path7} was not a directory`));
     } catch (error) {
       return reject(err(error));
     }
@@ -331,8 +330,8 @@ async function deleteEmptyFolders(dir) {
       return ok(`Path ${dir} does not exist`);
     const files3 = fs.readdirSync(dir);
     for (const file of files3) {
-      const p3 = join(dir, file);
-      if (isFolder2(p3)) {
+      const p3 = join4(dir, file);
+      if (isFolder(p3)) {
         if (fs.readdirSync(p3).length === 0)
           fs.rmSync(p3, { recursive: true, force: true });
         else
@@ -344,23 +343,23 @@ async function deleteEmptyFolders(dir) {
     return err(error);
   }
 }
-function deleteFile(path6) {
+function deleteFile(path7) {
   return new Promise((resolve, reject) => {
     try {
-      if (isFile(path6)) {
-        fs.rmSync(path6, { recursive: true, force: true });
-        return resolve(ok(`Deleted ${path6}`));
+      if (isFile(path7)) {
+        fs.rmSync(path7, { recursive: true, force: true });
+        return resolve(ok(`Deleted ${path7}`));
       }
-      return resolve(ok(`Path ${path6} was not a file`));
+      return resolve(ok(`Path ${path7} was not a file`));
     } catch (error) {
       return reject(err(error));
     }
   });
 }
-async function deleteGlob(path6) {
-  if (!path6.includes("*"))
-    return err(handleError(`Path ${path6} does not contain a glob`));
-  const directories = await default2([path6], { onlyDirectories: true });
+async function deleteGlob(path7) {
+  if (!path7.includes("*"))
+    return err(handleError(`Path ${path7} does not contain a glob`));
+  const directories = await default2([path7], { onlyDirectories: true });
   for (const directory of directories) {
     const result = await deleteFolder(directory);
     if (result.isErr()) {
@@ -371,14 +370,14 @@ async function deleteGlob(path6) {
   }
   return ok(`Deleted ${directories.length} directories`);
 }
-async function del(path6) {
-  if (isFile(path6))
-    return await deleteFile(path6);
-  if (isFolder2(path6))
-    return await deleteFolder(path6);
-  if (path6.includes("*"))
-    return await deleteGlob(path6);
-  return err(handleError(`Path ${path6} cannot be deleted due to an unhandled condition. Please report this issue.`));
+async function del(path7) {
+  if (isFile(path7))
+    return await deleteFile(path7);
+  if (isFolder(path7))
+    return await deleteFolder(path7);
+  if (path7.includes("*"))
+    return await deleteGlob(path7);
+  return err(handleError(`Path ${path7} cannot be deleted due to an unhandled condition. Please report this issue.`));
 }
 // src/zip.ts
 import {runCommand} from "@stacksjs/cli";
@@ -508,7 +507,7 @@ __export(exports_storage, {
   },
   isFolder: () => {
     {
-      return isFolder2;
+      return isFolder;
     }
   },
   isFile: () => {
@@ -668,7 +667,7 @@ __export(exports_storage, {
   },
   createFolder: () => {
     {
-      return createFolder2;
+      return createFolder;
     }
   },
   copyFolder: () => {
@@ -704,20 +703,18 @@ __export(exports_storage, {
 });
 
 // src/move.ts
-import {err as err2, ok as ok2} from "@stacksjs/error-handling";
+import {err as err2, handleError as handleError2, ok as ok2} from "@stacksjs/error-handling";
 import {log as log2} from "@stacksjs/logging";
-import {path as path7} from "@stacksjs/path";
+import {path as path8} from "@stacksjs/path";
 async function move(src, dest, options) {
   try {
     if (Array.isArray(src)) {
       const operations = src.map(async (file) => {
         const from2 = file;
-        const to2 = path7.resolve(dest, path7.basename(file));
+        const to2 = path8.resolve(dest, path8.basename(file));
         const result2 = await rename(from2, to2, options);
-        if (result2.isErr()) {
-          log2.error(result2.error);
-          return err2(handleError(result2.error.message, result2.error));
-        }
+        if (result2.isErr())
+          return log2.error(result2.error);
       });
       await Promise.all(operations);
       return ok2({ message: "Files moved successfully" });
@@ -727,17 +724,17 @@ async function move(src, dest, options) {
     const result = await rename(from, to, options);
     if (result.isErr()) {
       log2.error(result.error);
-      return err2(handleError(result.error));
+      return err2(handleError2(result.error));
     }
     return ok2({ message: "File moved successfully" });
   } catch (error) {
-    return err2(handleError(error));
+    return err2(handleError2(error));
   }
 }
 async function rename(from, to, options) {
   return new Promise((resolve, reject) => {
     try {
-      const dir = path7.dirname(to);
+      const dir = path8.dirname(to);
       if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
       if (!fs.existsSync(from))
@@ -778,7 +775,7 @@ export {
   readFileSync,
   put,
   mkdirSync,
-  isFolder2 as isFolder,
+  isFolder,
   isFile,
   isDirectoryEmpty,
   isDirectory,
@@ -815,7 +812,7 @@ export {
   del,
   deflateSync,
   decompress,
-  createFolder2 as createFolder,
+  createFolder,
   copyFolder,
   copyFile,
   copy,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/storage",
   "type": "module",
-  "version": "0.59.11",
+  "version": "0.61.1",
   "description": "The Stacks file system.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -58,7 +58,7 @@
     "@stacksjs/strings": "latest",
     "@stacksjs/types": "latest",
     "@types/archiver": "^6.0.2",
-    "archiver": "^7.0.0"
+    "archiver": "^7.0.1"
   },
   "dependencies": {
     "@stacksjs/arrays": "latest",
@@ -67,10 +67,10 @@
     "@stacksjs/strings": "latest",
     "@stacksjs/types": "latest",
     "@types/archiver": "^6.0.2",
-    "archiver": "^7.0.0",
+    "archiver": "^7.0.1",
     "fast-glob": "^3.3.2",
     "fs-extra": "^11.2.0",
-    "unstorage": "^1.10.1"
+    "unstorage": "^1.10.2"
   },
   "devDependencies": {
     "@stacksjs/development": "latest"

package/src/copy.ts

@@ -7,13 +7,9 @@ export function copy(src: string | string[], dest: string, exclude: string[] = [
     src.forEach((file) => {
       copy(file, dest, exclude)
     })
-  }
-  else {
-    if (fs.statSync(src).isDirectory())
-      copyFolder(src, dest, exclude)
-
-    else
-      copyFile(src, dest)
+  } else {
+    if (fs.statSync(src).isDirectory()) copyFolder(src, dest, exclude)
+    else copyFile(src, dest)
   }
 }
 
@@ -22,8 +18,7 @@ export function copyFile(src: string, dest: string): void {
 }
 
 export function copyFolder(src: string, dest: string, exclude: string[] = []): void {
-  if (!fs.existsSync(dest))
-    fs.mkdirSync(dest, { recursive: true })
+  if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true })
 
   if (fs.existsSync(src)) {
     fs.readdirSync(src).forEach((file) => {
@@ -31,11 +26,8 @@ export function copyFolder(src: string, dest: string, exclude: string[] = []): v
         const srcPath = join(src, file)
         const destPath = join(dest, file)
 
-        if (fs.statSync(srcPath).isDirectory())
-          copyFolder(srcPath, destPath, exclude)
-
-        else
-          fs.copyFileSync(srcPath, destPath)
+        if (fs.statSync(srcPath).isDirectory()) copyFolder(srcPath, destPath, exclude)
+        else fs.copyFileSync(srcPath, destPath)
       }
     })
   }

package/src/delete.ts

@@ -1,10 +1,11 @@
-import type { Result } from '@stacksjs/error-handling'
-import { err, ok } from '@stacksjs/error-handling'
 import { italic, log } from '@stacksjs/cli'
+import type { Result } from '@stacksjs/error-handling'
+import { err, handleError, ok } from '@stacksjs/error-handling'
+import { join } from '@stacksjs/path'
 import { isFile } from './files'
 import { isFolder } from './folders'
-import { glob } from './glob'
 import { fs } from './fs'
+import { glob } from './glob'
 
 export function deleteFolder(path: string): Promise<Result<string, Error>> {
   return new Promise((resolve, reject) => {
@@ -15,8 +16,7 @@ export function deleteFolder(path: string): Promise<Result<string, Error>> {
       }
 
       return resolve(ok(`Path ${path} was not a directory`))
-    }
-    catch (error) {
+    } catch (error) {
       return reject(err(error))
     }
   })
@@ -26,15 +26,12 @@ export async function isDirectoryEmpty(path: string): Promise<Result<boolean, Er
   return new Promise((resolve, reject) => {
     try {
       if (fs.statSync(path).isDirectory()) {
-        if (fs.readdirSync(path).length === 0)
-          return resolve(ok(true))
-        else
-          return resolve(ok(false))
+        if (fs.readdirSync(path).length === 0) return resolve(ok(true))
+        return resolve(ok(false))
       }
 
       return resolve(ok(false))
-    }
-    catch (error) {
+    } catch (error) {
       return reject(err(error))
     }
   })
@@ -48,12 +45,12 @@ export async function deleteEmptyFolder(path: string): Promise<Result<string, Er
           fs.rmSync(path, { recursive: true, force: true })
           return resolve(ok(`Deleted ${path}`))
         }
-        else { return resolve(ok(`Path ${path} was not empty`)) }
+
+        return resolve(ok(`Path ${path} was not empty`))
       }
 
       return resolve(ok(`Path ${path} was not a directory`))
-    }
-    catch (error) {
+    } catch (error) {
       return reject(err(error))
     }
   })
@@ -61,23 +58,19 @@ export async function deleteEmptyFolder(path: string): Promise<Result<string, Er
 
 export async function deleteEmptyFolders(dir: string): Promise<Result<string, Error>> {
   try {
-    if (!fs.existsSync(dir))
-      return ok(`Path ${dir} does not exist`)
+    if (!fs.existsSync(dir)) return ok(`Path ${dir} does not exist`)
 
     const files = fs.readdirSync(dir)
     for (const file of files) {
       const p = join(dir, file)
       if (isFolder(p)) {
-        if (fs.readdirSync(p).length === 0)
-          fs.rmSync(p, { recursive: true, force: true })
-        else
-          await deleteEmptyFolders(p)
+        if (fs.readdirSync(p).length === 0) fs.rmSync(p, { recursive: true, force: true })
+        else await deleteEmptyFolders(p)
       }
     }
 
     return ok(`Deleted empty folders located in ${dir}`)
-  }
-  catch (error: any) {
+  } catch (error: any) {
     return err(error)
   }
 }
@@ -91,16 +84,14 @@ export function deleteFile(path: string): Promise<Result<string, Error>> {
       }
 
       return resolve(ok(`Path ${path} was not a file`))
-    }
-    catch (error) {
+    } catch (error) {
       return reject(err(error))
     }
   })
 }
 
 export async function deleteGlob(path: string): Promise<Result<string, Error>> {
-  if (!path.includes('*'))
-    return err(handleError(`Path ${path} does not contain a glob`))
+  if (!path.includes('*')) return err(handleError(`Path ${path} does not contain a glob`))
 
   const directories = await glob([path], { onlyDirectories: true })
 
@@ -118,14 +109,11 @@ export async function deleteGlob(path: string): Promise<Result<string, Error>> {
 }
 
 export async function del(path: string): Promise<Result<string, Error>> {
-  if (isFile(path))
-    return await deleteFile(path)
+  if (isFile(path)) return await deleteFile(path)
 
-  if (isFolder(path))
-    return await deleteFolder(path)
+  if (isFolder(path)) return await deleteFolder(path)
 
-  if (path.includes('*'))
-    return await deleteGlob(path)
+  if (path.includes('*')) return await deleteGlob(path)
 
   return err(handleError(`Path ${path} cannot be deleted due to an unhandled condition. Please report this issue.`))
 }

package/src/drivers/aws.ts

@@ -1,15 +1,12 @@
-import type { NestedStackProps } from 'aws-cdk-lib'
+// import type { NestedStackProps } from 'aws-cdk-lib'
 import { NestedStack } from 'aws-cdk-lib'
-import type { Construct } from 'constructs'
+// import type { Construct } from 'constructs'
 
 export class StorageStack extends NestedStack {
-  constructor(scope: Construct, id: string, props?: NestedStackProps) {
-    super(scope, id, props)
-
-    // if (!storage.name)
-    //   throw new Error('./config storage.name is not defined')
-
-    // // eslint-disable-next-line no-new
-    // new s3.Bucket(this, storage.name)
-  }
+  // constructor(scope: Construct, id: string, props?: NestedStackProps) {
+  //   super(scope, id, props)
+  // if (!storage.name)
+  //   throw new Error('./config storage.name is not defined')
+  // new s3.Bucket(this, storage.name)
+  // }
 }

package/src/files.ts

@@ -1,8 +1,9 @@
-import type { JsonFile, PackageJson, TextFile } from '@stacksjs/types'
-import { detectIndent, detectNewline } from '@stacksjs/strings'
-import { dirname, join, path as p } from '@stacksjs/path'
 import { contains } from '@stacksjs/arrays'
-import { existsSync, fs } from './fs'
+import { dirname, join, path as p } from '@stacksjs/path'
+import { createFolder, isFolder } from '@stacksjs/storage'
+import { detectIndent, detectNewline } from '@stacksjs/strings'
+import type { JsonFile, PackageJson, TextFile } from '@stacksjs/types'
+import { fs, existsSync } from './fs'
 
 /**
  * Reads a JSON file and returns the parsed data.
@@ -28,11 +29,10 @@ export async function readPackageJson(name: string, cwd?: string) {
  * Writes the given text to the specified file.
  */
 export async function writeFile(path: string, data: any): Promise<number> {
-// export async function writeFile(path: Path, data: Data): Promise<number> {
+  // export async function writeFile(path: Path, data: Data): Promise<number> {
   if (typeof path === 'string') {
     const dirPath = dirname(path)
-    if (!await existsSync(dirPath))
-      await createFolder(dirPath)
+    if (!(await existsSync(dirPath))) await createFolder(dirPath)
 
     return await Bun.write(Bun.file(path), data)
   }
@@ -46,8 +46,7 @@ export async function writeFile(path: string, data: any): Promise<number> {
 export async function writeJsonFile(file: JsonFile): Promise<number> {
   let json = JSON.stringify(file.data, undefined, file.indent)
 
-  if (file.newline)
-    json += file.newline
+  if (file.newline) json += file.newline
 
   return writeTextFile({ ...file, data: json })
 }
@@ -59,16 +58,13 @@ export function readTextFile(name: string, cwd?: string): Promise<TextFile> {
   return new Promise((resolve, reject) => {
     let filePath: string
 
-    if (cwd)
-      filePath = join(cwd, name)
-    else
-      filePath = name
+    if (cwd) filePath = join(cwd, name)
+    else filePath = name
 
     fs.readFile(filePath, 'utf8', (err, text) => {
       if (err) {
         reject(err)
-      }
-      else {
+      } else {
         resolve({
           path: filePath,
           data: text,
@@ -106,8 +102,7 @@ export function doesNotExist(path: string): boolean {
 export function hasFiles(folder: string): boolean {
   try {
     return fs.readdirSync(folder).length > 0
-  }
-  catch (err) {
+  } catch (err) {
     return false
   }
 }
@@ -125,14 +120,9 @@ export function deleteFiles(dir: string, exclude: string[] = []) {
     fs.readdirSync(dir).forEach((file) => {
       const p = join(dir, file)
       if (fs.statSync(p).isDirectory()) {
-        if (fs.readdirSync(p).length === 0)
-          fs.rmSync(p, { recursive: true, force: true })
-
-        else
-          deleteFiles(p, exclude)
-      }
-
-      else if (!contains(p, exclude)) {
+        if (fs.readdirSync(p).length === 0) fs.rmSync(p, { recursive: true, force: true })
+        else deleteFiles(p, exclude)
+      } else if (!contains(p, exclude)) {
         fs.rmSync(p)
       }
     })
@@ -147,11 +137,8 @@ export function getFiles(dir: string, exclude: string[] = []): string[] {
     file = join(dir, file)
     const stat = fs.statSync(file)
 
-    if (stat && stat.isDirectory())
-      results = results.concat(getFiles(file, exclude))
-
-    else if (!contains(file, exclude))
-      results.push(file)
+    if (stat.isDirectory()) results = results.concat(getFiles(file, exclude))
+    else if (!contains(file, exclude)) results.push(file)
   })
 
   return results
@@ -160,8 +147,7 @@ export function getFiles(dir: string, exclude: string[] = []): string[] {
 export function put(path: string, contents: string) {
   const dirPath = dirname(path)
 
-  if (!fs.existsSync(dirPath))
-    fs.mkdirSync(dirPath, { recursive: true })
+  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true })
 
   fs.writeFileSync(path, contents, 'utf-8')
 }

package/src/folders.ts

@@ -7,8 +7,7 @@ import { fs } from './fs'
 export function isFolder(path: string): boolean {
   try {
     return fs.statSync(path).isDirectory()
-  }
-  catch {
+  } catch {
     return false
   }
 }
@@ -28,11 +27,8 @@ export function doesFolderExist(path: string) {
 export function createFolder(dir: string): Promise<void> {
   return new Promise((resolve, reject) => {
     fs.mkdirs(dir, (err: any) => {
-      if (err)
-        reject(err)
-
-      else
-        resolve()
+      if (err) reject(err)
+      else resolve()
     })
   })
 }

package/src/hash.ts

@@ -17,8 +17,7 @@ export function hashFileOrDirectory(path: string, hash: Hash): void {
       const filePath = p.join(path, file)
       hashFileOrDirectory(filePath, hash)
     }
-  }
-  else {
+  } else {
     hash.update(fs.readFileSync(path))
   }
 }
@@ -39,8 +38,7 @@ export function hashPaths(paths: string | string[]): string {
   const hash = createHash('sha256')
   const pathsArray = Array.isArray(paths) ? paths : [paths]
 
-  for (const path of pathsArray)
-    hashFileOrDirectory(path, hash)
+  for (const path of pathsArray) hashFileOrDirectory(path, hash)
 
   return hash.digest('hex')
 }

package/src/helpers.ts

@@ -2,22 +2,18 @@ import { fileURLToPath } from 'node:url'
 import { dirname } from '@stacksjs/path'
 import { fs } from './fs'
 
-export const _dirname = typeof __dirname !== 'undefined'
-  ? __dirname
-  : dirname(fileURLToPath(import.meta.url))
+export const _dirname = typeof __dirname !== 'undefined' ? __dirname : dirname(fileURLToPath(import.meta.url))
 
 export function updateConfigFile(filePath: string, newConfig: Record<string, unknown>): Promise<void> {
   return new Promise((resolve, reject) => {
     const config = JSON.parse(fs.readFileSync(filePath, 'utf8')) as Record<string, unknown>
 
-    for (const key in newConfig)
-      config[key] = newConfig[key]
+    for (const key in newConfig) config[key] = newConfig[key]
 
     try {
       fs.writeFileSync(filePath, JSON.stringify(config, null, 2))
       resolve()
-    }
-    catch (error) {
+    } catch (error) {
       reject(error)
     }
   })

package/src/move.ts

@@ -1,4 +1,4 @@
-import { type Result, err, ok } from '@stacksjs/error-handling'
+import { type Result, err, handleError, ok } from '@stacksjs/error-handling'
 import { log } from '@stacksjs/logging'
 import { path } from '@stacksjs/path'
 import { fs } from './fs'
@@ -20,10 +20,7 @@ export async function move(
         const to = path.resolve(dest, path.basename(file))
         const result = await rename(from, to, options)
 
-        if (result.isErr()) {
-          log.error(result.error)
-          return err(handleError(result.error.message, result.error))
-        }
+        if (result.isErr()) return log.error(result.error)
       })
 
       await Promise.all(operations)
@@ -41,28 +38,28 @@ export async function move(
     }
 
     return ok({ message: 'File moved successfully' })
-  }
-  catch (error: any) {
+  } catch (error: any) {
     return err(handleError(error))
   }
 }
 
-export async function rename(from: string, to: string, options?: MoveOptions): Promise<Result<{ message: string }, Error>> {
+export async function rename(
+  from: string,
+  to: string,
+  options?: MoveOptions,
+): Promise<Result<{ message: string }, Error>> {
   return new Promise((resolve, reject) => {
     try {
       // Check if the "to" directory exists
       const dir = path.dirname(to)
-      if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true })
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
 
       // Ensure the "from" file exists
-      if (!fs.existsSync(from))
-        return reject(err(new Error(`File or directory does not exist: ${from}`)))
+      if (!fs.existsSync(from)) return reject(err(new Error(`File or directory does not exist: ${from}`)))
 
       // Ensure the "to" file does not exist
       if (fs.existsSync(to)) {
-        if (!options?.overwrite)
-          return reject(err(new Error(`File or directory already exists: ${to}`)))
+        if (!options?.overwrite) return reject(err(new Error(`File or directory already exists: ${to}`)))
 
         fs.unlinkSync(to)
       }
@@ -71,12 +68,9 @@ export async function rename(from: string, to: string, options?: MoveOptions): P
       fs.renameSync(from, to)
 
       return resolve(ok({ message: 'File moved successfully' }))
-    }
-    catch (error: any) {
-      if (error.code === 'ENOENT')
-        log.error('File or directory does not exist\n\n', error)
-      else
-        log.error(error)
+    } catch (error: any) {
+      if (error.code === 'ENOENT') log.error('File or directory does not exist\n\n', error)
+      else log.error(error)
 
       return reject(err(new Error(error)))
     }

package/src/zip.ts

@@ -1,5 +1,5 @@
-import type { ZlibCompressionOptions } from 'bun'
 import { runCommand } from '@stacksjs/cli'
+import type { ZlibCompressionOptions } from 'bun'
 
 interface ZipOptions {
   cwd?: string
@@ -9,15 +9,13 @@ export async function zip(from: string | string[], to?: string, options?: ZipOpt
   const toPath = to || 'archive.zip'
   const fromPath = Array.isArray(from) ? from.join(' ') : from
 
-  if (Array.isArray(from))
-    return runCommand(`zip -r ${toPath} ${fromPath}`, options)
+  if (Array.isArray(from)) return runCommand(`zip -r ${toPath} ${fromPath}`, options)
 
   return runCommand(`zip -r ${to} ${from}`, options)
 }
 
 export async function unzip(paths: string | string[]) {
-  if (Array.isArray(paths))
-    return runCommand(`unzip ${paths.join(' ')}`)
+  if (Array.isArray(paths)) return runCommand(`unzip ${paths.join(' ')}`)
 
   return runCommand(`unzip ${paths}`)
 }

package/dist/copy.d.ts

@@ -1,3 +0,0 @@
-export declare function copy(src: string | string[], dest: string, exclude?: string[]): void;
-export declare function copyFile(src: string, dest: string): void;
-export declare function copyFolder(src: string, dest: string, exclude?: string[]): void;

package/dist/delete.d.ts

@@ -1,8 +0,0 @@
-import type { Result } from '@stacksjs/error-handling';
-export declare function deleteFolder(path: string): Promise<Result<string, Error>>;
-export declare function isDirectoryEmpty(path: string): Promise<Result<boolean, Error>>;
-export declare function deleteEmptyFolder(path: string): Promise<Result<string, Error>>;
-export declare function deleteEmptyFolders(dir: string): Promise<Result<string, Error>>;
-export declare function deleteFile(path: string): Promise<Result<string, Error>>;
-export declare function deleteGlob(path: string): Promise<Result<string, Error>>;
-export declare function del(path: string): Promise<Result<string, Error>>;

package/dist/files.d.ts

@@ -1,56 +0,0 @@
-import type { JsonFile, TextFile } from '@stacksjs/types';
-/**
- * Reads a JSON file and returns the parsed data.
- */
-export declare function readJsonFile(name: string, cwd?: string): Promise<JsonFile>;
-/**
- * Reads a package.json file and returns the parsed data.
- */
-export declare function readPackageJson(name: string, cwd?: string): Promise<PackageJson>;
-/**
- * Writes the given text to the specified file.
- */
-export declare function writeFile(path: string, data: any): Promise<number>;
-/**
- * Writes the given data to the specified JSON file.
- */
-export declare function writeJsonFile(file: JsonFile): Promise<number>;
-/**
- * Reads a text file and returns its contents.
- */
-export declare function readTextFile(name: string, cwd?: string): Promise<TextFile>;
-/**
- * Writes the given text to the specified file.
- */
-export declare function writeTextFile(file: TextFile): Promise<number>;
-/**
- * Determine whether a path exists.
- */
-export declare function isFile(path: string): boolean;
-export declare function doesExist(path: string): boolean;
-export declare function doesNotExist(path: string): boolean;
-/**
- * Determine whether a folder has any files in it.
- */
-export declare function hasFiles(folder: string): boolean;
-export declare function hasComponents(): boolean;
-export declare function hasFunctions(): boolean;
-export declare function deleteFiles(dir: string, exclude?: string[]): void;
-export declare function getFiles(dir: string, exclude?: string[]): string[];
-export declare function put(path: string, contents: string): void;
-export declare function get(path: string): Promise<string>;
-export declare const files: {
-    readJsonFile: typeof readJsonFile;
-    readPackageJson: typeof readPackageJson;
-    readTextFile: typeof readTextFile;
-    writeJsonFile: typeof writeJsonFile;
-    writeTextFile: typeof writeTextFile;
-    isFile: typeof isFile;
-    hasFiles: typeof hasFiles;
-    hasComponents: typeof hasComponents;
-    hasFunctions: typeof hasFunctions;
-    deleteFiles: typeof deleteFiles;
-    getFiles: typeof getFiles;
-    put: typeof put;
-    get: typeof get;
-};

package/dist/folders.d.ts

@@ -1,15 +0,0 @@
-/**
- * Determine whether a path is a folder.
- */
-export declare function isFolder(path: string): boolean;
-export declare function isDirectory(path: string): boolean;
-export declare function isDir(path: string): boolean;
-export declare function doesFolderExist(path: string): boolean;
-export declare function createFolder(dir: string): Promise<void>;
-export declare function getFolders(dir: string): string[];
-export declare const folders: {
-    isFolder: typeof isFolder;
-    doesFolderExist: typeof doesFolderExist;
-    createFolder: typeof createFolder;
-    getFolders: typeof getFolders;
-};

package/dist/fs.d.ts

@@ -1,4 +0,0 @@
-import * as fs from 'fs-extra';
-import { pathExists as existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs-extra';
-export declare function exists(path: string): Promise<boolean>;
-export { fs, existsSync, mkdirSync, writeFileSync, readFileSync };

package/dist/glob.d.ts

@@ -1 +0,0 @@
-export { default as glob } from 'fast-glob';

package/dist/hash.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-import type { Hash } from 'node:crypto';
-export declare function hashFileOrDirectory(path: string, hash: Hash): void;
-export declare function hashDirectory(directory: string): string;
-export declare function hashPath(path: string): string;
-export declare function hashPaths(paths: string | string[]): string;

package/dist/helpers.d.ts

@@ -1,6 +0,0 @@
-export declare const _dirname: string;
-export declare function updateConfigFile(filePath: string, newConfig: Record<string, unknown>): Promise<void>;
-export declare const helpers: {
-    _dirname: string;
-    updateConfigFile: typeof updateConfigFile;
-};

package/dist/index.d.ts

@@ -1,10 +0,0 @@
-export * from './files';
-export * from './folders';
-export * from './hash';
-export * from './helpers';
-export * from './fs';
-export * from './copy';
-export * from './glob';
-export * from './delete';
-export * from './zip';
-export * as storage from './storage';

package/dist/move.d.ts

@@ -1,11 +0,0 @@
-import { type Result } from '@stacksjs/error-handling';
-interface MoveOptions {
-    overwrite?: boolean;
-}
-export declare function move(src: string | string[], dest: string, options?: MoveOptions): Promise<Result<{
-    message: string;
-}, Error>>;
-export declare function rename(from: string, to: string, options?: MoveOptions): Promise<Result<{
-    message: string;
-}, Error>>;
-export {};

package/dist/storage.d.ts

@@ -1,9 +0,0 @@
-export * from './files';
-export * from './folders';
-export * from './helpers';
-export * from './fs';
-export * from './copy';
-export * from './delete';
-export * from './move';
-export * from './zip';
-export * from './visibility';

package/dist/visibility.d.ts

@@ -1 +0,0 @@
-export declare function setVisibility(): string;

package/dist/zip.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="bun-types" />
-/// <reference types="bun-types" />
-import type { ZlibCompressionOptions } from 'bun';
-interface ZipOptions {
-    cwd?: string;
-}
-export declare function zip(from: string | string[], to?: string, options?: ZipOptions): Promise<import("neverthrow").Result<Subprocess, CommandError>>;
-export declare function unzip(paths: string | string[]): Promise<import("neverthrow").Result<Subprocess, CommandError>>;
-export declare function archive(paths: string | string[]): Promise<import("neverthrow").Result<Subprocess, CommandError>>;
-export declare function unarchive(paths: string | string[]): Promise<import("neverthrow").Result<Subprocess, CommandError>>;
-export declare function compress(paths: string[]): Promise<import("neverthrow").Result<Subprocess, CommandError>>;
-export declare function decompress(paths: string | string[]): Promise<import("neverthrow").Result<Subprocess, CommandError>>;
-export declare function gzipSync(data: Uint8Array, options?: ZlibCompressionOptions): Uint8Array;
-export declare function gunzipSync(data: Uint8Array): Uint8Array;
-export declare function deflateSync(data: Uint8Array, options?: ZlibCompressionOptions): Uint8Array;
-export declare function inflateSync(data: Uint8Array): Uint8Array;
-export {};