@reliverse/relifso 1.4.4 → 2.2.7

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

@@ -1,17 +0,0 @@
-import type { WriteFileOptions } from "./write-file.js";
-/**
- * Ensures that the directory for the file exists and then writes the data to the file.
- *
- * @param file - The path to the file.
- * @param data - The data to write.
- * @param options - Options for writing the file (e.g., encoding, mode, flag).
- */
-export declare function outputFileSync(file: string, data: string | Uint8Array, options?: WriteFileOptions): void;
-/**
- * Ensures that the directory for the file exists and then asynchronously writes the data to the file.
- *
- * @param file - The path to the file.
- * @param data - The data to write.
- * @param options - Options for writing the file (e.g., encoding, mode, flag).
- */
-export declare function outputFile(file: string, data: string | Uint8Array, options?: WriteFileOptions): Promise<void>;

package/bin/impl/output-file.js

@@ -1,15 +0,0 @@
-import { dirname } from "node:path";
-import { mkdirsSync } from "./mkdirs.js";
-import { mkdirs } from "./mkdirs.js";
-import { writeFileSync } from "./write-file.js";
-import { writeFile } from "./write-file.js";
-export function outputFileSync(file, data, options) {
-  const dir = dirname(file);
-  mkdirsSync(dir);
-  writeFileSync(file, data, options);
-}
-export async function outputFile(file, data, options) {
-  const dir = dirname(file);
-  await mkdirs(dir);
-  await writeFile(file, data, options);
-}

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

@@ -1,21 +0,0 @@
-import type { WriteJsonOptions } from "./write-json.js";
-import { type JsonUtilsOptions } from "./json-utils.js";
-export interface OutputJsonOptions extends WriteJsonOptions {
-    useStreaming?: boolean;
-}
-/**
- * Ensures that the directory for the JSON file exists and then writes the JSON data to the file.
- *
- * @param file - The path to the file.
- * @param data - The JSON data to write.
- * @param options - Options for writing the JSON file (e.g., replacer, spaces).
- */
-export declare function outputJsonSync(file: string, data: unknown, options?: BufferEncoding | OutputJsonOptions): void;
-/**
- * Ensures that the directory for the JSON file exists and then asynchronously writes the JSON data to the file.
- *
- * @param file - The path to the file.
- * @param data - The JSON data to write.
- * @param options - Options for writing the JSON file (e.g., replacer, spaces).
- */
-export declare function outputJson(file: string, data: unknown, options?: BufferEncoding | OutputJsonOptions | JsonUtilsOptions): Promise<void>;

package/bin/impl/output-json.js

@@ -1,77 +0,0 @@
-import { createWriteStream } from "node:fs";
-import { Transform } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { logInternal } from "../utils/log.js";
-import { ensureJsonFileSync, ensureJsonFile } from "./json-utils.js";
-export function outputJsonSync(file, data, options) {
-  const jsonOptions = typeof options === "string" ? { encoding: options } : options ?? {};
-  ensureJsonFileSync(file, data, jsonOptions);
-}
-export async function outputJson(file, data, options) {
-  let useStreaming = false;
-  let encoding = "utf8";
-  let replacer;
-  let spaces;
-  let flag;
-  let mode;
-  let throws = true;
-  if (typeof options === "string") {
-    encoding = options;
-  } else if (options) {
-    if ("encoding" in options) {
-      encoding = options.encoding ?? encoding;
-    }
-    if ("replacer" in options) {
-      replacer = options.replacer;
-    }
-    if ("spaces" in options) {
-      spaces = options.spaces;
-    }
-    if ("flag" in options) {
-      flag = options.flag;
-    }
-    if ("mode" in options) {
-      mode = options.mode ? Number(options.mode) : void 0;
-    }
-    if ("useStreaming" in options) {
-      useStreaming = options.useStreaming ?? useStreaming;
-    }
-    if ("throws" in options && options.throws !== void 0) {
-      throws = options.throws;
-    }
-  }
-  try {
-    if (useStreaming) {
-      try {
-        const writeStream = createWriteStream(file, { encoding, mode, flags: flag });
-        const jsonString = JSON.stringify(data, replacer, spaces);
-        if (jsonString === void 0) {
-          throw new Error("Failed to stringify JSON object");
-        }
-        const transform = new Transform({
-          transform(chunk, _encoding, callback) {
-            callback(null, chunk);
-          }
-        });
-        transform.write(jsonString);
-        transform.end();
-        await pipeline(transform, writeStream);
-        return;
-      } catch (streamError) {
-      }
-    }
-    await ensureJsonFile(file, data, {
-      encoding,
-      replacer,
-      spaces,
-      flag,
-      mode,
-      throws,
-      useStreaming
-    });
-  } catch (err) {
-    if (throws) {
-      throw err;
-    }
-  }
-}

