core-graphics/lib/history/history-reducer.js

A core library for creating shape-based graphic editors

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.INITIAL_SCENE = undefined;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

exports.default = reducePersistedHistoryToScene;
exports.reduceHistoryEventsToScene = reduceHistoryEventsToScene;
exports.reducer = reducer;

var _historyEvent = require('../history/history-event');

var _math = require('../utils/math');

var _icepick = require('icepick');

var i = _interopRequireWildcard(_icepick);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function getWantedIndex(params) {
    var relative = params.relative;
    var length = params.length;
    var current = params.current;
    var value = params.value;

    if (relative) {
        var unpadded = current + value;
        if (unpadded <= 0) {
            return 0;
        }
        if (unpadded >= length - 1) {
            return length - 1;
        }
        return unpadded;
    }
    return (0, _math.modulus)(value, length);
}
var INITIAL_SCENE = exports.INITIAL_SCENE = {
    shapes: {},
    shapesOrder: []
};
// persisted events
function reducePersistedHistoryToScene(history) {
    var initialScene = arguments.length <= 1 || arguments[1] === undefined ? INITIAL_SCENE : arguments[1];

    if (history.length === 0) {
        return initialScene;
    }
    return history.reduce(function (scene, persistedEvent) {
        if (!persistedEvent.applied) {
            return scene;
        }
        return reducer(scene, (0, _historyEvent.getHistoryEventFromPersisted)(persistedEvent));
    }, initialScene);
}
// unpersisted events
function reduceHistoryEventsToScene(history) {
    var initialScene = arguments.length <= 1 || arguments[1] === undefined ? INITIAL_SCENE : arguments[1];

    if (history.length === 0) {
        return initialScene;
    }
    return history.reduce(reducer, initialScene);
}
// unpersisted events reducer
function reducer(scene, event) {
    var shapes = scene.shapes;
    var shapesOrder = scene.shapesOrder;

    if ((0, _historyEvent.isShapeAddEvent)(event)) {
        var addId = event.payload.id;

        var nextShapes = i.assoc(shapes, addId, event.payload);
        var nextShapesOrder = i.push(shapesOrder, addId);
        return i.chain(scene).assoc('shapes', nextShapes).assoc('shapesOrder', nextShapesOrder).value();
    }
    if ((0, _historyEvent.isShapeUpdateEvent)(event)) {
        var _event$payload = event.payload;
        var updateId = _event$payload.id;
        var shapeData = _event$payload.shapeData;

        if (!scene.shapes[updateId]) {
            return scene;
        }
        var _nextShapes = i.assoc(shapes, updateId, shapeData);
        return i.assoc(scene, 'shapes', _nextShapes);
    }
    if ((0, _historyEvent.isShapeRemoveEvent)(event)) {
        var _ret = function () {
            var removeId = event.payload.id;

            if (!shapes[removeId]) {
                return {
                    v: scene
                };
            }
            var nextShapes = i.dissoc(shapes, removeId);
            var nextShapesOrder = i.filter(function (id) {
                return id !== removeId;
            }, shapesOrder);
            return {
                v: i.chain(scene).assoc('shapes', nextShapes).assoc('shapesOrder', nextShapesOrder).value()
            };
        }();

        if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
    }
    if ((0, _historyEvent.isShapeChangeOrderEvent)(event)) {
        var castEvent = event;
        var _castEvent$payload = castEvent.payload;
        var id = _castEvent$payload.id;
        var value = _castEvent$payload.value;
        var relative = _castEvent$payload.relative;

        var newOrder = i.thaw(shapesOrder);
        var length = newOrder.length;

        var currentIndex = newOrder.indexOf(id);
        var wantedIndex = getWantedIndex({ relative: relative, length: length, current: currentIndex, value: value });
        if (wantedIndex > currentIndex) {
            newOrder.splice(wantedIndex + 1, 0, id);
            newOrder.splice(currentIndex, 1);
        } else {
            newOrder.splice(currentIndex, 1);
            newOrder.splice(wantedIndex, 0, id);
        }
        return i.assoc(scene, 'shapesOrder', newOrder);
    }
    if ((0, _historyEvent.isEraseAllEvent)(event)) {
        return {
            shapes: {},
            shapesOrder: []
        };
    }
    if ((0, _historyEvent.isHistoryEventsGroup)(event)) {
        var events = event.payload;
        return events.reduce(reducer, scene);
    }
    return scene;
}