graph-reducer/dist/index.modern.js

import { deepClone } from '@graphix/merge';

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

function _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  subClass.__proto__ = superClass;
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _construct(Parent, args, Class) {
  if (_isNativeReflectConstruct()) {
    _construct = Reflect.construct;
  } else {
    _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Function.bind.apply(Parent, a);
      var instance = new Constructor();
      if (Class) _setPrototypeOf(instance, Class.prototype);
      return instance;
    };
  }

  return _construct.apply(null, arguments);
}

function _isNativeFunction(fn) {
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
}

function _wrapNativeSuper(Class) {
  var _cache = typeof Map === "function" ? new Map() : undefined;

  _wrapNativeSuper = function _wrapNativeSuper(Class) {
    if (Class === null || !_isNativeFunction(Class)) return Class;

    if (typeof Class !== "function") {
      throw new TypeError("Super expression must either be null or a function");
    }

    if (typeof _cache !== "undefined") {
      if (_cache.has(Class)) return _cache.get(Class);

      _cache.set(Class, Wrapper);
    }

    function Wrapper() {
      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
    }

    Wrapper.prototype = Object.create(Class.prototype, {
      constructor: {
        value: Wrapper,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    return _setPrototypeOf(Wrapper, Class);
  };

  return _wrapNativeSuper(Class);
}

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 _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;
}

function _createForOfIteratorHelperLoose(o, allowArrayLike) {
  var it;

  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
      if (it) o = it;
      var i = 0;
      return function () {
        if (i >= o.length) return {
          done: true
        };
        return {
          done: false,
          value: o[i++]
        };
      };
    }

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

  it = o[Symbol.iterator]();
  return it.next.bind(it);
}

var isObject = function isObject(variable) {
  return Object.prototype.toString.call(variable) === '[object Object]';
};
var Select = function Select(value) {
  if (arguments.length) this.value = value;
};
var SELECT = new Select();
function select(value) {
  return arguments.length ? new Select(value) : new Select();
}
var StateSetter = /*#__PURE__*/function () {
  function StateSetter(setState, deepSelector, componentName) {
    Object.assign(this, {
      setState: setState,
      deepSelector: deepSelector,
      componentName: componentName
    });
  }

  var _proto = StateSetter.prototype;

  _proto.setFromGlobal = function setFromGlobal(newGlobalState) {
    this.setState(selectFromState(newGlobalState, this.deepSelector));
  };

  return StateSetter;
}();

var StateSetters = /*#__PURE__*/function (_Array) {
  _inheritsLoose(StateSetters, _Array);

  function StateSetters() {
    return _Array.apply(this, arguments) || this;
  }

  return StateSetters;
}( /*#__PURE__*/_wrapNativeSuper(Array));

var generateStateSetters = function generateStateSetters(state) {
  var setters = {};
  generateStateSettersR(state, setters);
  return setters;

  function generateStateSettersR(state, setters) {
    for (var _i = 0, _Object$entries = Object.entries(state); _i < _Object$entries.length; _i++) {
      var _Object$entries$_i = _Object$entries[_i],
          k = _Object$entries$_i[0],
          subState = _Object$entries$_i[1];

      if (isObject(subState)) {
        setters[k] = {};
        generateStateSettersR(subState, setters[k]);
        continue;
      }

      setters[k] = new StateSetters();
    }
  }
};
var getDeepSelector = function getDeepSelector(selectedState) {
  var selector = {};
  getDeepSelectorR(selectedState, selector);
  return selector;

  function getDeepSelectorR(selected, selector) {
    for (var _i2 = 0, _Object$entries2 = Object.entries(selected); _i2 < _Object$entries2.length; _i2++) {
      var _Object$entries2$_i = _Object$entries2[_i2],
          k = _Object$entries2$_i[0],
          subSelectedState = _Object$entries2$_i[1];

      if (isObject(subSelectedState)) {
        getDeepSelectorR(subSelectedState, selector[k] = {});
        continue;
      }

      selector[k] = SELECT;
    }
  }
};
function selectFromState(state, deepSelector) {
  var selectedState = {};
  selectFromStateR(state, deepSelector, selectedState);
  return selectedState;

  function selectFromStateR(state, deepSelector, selected) {
    for (var _i3 = 0, _Object$entries3 = Object.entries(deepSelector); _i3 < _Object$entries3.length; _i3++) {
      var _Object$entries3$_i = _Object$entries3[_i3],
          k = _Object$entries3$_i[0],
          subDeepSelector = _Object$entries3$_i[1];

      if (subDeepSelector instanceof Select) {
        selected[k] = state[k];
        continue;
      }

      selectFromStateR(state[k], subDeepSelector, selected[k] = {});
    }
  }
}
var registerNewStateSetter = function registerNewStateSetter(setter, newSetter, deepSelector) {
  var exploringPath = 'state';
  registerNewStateSetterR(deepSelector, setter);

  function registerNewStateSetterR(selector, setter) {
    for (var _i4 = 0, _Object$entries4 = Object.entries(selector); _i4 < _Object$entries4.length; _i4++) {
      var _Object$entries4$_i = _Object$entries4[_i4],
          k = _Object$entries4$_i[0],
          subDeepSelector = _Object$entries4$_i[1];
      var subSetter = setter[k];

      if (!(subDeepSelector instanceof Select)) {
        var previousExploringPath = exploringPath;
        exploringPath += '.' + k;
        registerNewStateSetterR(subDeepSelector, subSetter);
        exploringPath = previousExploringPath;
        continue;
      }

      if (!(subSetter instanceof StateSetters)) console.error('graph-reducer ERROR!', "subSetter isn't instanceof StateSetters! This means deepSelector hasn't been deep enough!\n", {
        exploringPath: exploringPath,
        k: k,
        subDeepSelector: subDeepSelector,
        newSetter: newSetter
      });
      if (subSetter.indexOf(newSetter) !== -1) console.error('`newSetter` already registered!', {
        exploringPath: exploringPath,
        k: k,
        subDeepSelector: subDeepSelector,
        newSetter: newSetter
      });else subSetter.push(newSetter);
    }
  }
};

var _process$env$DEBUG$sp, _process$env$DEBUG;
var debugEnv = (_process$env$DEBUG$sp = (_process$env$DEBUG = process.env.DEBUG) === null || _process$env$DEBUG === void 0 ? void 0 : _process$env$DEBUG.split(',')) != null ? _process$env$DEBUG$sp : [];
debugEnv.indexOf('graph-reducer') !== -1 || debugEnv.indexOf('*') !== -1 && debugEnv.indexOf('-graph-reducer') === -1;
var dr = Object.fromEntries(['group', 'groupCollapsed', 'groupEnd', 'debug', 'log', 'info', 'warn', 'error', 'trace'].map(function (x) {
  return [x,  console[x].bind(console, 'GRAPH-REDUCER:') ];
}));
var graphReducer = function graphReducer(srcState, paylector, stateSetters, _temp) {
  var _ref = _temp === void 0 ? {} : _temp,
      _ref$maxExploreDepth = _ref.maxExploreDepth,
      maxExploreDepth = _ref$maxExploreDepth === void 0 ? 64 : _ref$maxExploreDepth,
      _ref$mismatchWarning = _ref.mismatchWarning,
      mismatchWarning = _ref$mismatchWarning === void 0 ? true : _ref$mismatchWarning;

  if (!isObject(paylector)) throw new Error("payload is not an Object:\n" + paylector);
  var toFireStateSetters = [];
  var onlySelectionHappened = true;
  var noTransform = true;
  var badTransform = false;
  var exploringDepth = 0;
  var exploringPath = 'state';

  var newState = _extends({}, srcState);

  var selected = {};
  reduceR(newState, paylector, selected, 'state', stateSetters, mismatchWarning);

  if (badTransform) {
    noTransform = null;
    onlySelectionHappened = null;
  }

  return {
    newState: newState,
    selectedState: selected,
    noTransform: noTransform,
    onlySelectionHappened: onlySelectionHappened,
    toFireStateSetters: Array.from(new Set(toFireStateSetters))
  };

  function reduceR(state, paylector, selected, key, stateSetters, mismatchWarning) {
    {
      var _deepClone;

      dr.groupCollapsed(exploringDepth, exploringPath);
      dr.debug(deepClone((_deepClone = {}, _deepClone[key] = state, _deepClone.paylector = paylector, _deepClone.selected = selected, _deepClone.stateSetters = stateSetters, _deepClone)));
    }

    if (exploringDepth > maxExploreDepth) {
      dr.groupEnd();
      console.error('exploringDepth (%d) exceeds maxExploreDepth (%d)', exploringDepth, maxExploreDepth);
      badTransform = true;
      return;
    }

    for (var _i = 0, _Object$entries = Object.entries(state); _i < _Object$entries.length; _i++) {
      var _Object$entries$_i = _Object$entries[_i],
          k = _Object$entries$_i[0],
          subState = _Object$entries$_i[1];
      var subPaylector = void 0;
      var selectMode = void 0;

      if (paylector === SELECT) {
        subPaylector = SELECT;
        selectMode = true;
      } else {
        subPaylector = paylector[k];
        if (typeof subPaylector === 'function') subPaylector = subPaylector(subState, srcState);
        if (subPaylector instanceof Select) selectMode = true;
      }

      var subStateIsObject = isObject(subState);

      deepExploring: {
        if (selectMode) {
          if (!subStateIsObject) {
            if ('value' in subPaylector) {
              selected[k] = subPaylector = typeof subPaylector.value === 'function' ? subPaylector.value(subState) : subPaylector.value;
              break deepExploring;
            }

            selected[k] = subState;
            continue;
          }

          if ('value' in subPaylector) console.error('`subPaylector` can have `value` property only at leaf (final) nodes.', 'The `value` was ignored.', {
            subPaylector: subPaylector,
            subState: subState,
            exploringPath: exploringPath
          });
          selected[k] = _extends({}, subState);
        } else if (isObject(subPaylector)) {
          if (!subStateIsObject) {
            console.error('Mismatched types! `subPaylector` is a %s, but `subState` is a %s\n%o', Object.prototype.toString.call(subPaylector), Object.prototype.toString.call(subState), {
              subPaylector: subPaylector,
              subState: subState,
              exploringPath: exploringPath
            });
            continue;
          }

          selected[k] = {};
        }

        if (subStateIsObject) {
          state[k] = _extends({}, subState);

          if (!isObject(subPaylector)) {
            if (k in paylector) console.error('Mismatched types! `subPaylector` is a %s, but `subState` is a %s. ' + '`subPaylector` was ignored\n%o', Object.prototype.toString.call(subPaylector), Object.prototype.toString.call(subState), {
              subPaylector: subPaylector,
              subState: subState,
              exploringPath: exploringPath
            });
            subPaylector = {};
          }

          exploringDepth++;
          var previousExploringPath = exploringPath;
          exploringPath += '.' + k;
          reduceR(state[k], subPaylector, selected === null || selected === void 0 ? void 0 : selected[k], k, stateSetters[k], mismatchWarning);
          if (selected && !Object.keys(selected).length) delete selected[k];
          exploringPath = previousExploringPath;
          exploringDepth--;
          continue;
        }

        if (!(k in paylector)) continue;
      }

      onlySelectionHappened = false;
      var anyDifference = false;

      if (subPaylector instanceof Array) {
        if (!(subState instanceof Array)) {
          if (mismatchWarning) console.warn('Mismatched types! `subPaylector` is an Array, but `subState` is a %s\n%o', Object.prototype.toString.call(subState), {
            subPaylector: subPaylector,
            subState: subState,
            exploringPath: exploringPath
          });
          subState = state[k] = [];
        }

        for (var _iterator = _createForOfIteratorHelperLoose(subPaylector.entries()), _step; !(_step = _iterator()).done;) {
          var _step$value = _step.value,
              i = _step$value[0],
              value = _step$value[1];

          if (subState[i] !== value) {
            anyDifference = true;
            subState[i] = value;
          }
        }
      } else {
        anyDifference = subState !== subPaylector;
        state[k] = subPaylector;
      }

      if (anyDifference) {
        noTransform = false;
        toFireStateSetters.push.apply(toFireStateSetters, stateSetters[k]);
      }
    }

    {
      var _dr$debug;

      dr.debug((_dr$debug = {}, _dr$debug[key] = state, _dr$debug.selected = selected, _dr$debug.toFireStateSetters = toFireStateSetters, _dr$debug));
      dr.groupEnd();
    }
  }
};

export default graphReducer;
export { SELECT, StateSetter, generateStateSetters, getDeepSelector, graphReducer, isObject, registerNewStateSetter, select, selectFromState };
//# sourceMappingURL=index.modern.js.map