@stacksjs/storage 0.64.5 → 0.65.0

package/dist/move.d.ts

@@ -0,0 +1,7 @@
+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

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

package/dist/visibility.d.ts

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

package/dist/zip.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from "@stacksjs/error-handling";
+import type { CommandError, Subprocess } from "@stacksjs/types";
+import type { ZlibCompressionOptions } from "bun";
+interface ZipOptions {
+	cwd?: string;
+}
+export declare function zip(from: string | string[], to?: string, options?: ZipOptions): Promise<Result<Subprocess, CommandError>>;
+export declare function unzip(paths: string | string[]): Promise<Result<Subprocess, CommandError>>;
+export declare function archive(paths: string | string[]): Promise<Result<Subprocess, CommandError>>;
+export declare function unarchive(paths: string | string[]): Promise<Result<Subprocess, CommandError>>;
+export declare function compress(paths: string[]): Promise<Result<Subprocess, CommandError>>;
+export declare function decompress(paths: string | string[]): Promise<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 {};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/storage",
   "type": "module",
-  "version": "0.64.5",
+  "version": "0.65.0",
   "description": "The Stacks file system.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/storage#readme",
@@ -37,32 +38,25 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/arrays": "latest",
-    "@stacksjs/error-handling": "latest",
-    "@stacksjs/path": "latest",
-    "@stacksjs/strings": "latest",
-    "@stacksjs/types": "latest",
+    "@stacksjs/arrays": "0.64.6",
+    "@stacksjs/error-handling": "0.64.6",
+    "@stacksjs/path": "0.64.6",
+    "@stacksjs/strings": "0.64.6",
+    "@stacksjs/types": "0.64.6",
     "@types/archiver": "^6.0.2",
     "archiver": "^7.0.1",
-    "fast-glob": "^3.3.2",
     "fs-extra": "^11.2.0",
-    "unstorage": "^1.10.2"
+    "tinyglobby": "^0.2.9",
+    "unstorage": "^1.12.0"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest"
+    "@stacksjs/development": "0.64.6"
   }
 }

package/src/copy.ts

@@ -7,8 +7,10 @@ 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 {
+    if (fs.statSync(src).isDirectory())
+      copyFolder(src, dest, exclude)
     else copyFile(src, dest)
   }
 }
@@ -18,7 +20,8 @@ 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) => {
@@ -26,7 +29,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)
+        if (fs.statSync(srcPath).isDirectory())
+          copyFolder(srcPath, destPath, exclude)
         else fs.copyFileSync(srcPath, destPath)
       }
     })

package/src/delete.ts

@@ -1,5 +1,5 @@
-import { italic, log } from '@stacksjs/cli'
 import type { Result } from '@stacksjs/error-handling'
+import { italic, log } from '@stacksjs/cli'
 import { err, handleError, ok } from '@stacksjs/error-handling'
 import { join } from '@stacksjs/path'
 import { isFile } from './files'
@@ -16,7 +16,8 @@ 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,12 +27,14 @@ 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))
+        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))
     }
   })
@@ -50,7 +53,8 @@ export async function deleteEmptyFolder(path: string): Promise<Result<string, Er
       }
 
       return resolve(ok(`Path ${path} was not a directory`))
-    } catch (error) {
+    }
+    catch (error) {
       return reject(err(error))
     }
   })
@@ -58,19 +62,22 @@ 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 })
+        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)
   }
 }
@@ -84,14 +91,16 @@ 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 })
 
@@ -109,11 +118,14 @@ 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/files.ts

@@ -1,9 +1,10 @@
+import type { JsonFile, PackageJson, TextFile } from '@stacksjs/types'
 import { contains } from '@stacksjs/arrays'
+import { log } from '@stacksjs/logging'
 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'
+import { createFolder, isFolder } from './'
+import { existsSync, fs } from './fs'
 
 /**
  * Reads a JSON file and returns the parsed data.
@@ -20,7 +21,7 @@ export async function readJsonFile(name: string, cwd?: string): Promise<JsonFile
 /**
  * Reads a package.json file and returns the parsed data.
  */
-export async function readPackageJson(name: string, cwd?: string) {
+export async function readPackageJson(name: string, cwd?: string): Promise<PackageJson> {
   const file = await readJsonFile(name, cwd)
   return file.data as PackageJson
 }
@@ -32,7 +33,8 @@ export async function writeFile(path: string, data: any): 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,7 +48,8 @@ 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 })
 }
