core-graphics/lib/contrib/compress.js

A core library for creating shape-based graphic editors

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.compressPointsArray = compressPointsArray;
exports.decompressPointsArray = decompressPointsArray;
exports.compressHistoryEvent = compressHistoryEvent;
exports.decompressHistoryEvent = decompressHistoryEvent;
exports.decompressUnpersistedHistoryEvent = decompressUnpersistedHistoryEvent;

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

var _compressDeclarations = require('./compress-declarations');

var _data = require('../utils/data');

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

// points
function roundToSignificant(digits, n) {
    return Number(n.toFixed(2));
}
function compressPointsArray(points) {
    var mapped = points.map(function (p) {
        return [roundToSignificant(2, p.x), roundToSignificant(2, p.y)];
    });
    var reduced = mapped.reduce(function (total, curr) {
        return [].concat(_toConsumableArray(total), _toConsumableArray(curr));
    }, []);
    return reduced;
}
function decompressPointsArray(points) {
    return (0, _data.getPairs)(points).map(function (pair) {
        return { x: pair[0], y: pair[1] };
    });
}
// shape data
function compressShapeData(data) {
    var type = data.type;
    var id = data.id;
    var keyPoints = data.keyPoints;
    var customParams = data.customParams;
    var graphicalContextData = data.graphicalContextData;

    var compressedPoints = compressPointsArray(keyPoints);
    return [type, id, compressedPoints, customParams || null, graphicalContextData];
}
function decompressShapeData(data) {
    var type = data[0];
    var id = data[1];
    var keyPoints = data[2];
    var customParams = data[3];
    var graphicalContextData = data[4];

    var decompressedKeyPoints = decompressPointsArray(keyPoints);
    if (!customParams) {
        return { type: type, id: id, keyPoints: decompressedKeyPoints, graphicalContextData: graphicalContextData };
    }
    return { type: type, id: id, keyPoints: decompressedKeyPoints, customParams: customParams, graphicalContextData: graphicalContextData };
}
// persisted events
function compressHistoryEvent(pEv) {
    var id = pEv.id;
    var author = pEv.author;
    var applied = pEv.applied;
    var ev = pEv.ev;

    var compEv = compressUnpersistedHistoryEvent(ev);
    return [id, author, applied, compEv];
}
function decompressHistoryEvent(pEv) {
    var id = pEv[0];
    var author = pEv[1];
    var applied = pEv[2];
    var ev = pEv[3];

    var decompEv = decompressUnpersistedHistoryEvent(ev);
    return { id: id, author: author, applied: applied, ev: decompEv };
}
// unpersisted events
function compressUnpersistedHistoryEvent(ev) {
    var type = ev.type;

    if ((0, _historyEvent.isShapeAddEvent)(ev)) {
        var resAdd = [type, compressShapeData(ev.payload)];
        return resAdd;
    }
    if ((0, _historyEvent.isShapeUpdateEvent)(ev)) {
        var resUpdate = [type, ev.payload.id, compressShapeData(ev.payload.shapeData)];
        return resUpdate;
    }
    if ((0, _historyEvent.isShapeRemoveEvent)(ev)) {
        var resRemove = [type, ev.payload.id];
        return resRemove;
    }
    if ((0, _historyEvent.isShapeChangeOrderEvent)(ev)) {
        var _ev$payload = ev.payload;
        var id = _ev$payload.id;
        var value = _ev$payload.value;
        var relative = _ev$payload.relative;

        var resOrder = [type, id, value, relative];
        return resOrder;
    }
    if ((0, _historyEvent.isEraseAllEvent)(ev)) {
        var resErase = [type];
        return resErase;
    }
    if ((0, _historyEvent.isHistoryEventsGroup)(ev)) {
        var compressedEvents = ev.payload.map(compressUnpersistedHistoryEvent);
        var resGroup = [type, compressedEvents];
        return resGroup;
    }
    return null;
}
function decompressUnpersistedHistoryEvent(ev) {
    var type = ev[0];
    if ((0, _compressDeclarations.isCompressedShapeAddEvent)(ev)) {
        var add = { type: type, payload: decompressShapeData(ev[1]) };
        return add;
    }
    if ((0, _compressDeclarations.isCompressedShapeUpdateEvent)(ev)) {
        var update = { type: type, payload: { id: ev[1], shapeData: decompressShapeData(ev[2]) } };
        return update;
    }
    if ((0, _compressDeclarations.isCompressedShapeRemoveEvent)(ev)) {
        var remove = { type: type, payload: { id: ev[1] } };
        return remove;
    }
    if ((0, _compressDeclarations.isCompressedShapeChangeOrderEvent)(ev)) {
        var id = ev[1];
        var value = ev[2];
        var relative = ev[3];

        var changeOrder = { type: type, payload: { id: id, value: value, relative: relative } };
        return changeOrder;
    }
    if ((0, _compressDeclarations.isCompressedEraseAllEvent)(ev)) {
        var eraseAll = { type: type };
        return eraseAll;
    }
    if ((0, _compressDeclarations.isCompressedHistoryEventsGroup)(ev)) {
        var group = { type: type, payload: ev[1].map(decompressUnpersistedHistoryEvent) };
        return group;
    }
    return null;
}