package/bin/impl/path-exists.d.ts

@@ -1,2 +0,0 @@
-export declare function pathExistsSync(path: string): boolean;
-export declare function pathExists(path: string): Promise<boolean>;

package/bin/impl/path-exists.js

@@ -1,16 +0,0 @@
-import { existsSync } from "node:fs";
-import { stat } from "node:fs/promises";
-export function pathExistsSync(path) {
-  return existsSync(path);
-}
-export async function pathExists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}

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

@@ -1,31 +0,0 @@
-export interface ReadFileOptions {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-    isJson?: boolean;
-    useStreaming?: boolean;
-    reviver?: (key: string, value: unknown) => unknown;
-}
-/**
- * Synchronously reads the entire contents of a file.
- *
- * @param path - The path to the file.
- * @param options - Options for reading the file. Can be an encoding string or an object.
- * @returns The contents of the file as a string.
- */
-export declare function readFileSync(path: string, options?: BufferEncoding | ReadFileOptions): string;
-export declare function readFileSync(path: string, encoding: BufferEncoding): string;
-export declare function readFileSync(path: string, options: {
-    encoding: BufferEncoding;
-}): string;
-/**
- * Asynchronously reads the entire contents of a file.
- *
- * @param path - The path to the file.
- * @param options - Options for reading the file. Can be an encoding string or an object.
- * @returns A promise that resolves with the contents of the file as a string.
- */
-export declare function readFile(path: string, options?: BufferEncoding | ReadFileOptions): Promise<string>;
-export declare function readFile(path: string, encoding: BufferEncoding): Promise<string>;
-export declare function readFile(path: string, options: {
-    encoding: BufferEncoding;
-}): Promise<string>;

package/bin/impl/read-file.js

