@gorpacrate/core-graphics/lib/contrib/compress.js

A core library for creating shape-based graphic editors

"use strict";
exports.__esModule = true;
var invariant = require("invariant");
var history_event_1 = require("../history/history-event");
var data_1 = require("../utils/data");
var compress_declarations_1 = require("./compress-declarations");
// points
function roundToSignificant(digits, n) {
    return Number(n.toFixed(digits));
}
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 (total.concat(curr)); }, []);
    return reduced;
}
exports.compressPointsArray = compressPointsArray;
function decompressPointsArray(points) {
    return (data_1.getPairs(points).map(function (pair) { return ({ x: pair[0], y: pair[1] }); }));
}
exports.decompressPointsArray = decompressPointsArray;
// shape data
function compressShapeData(data) {
    var type = data.type, id = data.id, keyPoints = data.keyPoints, customParams = data.customParams, graphicalContextData = data.graphicalContextData;
    var compressedPoints = compressPointsArray(keyPoints);
    return [type, id, compressedPoints, customParams || undefined, graphicalContextData];
}
function decompressShapeData(data) {
    var type = data[0], id = data[1], keyPoints = data[2], customParams = data[3], 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, author = pEv.author, applied = pEv.applied, ev = pEv.ev;
    var compEv = compressUnpersistedHistoryEvent(ev);
    return [id, author, applied, compEv];
}
exports.compressHistoryEvent = compressHistoryEvent;
function decompressHistoryEvent(pEv) {
    var id = pEv[0], author = pEv[1], applied = pEv[2], ev = pEv[3];
    var decompEv = decompressUnpersistedHistoryEvent(ev);
    return { id: id, author: author, applied: applied, ev: decompEv };
}
exports.decompressHistoryEvent = decompressHistoryEvent;
// unpersisted events
function compressUnpersistedHistoryEvent(ev) {
    if (history_event_1.isShapeAddEvent(ev)) {
        var type = ev.type, payload = ev.payload;
        return [type, compressShapeData(payload)];
    }
    if (history_event_1.isShapeUpdateEvent(ev)) {
        var type = ev.type, _a = ev.payload, id = _a.id, shapeData = _a.shapeData;
        return [type, id, compressShapeData(shapeData)];
    }
    if (history_event_1.isShapeRemoveEvent(ev)) {
        var type = ev.type, id = ev.payload.id;
        return [type, id];
    }
    if (history_event_1.isShapeChangeOrderEvent(ev)) {
        var type = ev.type, _b = ev.payload, id = _b.id, value = _b.value, relative = _b.relative;
        return [type, id, value, relative];
    }
    if (history_event_1.isEraseAllEvent(ev)) {
        var type = ev.type;
        return [type];
    }
    if (history_event_1.isHistoryEventsGroup(ev)) {
        var type = ev.type, payload = ev.payload;
        return [type, payload.map(compressUnpersistedHistoryEvent)];
    }
    return invariant(false, 'unknown history event type');
}
function decompressUnpersistedHistoryEvent(ev) {
    if (compress_declarations_1.isCompressedShapeAddEvent(ev)) {
        var type = ev[0], payload = ev[1];
        return { type: type, payload: decompressShapeData(payload) };
    }
    if (compress_declarations_1.isCompressedShapeUpdateEvent(ev)) {
        var type = ev[0], id = ev[1], compressedShapeData = ev[2];
        return { type: type, payload: { id: id, shapeData: decompressShapeData(compressedShapeData) } };
    }
    if (compress_declarations_1.isCompressedShapeRemoveEvent(ev)) {
        return { type: 3 /* RemoveShape */, payload: { id: ev[1] } };
    }
    if (compress_declarations_1.isCompressedShapeChangeOrderEvent(ev)) {
        var type = ev[0], id = ev[1], value = ev[2], relative = ev[3];
        return { type: type, payload: { id: id, value: value, relative: relative } };
    }
    if (compress_declarations_1.isCompressedEraseAllEvent(ev)) {
        var type = ev[0];
        return { type: type };
    }
    if (compress_declarations_1.isCompressedHistoryEventsGroup(ev)) {
        var type = ev[0], payload = ev[1];
        return { type: type, payload: payload.map(decompressUnpersistedHistoryEvent) };
    }
    return invariant(false, 'unknown compressed event type');
}
exports.decompressUnpersistedHistoryEvent = decompressUnpersistedHistoryEvent;
//# sourceMappingURL=compress.js.map