feat: remove dep of lock config diff from api

Author: Elessar1802

src/Common/Helper.tsx

@@ -17,8 +17,6 @@
 import React, { SyntheticEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { components } from 'react-select'
 import * as Sentry from '@sentry/browser'
-import * as jsonpatch from 'fast-json-patch'
-import { JSONPath } from 'jsonpath-plus'
 import moment from 'moment'
 import { useLocation } from 'react-router-dom'
 import { toast } from 'react-toastify'
@@ -619,79 +617,111 @@ export const getFilteredChartVersions = (charts, selectedChartType) =>
             chartRefId: item.chartRefId,
         }))
 
-function removeEmptyObjectKeysAndNullValues(obj, originaljsonCopy) {
-    // It recursively removes empty object keys and empty array keys
-    for (const key in obj) {
-        if (Array.isArray(obj[key])) {
-            // Check if the array is empty
-            if (obj[key].length !== 0) {
-                obj[key].forEach((element, index) => {
-                    if (element === null || (typeof element === 'object' && Object.keys(element).length === 0))
-                        obj[key].splice(index, 1)
-                    else removeEmptyObjectKeysAndNullValues(element, originaljsonCopy[key][index])
-                })
-            }
-            if (obj[key].length === 0 && originaljsonCopy[key].length !== 0) {
-                delete obj[key]
-            }
-        } else if (obj[key] && typeof obj[key] === 'object') {
-            if (
-                removeEmptyObjectKeysAndNullValues(obj[key], originaljsonCopy[key]) &&
-                Object.keys(originaljsonCopy[key]).length !== 0
-            ) {
-                delete obj[key]
+/**
+ * This function takes a list of strings and checks if the strings
+ * have prefix matches in the list of prefixes
+ * @param strings check if a @string has a prefix match in @prefixes
+ * @param prefixes list of prefixes
+ * @returns array of booleans corresponding to each string in @strings
+ */
+export const getPrefixMatches = (strings: string[], prefixes: string[]) => {
+    // NOTE: a trie could have been used but it would have been memory inefficient
+    const set = new Set(prefixes)
+    return strings.map((string) => {
+        for (let index = 0; index <= string.length; index++) {
+            // NOTE: slice in v8 is O(1) https://mrale.ph/blog/2016/11/23/making-less-dart-faster.html
+            // due to using SlicedString construct that only keeps pointer to original string
+            // alternative tries would be tree structure (hard to cache)
+            const slice = string.slice(0, index)
+            if (set.has(slice)) {
+                return true
             }
-        } else if (obj[key] === undefined) {
-            delete obj[key]
         }
-    }
-    return Object.keys(obj).length === 0
+        return false
+    })
 }
 
-export function getUnlockedJSON(json, jsonPathArray, removeParentKeysAndEmptyArrays = false) {
-    if (!jsonPathArray.length) return { newDocument: json, removedPatches: [] }
+const _joinObjects = (A: object, B: object) => {
+    if (typeof A !== 'object' || typeof B !== 'object' || !B) {
+        return
+    }
+    Object.keys(B).forEach((key) => {
+        if (!A[key]) {
+            A[key] = structuredClone(B[key])
+            return
+        }
+        _joinObjects(A[key], B[key])
+    })
+}
 
-    const jsonCopy = JSON.parse(JSON.stringify(json))
-    const originaljsonCopy = JSON.parse(JSON.stringify(json))
-    const removedPatches = []
-    const patches = jsonPathArray.flatMap((jsonPath) => {
-        const pathsToRemove = JSONPath({ path: jsonPath, json: jsonCopy, resultType: 'all' })
-        // reversing patches to handle correct array index deletion
-        pathsToRemove.reverse()
-        return pathsToRemove.map((result) => {
-            // storing removed patches to have functionality of undo
-            removedPatches.push({ op: 'add', path: result.pointer, value: result.value })
-            return { op: 'remove', path: result.pointer }
-        })
+/**
+ * Merges @objects into one
+ * @param objects list of js objects
+ * @returns object after the merge
+ */
+export const joinObjects = (objects: object[]) => {
+    const join = {}
+    objects.forEach((object) => {
+        _joinObjects(join, object)
     })
-    const { newDocument } = jsonpatch.applyPatch(jsonCopy, patches)
-    if (removeParentKeysAndEmptyArrays) removeEmptyObjectKeysAndNullValues(newDocument, originaljsonCopy)
-    return { newDocument, removedPatches: removedPatches.reverse() }
-}
-
-export function getLockedJSON(json, jsonPathArray: string[]) {
-    const jsonCopy = JSON.parse(JSON.stringify(json))
-    const resultJson = {}
-    jsonPathArray.forEach((jsonPath) => {
-        const elements = JSONPath({ path: jsonPath, json: jsonCopy, resultType: 'all' })
-        elements.forEach((element) => {
-            const pathArray: string[] = JSONPath.toPathArray(element.path)
-            const lastPath = pathArray.pop()
-            let current = resultJson
-            for (let i = 0; i < pathArray.length; i++) {
-                const key = isNaN(Number(pathArray[i])) ? pathArray[i] : parseInt(pathArray[i])
-                if (!current[key]) {
-                    current[key] = isNaN(Number(pathArray[i + 1] ?? lastPath)) ? {} : []
-                }
-                current = current[key]
+    return join
+}
+
+const buildObjectFromPathTokens = (index: number, tokens: string[], value: any) => {
+    if (index === tokens.length) {
+        return value
+    }
+    const key = tokens[index]
+    const numberKey = Number(key)
+    const isKeyNumber = !Number.isNaN(numberKey)
+    return isKeyNumber
+        ? [...Array(numberKey).fill(null), buildObjectFromPathTokens(index + 1, tokens, value)]
+        : { [key]: buildObjectFromPathTokens(index + 1, tokens, value) }
+}
+
+// TODO: learn how to write js doc comments
+/**
+ * Builds an object from the provided @path
+ * @param path JSON pointer path of the form /path/to/1/...
+ * @param value property value
+ * @returns final object formed from the path
+ */
+export const buildObjectFromPath = (path: string, value: any) => {
+    const parts = path.split('/')
+    // NOTE: since the path has a leading / we need to delete the first element
+    parts.splice(0, 1)
+    return buildObjectFromPathTokens(0, parts, value)
+}
+
+/**
+ * Returns the list of indices at which the regex matched
+ * @param string the string to process
+ * @param regex @RegExp
+ * @returns array of indices where the @regex matched in @string
+ */
+export const getRegexMatchPositions = (string: string, regex: RegExp): number[] => {
+    const pos = string.search(regex)
+    if (pos < 0) {
+        return []
+    }
+    const nextToken = string.slice(pos + 1)
+    return [pos, ...getRegexMatchPositions(nextToken, regex).map((n) => n + pos + 1)]
+}
+
+// TODO: write js doc comment
+export const powerSetOfSubstringsFromStart = (strings: string[]) =>
+    strings.flatMap((key) => {
+        const _keys = [key]
+        const positions = getRegexMatchPositions(key, /\.|\[|\]/g)
+        positions.forEach((position) => {
+            const ch = key.charAt(position)
+            if (ch === ']') {
+                return
             }
-            const key = isNaN(Number(lastPath)) ? lastPath : parseInt(lastPath)
-            current[key] = element.value
+            _keys.push(key.slice(0, position))
         })
+        return _keys
     })
-    // eslint-disable-next-line dot-notation
-    return resultJson['$']
-}
 
 /**
  * Returns a debounced variant of the function