@reliverse/relifso 1.4.0 → 1.4.1

package/bin/impl/stats.d.ts

@@ -0,0 +1,31 @@
+import type { Stats } from "node:fs";
+/**
+ * Convert Bun file stats to Node.js Stats object
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function toNodeStats(path: string): Promise<Stats>;
+/**
+ * Get file stats with fallback to Node.js
+ * Uses Bun's optimized API when available
+ */
+export declare function getStats(path: string): Promise<Stats>;
+/**
+ * Get file stats synchronously with fallback to Node.js
+ * Uses Bun's optimized API when available
+ */
+export declare function getStatsSync(path: string): Stats;
+/**
+ * Check if a file exists
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function getFileExists(path: string): Promise<boolean>;
+/**
+ * Get file size
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function getFileSize(path: string): Promise<number>;
+/**
+ * Get file last modified time
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function getFileLastModified(path: string): Promise<Date>;

package/bin/impl/stats.js

@@ -0,0 +1,141 @@
+import { statSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { logInternal } from "../utils/log.js";
+import { isBun } from "./bun.js";
+export async function toNodeStats(path) {
+  if (!isBun) {
+    return stat(path);
+  }
+  try {
+    const file = Bun.file(path);
+    const size = file.size;
+    const lastModified = new Date(file.lastModified);
+    return {
+      dev: 0,
+      ino: 0,
+      mode: 0,
+      nlink: 0,
+      uid: 0,
+      gid: 0,
+      rdev: 0,
+      size,
+      blksize: 0,
+      blocks: 0,
+      atimeMs: lastModified.getTime(),
+      mtimeMs: lastModified.getTime(),
+      ctimeMs: lastModified.getTime(),
+      birthtimeMs: lastModified.getTime(),
+      atime: lastModified,
+      mtime: lastModified,
+      ctime: lastModified,
+      birthtime: lastModified,
+      isDirectory: () => false,
+      // Bun doesn't provide this info directly
+      isFile: () => true,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => false,
+      isFIFO: () => false,
+      isSocket: () => false
+    };
+  } catch (error) {
+    return stat(path);
+  }
+}
+export async function getStats(path) {
+  if (!isBun) {
+    return stat(path);
+  }
+  try {
+    return await toNodeStats(path);
+  } catch (error) {
+    return stat(path);
+  }
+}
+export function getStatsSync(path) {
+  if (!isBun) {
+    return statSync(path);
+  }
+  try {
+    const file = Bun.file(path);
+    const size = file.size;
+    const lastModified = new Date(file.lastModified);
+    return {
+      dev: 0,
+      ino: 0,
+      mode: 0,
+      nlink: 0,
+      uid: 0,
+      gid: 0,
+      rdev: 0,
+      size,
+      blksize: 0,
+      blocks: 0,
+      atimeMs: lastModified.getTime(),
+      mtimeMs: lastModified.getTime(),
+      ctimeMs: lastModified.getTime(),
+      birthtimeMs: lastModified.getTime(),
+      atime: lastModified,
+      mtime: lastModified,
+      ctime: lastModified,
+      birthtime: lastModified,
+      isDirectory: () => false,
+      isFile: () => true,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => false,
+      isFIFO: () => false,
+      isSocket: () => false
+    };
+  } catch (error) {
+    return statSync(path);
+  }
+}
+export async function getFileExists(path) {
+  if (!isBun) {
+    try {
+      await stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    const file = Bun.file(path);
+    return await file.exists();
+  } catch (error) {
+    return false;
+  }
+}
+export async function getFileSize(path) {
+  if (!isBun) {
+    try {
+      const stats = await stat(path);
+      return stats.size;
+    } catch (error) {
+      return 0;
+    }
+  }
+  try {
+    const file = Bun.file(path);
+    return file.size;
+  } catch (error) {
+    return 0;
+  }
+}
+export async function getFileLastModified(path) {
+  if (!isBun) {
+    try {
+      const stats = await stat(path);
+      return stats.mtime;
+    } catch (error) {
+      return /* @__PURE__ */ new Date(0);
+    }
+  }
+  try {
+    const file = Bun.file(path);
+    return new Date(file.lastModified);
+  } catch (error) {
+    return /* @__PURE__ */ new Date(0);
+  }
+}

package/bin/impl/write-file.d.ts

