stacks 0.58.73 → 0.59.2

package/core/storage/dist/index.js

@@ -1,816 +0,0 @@
-// @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 doesExist(path2) {
-  return !isFile(path2) || !isFolder(path2);
-}
-function doesNotExist(path2) {
-  return !isFile(path2) && !isFolder(path2);
-}
-function hasFiles(folder) {
-  try {
-    return fs.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 isFolder2(path3) {
-  try {
-    return fs.statSync(path3).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isDirectory(path3) {
-  return isFolder2(path3);
-}
-function isDir(path3) {
-  return isFolder2(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: isFolder2,
-  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 = "/home/runner/work/stacks/stacks/storage/framework/core/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 (isFolder2(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 (isFolder2(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 (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.`));
-}
-// 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 isFolder2;
-    }
-  },
-  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;
-    }
-  },
-  doesNotExist: () => {
-    {
-      return doesNotExist;
-    }
-  },
-  doesFolderExist: () => {
-    {
-      return doesFolderExist;
-    }
-  },
-  doesExist: () => {
-    {
-      return doesExist;
-    }
-  },
-  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,
-  isFolder2 as 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,
-  doesNotExist,
-  doesFolderExist,
-  doesExist,
-  deleteGlob,
-  deleteFolder,
-  deleteFiles,
-  deleteFile,
-  deleteEmptyFolders,
-  deleteEmptyFolder,
-  del,
-  deflateSync,
-  decompress,
-  createFolder2 as createFolder,
-  copyFolder,
-  copyFile,
-  copy,
-  compress,
-  archive,
-  _dirname
-};