@reliverse/relifso 1.4.0 → 1.4.1

package/bin/utils/json/stream/jsonl.js

@@ -0,0 +1,55 @@
+import { Transform } from "node:stream";
+import { JsonStreamError } from "./JsonStreamError.js";
+export function createJsonlParser(options = {}) {
+  const {
+    chunkSize = 1024 * 1024,
+    // 1MB default chunk size
+    reviver
+  } = options;
+  let buffer = "";
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const text = chunk.toString();
+        buffer += text;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.trim()) {
+            try {
+              const parsed = JSON.parse(line, reviver);
+              this.push(parsed);
+            } catch (error) {
+              const parseError = error;
+              throw new JsonStreamError(`Failed to parse JSONL line: ${parseError.message}`);
+            }
+          }
+        }
+        if (buffer.length > chunkSize) {
+          throw new JsonStreamError("Chunk size exceeded without finding complete JSONL line");
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}
+export function createJsonlWriter(options = {}) {
+  const { replacer } = options;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const jsonStr = JSON.stringify(chunk, replacer);
+        if (jsonStr === void 0) {
+          throw new JsonStreamError("Failed to stringify JSON object");
+        }
+        this.push(`${jsonStr}
+`);
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}

package/bin/utils/json/stream/parser.d.ts

@@ -0,0 +1,14 @@
+import { Transform } from "node:stream";
+interface ParserOptions {
+    chunkSize?: number;
+    maxDepth?: number;
+    reviver?: (key: string, value: unknown) => unknown;
+}
+/**
+ * Creates a transform stream that parses JSON data chunk by chunk.
+ *
+ * @param options - Parser options
+ * @returns A transform stream that emits parsed JSON objects
+ */
+export declare function createJsonStreamParser(options?: ParserOptions): Transform;
+export {};

package/bin/utils/json/stream/parser.js

