Merge branch 'chore/locked-update-diff' into feat/gui-view-hidden

Author: Elessar1802

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "@devtron-labs/devtron-fe-common-lib",
-    "version": "0.0.98",
+    "version": "0.0.97-beta-2",
     "description": "Supporting common component library",
     "type": "module",
     "main": "dist/index.js",
@@ -92,7 +92,6 @@
     "dependencies": {
         "ansi_up": "^5.2.1",
         "fast-json-patch": "^3.1.1",
-        "jsonpath-plus": "^7.2.0",
         "react-monaco-editor": "^0.54.0",
         "sass": "^1.69.7",
         "tslib": "^2.4.1"

package.json

@@ -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'
@@ -622,79 +620,110 @@ 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]
-            }
-        } else if (obj[key] === undefined) {
-            delete obj[key]
-        }
+/**
+ * Removes nulls from the arrays in the provided object
+ * @param {object} object from which we need to delete nulls in its arrays
+ * @returns object after removing (in-place) the null items in arrays
+ */
+export const recursivelyRemoveNullsFromArraysInObject = (object: object) => {
+    // NOTE: typeof null === 'object'
+    if (typeof object !== 'object' || !object) {
+        return object
+    }
+    if (Array.isArray(object)) {
+        return object.filter((item) => {
+            recursivelyRemoveNullsFromArraysInObject(item)
+            return !!item
+        })
     }
-    return Object.keys(obj).length === 0
+    Object.keys(object).forEach((key) => {
+        object[key] = recursivelyRemoveNullsFromArraysInObject(object[key])
+    })
+    return object
 }
 
-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 the objects into one object
+ * @param {object[]} 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]
-            }
-            const key = isNaN(Number(lastPath)) ? lastPath : parseInt(lastPath)
-            current[key] = element.value
+    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) }
+}
+
+/**
+ * Builds an object from the provided path
+ * @param {string} path JSON pointer path of the form /path/to/1/...
+ * @param {any} 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)]
+}
+
+/**
+ * Returns all the substrings from 0th index to progressively next regex match position
+ * Eg. Suppose a string is /path/to/folder then it will return [/path, /path/to, /path/to/folder]
+ * @param strings list of strings
+ * @param regex that matches the separators for the substrings
+ * @returns set of substrings
+ */
+export const powerSetOfSubstringsFromStart = (strings: string[], regex: RegExp) =>
+    strings.flatMap((key) => {
+        const _keys = [key]
+        const positions = getRegexMatchPositions(key, regex)
+        positions.forEach((position) => {
+            _keys.push(key.slice(0, position))
         })
+        return _keys
     })
-    // eslint-disable-next-line dot-notation
-    return resultJson['$']
-}
 
 /**
  * Returns a debounced variant of the function