@@ -1,20 +1,31 @@
-import { type PathLike } from "node:fs";
-export type WriteFileOptions = import("node:fs").WriteFileOptions;
+import { type PathLike, type WriteStream } from "node:fs";
+import { URL } from "node:url";
+export interface WriteFileOptions {
+    encoding?: BufferEncoding | null;
+    mode?: number;
+    flag?: string;
+    isJson?: boolean;
+    useStreaming?: boolean;
+    replacer?: (key: string, value: unknown) => unknown;
+    spaces?: string | number;
+}
+type WriteTarget = PathLike | number | URL | WriteStream;
 /**
  * Synchronously writes data to a file, replacing the file if it already exists.
  * Ensures the directory exists before writing.
  *
- * @param file - Path to the file.
- * @param data - The data to write. If something other than a Buffer or Uint8Array is provided, it is converted to a string.
+ * @param file - Path to the file, file descriptor, URL, or special streams (stdout/stderr).
+ * @param data - The data to write. Can be a string, Buffer, Uint8Array, Blob, Response, or other ArrayBufferView.
  * @param options - Options for writing the file. Can be an encoding string or an object.
  */
-export declare function writeFileSync(file: PathLike | number, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): void;
+export declare function writeFileSync(file: WriteTarget, data: string | NodeJS.ArrayBufferView | Blob | Response, options?: WriteFileOptions): void;
 /**
  * Asynchronously writes data to a file, replacing the file if it already exists.
  * Ensures the directory exists before writing.
  *
- * @param file - Path to the file.
- * @param data - The data to write. If something other than a Buffer or Uint8Array is provided, it is converted to a string.
+ * @param file - Path to the file, file descriptor, URL, or special streams (stdout/stderr).
+ * @param data - The data to write. Can be a string, Buffer, Uint8Array, Blob, Response, or other ArrayBufferView.
  * @param options - Options for writing the file. Can be an encoding string or an object.
  */
