json-prism/lib/core/virtual/SentientBatch.js

Immutable Prisms, i.e. Taking a Multifoci Json Path to Immutability, or A sentient item has some ability to communicate, either by sharing its emotions, broadcasting its thoughts telepathically, or speaking aloud.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var F = require('functional-pipelines');

var _require = require('json-atom'),
    get = _require.get,
    set = _require.set,
    apply = _require.apply;

var _require2 = require('./Sentient'),
    Writer = _require2.Writer;

var _require3 = require('../../utils/trace'),
    show = _require3.show,
    aLine = _require3.aLine;

var uuidV4 = require('uuid/v4');

var normalizePath = function normalizePath(path) {
  return path[0] === '$' ? path : "$.".concat(path);
}; // @TODO: BASIC IDEA, a catcher can get nodes, upon setting it would use the unknown bound to a stream, and return jsonpath nodes that can be materialized into an active dictionary


var MultiWriter = function MultiWriter(subject) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$labels = _ref.labels,
      labels = _ref$labels === void 0 ? [uuidV4()] : _ref$labels;

  return function (keys) {
    var _ref8;

    var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        _ref2$withoutKeys = _ref2.withoutKeys,
        withoutKeys = _ref2$withoutKeys === void 0 ? [] : _ref2$withoutKeys,
        _ref2$sortUpdates = _ref2.sortUpdates,
        sortUpdates = _ref2$sortUpdates === void 0 ? false : _ref2$sortUpdates;

    var journalWriter = Writer(subject, {
      labels: labels
    });

    var setInto = function setInto(writer) {
      return function (path) {
        return function (value) {
          return writer.sets(normalizePath(path))(value);
        };
      };
    };

    var getFrom = function getFrom(writer) {
      return function (path) {
        return writer.gets(normalizePath(path));
      };
    };

    return _ref8 = {}, (0, _defineProperty2["default"])(_ref8, '___included', function ___included(newKeys) {
      // keys = newKeys ? newKeys : keys; // @TODO: encourage reuse or be immutable about focus points
      return keys;
    }), (0, _defineProperty2["default"])(_ref8, "___excluded", function ___excluded(newNotKeys) {
      // withoutKeys = newNotKeys ? newNotKeys : withoutKeys;  // @TODO: encourage reuse or be immutable about focus points
      return withoutKeys;
    }), (0, _defineProperty2["default"])(_ref8, "___filtered", function ___filtered() {
      throw new Error('Not Implemented Yet! @2019-05-17T23:40:34.616Z');
    }), (0, _defineProperty2["default"])(_ref8, "updates", function updates(newValues) {
      if (newValues === undefined) {
        var getter = getFrom(journalWriter);

        var ___included = this.___included();

        show("GET-ATTR::", ___included);
        return ___included.map(function (k) {
          return show('<< K::', k), show('<< V::', getter(k)), getter(k);
        });
      } else {
        var setter = setInto(journalWriter);

        var _included = this.___included();

        var reducingFn = function reducingFn(_ref3, _ref4) {
          var revisionSetter = _ref3.revisionSetter,
              value = _ref3.value;

          var _ref5 = (0, _slicedToArray2["default"])(_ref4, 2),
              k = _ref5[0],
              nV = _ref5[1];

          var newRevision = revisionSetter(k)(nV);
          return {
            revisionSetter: setter,
            value: newRevision
          }; // @TODO: do we need to create a new setter into a new Writer ever?
        };

        var initFn = function initFn() {
          return {
            revisionSetter: setter
          };
        };

        var sortBy = function sortBy(a, b) {
          return +(a[0] > b[0]) || +(b[0] === a[0]) - 1;
        };

        var sortedPairs = sortUpdates ? (0, _toConsumableArray2["default"])(F.zip(_included, newValues)).sort(sortBy) : (0, _toConsumableArray2["default"])(F.zip(_included, newValues));
        show({
          sortedPairs: sortedPairs
        });

        var resultFn = function resultFn(x) {
          return x.value;
        };

        var HEAD = F.reduce(reducingFn, initFn, sortedPairs, resultFn); //
        // const revisions = F.map(
        //     ([k, nV]) => (console.log('>> K::', k), console.log('>> V::', nV), setter(k)(nV)),
        //     F.zip(___included, newValues));

        show("SET-ATTR::", sortedPairs.map(function (_ref6) {
          var _ref7 = (0, _slicedToArray2["default"])(_ref6, 2),
              k = _ref7[0],
              v = _ref7[1];

          return show(k, ':=', v);
        }).length, 'updates in total');
        return HEAD;
      }
    }), _ref8;
  };
};

module.exports = {
  MultiWriter: MultiWriter
};