@@ -1,165 +0,0 @@
-import { readFileSync as nodeReadFileSync } from "node:fs";
-import { createReadStream } from "node:fs";
-import { readFile as nodeReadFileAsync } from "node:fs/promises";
-import { Transform } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { jsonrepair } from "../utils/json/regular/jsonrepair.js";
-import { logInternal } from "../utils/log.js";
-import { isBun, getFileBun } from "./bun.js";
-export function readFileSync(path, options) {
-  let encoding;
-  let flag;
-  if (typeof options === "string") {
-    encoding = options;
-  } else if (options) {
-    encoding = options.encoding;
-    flag = options.flag;
-  }
-  if (isBun) {
-    try {
-      const file = getFileBun(path);
-      if (encoding) {
-        try {
-          const text = file.text();
-          if (text instanceof Promise) {
-            throw new Error("Bun's text() returned a Promise in sync context");
-          }
-          return text;
-        } catch (_error) {
-          const buffer = file.arrayBuffer();
-          if (buffer instanceof Promise) {
-            throw new Error("Bun's arrayBuffer() returned a Promise in sync context");
-          }
-          return Buffer.from(buffer).toString(encoding);
-        }
-      }
-      try {
-        const buffer = file.arrayBuffer();
-        if (buffer instanceof Promise) {
-          throw new Error("Bun's arrayBuffer() returned a Promise in sync context");
-        }
-        return Buffer.from(buffer).toString(encoding || "utf8");
-      } catch (_error) {
-        const text = file.text();
-        if (text instanceof Promise) {
-          throw new Error("Bun's text() returned a Promise in sync context");
-        }
-        return text;
-      }
-    } catch (error) {
-    }
-  }
-  if (encoding) {
-    return nodeReadFileSync(path, { encoding, flag });
-  }
-  return nodeReadFileSync(path, { encoding: "utf8", flag });
-}
-export async function readFile(path, options) {
-  let encoding;
-  let flag;
-  let isJson = false;
-  let useStreaming = false;
-  let reviver;
-  if (typeof options === "string") {
-    encoding = options;
-  } else if (options) {
-    encoding = options.encoding;
-    flag = options.flag;
-    isJson = options.isJson ?? isJson;
-    useStreaming = options.useStreaming ?? useStreaming;
-    reviver = options.reviver;
-  }
-  if (isBun) {
-    try {
-      const file = getFileBun(path);
-      if (encoding) {
-        try {
-          const result = await file.text();
-          if (isJson) {
-            try {
-              return JSON.stringify(JSON.parse(result, reviver));
-            } catch (_parseError) {
-              const repaired = jsonrepair(result);
-              return JSON.stringify(JSON.parse(repaired, reviver));
-            }
-          }
-          return result;
-        } catch (_error) {
-          const buffer = await file.arrayBuffer();
-          const text = Buffer.from(buffer).toString(encoding);
-          if (isJson) {
-            try {
-              return JSON.stringify(JSON.parse(text, reviver));
-            } catch (_parseError) {
-              const repaired = jsonrepair(text);
-              return JSON.stringify(JSON.parse(repaired, reviver));
-            }
-          }
-          return text;
-        }
-      }
-      try {
-        const buffer = await file.arrayBuffer();
-        const text = Buffer.from(buffer).toString(encoding || "utf8");
-        if (isJson) {
-          try {
-            return JSON.stringify(JSON.parse(text, reviver));
-          } catch (_parseError) {
-            const repaired = jsonrepair(text);
-            return JSON.stringify(JSON.parse(repaired, reviver));
-          }
-        }
-        return text;
-      } catch (_error) {
-        const text = await file.text();
-        if (isJson) {
-          try {
-            return JSON.stringify(JSON.parse(text, reviver));
-          } catch (_parseError) {
-            const repaired = jsonrepair(text);
-            return JSON.stringify(JSON.parse(repaired, reviver));
-          }
-        }
-        return text;
-      }
-    } catch (error) {
-    }
-  }
-  if (useStreaming && encoding) {
-    try {
-      const chunks = [];
-      const transform = new Transform({
-        transform(chunk, _encoding, callback) {
-          chunks.push(chunk.toString());
-          callback();
-        }
-      });
-      const readStream = createReadStream(path, { encoding, flags: flag });
-      await pipeline(readStream, transform);
-      const text = chunks.join("");
-      if (isJson) {
-        try {
-          return JSON.stringify(JSON.parse(text, reviver));
-        } catch (_parseError) {
-          const repaired = jsonrepair(text);
-          return JSON.stringify(JSON.parse(repaired, reviver));
-        }
-      }
-      return text;
-    } catch (streamError) {
-    }
-  }
-  if (encoding) {
-    const text = await nodeReadFileAsync(path, { encoding, flag });
-    if (isJson) {
-      try {
-        return JSON.stringify(JSON.parse(text, reviver));
-      } catch (_parseError) {
-        const repaired = jsonrepair(text);
-        return JSON.stringify(JSON.parse(repaired, reviver));
-      }
-    }
-    return text;
-  }
-  return await nodeReadFileAsync(path, { encoding: "utf8", flag });
-}

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