@@ -0,0 +1,81 @@
+import { Transform } from "node:stream";
+import { JsonStreamError } from "./JsonStreamError.js";
+export function createJsonStreamParser(options = {}) {
+  const {
+    chunkSize = 1024 * 1024,
+    // 1MB default chunk size
+    maxDepth = 100,
+    reviver
+  } = options;
+  let buffer = "";
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const text = chunk.toString();
+        buffer += text;
+        while (buffer.length > 0) {
+          const start = buffer.indexOf("{");
+          if (start === -1) {
+            buffer = "";
+            break;
+          }
+          buffer = buffer.slice(start);
+          depth = 0;
+          inString = false;
+          escapeNext = false;
+          let end = -1;
+          for (let i = 0; i < buffer.length; i++) {
+            const char = buffer[i];
+            if (escapeNext) {
+              escapeNext = false;
+              continue;
+            }
+            if (char === "\\") {
+              escapeNext = true;
+              continue;
+            }
+            if (char === '"' && !escapeNext) {
+              inString = !inString;
+              continue;
+            }
+            if (!inString) {
+              if (char === "{") {
+                depth++;
+                if (depth > maxDepth) {
+                  throw new JsonStreamError(`Maximum nesting depth of ${maxDepth} exceeded`);
+                }
+              } else if (char === "}") {
+                depth--;
+                if (depth === 0) {
+                  end = i + 1;
+                  break;
+                }
+              }
+            }
+          }
+          if (end === -1) {
+            if (buffer.length > chunkSize) {
+              throw new JsonStreamError("Chunk size exceeded without finding complete JSON object");
+            }
+            break;
+          }
+          const jsonStr = buffer.slice(0, end);
+          try {
+            const parsed = JSON.parse(jsonStr, reviver);
+            this.push(parsed);
+          } catch (error) {
+            const parseError = error;
+            throw new JsonStreamError(`Failed to parse JSON: ${parseError.message}`);
+          }
+          buffer = buffer.slice(end);
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}

package/bin/utils/json/stream/stack.d.ts

@@ -0,0 +1,19 @@
+export declare enum Caret {
+    beforeValue = "beforeValue",
+    afterValue = "afterValue",
+    beforeKey = "beforeKey"
+}
+export declare enum StackType {
+    root = "root",
+    object = "object",
+    array = "array",
+    ndJson = "ndJson",
+    functionCall = "dataType"
+}
+export declare function createStack(): {
+    readonly type: StackType | undefined;
+    readonly caret: Caret;
+    pop(): true;
+    push(type: StackType, newCaret: Caret): true;
+    update(newCaret: Caret): true;
+};

package/bin/utils/json/stream/stack.js

@@ -0,0 +1,43 @@
+export var Caret = /* @__PURE__ */ ((Caret2) => {
+  Caret2["beforeValue"] = "beforeValue";
+  Caret2["afterValue"] = "afterValue";
+  Caret2["beforeKey"] = "beforeKey";
+  return Caret2;
+})(Caret || {});
+export var StackType = /* @__PURE__ */ ((StackType2) => {
+  StackType2["root"] = "root";
+  StackType2["object"] = "object";
+  StackType2["array"] = "array";
+  StackType2["ndJson"] = "ndJson";
+  StackType2["functionCall"] = "dataType";
+  return StackType2;
+})(StackType || {});
+export function createStack() {
+  const stack = ["root" /* root */];
+  let caret = "beforeValue" /* beforeValue */;
+  return {
+    get type() {
+      return last(stack);
+    },
+    get caret() {
+      return caret;
+    },
+    pop() {
+      stack.pop();
+      caret = "afterValue" /* afterValue */;
+      return true;
+    },
+    push(type, newCaret) {
+      stack.push(type);
+      caret = newCaret;
+      return true;
+    },
+    update(newCaret) {
+      caret = newCaret;
+      return true;
+    }
+  };
+}
+function last(array) {
+  return array[array.length - 1];
+}

package/bin/utils/json/stream/stream.d.ts

@@ -0,0 +1,6 @@
+import { Transform } from "node:stream";
+export interface JsonRepairTransformOptions {
+    chunkSize?: number;
+    bufferSize?: number;
+}
+export declare function jsonrepairTransform(options?: JsonRepairTransformOptions): Transform;

package/bin/utils/json/stream/stream.js

@@ -0,0 +1,30 @@
+import { Transform } from "node:stream";
+import { jsonrepairCore } from "./core.js";
+export function jsonrepairTransform(options) {
+  const repair = jsonrepairCore({
+    onData: (chunk) => transform.push(chunk),
+    bufferSize: options?.bufferSize,
+    chunkSize: options?.chunkSize
+  });
+  const transform = new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        repair.transform(chunk.toString());
+      } catch (err) {
+        this.emit("error", err);
+      } finally {
+        callback();
+      }
+    },
+    flush(callback) {
+      try {
+        repair.flush();
+      } catch (err) {
+        this.emit("error", err);
+      } finally {
+        callback();
+      }
+    }
+  });
+  return transform;
+}

package/bin/utils/json/stream/writer.d.ts

@@ -0,0 +1,14 @@
+import { Transform } from "node:stream";
+interface WriterOptions {
+    chunkSize?: number;
+    replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
+    spaces?: string | number;
+}
+/**
+ * Creates a transform stream that writes JSON data chunk by chunk.
+ *
+ * @param options - Writer options
+ * @returns A transform stream that accepts objects and outputs JSON strings
+ */
+export declare function createJsonStreamWriter(options?: WriterOptions): Transform;
+export {};

package/bin/utils/json/stream/writer.js

