full-json-extractor 1.0.0 → 1.0.2

package/src/extractor.ts

@@ -1,208 +1,228 @@
+import IntervalTree from "interval-tree-1d";
+
 import {
-  BraceLocationInfo,
-  IntervalTreeType,
-  Limit,
-  MemoPosition,
+    BraceLocationInfo,
+    IntervalTreeType,
+    Limit,
+    MemoPosition,
 } from "./interfaces";
-import { Queue } from "./queue";
-import IntervalTree from "interval-tree-1d";
+import Denque from "denque";
 
 const LBRACE = "{";
 const RBRACE = "}";
 
 class JsonExtractError extends Error {}
 
-function convertMemoPositionToKey(memoPosition: MemoPosition) {
-  return `${memoPosition.left}-${memoPosition.right}`;
-}
-
-function generateBracesPrefixAndSufix(input: string): BraceLocationInfo {
-  const prefix: number[] = [];
-  const suffix: number[] = [];
-  const braceCounter: Map<number, number> = new Map();
-
-  for (let i = 0; i < input.length; i++) {
-    if (input[i] == LBRACE) {
-      prefix.push(i);
-      braceCounter.set(i, prefix.length - suffix.length);
-    } else if (input[i] == RBRACE) {
-      suffix.push(i);
-      braceCounter.set(i, prefix.length - suffix.length);
-    }
-  }
-
-  return {
-    prefix,
-    suffix,
-  };
-}
-
-function queryIntervalSync(
-  tree: IntervalTreeType,
-  low: number,
-  high: number,
-): boolean {
-  let intervalExists: boolean = false;
-  tree.queryInterval(low, high, (interval: [number, number]) => {
-    const [left, right] = interval;
-    if (left < low && high < right) {
-      intervalExists = true;
-      return;
-    }
-  });
-  return intervalExists;
-}
-
 /**
- * Coarse pre-check to filter out invalid json candidates. Short circuits if >1 json candidates exist in slice
- * @param input
- * @param left
- * @param right
- * @returns
+ * Extracts json objects from a given input string
+ * @param input input string
+ * @param limit Sets pre-check behavior. If set to 'log2', method will terminate pre-check after reaching log2(n) characters. Useful for extremely large malformed data i.e. many {} + non-json text
+ * Else, will do a O(n) pre-check scan to coarsely validate brace matches. Useful for many json objects (i.e. early termination)
+ * @returns array of JSON objects
  */