-export declare function writeFile(file: PathLike | number, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
+export declare function writeFile(file: WriteTarget, data: string | NodeJS.ArrayBufferView | Blob | Response | unknown, options?: WriteFileOptions): Promise<void>;
+export {};

package/bin/impl/write-file.js

@@ -1,22 +1,187 @@
-import { writeFileSync as nodeWriteFileSync } from "node:fs";
+import { writeFileSync as nodeWriteFileSync, createWriteStream } from "node:fs";
 import { mkdir, writeFile as nodeWriteFileAsync, stat } from "node:fs/promises";
 import path from "node:path";
-import { isBun, getFileBun } from "./bun.js";
-import { logInternal } from "./logger.js";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { URL } from "node:url";
+import { logInternal } from "../utils/log.js";
+import { isBun } from "./bun.js";
 import { mkdirsSync } from "./mkdirs.js";
+function isStdStream(target) {
+  return typeof target === "object" && target !== null && "write" in target && typeof target.write === "function";
+}
+function isFileDescriptor(target) {
+  return typeof target === "number";
+}
+function isPathLike(target) {
+  return !isStdStream(target) && !isFileDescriptor(target) && !(target instanceof URL);
+}
 export function writeFileSync(file, data, options) {
+  if (isStdStream(file)) {
+    if (typeof data === "string") {
+      file.write(data);
+    } else if (data instanceof Uint8Array) {
+      file.write(data);
+    } else if (data instanceof Blob || data instanceof Response) {
+      throw new Error("Blob and Response are not supported for stdout/stderr in sync context");
+    } else if (data instanceof ArrayBuffer) {
+      file.write(Buffer.from(new Uint8Array(data)));
+    } else if (ArrayBuffer.isView(data)) {
+      file.write(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+    } else {
+      throw new Error("Unsupported data type for stream writing");
+    }
+    return;
+  }
+  if (isFileDescriptor(file)) {
+    if (isBun) {
+      let writeData;
+      if (typeof data === "string") {
+        writeData = data;
+      } else if (data instanceof Uint8Array) {
+        writeData = data;
+      } else if (data instanceof Blob || data instanceof Response) {
+        throw new Error("Blob and Response are not supported in sync context with Bun");
+      } else if (data instanceof ArrayBuffer) {
+        writeData = new Uint8Array(data);
+      } else if (ArrayBuffer.isView(data)) {
+        writeData = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      } else {
+        throw new Error("Unsupported data type for Bun file descriptor writing");
+      }
+      Bun.write(Bun.file(file), writeData);
+      return;
+    }
+    if (data instanceof Blob || data instanceof Response) {
+      throw new Error("Blob and Response are not supported for file descriptors in sync context");
+    }
+    nodeWriteFileSync(file, data, options);
+    return;
+  }
+  if (file instanceof URL) {
+    if (file.protocol !== "file:") {
+      throw new Error("Only file:// URLs are supported");
+    }
+    file = file.pathname;
+  }
+  if (!isPathLike(file)) {
+    throw new Error("Invalid file target");
+  }
   const dir = path.dirname(file.toString());
   mkdirsSync(dir);
   if (isBun) {
     try {
-      nodeWriteFileSync(file, data, options);
+      const filePath = file.toString();
+      let writeData;
+      if (typeof data === "string") {
+        writeData = data;
+      } else if (data instanceof Uint8Array) {
+        writeData = data;
+      } else if (data instanceof Blob || data instanceof Response) {
+        throw new Error("Blob and Response are not supported in sync context with Bun");
+      } else if (data instanceof ArrayBuffer) {
+        writeData = new Uint8Array(data);
+      } else if (ArrayBuffer.isView(data)) {
+        writeData = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      } else {
+        throw new Error("Unsupported data type for Bun file writing");
+      }
+      Bun.write(filePath, writeData);
       return;
     } catch (_error) {
     }
   }
-  nodeWriteFileSync(file, data, options);
+  let nodeData;
+  if (data instanceof Blob || data instanceof Response) {
+    throw new Error("Blob and Response are not supported in sync context");
+  } else if (typeof data === "string") {
+    nodeData = data;
+  } else if (data instanceof ArrayBuffer) {
+    nodeData = Buffer.from(new Uint8Array(data));
+  } else if (ArrayBuffer.isView(data)) {
+    nodeData = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    throw new Error("Unsupported data type for Node.js file writing");
+  }
+  nodeWriteFileSync(file, nodeData, options);
 }
 export async function writeFile(file, data, options) {
+  let isJson = false;
+  let useStreaming = false;
+  let replacer;
+  let spaces;
+  let encoding;
+  let mode;
+  let flag;
+  if (options) {
+    isJson = options.isJson ?? isJson;
+    useStreaming = options.useStreaming ?? useStreaming;
+    replacer = options.replacer;
+    spaces = options.spaces;
+    encoding = options.encoding;
+    mode = options.mode ? Number(options.mode) : void 0;
+    flag = options.flag;
+  }
+  if (isJson && typeof data !== "string" && !(data instanceof Uint8Array) && !(data instanceof Blob) && !(data instanceof Response)) {
+    try {
+      const jsonString = JSON.stringify(data, replacer, spaces);
+      if (jsonString === void 0) {
+        throw new Error("Failed to stringify JSON object");
+      }
+      data = jsonString;
+    } catch (err) {
+      throw new Error(`Failed to stringify JSON data: ${err}`);
+    }
+  }
+  if (isStdStream(file)) {
+    if (typeof data === "string") {
+      file.write(data);
+    } else if (data instanceof Uint8Array) {
+      file.write(data);
+    } else if (data instanceof Blob || data instanceof Response) {
+      throw new Error("Blob and Response are not supported for stdout/stderr in sync context");
+    } else if (data instanceof ArrayBuffer) {
+      file.write(Buffer.from(new Uint8Array(data)));
+    } else if (ArrayBuffer.isView(data)) {
+      file.write(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+    } else {
+      throw new Error("Unsupported data type for stream writing");
+    }
+    return;
+  }
+  if (isFileDescriptor(file)) {
+    if (isBun) {
+      let writeData;
+      if (typeof data === "string") {
+        writeData = data;
+      } else if (data instanceof Uint8Array) {
+        writeData = data;
+      } else if (data instanceof Blob || data instanceof Response) {
+        throw new Error("Blob and Response are not supported in sync context with Bun");
+      } else if (data instanceof ArrayBuffer) {
+        writeData = new Uint8Array(data);
+      } else if (ArrayBuffer.isView(data)) {
+        writeData = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      } else {
+        throw new Error("Unsupported data type for Bun file descriptor writing");
+      }
+      Bun.write(Bun.file(file), writeData);
+      return;
+    }
+    if (data instanceof Blob || data instanceof Response) {
+      throw new Error("Blob and Response are not supported for file descriptors in sync context");
+    }
+    return nodeWriteFileSync(file, data, options);
+  }
+  if (file instanceof URL) {
+    if (file.protocol !== "file:") {
+      throw new Error("Only file:// URLs are supported");
+    }
+    file = file.pathname;
+  }
+  if (!isPathLike(file)) {
+    throw new Error("Invalid file target");
+  }
   const dir = path.dirname(file.toString());
   try {
     await stat(dir);
@@ -27,22 +192,66 @@ export async function writeFile(file, data, options) {
       throw _error;
     }
   }
+  if (useStreaming && typeof data === "string") {
+    try {
+      const writeStream = createWriteStream(file.toString(), {
+        encoding,
+        mode,
+        flags: flag
+      });
+      const transform = new Transform({
+        transform(chunk, _encoding, callback) {
+          callback(null, chunk);
+        }
+      });
+      transform.write(data);
+      transform.end();
+      await pipeline(transform, writeStream);
+      return;
+    } catch (streamError) {
+    }
+  }
   if (isBun) {
     try {
       const filePath = file.toString();
-      const bunFile = getFileBun(filePath);
       let writeData;
       if (typeof data === "string") {
         writeData = data;
       } else if (data instanceof Uint8Array) {
         writeData = data;
+      } else if (data instanceof Blob) {
+        const buffer = await data.arrayBuffer();
+        writeData = new Uint8Array(buffer);
+      } else if (data instanceof Response) {
+        const buffer = await data.arrayBuffer();
+        writeData = new Uint8Array(buffer);
+      } else if (data instanceof ArrayBuffer) {
+        writeData = new Uint8Array(data);
+      } else if (ArrayBuffer.isView(data)) {
+        writeData = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
       } else {
-        writeData = new Uint8Array(data.buffer);
+        throw new Error("Unsupported data type for Bun file writing");
       }
-      await Bun.write(bunFile, writeData);
+      await Bun.write(filePath, writeData);
       return;
     } catch (_error) {
     }
   }
-  return nodeWriteFileAsync(file, data, options);
+  let nodeData;
+  if (data instanceof Blob) {
+    const buffer = await data.arrayBuffer();
+    nodeData = Buffer.from(buffer);
+  } else if (data instanceof Response) {
+    const buffer = await data.arrayBuffer();
+    nodeData = Buffer.from(buffer);
+  } else if (typeof data === "string") {
+    nodeData = data;
+  } else if (data instanceof ArrayBuffer) {
+    nodeData = Buffer.from(new Uint8Array(data));
+  } else if (ArrayBuffer.isView(data)) {
+    nodeData = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    throw new Error("Unsupported data type for Node.js file writing");
+  }
+  await nodeWriteFileAsync(file, nodeData, options);
 }

package/bin/impl/write-json.d.ts

@@ -1,15 +1,26 @@
-import type { Mode } from "node:fs";
 export interface JsonStringifyOptions {
     replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
     spaces?: string | number;
+    /**
+     * Whether to include comments when writing JSONC files
+     * @default false
+     */
+    includeComments?: boolean;
 }
 export interface WriteJsonOptions {
     encoding?: BufferEncoding | null;
-    mode?: Mode;
+    mode?: number;
     flag?: string;
     replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
     spaces?: string | number;
     throws?: boolean;
+    useStreaming?: boolean;
+    chunkSize?: number;
+    /**
+     * Whether to include comments when writing JSONC files
+     * @default false
+     */
+    includeComments?: boolean;
 }
 /**
  * Synchronously writes a JSON file.

package/bin/impl/write-json.js

@@ -1,5 +1,10 @@
+import { createWriteStream } from "node:fs";
+import { extname } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { stringifyJsonc } from "../utils/json/regular/jsonc.js";
+import { logInternal } from "../utils/log.js";
 import { isBun, getFileBun } from "./bun.js";
-import { logInternal } from "./logger.js";
 import { writeFileSync } from "./write-file.js";
 import { writeFile } from "./write-file.js";
 export function writeJsonSync(file, object, options) {
@@ -9,6 +14,7 @@ export function writeJsonSync(file, object, options) {
   let flag;
   let mode;
   let throws = true;
+  let includeComments = false;
   if (typeof options === "string") {
     encoding = options;
   } else if (options) {
@@ -17,6 +23,7 @@ export function writeJsonSync(file, object, options) {
     spaces = options.spaces;
     flag = options.flag;
     mode = options.mode;
+    includeComments = options.includeComments ?? includeComments;
     if (options.throws !== void 0) {
       throws = options.throws;
     }
@@ -25,19 +32,19 @@ export function writeJsonSync(file, object, options) {
     if (object === void 0) {
       throw new Error("Cannot write undefined as JSON");
     }
+    const isJsonc = extname(file).toLowerCase() === ".jsonc";
     if (isBun) {
       try {
-        const fileRef = getFileBun(file);
-        const jsonString2 = JSON.stringify(object, replacer, spaces);
+        const jsonString2 = isJsonc ? stringifyJsonc(object, { includeComments, spaces: typeof spaces === "number" ? spaces : 2 }) : JSON.stringify(object, replacer, spaces);
         if (jsonString2 === void 0) {
           throw new Error("Failed to stringify JSON object");
         }
-        Bun.write(fileRef, jsonString2);
+        writeFileSync(file, jsonString2, { encoding, flag, mode });
         return;
       } catch (error) {
       }
     }
-    const jsonString = JSON.stringify(object, replacer, spaces);
+    const jsonString = isJsonc ? stringifyJsonc(object, { includeComments, spaces: typeof spaces === "number" ? spaces : 2 }) : JSON.stringify(object, replacer, spaces);
     if (jsonString === void 0) {
       throw new Error("Failed to stringify JSON object");
     }
@@ -55,6 +62,9 @@ export async function writeJson(file, object, options) {
   let flag;
   let mode;
   let throws = true;
+  let useStreaming = false;
+  let chunkSize = 1024 * 1024;
+  let includeComments = false;
   if (typeof options === "string") {
     encoding = options;
   } else if (options) {
@@ -63,6 +73,9 @@ export async function writeJson(file, object, options) {
     spaces = options.spaces;
     flag = options.flag;
     mode = options.mode;
+    useStreaming = options.useStreaming ?? useStreaming;
+    chunkSize = options.chunkSize ?? chunkSize;
+    includeComments = options.includeComments ?? includeComments;
     if (options.throws !== void 0) {
       throws = options.throws;
     }
@@ -71,10 +84,11 @@ export async function writeJson(file, object, options) {
     if (object === void 0) {
       throw new Error("Cannot write undefined as JSON");
     }
+    const isJsonc = extname(file).toLowerCase() === ".jsonc";
     if (isBun) {
       try {
         const fileRef = getFileBun(file);
-        const jsonString2 = JSON.stringify(object, replacer, spaces);
+        const jsonString2 = isJsonc ? stringifyJsonc(object, { includeComments, spaces: typeof spaces === "number" ? spaces : 2 }) : JSON.stringify(object, replacer, spaces);
         if (jsonString2 === void 0) {
           throw new Error("Failed to stringify JSON object");
         }
@@ -83,7 +97,32 @@ export async function writeJson(file, object, options) {
       } catch (error) {
       }
     }
-    const jsonString = JSON.stringify(object, replacer, spaces);
+    if (useStreaming) {
+      try {
+        const writeStream = createWriteStream(file, {
+          encoding,
+          mode: mode ? Number(mode) : void 0,
+          flags: flag,
+          highWaterMark: chunkSize
+          // Use chunkSize for stream buffer size
+        });
+        const jsonString2 = isJsonc ? stringifyJsonc(object, { includeComments, spaces: typeof spaces === "number" ? spaces : 2 }) : JSON.stringify(object, replacer, spaces);
+        if (jsonString2 === void 0) {
+          throw new Error("Failed to stringify JSON object");
+        }
+        const transform = new Transform({
+          transform(chunk, _encoding, callback) {
+            callback(null, chunk);
+          }
+        });
+        transform.write(jsonString2);
+        transform.end();
+        await pipeline(transform, writeStream);
+        return;
+      } catch (streamError) {
+      }
+    }
+    const jsonString = isJsonc ? stringifyJsonc(object, { includeComments, spaces: typeof spaces === "number" ? spaces : 2 }) : JSON.stringify(object, replacer, spaces);
     if (jsonString === void 0) {
       throw new Error("Failed to stringify JSON object");
     }