@@ -0,0 +1,44 @@
+import { Transform } from "node:stream";
+import { JsonStreamError } from "./JsonStreamError.js";
+export function createJsonStreamWriter(options = {}) {
+  const {
+    chunkSize = 1024 * 1024,
+    // 1MB default chunk size
+    replacer,
+    spaces
+  } = options;
+  let isFirst = true;
+  let buffer = "";
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const jsonStr = JSON.stringify(chunk, replacer, spaces);
+        if (jsonStr === void 0) {
+          throw new JsonStreamError("Failed to stringify JSON object");
+        }
+        if (!isFirst) {
+          buffer += ",";
+        }
+        isFirst = false;
+        buffer += jsonStr;
+        if (buffer.length >= chunkSize) {
+          this.push(buffer);
+          buffer = "";
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    },
+    flush(callback) {
+      try {
+        if (buffer.length > 0) {
+          this.push(buffer);
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}

package/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "name": "@reliverse/relifso",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "keywords": [
     "fs",
     "file",
@@ -38,7 +38,8 @@
     "bin",
     "package.json",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "LICENSES"
   ],
   "main": "./bin/mod.js",
   "module": "./bin/mod.js",

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

@@ -1,2 +0,0 @@
-export declare function createFileSync(file: string, content?: string): void;
-export declare function createFile(file: string, content?: string): Promise<void>;

package/bin/impl/create-file.js

@@ -1,21 +0,0 @@
-import { existsSync } from "node:fs";
-import { stat } from "node:fs/promises";
-import { writeFileSync } from "./write-file.js";
-import { writeFile } from "./write-file.js";
-export function createFileSync(file, content = "") {
-  if (existsSync(file)) {
-    return;
-  }
-  return writeFileSync(file, content);
-}
-export async function createFile(file, content = "") {
-  try {
-    await stat(file);
-    return;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return writeFile(file, content);
-    }
-    throw error;
-  }
-}

package/bin/impl/dive-async.d.ts

@@ -1,11 +0,0 @@
-import type { Stats } from "node:fs";
-import type { DiveOptions } from "./dive.js";
-/**
- * Recursively dives into a directory and yields files and directories.
- * @param directory - The directory to dive into.
- * @param action - An optional callback function to execute for each file or directory.
- * @param options - An optional object containing options for the dive.
- * @returns A Promise that resolves to an array of file paths if no action is provided, or void if an action is provided.
- */
-export declare function dive(directory: string, action: (file: string, stat: Stats) => void | Promise<void>, options?: DiveOptions): Promise<void>;
-export declare function dive(directory: string, options?: DiveOptions): Promise<string[]>;

package/bin/impl/dive-async.js

@@ -1,88 +0,0 @@
-import { readdir as nodeReaddirInternal, stat as nodeStatInternal } from "node:fs/promises";
-import { join as pathJoin } from "node:path";
-import { isBun, getStatsBun } from "./bun.js";
-async function* _diveWorker(currentPath, options, currentDepth) {
-  const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
-  if (currentDepth > maxDepth) {
-    return;
-  }
-  let entries;
-  try {
-    entries = await nodeReaddirInternal(currentPath, { withFileTypes: true });
-  } catch (_err) {
-    return;
-  }
-  for (const entry of entries) {
-    const entryPath = pathJoin(currentPath, entry.name);
-    if (!(options.all ?? false) && entry.name.startsWith(".")) {
-      continue;
-    }
-    if (options.ignore) {
-      if (Array.isArray(options.ignore) && options.ignore.some((pattern) => entry.name.includes(pattern))) {
-        continue;
-      }
-      if (options.ignore instanceof RegExp && options.ignore.test(entryPath)) {
-        continue;
-      }
-    }
-    let entryStat;
-    try {
-      if (isBun) {
-        try {
-          entryStat = await getStatsBun(entryPath);
-        } catch (_error) {
-          entryStat = await nodeStatInternal(entryPath);
-        }
-      } else {
-        entryStat = await nodeStatInternal(entryPath);
-      }
-    } catch (_err) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      if (options.directories ?? false) {
-        yield { file: entryPath, stat: entryStat };
-      }
-      if (options.recursive ?? true) {
-        if (currentDepth < maxDepth) {
-          yield* _diveWorker(entryPath, options, currentDepth + 1);
-        }
-      }
-    } else if (entry.isFile()) {
-      if (options.files ?? true) {
-        yield { file: entryPath, stat: entryStat };
-      }
-    }
-  }
-}
-export async function dive(directory, actionOrOptions, optionsOnly) {
-  let action;
-  let options;
-  if (typeof actionOrOptions === "function") {
-    action = actionOrOptions;
-    options = optionsOnly;
-  } else {
-    options = actionOrOptions;
-  }
-  const currentOptions = {
-    recursive: true,
-    files: true,
-    directories: false,
-    all: false,
-    depth: Number.POSITIVE_INFINITY,
-    ...options
-    // User options override defaults
-  };
-  if (action) {
-    for await (const { file, stat: entryStat } of _diveWorker(directory, currentOptions, 0)) {
-      await action(file, entryStat);
-    }
-    return;
-  } else {
-    const results = [];
-    for await (const { file } of _diveWorker(directory, currentOptions, 0)) {
-      results.push(file);
-    }
-    return results;
-  }
-}

package/bin/impl/empty-dir.d.ts

@@ -1,2 +0,0 @@
-export declare function emptyDirSync(dir: string): void;
-export declare function emptyDir(dir: string): Promise<void>;

package/bin/impl/empty-dir.js

@@ -1,24 +0,0 @@
-import { existsSync, readdirSync, rmSync } from "node:fs";
-import { readdir, rm, stat } from "node:fs/promises";
-import path from "node:path";
-export function emptyDirSync(dir) {
-  if (!existsSync(dir)) {
-    return;
-  }
-  for (const file of readdirSync(dir)) {
-    rmSync(path.resolve(dir, file), { recursive: true, force: true });
-  }
-}
-export async function emptyDir(dir) {
-  try {
-    await stat(dir);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return;
-    }
-    throw error;
-  }
-  for (const file of await readdir(dir)) {
-    await rm(path.resolve(dir, file), { recursive: true, force: true });
-  }
-}

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

