@reliverse/relifso 1.4.0 → 1.4.2

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

@@ -0,0 +1,68 @@
+export function createInputBuffer() {
+  let buffer = "";
+  let offset = 0;
+  let currentLength = 0;
+  let closed = false;
+  function ensure(index) {
+    if (index < offset) {
+      throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`);
+    }
+    if (index >= currentLength) {
+      if (!closed) {
+        throw new Error(`${indexOutOfRangeMessage} (index: ${index})`);
+      }
+    }
+  }
+  function push(chunk) {
+    buffer += chunk;
+    currentLength += chunk.length;
+  }
+  function flush(position) {
+    if (position > currentLength) {
+      return;
+    }
+    buffer = buffer.substring(position - offset);
+    offset = position;
+  }
+  function charAt(index) {
+    ensure(index);
+    return buffer.charAt(index - offset);
+  }
+  function charCodeAt(index) {
+    ensure(index);
+    return buffer.charCodeAt(index - offset);
+  }
+  function substring(start, end) {
+    ensure(end - 1);
+    ensure(start);
+    return buffer.slice(start - offset, end - offset);
+  }
+  function length() {
+    if (!closed) {
+      throw new Error("Cannot get length: input is not yet closed");
+    }
+    return currentLength;
+  }
+  function isEnd(index) {
+    if (!closed) {
+      ensure(index);
+    }
+    return index >= currentLength;
+  }
+  function close() {
+    closed = true;
+  }
+  return {
+    push,
+    flush,
+    charAt,
+    charCodeAt,
+    substring,
+    length,
+    currentLength: () => currentLength,
+    currentBufferSize: () => buffer.length,
+    isEnd,
+    close
+  };
+}
+const indexOutOfRangeMessage = "Index out of range, please configure a larger buffer size";

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

@@ -0,0 +1,17 @@
+export interface OutputBuffer {
+    push: (text: string) => void;
+    unshift: (text: string) => void;
+    remove: (start: number, end?: number) => void;
+    insertAt: (index: number, text: string) => void;
+    length: () => number;
+    flush: () => void;
+    stripLastOccurrence: (textToStrip: string, stripRemainingText?: boolean) => void;
+    insertBeforeLastWhitespace: (textToInsert: string) => void;
+    endsWithIgnoringWhitespace: (char: string) => boolean;
+}
+export interface OutputBufferOptions {
+    write: (chunk: string) => void;
+    chunkSize: number;
+    bufferSize: number;
+}
+export declare function createOutputBuffer({ write, chunkSize, bufferSize }: OutputBufferOptions): OutputBuffer;

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

@@ -0,0 +1,101 @@
+import { isWhitespace } from "../../helpers/stringUtils.js";
+export function createOutputBuffer({ write, chunkSize, bufferSize }) {
+  let buffer = "";
+  let offset = 0;
+  function flushChunks(minSize = bufferSize) {
+    while (buffer.length >= minSize + chunkSize) {
+      const chunk = buffer.substring(0, chunkSize);
+      write(chunk);
+      offset += chunkSize;
+      buffer = buffer.substring(chunkSize);
+    }
+  }
+  function flush() {
+    flushChunks(0);
+    if (buffer.length > 0) {
+      write(buffer);
+      offset += buffer.length;
+      buffer = "";
+    }
+  }
+  function push(text) {
+    buffer += text;
+    flushChunks();
+  }
+  function unshift(text) {
+    if (offset > 0) {
+      throw new Error(`Cannot unshift: ${flushedMessage}`);
+    }
+    buffer = text + buffer;
+    flushChunks();
+  }
+  function remove(start, end) {
+    if (start < offset) {
+      throw new Error(`Cannot remove: ${flushedMessage}`);
+    }
+    if (end !== void 0) {
+      buffer = buffer.substring(0, start - offset) + buffer.substring(end - offset);
+    } else {
+      buffer = buffer.substring(0, start - offset);
+    }
+  }
+  function insertAt(index, text) {
+    if (index < offset) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, index - offset) + text + buffer.substring(index - offset);
+  }
+  function length() {
+    return offset + buffer.length;
+  }
+  function stripLastOccurrence(textToStrip, stripRemainingText = false) {
+    const bufferIndex = buffer.lastIndexOf(textToStrip);
+    if (bufferIndex !== -1) {
+      if (stripRemainingText) {
+        buffer = buffer.substring(0, bufferIndex);
+      } else {
+        buffer = buffer.substring(0, bufferIndex) + buffer.substring(bufferIndex + textToStrip.length);
+      }
+    }
+  }
+  function insertBeforeLastWhitespace(textToInsert) {
+    let bufferIndex = buffer.length;
+    if (!isWhitespace(buffer, bufferIndex - 1)) {
+      push(textToInsert);
+      return;
+    }
+    while (isWhitespace(buffer, bufferIndex - 1)) {
+      bufferIndex--;
+    }
+    if (bufferIndex <= 0) {
+      throw new Error(`Cannot insert: ${flushedMessage}`);
+    }
+    buffer = buffer.substring(0, bufferIndex) + textToInsert + buffer.substring(bufferIndex);
+    flushChunks();
+  }
+  function endsWithIgnoringWhitespace(char) {
+    let i = buffer.length - 1;
+    while (i > 0) {
+      if (char === buffer.charAt(i)) {
+        return true;
+      }
+      if (!isWhitespace(buffer, i)) {
+        return false;
+      }
+      i--;
+    }
+    return false;
+  }
+  return {
+    push,
+    unshift,
+    remove,
+    insertAt,
+    length,
+    flush,
+    stripLastOccurrence,
+    insertBeforeLastWhitespace,
+    endsWithIgnoringWhitespace
+  };
+}
+const flushedMessage = "start of the output is already flushed from the buffer";

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

@@ -0,0 +1,10 @@
+export interface JsonRepairCoreOptions {
+    onData: (chunk: string) => void;
+    chunkSize?: number;
+    bufferSize?: number;
+}
+export interface JsonRepairCore {
+    transform: (chunk: string) => void;
+    flush: () => void;
+}
+export declare function jsonrepairCore({ onData, bufferSize, chunkSize, }: JsonRepairCoreOptions): JsonRepairCore;