@fixefy/fixefy-ui-utils 0.0.334 → 0.0.335

package/dist/src/json/index.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getJPart: function() {
+        return getJPart;
+    },
+    getJToken: function() {
+        return getJToken;
+    },
+    isHasKey: function() {
+        return isHasKey;
+    },
+    isJson: function() {
+        return isJson;
+    },
+    isNested: function() {
+        return isNested;
+    },
+    isResultValid: function() {
+        return isResultValid;
+    },
+    setJToken: function() {
+        return setJToken;
+    }
+});
+const _ = require("..");
+const getJToken = (jToken, jsonPath, defaultValue)=>{
+    // input check - if key is invalid - return error
+    if ((0, _.isObjectValid)(jToken) === false) return defaultValue;
+    // convert indexes to properties
+    jsonPath = jsonPath.replace(/\[(\w+)\]/g, '.$1');
+    // strip a leading dot
+    jsonPath = jsonPath.replace(/^\./, '');
+    // split path by '.'
+    let isContinueLoop = true;
+    let currentToken;
+    const jsonPathParts = jsonPath.split('.');
+    try {
+        //for ( let i = 0, n = jsonPathParts.length && isContinueLoop; i < n; ++i ) {
+        for(let i = 0, n = jsonPathParts.length; isContinueLoop && i < n; ++i){
+            currentToken = jsonPathParts[i];
+            if (typeof jToken === 'string') {
+                jToken = JSON.parse(jToken);
+            }
+            if (currentToken in jToken) {
+                jToken = jToken[currentToken];
+            } else {
+                // if something in the process failed:
+                //  1. set the rv as the default value
+                //  2. stop the loop
+                jToken = defaultValue;
+                isContinueLoop = false;
+            }
+        }
+    } catch (e) {
+        jToken = 'No Value Found';
+    }
+    return jToken;
+};
+const getJPart = (j, jsonPath, defaultValue)=>{
+    // if key is invalid - return error
+    if (j == null) return defaultValue;
+    // convert indexes to properties
+    jsonPath = jsonPath.replace(/\[(\w+)\]/g, '.$1');
+    // strip a leading dot
+    jsonPath = jsonPath.replace(/^\./, '');
+    // split path by '.'
+    let _isArrayValid = false, _isStringValid = false, currentPathPart, isLoop = true;
+    const pathParts = jsonPath.split('.');
+    for(let i = 0, n = pathParts.length; isLoop && i < n; ++i){
+        currentPathPart = pathParts[i];
+        _isStringValid = (0, _.isStringValid)(j);
+        _isArrayValid = (0, _.isArrayValid)(j);
+        if (_isStringValid === true || _isArrayValid === true) {
+            if (_isStringValid === true) {
+                j = JSON.parse(j);
+            } else {
+                j = j.reduce((acc, cur)=>{
+                    const innerJ = getJPart(cur, pathParts.slice(i).join('.'), defaultValue);
+                    if ((0, _.isArrayValid)(innerJ)) {
+                        acc.push(...innerJ);
+                    } else {
+                        acc.push(innerJ);
+                    }
+                    return acc;
+                }, []);
+                isLoop = false;
+            }
+        } else {
+            if (j[currentPathPart] != null && currentPathPart in j) {
+                j = j[currentPathPart];
+            } else {
+                // if something in the process failed:
+                //  1. set the rv as the default value
+                //  2. stop the loop`
+                j = defaultValue;
+                isLoop = false;
+            }
+        }
+    }
+    return j;
+};
+const isHasKey = (array, key)=>{
+    let rv = false, isContinueLoop = true, current_keys;
+    for(let i = 0; i < array.length && isContinueLoop; ++i){
+        current_keys = Object.keys(array[i]);
+        if ((current_keys || []).indexOf(key) > -1) {
+            rv = true;
+            isContinueLoop = false;
+        }
+    }
+    return rv;
+};
+const isJson = (obj)=>{
+    let objAsString;
+    try {
+        objAsString = JSON.stringify(obj);
+    } catch (e) {
+        objAsString = null;
+    }
+    if (!objAsString || (0, _.isStringValid)(objAsString) === false) return false;
+    const rv = (objAsString === null || objAsString === void 0 ? void 0 : objAsString.indexOf('{')) === 0 && (objAsString === null || objAsString === void 0 ? void 0 : objAsString.indexOf('}')) === (objAsString === null || objAsString === void 0 ? void 0 : objAsString.length) - 1;
+    return rv;
+};
+const isNested = (obj)=>{
+    const rv = Object.keys(obj).some((key)=>{
+        return obj[key] && typeof obj[key] === 'object';
+    });
+    return rv;
+};
+const isResultValid = (jResult)=>{
+    if ((0, _.isObjectValid)(jResult) === false) return false;
+    const rv = getJPart(jResult, 'ok', 0);
+    return !!rv;
+};
+const setJToken = (jEntity, fieldPathsAndValues)=>{
+    let jCurrentToken, currentPath, pathParts, fieldName;
+    for(let i = 0; i < fieldPathsAndValues.length; ++i){
+        currentPath = fieldPathsAndValues[i]['json_path'];
+        if ((0, _.isStringValid)(currentPath)) {
+            fieldName = currentPath;
+            pathParts = currentPath.split('.');
+            if ((0, _.isArrayValid)(pathParts)) {
+                fieldName = pathParts[pathParts.length - 1];
+                pathParts = pathParts.splice(0, Math.max(0, pathParts.length - 1));
+                if ((0, _.isArrayValid)(pathParts)) {
+                    currentPath = pathParts.join('.');
+                }
+            }
+            jCurrentToken = getJPart(jEntity, currentPath, null);
+            if ((0, _.isObjectValid)(jCurrentToken) || isJson(jCurrentToken) === false) {
+                jCurrentToken = jEntity;
+            }
+            jCurrentToken[fieldName] = fieldPathsAndValues[i]['value'];
+        }
+    }
+};