@visactor/vgrammar-core/cjs/graph/mark/differ.js

VGrammar is a visual grammar library

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: !0
}), exports.diffMultiple = exports.diffSingle = exports.Differ = exports.groupData = void 0;

const vutils_1 = require("@visactor/vutils"), util_1 = require("../../parse/util"), constants_1 = require("../constants");

function groupData(data, key, sort) {
    const groupedData = new Map;
    if (!data || 0 === data.length) return {
        keys: [],
        data: groupedData
    };
    if (!key) return groupedData.set(constants_1.DefaultKey, sort ? data.slice().sort(sort) : data.slice()), 
    {
        keys: constants_1.DefaultGroupKeys,
        data: groupedData
    };
    const keyGetter = (0, util_1.parseField)(key);
    if (1 === data.length) {
        const key = keyGetter(data[0]);
        return groupedData.set(key, [ data[0] ]), {
            keys: [ key ],
            data: groupedData
        };
    }
    const keys = new Set;
    return data.forEach((entry => {
        var _a;
        const key = keyGetter(entry), lastData = null !== (_a = groupedData.get(key)) && void 0 !== _a ? _a : [];
        lastData.push(entry), groupedData.set(key, lastData), keys.add(key);
    })), sort && keys.forEach((key => {
        groupedData.get(key).sort(sort);
    })), {
        keys: Array.from(keys),
        data: groupedData
    };
}

exports.groupData = groupData;

class Differ {
    constructor(data, key, sort) {
        this.prevData = (null == data ? void 0 : data.length) ? groupData(data, null != key ? key : null, sort) : null;
    }
    setCurrentData(currentData) {
        this.currentData = currentData;
    }
    getCurrentData() {
        return this.currentData;
    }
    doDiff() {
        if (this.callback) if (this.currentData && this.prevData) {
            const prevMap = new Map(this.prevData.data);
            this.currentData.keys.forEach((key => {
                this.callback(key, this.currentData.data.get(key), prevMap.get(key)), prevMap.delete(key);
            })), this.prevData.keys.forEach((key => {
                prevMap.has(key) && this.callback(key, null, prevMap.get(key));
            }));
        } else if (this.currentData) {
            this.currentData.keys.forEach((key => {
                this.callback(key, this.currentData.data.get(key), null);
            }));
        } else this.prevData && this.prevData.keys.forEach((key => {
            this.callback(key, null, this.prevData.data.get(key));
        }));
    }
    setCallback(callback) {
        this.callback = callback;
    }
    updateToCurrent() {
        this.prevData = this.currentData, this.currentData = null;
    }
    reset() {
        this.prevData = null;
    }
}

function diffSingle(prev, next, key) {
    const result = {
        enter: [],
        exit: [],
        update: []
    }, differ = new Differ(prev, key);
    return differ.setCallback(((key, data, prevData) => {
        (0, vutils_1.isNil)(data) ? result.exit.push({
            prev: prevData[0]
        }) : (0, vutils_1.isNil)(prevData) ? result.enter.push({
            next: data[0]
        }) : result.update.push({
            next: data[0],
            prev: prevData[0]
        });
    })), differ.setCurrentData(groupData(next, key)), differ.doDiff(), result;
}

function diffMultiple(prev, next, key) {
    const result = {
        enter: [],
        exit: [],
        update: []
    }, differ = new Differ(prev, key);
    return differ.setCallback(((key, data, prevData) => {
        (0, vutils_1.isNil)(data) ? result.exit.push({
            prev: prevData
        }) : (0, vutils_1.isNil)(prevData) ? result.enter.push({
            next: data
        }) : result.update.push({
            next: data,
            prev: prevData
        });
    })), differ.setCurrentData(groupData(next, key)), differ.doDiff(), result;
}

exports.Differ = Differ, exports.diffSingle = diffSingle, exports.diffMultiple = diffMultiple;
//# sourceMappingURL=differ.js.map