@@ -1,31 +0,0 @@
-export interface ReadJsonOptions {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-    reviver?: (key: string, value: unknown) => unknown;
-    throws?: boolean;
-    defaultValue?: unknown;
-    ensure?: boolean;
-    useStreaming?: boolean;
-    /**
-     * Whether to preserve comments when reading JSONC files
-     * @default false
-     */
-    preserveComments?: boolean;
-}
-/**
- * Reads a JSON file and then parses it into an object.
- * If the file doesn't exist and ensure is true, creates the file with defaultValue.
- *
- * @param file - The path to the file.
- * @param options - Options for reading the file or parsing JSON. Can be an encoding string or an object.
- * @returns The parsed JSON object.
- */
-export declare function readJsonSync<T = unknown>(file: string, options?: BufferEncoding | ReadJsonOptions): T;
-/**
- * Asynchronously reads a JSON file and then parses it into an object.
- *
- * @param file - The path to the file.
- * @param options - Options for reading the file or parsing JSON. Can be an encoding string or an object.
- * @returns A promise that resolves with the parsed JSON object.
- */
-export declare function readJson<T = unknown>(file: string, options?: BufferEncoding | ReadJsonOptions): Promise<T>;

package/bin/impl/read-json.js

@@ -1,241 +0,0 @@
-import { readFileSync, createReadStream } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { extname } from "node:path";
-import { Transform } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { parseJsonc, isValidJsonc } from "../utils/json/regular/jsonc.js";
-import { jsonrepair } from "../utils/json/regular/jsonrepair.js";
-import { logInternal } from "../utils/log.js";
-import { isBun, getFileBun } from "./bun.js";
-import { ensureJsonFileSync } from "./json-utils.js";
-import { pathExistsSync } from "./path-exists.js";
-export function readJsonSync(file, options) {
-  let encoding = "utf8";
-  let reviver;
-  let throws = true;
-  let defaultValue = { sync: true };
-  let ensure = true;
-  let preserveComments = false;
-  if (typeof options === "string") {
-    encoding = options;
-  } else if (options) {
-    encoding = options.encoding ?? encoding;
-    reviver = options.reviver;
-    if (options.throws !== void 0) {
-      throws = options.throws;
-    }
-    if (options.defaultValue !== void 0) {
-      defaultValue = options.defaultValue;
-    }
-    if (options.ensure !== void 0) {
-      ensure = options.ensure;
-    }
-    if (options.preserveComments !== void 0) {
-      preserveComments = options.preserveComments;
-    }
-  }
-  try {
-    if (!pathExistsSync(file) && ensure) {
-      ensureJsonFileSync(file, defaultValue);
-      return defaultValue;
-    }
-    if (isBun) {
-      try {
-        const fileRef = getFileBun(file);
-        try {
-          const parsed = fileRef.json();
-          if (parsed instanceof Promise) {
-            throw new Error("Bun's json() returned a Promise in sync context");
-          }
-          if (parsed === null || typeof parsed !== "object") {
-            if (throws) {
-              throw new Error("Invalid JSON data: expected an object");
-            }
-            return defaultValue;
-          }
-          return parsed;
-        } catch (parseError) {
-          if (throws) {
-            throw parseError;
-          }
-          return defaultValue;
-        }
-      } catch (error) {
-      }
-    }
-    const data = readFileSync(file, { encoding });
-    if (!data || !data.trim()) {
-      return defaultValue;
-    }
-    const isJsonc = extname(file).toLowerCase() === ".jsonc" || isValidJsonc(data);
-    try {
-      if (isJsonc) {
-        const parsed = parseJsonc(data, { preserveComments, throws });
-        if (parsed === null || typeof parsed !== "object") {
-          if (throws) {
-            throw new Error("Invalid JSONC data: expected an object");
-          }
-          return defaultValue;
-        }
-        return parsed;
-      } else {
-        const parsed = JSON.parse(data, reviver);
-        if (parsed === null || typeof parsed !== "object") {
-          if (throws) {
-            throw new Error("Invalid JSON data: expected an object");
-          }
-          return defaultValue;
-        }
-        return parsed;
-      }
-    } catch (parseError) {
-      try {
-        const repaired = jsonrepair(data);
-        const parsed = JSON.parse(repaired, reviver);
-        if (parsed === null || typeof parsed !== "object") {
-          if (throws) {
-            throw parseError;
-          }
-          return defaultValue;
-        }
-        return parsed;
-      } catch (_repairError) {
-        if (throws) {
-          throw parseError;
-        }
-        return defaultValue;
-      }
-    }
-  } catch (err) {
-    if (throws) {
-      throw err;
-    }
-    return defaultValue;
-  }
-}
-export async function readJson(file, options) {
-  let encoding = "utf8";
-  let reviver;
-  let throws = true;
-  let flag;
-  let defaultValue = {};
-  let useStreaming = false;
-  if (typeof options === "string") {
-    encoding = options;
-  } else if (options) {
-    encoding = options.encoding ?? encoding;
-    reviver = options.reviver;
-    flag = options.flag;
-    useStreaming = options.useStreaming ?? useStreaming;
-    if (options.throws !== void 0) {
-      throws = options.throws;
-    }
-    if (options.defaultValue !== void 0) {
-      defaultValue = options.defaultValue;
-    }
-  }
-  try {
-    if (isBun) {
-      try {
-        const fileRef = getFileBun(file);
-        try {
-          const parsed = await fileRef.json();
-          if (parsed === null || typeof parsed !== "object") {
-            if (throws) {
-              throw new Error("Invalid JSON data: expected an object");
-            }
-            return defaultValue;
-          }
-          return parsed;
-        } catch (parseError) {
-          if (throws) {
-            throw parseError;
-          }
-          return defaultValue;
-        }
-      } catch (error) {
-      }
-    }
-    if (useStreaming) {
-      try {
-        const chunks = [];
-        const transform = new Transform({
-          transform(chunk, _encoding, callback) {
-            chunks.push(chunk.toString());
-            callback();
-          }
-        });
-        const readStream = createReadStream(file, { encoding, flags: flag });
-        await pipeline(readStream, transform);
-        const data2 = chunks.join("");
-        if (!data2 || !data2.trim()) {
-          return defaultValue;
-        }
-        try {
-          const parsed = JSON.parse(data2, reviver);
-          if (parsed === null || typeof parsed !== "object") {
-            if (throws) {
-              throw new Error("Invalid JSON data: expected an object");
-            }
-            return defaultValue;
-          }
-          return parsed;
-        } catch (parseError) {
-          try {
-            const repaired = jsonrepair(data2);
-            const parsed = JSON.parse(repaired, reviver);
-            if (parsed === null || typeof parsed !== "object") {
-              if (throws) {
-                throw parseError;
-              }
-              return defaultValue;
-            }
-            return parsed;
-          } catch (_repairError) {
-            if (throws) {
-              throw parseError;
-            }
-            return defaultValue;
-          }
-        }
-      } catch (streamError) {
-      }
-    }
-    const data = await readFile(file, { encoding, flag });
-    if (!data || !data.trim()) {
-      return defaultValue;
-    }
-    try {
-      const parsed = JSON.parse(data, reviver);
-      if (parsed === null || typeof parsed !== "object") {
-        if (throws) {
-          throw new Error("Invalid JSON data: expected an object");
-        }
-        return defaultValue;
-      }
-      return parsed;
-    } catch (parseError) {
-      try {
-        const repaired = jsonrepair(data);
-        const parsed = JSON.parse(repaired, reviver);
-        if (parsed === null || typeof parsed !== "object") {
-          if (throws) {
-            throw parseError;
-          }
-          return defaultValue;
-        }
-        return parsed;
-      } catch (_repairError) {
-        if (throws) {
-          throw parseError;
-        }
-        return defaultValue;
-      }
-    }
-  } catch (err) {
-    if (throws) {
-      throw err;
-    }
-    return defaultValue;
-  }
-}

package/bin/impl/remove.d.ts

@@ -1,2 +0,0 @@
-export declare function removeSync(path: string): void;
-export declare function remove(path: string): Promise<void>;

package/bin/impl/remove.js

@@ -1,8 +0,0 @@
-import { rmSync } from "node:fs";
-import { rm } from "node:fs/promises";
-export function removeSync(path) {
-  return rmSync(path, { recursive: true, force: true });
-}
-export async function remove(path) {
-  return rm(path, { recursive: true, force: true });
-}

package/bin/impl/stats.d.ts

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