@stacksjs/storage 0.57.4 → 0.58.20

package/README.md

@@ -12,7 +12,7 @@ This package contains the Stacks File System source.
 ## 🤖 Usage
 
 ```bash
-pnpm i -D @stacksjs/storage
+bun install -d @stacksjs/storage
 ```
 
 Now, you can use it in your project:
@@ -20,33 +20,33 @@ Now, you can use it in your project:
 ```js
 import {
   _dirname,
-  readJsonFile,
-  writeJsonFile,
-  readTextFile,
-  writeTextFile,
-  isFolder,
-  isFile,
-  hasFiles,
-  hasComponents,
-  hasFunctions,
   copyFolder,
-  deleteFolder,
-  deleteFiles,
   deleteEmptyFolders,
+  deleteFiles,
+  deleteFolder,
   doesFolderExist,
-  fs, // fs-extra Node module
   fileURLToPath,
+  fs, // fs-extra Node module
+  hasComponents,
+  hasFiles,
+  hasFunctions,
+  isFile,
+  isFolder,
+  readJsonFile,
+  readTextFile,
+  writeJsonFile,
+  writeTextFile,
 } from '@stacksjs/storage'
 
 // wip
 ```
 
-To view the full documentation, please visit [https://stacksjs.dev/storage](https://stacksjs.dev/storage).
+To view the full documentation, please visit [https://stacksjs.org/storage](https://stacksjs.org/storage).
 
 ## 🧪 Testing
 
 ```bash
-pnpm test
+bun test
 ```
 
 ## 📈 Changelog
@@ -65,10 +65,10 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.ow3.org)
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
 
 ## 📄 License
 
 The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
 
-Made with ❤️
+Made with 💙

package/dist/index.js

@@ -0,0 +1,798 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// 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";
+
+// src/fs.ts
+import {mkdirSync, writeFileSync} from "fs";
+import * as fs from "fs-extra";
+import {pathExists as existsSync} from "fs-extra";
+async function exists(path) {
+  return await existsSync(path);
+}
+
+// src/files.ts
+async function readJsonFile(name, cwd) {
+  const file = await readTextFile(name, cwd);
+  const data = JSON.parse(file.data);
+  const indent = detectIndent(file.data).indent;
+  const newline = detectNewline(file.data);
+  return { ...file, data, indent, newline };
+}
+async function readPackageJson(name, cwd) {
+  const file = await readJsonFile(name, cwd);
+  return file.data;
+}
+async function writeFile(path2, data) {
+  if (typeof path2 === "string") {
+    const dirPath = dirname(path2);
+    if (!await existsSync(dirPath))
+      await createFolder(dirPath);
+    return await Bun.write(Bun.file(path2), data);
+  }
+  return await Bun.write(path2, data);
+}
+async function writeJsonFile(file) {
+  let json = JSON.stringify(file.data, undefined, file.indent);
+  if (file.newline)
+    json += file.newline;
+  return writeTextFile({ ...file, data: json });
+}
+function readTextFile(name, cwd) {
+  return new Promise((resolve, reject) => {
+    let filePath;
+    if (cwd)
+      filePath = join2(cwd, name);
+    else
+      filePath = name;
+    fs.readFile(filePath, "utf8", (err, text) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          path: filePath,
+          data: text
+        });
+      }
+    });
+  });
+}
+async function writeTextFile(file) {
+  return await Bun.write(file.path, file.data);
+}
+function isFile(path2) {
+  return fs.existsSync(path2);
+}
+function hasFiles(folder) {
+  try {
+    return fs.default.readdirSync(folder).length > 0;
+  } catch (err) {
+    return false;
+  }
+}
+function hasComponents() {
+  return hasFiles(p.componentsPath());
+}
+function hasFunctions() {
+  return hasFiles(p.functionsPath());
+}
+function deleteFiles(dir, exclude = []) {
+  if (fs.existsSync(dir)) {
+    fs.readdirSync(dir).forEach((file) => {
+      const p2 = join2(dir, file);
+      if (fs.statSync(p2).isDirectory()) {
+        if (fs.readdirSync(p2).length === 0)
+          fs.rmSync(p2, { recursive: true, force: true });
+        else
+          deleteFiles(p2, exclude);
+      } else if (!contains(p2, exclude)) {
+        fs.rmSync(p2);
+      }
+    });
+  }
+}
+function getFiles(dir, exclude = []) {
+  let results = [];
+  const list = fs.readdirSync(dir);
+  list.forEach((file) => {
+    file = join2(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);
+  });
+  return results;
+}
+function put(path2, contents) {
+  const dirPath = dirname(path2);
+  if (!fs.existsSync(dirPath))
+    fs.mkdirSync(dirPath, { recursive: true });
+  fs.writeFileSync(path2, contents, "utf-8");
+}
+async function get(path2) {
+  return Bun.file(path2).text();
+}
+var files = {
+  readJsonFile,
+  readPackageJson,
+  readTextFile,
+  writeJsonFile,
+  writeTextFile,
+  isFile,
+  hasFiles,
+  hasComponents,
+  hasFunctions,
+  deleteFiles,
+  getFiles,
+  put,
+  get
+};
+// src/folders.ts
+import {join as join3} from "@stacksjs/path";
+function isFolder(path3) {
+  try {
+    return fs.statSync(path3).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isDirectory(path3) {
+  return isFolder(path3);
+}
+function isDir(path3) {
+  return isFolder(path3);
+}
+function doesFolderExist(path3) {
+  return fs.existsSync(path3);
+}
+function createFolder2(dir) {
+  return new Promise((resolve, reject) => {
+    fs.mkdirs(dir, (err) => {
+      if (err)
+        reject(err);
+      else
+        resolve();
+    });
+  });
+}
+function getFolders(dir) {
+  return fs.readdirSync(dir).filter((file) => {
+    return fs.statSync(join3(dir, file)).isDirectory();
+  });
+}
+var folders = {
+  isFolder,
+  doesFolderExist,
+  createFolder: createFolder2,
+  getFolders
+};
+// src/hash.ts
+import {createHash} from "crypto";
+import {path as p2} from "@stacksjs/path";
+function hashFileOrDirectory(path4, hash) {
+  if (fs.statSync(path4).isDirectory()) {
+    const files2 = fs.readdirSync(path4);
+    for (const file of files2) {
+      const filePath = p2.join(path4, file);
+      hashFileOrDirectory(filePath, hash);
+    }
+  } else {
+    hash.update(fs.readFileSync(path4));
+  }
+}
+function hashDirectory(directory) {
+  const hash = createHash("sha256");
+  hashFileOrDirectory(directory, hash);
+  return hash.digest("hex");
+}
+function hashPath(path4) {
+  const hash = createHash("sha256");
+  hashFileOrDirectory(path4, hash);
+  return hash.digest("hex");
+}
+function hashPaths(paths) {
+  const hash = createHash("sha256");
+  const pathsArray = Array.isArray(paths) ? paths : [paths];
+  for (const path4 of pathsArray)
+    hashFileOrDirectory(path4, hash);
+  return hash.digest("hex");
+}
+// src/helpers.ts
+import {fileURLToPath} from "url";
+import {dirname as dirname2} from "@stacksjs/path";
+function updateConfigFile(filePath, newConfig) {
+  return new Promise((resolve, reject) => {
+    const config = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    for (const key in newConfig)
+      config[key] = newConfig[key];
+    try {
+      fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+var __dirname = "/Users/chrisbreuer/Code/stacks/storage/framework/core/src/storage/src";
+var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname2(fileURLToPath(import.meta.url));
+var helpers = {
+  _dirname,
+  updateConfigFile
+};
+// src/copy.ts
+import {contains as contains2} from "@stacksjs/arrays";
+import {join as join4} from "@stacksjs/path";
+function copy(src, dest, exclude = []) {
+  if (Array.isArray(src)) {
+    src.forEach((file) => {
+      copy(file, dest, exclude);
+    });
+  } else {
+    if (fs.statSync(src).isDirectory())
+      copyFolder(src, dest, exclude);
+    else
+      copyFile(src, dest);
+  }
+}
+function copyFile(src, dest) {
+  fs.copyFileSync(src, dest);
+}
+function copyFolder(src, dest, exclude = []) {
+  if (!fs.existsSync(dest))
+    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 (fs.statSync(srcPath).isDirectory())
+          copyFolder(srcPath, destPath, exclude);
+        else
+          fs.copyFileSync(srcPath, destPath);
+      }
+    });
+  }
+}
+// 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) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (isFolder(path6)) {
+        fs.rmSync(path6, { recursive: true, force: true });
+        return resolve(ok(`Deleted ${path6}`));
+      }
+      return resolve(ok(`Path ${path6} was not a directory`));
+    } catch (error) {
+      return reject(err(error));
+    }
+  });
+}
+async function isDirectoryEmpty(path6) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (fs.statSync(path6).isDirectory()) {
+        if (fs.readdirSync(path6).length === 0)
+          return resolve(ok(true));
+        else
+          return resolve(ok(false));
+      }
+      return resolve(ok(false));
+    } catch (error) {
+      return reject(err(error));
+    }
+  });
+}
+async function deleteEmptyFolder(path6) {
+  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`));
+        }
+      }
+      return resolve(ok(`Path ${path6} was not a directory`));
+    } catch (error) {
+      return reject(err(error));
+    }
+  });
+}
+async function deleteEmptyFolders(dir) {
+  try {
+    if (!fs.existsSync(dir))
+      return ok(`Path ${dir} does not exist`);
+    const files3 = fs.readdirSync(dir);
+    for (const file of files3) {
+      const p3 = join(dir, file);
+      if (isFolder(p3)) {
+        if (fs.readdirSync(p3).length === 0)
+          fs.rmSync(p3, { recursive: true, force: true });
+        else
+          await deleteEmptyFolders(p3);
+      }
+    }
+    return ok(`Deleted empty folders located in ${dir}`);
+  } catch (error) {
+    return err(error);
+  }
+}
+function deleteFile(path6) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (isFile(path6)) {
+        fs.rmSync(path6, { recursive: true, force: true });
+        return resolve(ok(`Deleted ${path6}`));
+      }
+      return resolve(ok(`Path ${path6} 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 });
+  for (const directory of directories) {
+    const result = await deleteFolder(directory);
+    if (result.isErr()) {
+      log.error(result.error);
+      return result;
+    }
+    log.info(`Deleted ${italic(directory)}`);
+  }
+  return ok(`Deleted ${directories.length} directories`);
+}
+async function del(path6) {
+  if (isFile(path6))
+    return await deleteFile(path6);
+  if (isFolder(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.`));
+}
+// src/zip.ts
+import {runCommand} from "@stacksjs/cli";
+async function zip(from, to, options) {
+  const toPath = to || "archive.zip";
+  const fromPath = Array.isArray(from) ? from.join(" ") : from;
+  if (Array.isArray(from))
+    return runCommand(`zip -r ${toPath} ${fromPath}`, options);
+  return runCommand(`zip -r ${to} ${from}`, options);
+}
+async function unzip(paths) {
+  if (Array.isArray(paths))
+    return runCommand(`unzip ${paths.join(" ")}`);
+  return runCommand(`unzip ${paths}`);
+}
+function archive(paths) {
+  return zip(paths);
+}
+function unarchive(paths) {
+  return unzip(paths);
+}
+function compress(paths) {
+  return zip(paths);
+}
+function decompress(paths) {
+  return unzip(paths);
+}
+function gzipSync(data, options) {
+  return Bun.gzipSync(data, options);
+}
+function gunzipSync(data) {
+  return Bun.gunzipSync(data);
+}
+function deflateSync(data, options) {
+  return Bun.deflateSync(data, options);
+}
+function inflateSync(data) {
+  return Bun.inflateSync(data);
+}
+// src/storage.ts
+var exports_storage = {};
+__export(exports_storage, {
+  zip: () => {
+    {
+      return zip;
+    }
+  },
+  writeTextFile: () => {
+    {
+      return writeTextFile;
+    }
+  },
+  writeJsonFile: () => {
+    {
+      return writeJsonFile;
+    }
+  },
+  writeFileSync: () => {
+    {
+      return writeFileSync;
+    }
+  },
+  writeFile: () => {
+    {
+      return writeFile;
+    }
+  },
+  updateConfigFile: () => {
+    {
+      return updateConfigFile;
+    }
+  },
+  unzip: () => {
+    {
+      return unzip;
+    }
+  },
+  unarchive: () => {
+    {
+      return unarchive;
+    }
+  },
+  setVisibility: () => {
+    {
+      return setVisibility;
+    }
+  },
+  rename: () => {
+    {
+      return rename;
+    }
+  },
+  readTextFile: () => {
+    {
+      return readTextFile;
+    }
+  },
+  readPackageJson: () => {
+    {
+      return readPackageJson;
+    }
+  },
+  readJsonFile: () => {
+    {
+      return readJsonFile;
+    }
+  },
+  put: () => {
+    {
+      return put;
+    }
+  },
+  move: () => {
+    {
+      return move;
+    }
+  },
+  mkdirSync: () => {
+    {
+      return mkdirSync;
+    }
+  },
+  isFolder: () => {
+    {
+      return isFolder;
+    }
+  },
+  isFile: () => {
+    {
+      return isFile;
+    }
+  },
+  isDirectoryEmpty: () => {
+    {
+      return isDirectoryEmpty;
+    }
+  },
+  isDirectory: () => {
+    {
+      return isDirectory;
+    }
+  },
+  isDir: () => {
+    {
+      return isDir;
+    }
+  },
+  inflateSync: () => {
+    {
+      return inflateSync;
+    }
+  },
+  helpers: () => {
+    {
+      return helpers;
+    }
+  },
+  hasFunctions: () => {
+    {
+      return hasFunctions;
+    }
+  },
+  hasFiles: () => {
+    {
+      return hasFiles;
+    }
+  },
+  hasComponents: () => {
+    {
+      return hasComponents;
+    }
+  },
+  gzipSync: () => {
+    {
+      return gzipSync;
+    }
+  },
+  gunzipSync: () => {
+    {
+      return gunzipSync;
+    }
+  },
+  getFolders: () => {
+    {
+      return getFolders;
+    }
+  },
+  getFiles: () => {
+    {
+      return getFiles;
+    }
+  },
+  get: () => {
+    {
+      return get;
+    }
+  },
+  fs: () => {
+    {
+      return fs;
+    }
+  },
+  folders: () => {
+    {
+      return folders;
+    }
+  },
+  files: () => {
+    {
+      return files;
+    }
+  },
+  existsSync: () => {
+    {
+      return existsSync;
+    }
+  },
+  exists: () => {
+    {
+      return exists;
+    }
+  },
+  doesFolderExist: () => {
+    {
+      return doesFolderExist;
+    }
+  },
+  deleteGlob: () => {
+    {
+      return deleteGlob;
+    }
+  },
+  deleteFolder: () => {
+    {
+      return deleteFolder;
+    }
+  },
+  deleteFiles: () => {
+    {
+      return deleteFiles;
+    }
+  },
+  deleteFile: () => {
+    {
+      return deleteFile;
+    }
+  },
+  deleteEmptyFolders: () => {
+    {
+      return deleteEmptyFolders;
+    }
+  },
+  deleteEmptyFolder: () => {
+    {
+      return deleteEmptyFolder;
+    }
+  },
+  del: () => {
+    {
+      return del;
+    }
+  },
+  deflateSync: () => {
+    {
+      return deflateSync;
+    }
+  },
+  decompress: () => {
+    {
+      return decompress;
+    }
+  },
+  createFolder: () => {
+    {
+      return createFolder2;
+    }
+  },
+  copyFolder: () => {
+    {
+      return copyFolder;
+    }
+  },
+  copyFile: () => {
+    {
+      return copyFile;
+    }
+  },
+  copy: () => {
+    {
+      return copy;
+    }
+  },
+  compress: () => {
+    {
+      return compress;
+    }
+  },
+  archive: () => {
+    {
+      return archive;
+    }
+  },
+  _dirname: () => {
+    {
+      return _dirname;
+    }
+  }
+});
+
+// src/move.ts
+import {err as err2, ok as ok2} from "@stacksjs/error-handling";
+import {log as log2} from "@stacksjs/logging";
+import {path as path7} 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 result2 = await rename(from2, to2, options);
+        if (result2.isErr()) {
+          log2.error(result2.error);
+          return err2(handleError(result2.error.message, result2.error));
+        }
+      });
+      await Promise.all(operations);
+      return ok2({ message: "Files moved successfully" });
+    }
+    const from = src;
+    const to = dest;
+    const result = await rename(from, to, options);
+    if (result.isErr()) {
+      log2.error(result.error);
+      return err2(handleError(result.error));
+    }
+    return ok2({ message: "File moved successfully" });
+  } catch (error) {
+    return err2(handleError(error));
+  }
+}
+async function rename(from, to, options) {
+  return new Promise((resolve, reject) => {
+    try {
+      const dir = path7.dirname(to);
+      if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+      if (!fs.existsSync(from))
+        return reject(err2(new Error(`File or directory does not exist: ${from}`)));
+      if (fs.existsSync(to)) {
+        if (!options?.overwrite)
+          return reject(err2(new Error(`File or directory already exists: ${to}`)));
+        fs.unlinkSync(to);
+      }
+      fs.renameSync(from, to);
+      return resolve(ok2({ message: "File moved successfully" }));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        log2.error("File or directory does not exist\n\n", error);
+      else
+        log2.error(error);
+      return reject(err2(new Error(error)));
+    }
+  });
+}
+// src/visibility.ts
+function setVisibility() {
+  return "wip";
+}
+export {
+  zip,
+  writeTextFile,
+  writeJsonFile,
+  writeFileSync,
+  writeFile,
+  updateConfigFile,
+  unzip,
+  unarchive,
+  exports_storage as storage,
+  readTextFile,
+  readPackageJson,
+  readJsonFile,
+  put,
+  mkdirSync,
+  isFolder,
+  isFile,
+  isDirectoryEmpty,
+  isDirectory,
+  isDir,
+  inflateSync,
+  helpers,
+  hashPaths,
+  hashPath,
+  hashFileOrDirectory,
+  hashDirectory,
+  hasFunctions,
+  hasFiles,
+  hasComponents,
+  gzipSync,
+  gunzipSync,
+  default2 as glob,
+  getFolders,
+  getFiles,
+  get,
+  fs,
+  folders,
+  files,
+  existsSync,
+  exists,
+  doesFolderExist,
+  deleteGlob,
+  deleteFolder,
+  deleteFiles,
+  deleteFile,
+  deleteEmptyFolders,
+  deleteEmptyFolder,
+  del,
+  deflateSync,
+  decompress,
+  createFolder2 as createFolder,
+  copyFolder,
+  copyFile,
+  copy,
+  compress,
+  archive,
+  _dirname
+};

package/package.json

@@ -1,23 +1,16 @@
 {
   "name": "@stacksjs/storage",
   "type": "module",
-  "version": "0.57.4",
-  "packageManager": "pnpm@8.6.6",
+  "version": "0.58.20",
   "description": "The Stacks file system.",
   "author": "Chris Breuer",
   "license": "MIT",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
-    }
-  },
   "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/.stacks/core/storage#readme",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/src/storage#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./.stacks/core/storage"
+    "directory": "./storage/framework/core/src/storage"
   },
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
@@ -26,35 +19,59 @@
     "storage",
     "fs",
     "file system",
+    "glob",
     "api",
     "collections",
     "utilities",
     "functions",
+    "bun",
     "stacks"
   ],
-  "module": "dist/index.mjs",
+  ".": {
+    "bun": "./src/index.ts",
+    "import": "./dist/index.js"
+  },
+  "./*": {
+    "bun": "./src/*",
+    "import": "./dist/*"
+  },
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "contributors": [
-    "Chris Breuer <chris@ow3.org>"
+    "Chris Breuer <chris@stacksjs.org>"
   ],
   "files": [
-    "dist",
-    "README.md"
+    "README.md",
+    "dist"
   ],
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun --bun run build"
+  },
   "peerDependencies": {
-    "fs-extra": "^11.1.1",
-    "unstorage": "^1.7.0",
-    "@stacksjs/path": "0.57.4",
-    "@stacksjs/arrays": "0.57.4",
-    "@stacksjs/types": "0.57.4",
-    "@stacksjs/strings": "0.57.4"
+    "@stacksjs/arrays": "workspace:*",
+    "@stacksjs/cli": "workspace:*",
+    "@stacksjs/error-handling": "workspace:*",
+    "@stacksjs/path": "workspace:*",
+    "@stacksjs/strings": "workspace:*",
+    "@stacksjs/types": "workspace:*",
+    "@types/archiver": "^6.0.2",
+    "archiver": "^6.0.1"
   },
-  "devDependencies": {
-    "@stacksjs/development": "0.57.4"
+  "dependencies": {
+    "@stacksjs/arrays": "workspace:*",
+    "@stacksjs/error-handling": "workspace:*",
+    "@stacksjs/path": "workspace:*",
+    "@stacksjs/strings": "workspace:*",
+    "@stacksjs/types": "workspace:*",
+    "@types/archiver": "^6.0.2",
+    "archiver": "^6.0.1",
+    "fast-glob": "^3.3.2",
+    "fs-extra": "^11.2.0",
+    "unstorage": "^1.10.1"
   },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "typecheck": "tsc --noEmit"
+  "devDependencies": {
+    "@stacksjs/development": "workspace:*"
   }
-}
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2022 Open Web Foundation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.d.ts

@@ -1,45 +0,0 @@
-import fs from 'fs-extra';
-import type { JsonFile, TextFile } from '@stacksjs/types';
-export declare const _dirname: any;
-/**
- * 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 data to the specified JSON file.
- */
-export declare function writeJsonFile(file: JsonFile): Promise<void>;
-/**
- * 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<void>;
-/**
- * Determine whether a path is a folder.
- */
-export declare function isFolder(path: string): boolean;
-/**
- * Determine whether a path is a file.
- */
-export declare function isFile(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 copyFolder(src: string, dest: string, exclude?: string[]): void;
-export declare function deleteFolder(path: string): Promise<void>;
-export declare function deleteFiles(dir: string, exclude?: string[]): void;
-export declare function deleteEmptyFolders(dir: string): void;
-export declare function doesFolderExist(path: string): any;
-export declare function createFolder(dir: string): Promise<void>;
-export declare function updateConfigFile(filePath: string, newConfig: Record<string, unknown>): Promise<void>;
-export { fs };

package/dist/index.mjs

@@ -1,144 +0,0 @@
-import { fileURLToPath } from "node:url";
-import fs from "fs-extra";
-import { detectIndent, detectNewline } from "@stacksjs/strings";
-import { componentsPath, dirname, functionsPath, join, projectPath } from "@stacksjs/path";
-import { contains } from "@stacksjs/arrays";
-export const _dirname = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
-export async function readJsonFile(name, cwd) {
-  const file = await readTextFile(name, cwd);
-  const data = JSON.parse(file.data);
-  const indent = detectIndent(file.data).indent;
-  const newline = detectNewline(file.data);
-  return { ...file, data, indent, newline };
-}
-export async function readPackageJson(name, cwd) {
-  const file = await readJsonFile(name, cwd);
-  const data = file.data;
-  return data;
-}
-export async function writeJsonFile(file) {
-  let json = JSON.stringify(file.data, void 0, file.indent);
-  if (file.newline)
-    json += file.newline;
-  return writeTextFile({ ...file, data: json });
-}
-export function readTextFile(name, cwd) {
-  return new Promise((resolve, reject) => {
-    let filePath;
-    if (cwd)
-      filePath = join(cwd, name);
-    else
-      filePath = name;
-    fs.readFile(filePath, "utf8", (err, text) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve({
-          path: filePath,
-          data: text
-        });
-      }
-    });
-  });
-}
-export function writeTextFile(file) {
-  return new Promise((resolve, reject) => {
-    fs.writeFile(file.path, file.data, (err) => {
-      if (err)
-        reject(err);
-      else
-        resolve();
-    });
-  });
-}
-export function isFolder(path) {
-  try {
-    return fs.statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-export function isFile(path) {
-  return fs.existsSync(projectPath(path));
-}
-export function hasFiles(folder) {
-  return fs.readdirSync(folder).length > 0;
-}
-export function hasComponents() {
-  return hasFiles(componentsPath());
-}
-export function hasFunctions() {
-  return hasFiles(functionsPath());
-}
-export function copyFolder(src, dest, exclude = []) {
-  if (!fs.existsSync(dest))
-    fs.mkdirSync(dest, { recursive: true });
-  if (fs.existsSync(src)) {
-    fs.readdirSync(src).forEach((file) => {
-      if (!contains(join(src, file), exclude)) {
-        const srcPath = join(src, file);
-        const destPath = join(dest, file);
-        if (fs.statSync(srcPath).isDirectory())
-          copyFolder(srcPath, destPath, exclude);
-        else
-          fs.copyFileSync(srcPath, destPath);
-      }
-    });
-  }
-}
-export async function deleteFolder(path) {
-  if (fs.statSync(path).isDirectory())
-    await fs.rmSync(path, { recursive: true, force: true });
-}
-export function deleteFiles(dir, exclude = []) {
-  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 });
-        else
-          deleteFiles(p, exclude);
-      } else if (!contains(p, exclude)) {
-        fs.rmSync(p);
-      }
-    });
-  }
-}
-export function deleteEmptyFolders(dir) {
-  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 });
-        else
-          deleteEmptyFolders(p);
-      }
-    });
-  }
-}
-export function doesFolderExist(path) {
-  return fs.existsSync(path);
-}
-export function createFolder(dir) {
-  return new Promise((resolve, reject) => {
-    fs.mkdirs(dir, (err) => {
-      if (err)
-        reject(err);
-      else
-        resolve();
-    });
-  });
-}
-export function updateConfigFile(filePath, newConfig) {
-  return new Promise((resolve, reject) => {
-    const config = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    for (const key in newConfig) {
-      config[key] = newConfig[key];
-    }
-    fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
-    resolve();
-  });
-}
-export { fs };