@@ -1,20 +0,0 @@
-export declare function readText(filePath: string, options?: BufferEncoding | {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-}): Promise<string | Buffer<ArrayBufferLike>>;
-export declare function readTextSync(filePath: string, options?: BufferEncoding | {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-}): string | Buffer<ArrayBufferLike>;
-export declare function readLines(filePath: string, options?: BufferEncoding | {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-}): Promise<string[]>;
-export declare function readLinesSync(filePath: string, options?: BufferEncoding | {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-}): string[];
-export declare function isDirectory(filePath: string): Promise<boolean>;
-export declare function isDirectorySync(filePath: string): boolean;
-export declare function isSymlink(filePath: string): Promise<boolean>;
-export declare function isSymlinkSync(filePath: string): boolean;

package/bin/impl/file-utils.js

@@ -1,63 +0,0 @@
-import { statSync, lstatSync } from "node:fs";
-import { stat, lstat } from "node:fs/promises";
-import { readFile, readFileSync } from "./read-file.js";
-export async function readText(filePath, options = "utf8") {
-  return readFile(filePath, options);
-}
-export function readTextSync(filePath, options = "utf8") {
-  return readFileSync(filePath, options);
-}
-export async function readLines(filePath, options = { encoding: "utf8" }) {
-  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
-  const contentBuffer = await readFile(filePath, { ...effectiveOptions, encoding: null });
-  return contentBuffer.toString().split(/\r?\n/);
-}
-export function readLinesSync(filePath, options = { encoding: "utf8" }) {
-  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
-  const contentBuffer = readFileSync(filePath, { ...effectiveOptions, encoding: null });
-  return contentBuffer.toString().split(/\r?\n/);
-}
-export async function isDirectory(filePath) {
-  try {
-    const stats = await stat(filePath);
-    return stats.isDirectory();
-  } catch (error) {
-    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
-      return false;
-    }
-    throw error;
-  }
-}
-export function isDirectorySync(filePath) {
-  try {
-    const stats = statSync(filePath);
-    return stats.isDirectory();
-  } catch (error) {
-    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
-      return false;
-    }
-    throw error;
-  }
-}
-export async function isSymlink(filePath) {
-  try {
-    const stats = await lstat(filePath);
-    return stats.isSymbolicLink();
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-export function isSymlinkSync(filePath) {
-  try {
-    const stats = lstatSync(filePath);
-    return stats.isSymbolicLink();
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}