@@ -58,13 +61,15 @@ export function readTextFile(name: string, cwd?: string): Promise<TextFile> {
   return new Promise((resolve, reject) => {
     let filePath: string
 
-    if (cwd) filePath = join(cwd, 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,
@@ -102,7 +107,9 @@ export function doesNotExist(path: string): boolean {
 export function hasFiles(folder: string): boolean {
   try {
     return fs.readdirSync(folder).length > 0
-  } catch (err) {
+  }
+  catch (err) {
+    log.debug(`Error reading folder: ${folder}`, err)
     return false
   }
 }
@@ -115,14 +122,16 @@ export function hasFunctions(): boolean {
   return hasFiles(p.functionsPath())
 }
 
-export function deleteFiles(dir: string, exclude: string[] = []) {
+export function deleteFiles(dir: string, exclude: string[] = []): void {
   if (fs.existsSync(dir)) {
     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 })
+        if (fs.readdirSync(p).length === 0)
+          fs.rmSync(p, { recursive: true, force: true })
         else deleteFiles(p, exclude)
-      } else if (!contains(p, exclude)) {
+      }
+      else if (!contains(p, exclude)) {
         fs.rmSync(p)
       }
     })
@@ -137,17 +146,20 @@ export function getFiles(dir: string, exclude: string[] = []): string[] {
     file = join(dir, file)
     const stat = fs.statSync(file)
 
-    if (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
 }
 
-export function put(path: string, contents: string) {
+export function put(path: string, contents: string): void {
   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')
 }
@@ -156,7 +168,23 @@ export async function get(path: string): Promise<string> {
   return Bun.file(path).text()
 }
 
-export const files = {
+export interface 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
+}
+
+export const files: Files = {
   readJsonFile,
   readPackageJson,
   readTextFile,

package/src/folders.ts

@@ -7,7 +7,8 @@ import { fs } from './fs'
 export function isFolder(path: string): boolean {
   try {
     return fs.statSync(path).isDirectory()
-  } catch {
+  }
+  catch {
     return false
   }
 }
@@ -20,14 +21,15 @@ export function isDir(path: string): boolean {
   return isFolder(path)
 }
 
-export function doesFolderExist(path: string) {
+export function doesFolderExist(path: string): boolean {
   return fs.existsSync(path)
 }
 
 export function createFolder(dir: string): Promise<void> {
   return new Promise((resolve, reject) => {
     fs.mkdirs(dir, (err: any) => {
-      if (err) reject(err)
+      if (err)
+        reject(err)
       else resolve()
     })
   })
@@ -39,7 +41,14 @@ export function getFolders(dir: string): string[] {
   })
 }
 
-export const folders = {
+export interface Folders {
+  isFolder: (path: string) => boolean
+  doesFolderExist: (path: string) => boolean
+  createFolder: (dir: string) => Promise<void>
+  getFolders: (dir: string) => string[]
+}
+
+export const folders: Folders = {
   isFolder,
   doesFolderExist,
   createFolder,

package/src/fs.ts

@@ -5,4 +5,4 @@ export async function exists(path: string): Promise<boolean> {
   return await existsSync(path)
 }
 
-export { fs, existsSync, mkdirSync, writeFileSync, readFileSync, fsWatch, watchFile }
+export { existsSync, fs, fsWatch, mkdirSync, readFileSync, watchFile, writeFileSync }

package/src/glob.ts

@@ -1 +1,23 @@
-export { default as glob } from 'fast-glob'
+import { globSync as gs } from 'tinyglobby'
+
+export { glob } from 'tinyglobby'
+
+export interface GlobOptions {
+  absolute?: boolean
+  cwd?: string
+  patterns?: string[]
+  ignore?: string[]
+  dot?: boolean
+  deep?: number
+  expandDirectories?: boolean
+  onlyDirectories?: boolean
+  onlyFiles?: boolean
+}
+
+export function globSync(patterns: string | string[], options?: Omit<GlobOptions, 'patterns'>): string[] {
+  if (typeof patterns === 'string') {
+    return gs([patterns], options)
+  }
+
+  return gs(patterns, options)
+}

package/src/hash.ts

@@ -17,7 +17,8 @@ export function hashFileOrDirectory(path: string, hash: Hash): void {
       const filePath = p.join(path, file)
       hashFileOrDirectory(filePath, hash)
     }
-  } else {
+  }
+  else {
     hash.update(fs.readFileSync(path))
   }
 }

package/src/helpers.ts

@@ -2,7 +2,7 @@ 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: string = 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) => {
@@ -13,13 +13,19 @@ export function updateConfigFile(filePath: string, newConfig: Record<string, unk
     try {
       fs.writeFileSync(filePath, JSON.stringify(config, null, 2))
       resolve()
-    } catch (error) {
+    }
+    catch (error) {
       reject(error)
     }
   })
 }
 
-export const helpers = {
+interface Helpers {
+  _dirname: string
+  updateConfigFile: (filePath: string, newConfig: Record<string, unknown>) => Promise<void>
+}
+
+export const helpers: Helpers = {
   _dirname,
   updateConfigFile,
 }

package/src/index.ts

@@ -1,11 +1,11 @@
+export * from './copy'
+export * from './delete'
 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 * from './hash'
+export * from './helpers'
 export * as storage from './storage'
+
+export * from './zip'

package/src/move.ts

@@ -1,4 +1,4 @@
-import { type Result, err, handleError, ok } from '@stacksjs/error-handling'
+import { err, handleError, ok, type Result } from '@stacksjs/error-handling'
 import { log } from '@stacksjs/logging'
 import { path } from '@stacksjs/path'
 import { fs } from './fs'
@@ -20,7 +20,8 @@ export async function move(
         const to = path.resolve(dest, path.basename(file))
         const result = await rename(from, to, options)
 
-        if (result.isErr()) return log.error(result.error)
+        if (result.isErr())
+          return log.error(result.error)
       })
 
       await Promise.all(operations)
@@ -38,7 +39,8 @@ export async function move(
     }
 
     return ok({ message: 'File moved successfully' })
-  } catch (error: any) {
+  }
+  catch (error: any) {
     return err(handleError(error))
   }
 }
@@ -52,14 +54,17 @@ export async function rename(
     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)
       }
@@ -68,8 +73,10 @@ export async function rename(
       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)
+    }
+    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/storage.ts

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