-function isBalancedWithOneJson(
-  input: string,
-  left: number,
-  right: number,
-  limit: Limit,
-): boolean {
-  const terminationThreshold = generateLimit(input, left, limit);
-  let braceCount = 0;
-  let inString = false;
-  let escapeNext = false;
-  let firstJsonObj = true;
-
-  for (let i = left; i <= right; i++) {
-    if (i >= terminationThreshold) {
-      return true;
-    }
-    const char = input[i];
-
-    if (escapeNext) {
-      escapeNext = false;
-      continue;
+export function extractJsons<T = unknown>(
+    input: string,
+    limit: Limit = "none",
+): T[] {
+    if (!input.length) {
+        return [];
     }
 
-    if (char === "\\") {
-      escapeNext = true;
-      continue;
+    const locations = generateBracesPrefixAndSufix(input);
+    if (!locations.prefix.length || !locations.suffix.length) {
+        return [];
     }
 
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-
-    if (inString) continue;
-
-    if (char === LBRACE) {
-      braceCount++;
-    } else if (char === RBRACE) {
-      braceCount--;
-    }
+    return findValidJsons<T>(locations, input, limit);
+}
 
-    if (braceCount < 0) {
-      return false;
+function setMapValue(
+    memo: Map<number, Set<number>>,
+    leftIndex: number,
+    rightIndex: number,
+): boolean {
+    let set = memo.get(leftIndex);
+    if (!set) {
+        set = new Set<number>();
+        memo.set(leftIndex, set);
     }
-
-    if (braceCount === 0) {
-      if (!firstJsonObj) {
+    if (set.has(rightIndex)) {
         return false;
-      }
-      firstJsonObj = !firstJsonObj;
     }
-  }
-
-  return braceCount === 0;
+    set.add(rightIndex);
+    return true;
 }
 
-function findValidJsons(
-  { prefix, suffix }: BraceLocationInfo,
-  input: string,
-  limit: Limit,
-): object[] {
-  const tree = IntervalTree();
-  const startingPosition: MemoPosition = {
-    left: 0,
-    right: suffix.length - 1,
-  };
-  const queue: Queue<MemoPosition> = new Queue(startingPosition);
-  const memo = new Set<string>([convertMemoPositionToKey(startingPosition)]);
-  const jsons: object[] = [];
-
-  while (queue.length()) {
-    const { left: leftIndex, right: rightIndex } = queue.dequeue()!;
-    const leftPosition: number = prefix[leftIndex]!;
-    const rightPosition: number = suffix[rightIndex]!;
-
-    if (
-      rightPosition < leftPosition ||
-      queryIntervalSync(tree, leftPosition, rightPosition)
-    ) {
-      continue;
+function findValidJsons<T = unknown>(
+    { prefix, suffix }: BraceLocationInfo,
+    input: string,
+    limit: Limit,
+): T[] {
+    const tree = IntervalTree();
+    const queue = new Denque<MemoPosition>([[0, suffix.length - 1]]);
+    const memo = new Map<number, Set<number>>([
+        [0, new Set([suffix.length - 1])],
+    ]);
+    const jsons: T[] = [];
+
+    while (!queue.isEmpty()) {
+        const [leftIndex, rightIndex] = queue.shift()!;
+        const leftPosition: number = prefix[leftIndex]!;
+        const rightPosition: number = suffix[rightIndex]!;
+
+        if (
+            rightPosition < leftPosition ||
+            queryIntervalSync(tree, leftPosition, rightPosition)
+        ) {
+            continue;
+        }
+
+        const set = memo.get(leftIndex)!;
+        set.delete(rightIndex);
+
+        try {
+            if (
+                isBalancedWithOneJson(input, leftPosition, rightPosition, limit)
+            ) {
+                jsons.push(
+                    JSON.parse(input.slice(leftPosition, rightPosition + 1)),
+                );
+                tree.insert([leftPosition, rightPosition]);
+                continue;
+            }
+        } catch (error) {
+            if (!(error instanceof SyntaxError)) {
+                throw error as JsonExtractError;
+            }
+        }
+        if (
+            rightIndex - 1 >= 0 &&
+            setMapValue(memo, leftIndex, rightIndex - 1)
+        ) {
+            queue.push([leftIndex, rightIndex - 1]);
+        }
+
+        if (
+            leftIndex + 1 < prefix.length &&
+            setMapValue(memo, leftIndex + 1, rightIndex)
+        ) {
+            queue.push([leftIndex + 1, rightIndex]);
+        }
+
+        if (!set.size) {
+            memo.delete(leftIndex);
+        }
     }
+    return jsons;
+}
 
-    try {
-      if (isBalancedWithOneJson(input, leftPosition, rightPosition, limit)) {
-        jsons.push(JSON.parse(input.slice(leftPosition, rightPosition + 1)));
-        tree.insert([leftPosition, rightPosition]);
-        continue;
-      }
-    } catch (error) {
-      if (!(error instanceof SyntaxError)) {
-        throw error as JsonExtractError;
-      }
+function generateBracesPrefixAndSufix(input: string): BraceLocationInfo {
+    const prefix: number[] = [];
+    const suffix: number[] = [];
+
+    for (let i = 0; i < input.length; i++) {
+        if (input[i] == LBRACE) {
+            prefix.push(i);
+        } else if (input[i] == RBRACE) {
+            suffix.push(i);
+        }
     }
 
-    const positions: MemoPosition[] = [
-      {
-        left: leftIndex,
-        right: rightIndex - 1 >= 0 ? rightIndex - 1 : rightIndex,
-      },
-      {
-        left: leftIndex + 1 < prefix.length ? leftIndex + 1 : leftIndex,
-        right: rightIndex,
-      },
-    ];
-
-    for (const position of positions) {
-      const key = convertMemoPositionToKey(position);
-      if (!memo.has(key)) {
-        queue.enqueue(position);
-        memo.add(key);
-      }
-    }
-  }
-  return jsons;
+    return {
+        prefix,
+        suffix,
+    };
 }
 
 function generateLimit(input: string, left: number, limit: Limit) {
-  switch (limit) {
-    case "log2":
-      return left + Math.ceil(Math.log2(input.length));
-    case "none":
-      return input.length;
-    default:
-      throw new JsonExtractError("unknown limit type provided");
-  }
+    switch (limit) {
+        case "log2":
+            return (
+                left +
+                Math.min(input.length, Math.ceil(Math.log2(input.length)))
+            );
+        case "none":
+            return input.length;
+        default:
+            throw new JsonExtractError("unknown limit type provided");
+    }
 }
 
 /**
- * Extracts json objects from a given input string
- * @param input input string
- * @param limit Sets pre-check behavior. If set to 'log2', method will terminate pre-check after reaching log2(n) characters. Useful for large malformed data i.e. many {} + non-json text
- * Else, will do a O(n) scan to coarsely validate brace matches. Useful for many json objects (i.e. early termination)
- * @returns array of JSON objects
+ * Coarse pre-check to filter out invalid json candidates. Short circuits if >1 json candidates exist in slice
+ * @param input
+ * @param left
+ * @param right
+ * @returns
  */
-export function extractJsons(input: string, limit: Limit = "none"): object[] {
-  if (!input?.length) {
-    return [];
-  }
+function isBalancedWithOneJson(
+    input: string,
+    left: number,
+    right: number,
+    limit: Limit,
+): boolean {
+    const terminationThreshold = generateLimit(input, left, limit);
+    let braceCount = 0;
+    let inString = false;
+    let escapeNext = false;
+    let firstJsonObj = true;
+
+    for (let i = left; i <= right; i++) {
+        if (i >= terminationThreshold) {
+            return true;
+        }
+
+        const char = input[i];
+
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+
+        if (char === "\\") {
+            escapeNext = true;
+            continue;
+        }
+
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+
+        if (inString) continue;
+
+        if (char === LBRACE) {
+            braceCount++;
+        } else if (char === RBRACE) {
+            braceCount--;
+        }
+
+        if (braceCount < 0) {
+            return false;
+        }
+
+        if (braceCount === 0) {
+            if (!firstJsonObj) {
+                return false;
+            }
+            firstJsonObj = !firstJsonObj;
+        }
+    }
 
-  const locations = generateBracesPrefixAndSufix(input);
-  if (!locations.prefix.length || !locations.suffix.length) {
-    return [];
-  }
+    return braceCount === 0;
+}
 
-  return findValidJsons(locations, input, limit);
+function queryIntervalSync(
+    tree: IntervalTreeType,
+    low: number,
+    high: number,
+): boolean {
+    let intervalExists = false;
+    tree.queryInterval(low, high, ([left, right]: [number, number]) => {
+        if (left < low && high < right) {
+            intervalExists = true;
+            return;
+        }
+    });
+    return intervalExists;
 }

package/src/interfaces.ts

@@ -1,37 +1,37 @@
-export type Interval = [number, number];
-
-interface IntervalTreeNode {
-  mid: number;
-  left: IntervalTreeNode | null;
-  right: IntervalTreeNode | null;
-  leftPoints: Interval[];
-  rightPoints: Interval[];
-  count: number;
-  intervals(result?: Interval[]): Interval[];
-  insert(interval: Interval): void;
-  remove(interval: Interval): number;
-  queryPoint(x: number, cb: (interval: Interval) => any): any;
-  queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+export interface BraceLocationInfo {
+    readonly prefix: number[];
+    readonly suffix: number[];
 }
 
+export type Interval = [number, number];
+
 export interface IntervalTreeType {
-  root: IntervalTreeNode | null;
-  insert(interval: Interval): void;
-  remove(interval: Interval): boolean;
-  queryPoint(x: number, cb: (interval: Interval) => any): any;
-  queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
-  readonly count: number;
-  readonly intervals: Interval[];
+    readonly count: number;
+    insert(interval: Interval): void;
+    readonly intervals: Interval[];
+    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+    queryPoint(x: number, cb: (interval: Interval) => any): any;
+    remove(interval: Interval): boolean;
+    root: IntervalTreeNode | null;
 }
 
-export interface MemoPosition {
-  readonly left: number;
-  readonly right: number;
-}
+export type Limit = "log2" | "none";
 
-export interface BraceLocationInfo {
-  readonly prefix: number[];
-  readonly suffix: number[];
-}
+/**
+ * [left, right]: [number, number]
+ */
+export type MemoPosition = [number, number];
 
-export type Limit = "log2" | "none";
+interface IntervalTreeNode {
+    count: number;
+    insert(interval: Interval): void;
+    intervals(result?: Interval[]): Interval[];
+    left: IntervalTreeNode | null;
+    leftPoints: Interval[];
+    mid: number;
+    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+    queryPoint(x: number, cb: (interval: Interval) => any): any;
+    remove(interval: Interval): number;
+    right: IntervalTreeNode | null;
+    rightPoints: Interval[];
+}

package/src/types/interval-tree-1d.d.ts

@@ -1,31 +1,39 @@
 declare module "interval-tree-1d" {
-  type Interval = [number, number];
+    type Interval = [number, number];
 
-  interface IntervalTreeNode {
-    mid: number;
-    left: IntervalTreeNode | null;
-    right: IntervalTreeNode | null;
-    leftPoints: Interval[];
-    rightPoints: Interval[];
-    count: number;
-    intervals(result?: Interval[]): Interval[];
-    insert(interval: Interval): void;
-    remove(interval: Interval): number;
-    queryPoint(x: number, cb: (interval: Interval) => any): any;
-    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
-  }
+    interface IntervalTree {
+        readonly count: number;
+        insert(interval: Interval): void;
+        readonly intervals: Interval[];
+        queryInterval(
+            lo: number,
+            hi: number,
+            cb: (interval: Interval) => any,
+        ): any;
+        queryPoint(x: number, cb: (interval: Interval) => any): any;
+        remove(interval: Interval): boolean;
+        root: IntervalTreeNode | null;
+    }
 
-  interface IntervalTree {
-    root: IntervalTreeNode | null;
-    insert(interval: Interval): void;
-    remove(interval: Interval): boolean;
-    queryPoint(x: number, cb: (interval: Interval) => any): any;
-    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
-    readonly count: number;
-    readonly intervals: Interval[];
-  }
+    interface IntervalTreeNode {
+        count: number;
+        insert(interval: Interval): void;
+        intervals(result?: Interval[]): Interval[];
+        left: IntervalTreeNode | null;
+        leftPoints: Interval[];
+        mid: number;
+        queryInterval(
+            lo: number,
+            hi: number,
+            cb: (interval: Interval) => any,
+        ): any;
+        queryPoint(x: number, cb: (interval: Interval) => any): any;
+        remove(interval: Interval): number;
+        right: IntervalTreeNode | null;
+        rightPoints: Interval[];
+    }
 
-  function createWrapper(intervals?: Interval[]): IntervalTree;
+    function createWrapper(intervals?: Interval[]): IntervalTree;
 
-  export = createWrapper;
+    export = createWrapper;
 }

package/tsconfig.json

@@ -49,6 +49,6 @@
   ],
   "exclude": [
     "node_modules",
-    "src/**/__tests__"
+    "src/**/__tests__",
   ]
 }

package/dist/queue.d.ts

@@ -1,10 +0,0 @@
-export declare class Queue<T> {
-    private popQueue;
-    private pushQueue;
-    constructor(...value: T[]);
-    private migratePushToPopQueue;
-    enqueue(...value: T[]): void;
-    dequeue(): T | null;
-    length(): number;
-}
-//# sourceMappingURL=queue.d.ts.map

package/dist/queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK,CAAC,CAAC;IAClB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,SAAS,CAAM;gBAEX,GAAG,KAAK,EAAE,CAAC,EAAE;IAKzB,OAAO,CAAC,qBAAqB;IAMtB,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAI5B,OAAO,IAAI,CAAC,GAAG,IAAI;IAYnB,MAAM,IAAI,MAAM;CAGxB"}

package/dist/queue.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
-class Queue {
-    popQueue;
-    pushQueue;
-    constructor(...value) {
-        this.popQueue = [];
-        this.pushQueue = value;
-    }
-    migratePushToPopQueue() {
-        while (this.pushQueue.length) {
-            this.popQueue.push(this.pushQueue.pop());
-        }
-    }
-    enqueue(...value) {
-        this.pushQueue.push(...value);
-    }
-    dequeue() {
-        if (!this.popQueue.length) {
-            this.migratePushToPopQueue();
-        }
-        if (!this.popQueue.length) {
-            return null;
-        }
-        else {
-            return this.popQueue.pop();
-        }
-    }
-    length() {
-        return this.popQueue.length + this.pushQueue.length;
-    }
-}
-exports.Queue = Queue;
-//# sourceMappingURL=queue.js.map

package/dist/queue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue.js","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":";;;AAAA,MAAa,KAAK;IACR,QAAQ,CAAM;IACd,SAAS,CAAM;IAEvB,YAAY,GAAG,KAAU;QACvB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IAEO,qBAAqB;QAC3B,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YAC7B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,EAAG,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC;IAEM,OAAO,CAAC,GAAG,KAAU;QAC1B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;IAChC,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAG,CAAC;QAC9B,CAAC;IACH,CAAC;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IACtD,CAAC;CACF;AAlCD,sBAkCC"}

package/src/queue.ts

@@ -1,35 +0,0 @@
-export class Queue<T> {
-  private popQueue: T[];
-  private pushQueue: T[];
-
-  constructor(...value: T[]) {
-    this.popQueue = [];
-    this.pushQueue = value;
-  }
-
-  private migratePushToPopQueue(): void {
-    while (this.pushQueue.length) {
-      this.popQueue.push(this.pushQueue.pop()!);
-    }
-  }
-
-  public enqueue(...value: T[]): void {
-    this.pushQueue.push(...value);
-  }
-
-  public dequeue(): T | null {
-    if (!this.popQueue.length) {
-      this.migratePushToPopQueue();
-    }
-
-    if (!this.popQueue.length) {
-      return null;
-    } else {
-      return this.popQueue.pop()!;
-    }
-  }
-
-  public length(): number {
-    return this.popQueue.length + this.pushQueue.length;
-  }
-}