@cookbook/dot-notation/lib/parse.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _pick = _interopRequireDefault(require("./pick"));

var _parseKey = _interopRequireDefault(require("./parse-key"));

var _getArrayIndex2 = _interopRequireDefault(require("./utils/get-array-index"));

var _is = _interopRequireDefault(require("./utils/is"));

var _merge = _interopRequireDefault(require("./utils/merge"));

var _createPathBreadcrumb = _interopRequireDefault(require("./utils/create-path-breadcrumb"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var compile = function compile(source, instructions, value) {
  var data = _is.default.array(source) ? _toConsumableArray(source) : _objectSpread({}, source);

  if (_is.default.object(data)) {
    return (0, _merge.default)(data, (0, _parseKey.default)(instructions.join('.'), value));
  }

  var _getArrayIndex = (0, _getArrayIndex2.default)(instructions.join('.')),
      idx = _getArrayIndex[1],
      index = _getArrayIndex.index;

  if (+idx > data.length) {
    throw new RangeError("Expected array index for path \"".concat(instructions.join('.'), "\" to be \"").concat(data.length, "\" but found instead \"").concat(idx, "\""));
  }

  if (_is.default.nullOrUndefined(data[+idx])) {
    data.push.apply(data, _toConsumableArray((0, _parseKey.default)(instructions.splice(index).join('.'), value)));
  } else {
    var hasChild = instructions.length > 1;
    var result = hasChild ? compile(data[+idx], instructions.slice(1), value) : value;

    if (_is.default.object(result)) {
      data[+idx] = _objectSpread({}, result);
    } else if (_is.default.array(result)) {
      data[+idx] = _toConsumableArray(result);
    } else {
      data[+idx] = result;
    }
  }

  return data;
};
/**
 * Parse object from dot notation
 * @template T
 * @param {object} source - Dot notation object
 * @returns {object}
 * @param source
 * @return {T|T[]}
 */


var parse = function parse(source) {
  var paths = Object.keys(source);
  var result = (0, _getArrayIndex2.default)((0, _createPathBreadcrumb.default)(paths[0])[0]) ? [] : {};

  for (var i = 0; i < paths.length; i += 1) {
    var path = paths[i];
    var hasArrayNotation = (0, _getArrayIndex2.default)(path);
    var value = source[path];
    var parsedValue = (0, _parseKey.default)(path, value);

    if (hasArrayNotation) {
      var commonPath = path.substr(0, hasArrayNotation.index);
      var workingPath = (0, _createPathBreadcrumb.default)(path.replace(commonPath, ''));
      var workingNode = commonPath ? (0, _pick.default)(result, commonPath) || [] : result;
      parsedValue = compile(workingNode, workingPath, value);

      if (commonPath) {
        parsedValue = (0, _parseKey.default)(commonPath, parsedValue);
      }
    }

    if (_is.default.array(parsedValue)) {
      result = parsedValue;
    }

    result = (0, _merge.default)(result, parsedValue);
  }

  return result;
};

var _default = parse;
exports.default = _default;