@stacksjs/storage 0.70.87 → 0.70.90

package/dist/files.js

@@ -0,0 +1,126 @@
+import { contains } from "@stacksjs/arrays";
+import { log } from "@stacksjs/logging";
+import { dirname, join, path as p } from "@stacksjs/path";
+import { detectIndent, detectNewline } from "@stacksjs/strings";
+import { createFolder, isFolder } from "./folders";
+import { existsSync, fs } from "./fs";
+export async function readJsonFile(name, cwd) {
+  const file = await readTextFile(name, cwd);
+  let data;
+  try {
+    data = JSON.parse(file.data);
+  } catch (error) {
+    throw Error(`Failed to parse JSON file "${name}": ${error.message}`);
+  }
+  const indent = detectIndent(file.data).indent, newline = detectNewline(file.data);
+  return { ...file, data, indent, newline };
+}
+export async function readPackageJson(name, cwd) {
+  return (await readJsonFile(name, cwd)).data;
+}
+export async function writeFile(path, data) {
+  if (typeof path === "string") {
+    const dirPath = dirname(path);
+    if (!await existsSync(dirPath))
+      await createFolder(dirPath);
+    return await Bun.write(Bun.file(path), data);
+  }
+  return await Bun.write(path, 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 async function writeTextFile(file) {
+  return await Bun.write(file.path, file.data);
+}
+function isFile(path) {
+  return fs.existsSync(path);
+}
+export function doesExist(path) {
+  return isFile(path) || isFolder(path);
+}
+export function doesNotExist(path) {
+  return !isFile(path) && !isFolder(path);
+}
+export function hasFiles(folder) {
+  try {
+    return fs.readdirSync(folder).length > 0;
+  } catch (err) {
+    log.debug(`Error reading folder: ${folder}`, err);
+    return !1;
+  }
+}
+export function hasComponents() {
+  return hasFiles(p.componentsPath());
+}
+export function hasFunctions() {
+  return hasFiles(p.functionsPath());
+}
+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: !0, force: !0 });
+        else
+          deleteFiles(p, exclude);
+      else if (!contains(p, exclude))
+        fs.rmSync(p);
+    });
+}
+export function getFiles(dir, exclude = []) {
+  let results = [];
+  fs.readdirSync(dir).forEach((file) => {
+    file = join(dir, file);
+    if (fs.statSync(file).isDirectory())
+      results = results.concat(getFiles(file, exclude));
+    else if (!contains(file, exclude))
+      results.push(file);
+  });
+  return results;
+}
+export function put(path, contents) {
+  const dirPath = dirname(path);
+  if (!fs.existsSync(dirPath))
+    fs.mkdirSync(dirPath, { recursive: !0 });
+  fs.writeFileSync(path, contents, "utf-8");
+}
+export async function get(path) {
+  return Bun.file(path).text();
+}
+export const files = {
+  readJsonFile,
+  readPackageJson,
+  readTextFile,
+  writeJsonFile,
+  writeTextFile,
+  hasFiles,
+  hasComponents,
+  hasFunctions,
+  deleteFiles,
+  getFiles,
+  put,
+  get
+};

package/dist/folders.js