package/src/visibility.ts

@@ -1,6 +1,6 @@
 // type Visibility = 'public' | 'private'
 
 // export function setVisibility(path: string, visibility: Visibility) {
-export function setVisibility() {
+export function setVisibility(): string {
   return 'wip'
 }

package/src/zip.ts

@@ -1,53 +1,61 @@
-import { runCommand } from '@stacksjs/cli'
+import type { Result } from '@stacksjs/error-handling'
+import type { CommandError, Subprocess } from '@stacksjs/types'
 import type { ZlibCompressionOptions } from 'bun'
+import { runCommand } from '@stacksjs/cli'
 
 interface ZipOptions {
   cwd?: string
 }
 
-export async function zip(from: string | string[], to?: string, options?: ZipOptions) {
+export async function zip(
+  from: string | string[],
+  to?: string,
+  options?: ZipOptions,
+): Promise<Result<Subprocess, CommandError>> {
   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(' ')}`)
+export async function unzip(paths: string | string[]): Promise<Result<Subprocess, CommandError>> {
+  if (Array.isArray(paths))
+    return runCommand(`unzip ${paths.join(' ')}`)
 
   return runCommand(`unzip ${paths}`)
 }
 
-export function archive(paths: string | string[]) {
+export function archive(paths: string | string[]): Promise<Result<Subprocess, CommandError>> {
   return zip(paths)
 }
 
-export function unarchive(paths: string | string[]) {
+export function unarchive(paths: string | string[]): Promise<Result<Subprocess, CommandError>> {
   return unzip(paths)
 }
 
-export function compress(paths: string[]) {
+export function compress(paths: string[]): Promise<Result<Subprocess, CommandError>> {
   return zip(paths)
 }
 
-export function decompress(paths: string | string[]) {
+export function decompress(paths: string | string[]): Promise<Result<Subprocess, CommandError>> {
   return unzip(paths)
 }
 
-export function gzipSync(data: Uint8Array, options?: ZlibCompressionOptions) {
+export function gzipSync(data: Uint8Array, options?: ZlibCompressionOptions): Uint8Array {
   return Bun.gzipSync(data, options) // buffer extends Uint8Array
 }
 
-export function gunzipSync(data: Uint8Array) {
+export function gunzipSync(data: Uint8Array): Uint8Array {
   return Bun.gunzipSync(data) // decompressed
 }
 
-export function deflateSync(data: Uint8Array, options?: ZlibCompressionOptions) {
+export function deflateSync(data: Uint8Array, options?: ZlibCompressionOptions): Uint8Array {
   return Bun.deflateSync(data, options) // compressed
 }
 
-export function inflateSync(data: Uint8Array) {
+export function inflateSync(data: Uint8Array): Uint8Array {
   return Bun.inflateSync(data) // decompressed
 }