base64-text-decoder/dist/umd/base64TextDecoder.js

Decodes any Base64 encoded strings in Strings, Arrays, Objects and URL search params.

(function (factory) {
  typeof define === 'function' && define.amd ? define(factory) :
  factory();
}((function () { 'use strict';

  var global = typeof self !== undefined ? self : this;

  var _this = undefined;

  var isBase64 = require("is-base64");

  var isJSON = require("is-json");

  var isString = require("is-string");

  var isPlainObject = require("is-plain-object").isPlainObject;

  var decode = require("js-base64").decode;

  var _getText = function _getText(something) {
    if (Array.isArray(something)) {
      var result = [];
      something.forEach(function (element) {
        result.push(_getText(element));
      });
      return result;
    } else if (isPlainObject(something)) {
      return processObject(something);
    } else if (isBase64(something)) {
      // console.log(`Processing a base64 encoded string:`, something);
      return decode(something);
    } else if (isJSON(something)) {
      try {
        // console.log(`Processing what seems to be JSON:`, something);
        var somethingParsed = JSON.parse(something);
        return processObject(somethingParsed);
      } catch (e) {
        // console.error(`Could not JSON parse:`, something);
        return something;
      }
    } else {
      return something;
    }
  };

  function processObject(someObject) {
    traverse(someObject, function (returnedObject, key, value, scope) {
      // let keyText = _getText(key);
      var valueText = _getText(value);

      someObject[key] = valueText;
    });
    return JSON.stringify(someObject, null, 4);
  }

  var decodeURLParams = function decodeURLParams(search) {
    // console.log(`Processing a search`);
    var hashes = search.slice(search.indexOf("?") + 1).split("&");
    return hashes.reduce(function (params, hash) {
      var _Object$assign2;

      var split = hash.indexOf("=");

      if (split < 0) {
        var _Object$assign;

        return Object.assign(params, (_Object$assign = {}, _Object$assign[hash] = null, _Object$assign));
      }

      var key = hash.slice(0, split);
      var val = hash.slice(split + 1);
      return Object.assign(params, (_Object$assign2 = {}, _Object$assign2[key] = decodeURIComponent(val), _Object$assign2));
    }, {});
  };

  var getText = function getText(something) {
    try {
      if (!something) return something;

      var textResult = _getText(something); // console.log(`Processed:`, something, textResult);


      return textResult;
    } catch (error) {
      return something;
    }
  };

  var getSearchText = function getSearchText(search) {
    if (!search || !isString(search)) return search;
    var searchObject = decodeURLParams(search);
    var textResult = getText(searchObject); // console.log("Getting search test:", searchObject, textResult);

    return textResult;
  };

  var traverse = function traverse(obj, fn, scope) {
    if (scope === void 0) {
      scope = [];
    }

    // console.log(`Traversing an Object`, obj, scope);
    Object.entries(obj).forEach(function (_ref) {
      var key = _ref[0],
          value = _ref[1];
      fn.apply(_this, [obj, key, value, scope]); // callback

      if (value !== null && typeof value === "object") {
        traverse(value, fn, scope.concat(key));
      }
    });
  };

  module.exports = {
    getText: getText,
    getSearchText: getSearchText
  };

})));