@@ -0,0 +1,36 @@
+import { join } from "@stacksjs/path";
+import { fs } from "./fs";
+export function isFolder(path) {
+  try {
+    return fs.statSync(path).isDirectory();
+  } catch {
+    return !1;
+  }
+}
+export function isDir(path) {
+  return isFolder(path);
+}
+export function doesFolderExist(path) {
+  return fs.existsSync(path);
+}
+export function createFolder(dir) {
+  return new Promise((resolve, reject) => {
+    try {
+      fs.mkdirSync(dir, { recursive: !0 });
+      resolve();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+export function getFolders(dir) {
+  return fs.readdirSync(dir).filter((file) => {
+    return fs.statSync(join(dir, file)).isDirectory();
+  });
+}
+export const folders = {
+  isFolder,
+  doesFolderExist,
+  createFolder,
+  getFolders
+};

package/dist/fs.js

@@ -0,0 +1,7 @@
+import * as fs from "node:fs";
+import { existsSync, watch as fsWatch, mkdirSync, readFileSync, watchFile, writeFileSync } from "node:fs";
+export function exists(path) {
+  return existsSync(path);
+}
+
+export { existsSync, fsWatch, mkdirSync, readFileSync, watchFile, writeFileSync, fs };

package/dist/glob.js

@@ -0,0 +1,40 @@
+import { Glob as BunGlob } from "bun";
+function isEnoent(err) {
+  return !!err && typeof err === "object" && err.code === "ENOENT";
+}
+export function globSync(patterns, options) {
+  const patternArray = typeof patterns === "string" ? [patterns] : patterns, results = [];
+  for (const pattern of patternArray)
+    try {
+      const matches = new BunGlob(pattern).scanSync({
+        cwd: options?.cwd,
+        absolute: options?.absolute,
+        dot: options?.dot,
+        onlyFiles: options?.onlyFiles
+      });
+      for (const match of matches)
+        results.push(match);
+    } catch (err) {
+      if (!isEnoent(err))
+        throw err;
+    }
+  return results;
+}
+export async function glob(patterns, options) {
+  const patternArray = typeof patterns === "string" ? [patterns] : patterns, results = [];
+  for (const pattern of patternArray)
+    try {
+      const matches = new BunGlob(pattern).scan({
+        cwd: options?.cwd,
+        absolute: options?.absolute,
+        dot: options?.dot,
+        onlyFiles: options?.onlyFiles
+      });
+      for await (const match of matches)
+        results.push(match);
+    } catch (err) {
+      if (!isEnoent(err))
+        throw err;
+    }
+  return results;
+}

package/dist/hash.js

@@ -0,0 +1,33 @@
+import { createHash } from "node:crypto";
+import { path as p } from "@stacksjs/path";
+import { fs } from "./fs";
+export function hashFileOrDirectory(path, hash) {
+  if (!fs.existsSync(path)) {
+    console.error(`Path does not exist: ${path}`);
+    return;
+  }
+  if (fs.statSync(path).isDirectory()) {
+    const files = fs.readdirSync(path);
+    for (const file of files) {
+      const filePath = p.join(path, file);
+      hashFileOrDirectory(filePath, hash);
+    }
+  } else
+    hash.update(fs.readFileSync(path));
+}
+export function hashDirectory(directory) {
+  const hash = createHash("sha256");
+  hashFileOrDirectory(directory, hash);
+  return hash.digest("hex");
+}
+export function hashPath(path) {
+  const hash = createHash("sha256");
+  hashFileOrDirectory(path, hash);
+  return hash.digest("hex");
+}
+export function hashPaths(paths) {
+  const hash = createHash("sha256"), pathsArray = Array.isArray(paths) ? paths : [paths];
+  for (const path of pathsArray)
+    hashFileOrDirectory(path, hash);
+  return hash.digest("hex");
+}

package/dist/helpers.js

@@ -0,0 +1,28 @@
+var __dirname = "";
+import { fileURLToPath } from "node:url";
+import { dirname } from "@stacksjs/path";
+import { fs } from "./fs";
+export const _dirname = typeof __dirname < "u" ? __dirname : dirname(fileURLToPath(import.meta.url));
+export function updateConfigFile(filePath, newConfig) {
+  return new Promise((resolve, reject) => {
+    let config;
+    try {
+      config = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch (error) {
+      reject(Error(`Failed to parse config file "${filePath}": ${error.message}`));
+      return;
+    }
+    for (const key in newConfig)
+      config[key] = newConfig[key];
+    try {
+      fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+export const helpers = {
+  _dirname,
+  updateConfigFile
+};

package/dist/image.js

@@ -1,8 +1,4 @@
-// @bun
-var __require = import.meta.require;
-
-// src/image.ts
-var cachedSharp = null;
+let cachedSharp = null;
 async function loadSharp() {
   if (cachedSharp)
     return cachedSharp;
@@ -11,33 +7,23 @@ async function loadSharp() {
     cachedSharp = mod.default ?? mod;
     return cachedSharp;
   } catch (err) {
-    throw new Error(`[storage/image] \`sharp\` is not installed. Image transforms require it as a peer dependency.
+    throw Error(`[storage/image] \`sharp\` is not installed. Image transforms require it as a peer dependency.
   Install with: \`bun add sharp\`
   Original load error: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function transform(pipeline) {
+export function transform(pipeline) {
   return async (input) => {
-    const sharp = await loadSharp();
-    const bytes = input instanceof ArrayBuffer ? new Uint8Array(input) : input;
-    const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
-    const img = sharp(buf);
-    const piped = await pipeline(img);
-    return piped.toBuffer();
+    const sharp = await loadSharp(), bytes = input instanceof ArrayBuffer ? new Uint8Array(input) : input, buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes), img = sharp(buf);
+    return (await pipeline(img)).toBuffer();
   };
 }
-function avatar(size = 512, quality = 85) {
+export function avatar(size = 512, quality = 85) {
   return transform((img) => img.resize(size, size, { fit: "cover" }).webp({ quality }));
 }
-function resize(width, height, fit = "inside") {
+export function resize(width, height, fit = "inside") {
   return transform((img) => img.resize(width, height, { fit }));
 }
-function stripMetadata() {
+export function stripMetadata() {
   return transform((img) => img);
 }
-export {
-  transform,
-  stripMetadata,
-  resize,
-  avatar
-};