@logic-pad/core/dist/data/gridZones.js

import { isSameEdge } from './dataHelper.js';
export default class GridZones {
    constructor(edges) {
        Object.defineProperty(this, "edges", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.edges = GridZones.deduplicateEdges(edges ?? []);
    }
    addEdge(edge) {
        if (this.edges.some(e => isSameEdge(e, edge))) {
            return this;
        }
        return new GridZones([...this.edges, edge]);
    }
    removeEdge(edge) {
        return new GridZones(this.edges.filter(e => !isSameEdge(e, edge)));
    }
    hasEdge(edge) {
        if (edge.x1 === edge.x2 && edge.y1 === edge.y2)
            return true;
        return this.edges.some(e => isSameEdge(e, edge));
    }
    getEdgesAt({ x, y }) {
        return this.edges.filter(e => (e.x1 === x && e.y1 === y) || (e.x2 === x && e.y2 === y));
    }
    /**
     * Check if two GridZones objects are equal.
     * @param other The other GridZones object to compare to.
     * @returns Whether the two objects are equal.
     */
    equals(other) {
        if (this.edges.length !== other.edges.length)
            return false;
        for (const edge of this.edges) {
            if (!other.hasEdge(edge))
                return false;
        }
        return true;
    }
    /**
     * Deduplicate an array of edges.
     * @param edges The array of edges to deduplicate.
     * @returns The deduplicated array of edges.
     */
    static deduplicateEdges(edges) {
        return edges.filter((edge, index) => edges.findIndex(e => isSameEdge(e, edge)) === index);
    }
    static validateEdges(connections, width, height) {
        const newEdges = [];
        for (const edge of connections.edges) {
            if (edge.x1 < -1 ||
                edge.x1 >= width + 1 ||
                edge.y1 < -1 ||
                edge.y1 >= height + 1) {
                continue;
            }
            if (edge.x2 < -1 ||
                edge.x2 >= width + 1 ||
                edge.y2 < -1 ||
                edge.y2 >= height + 1) {
                continue;
            }
            if ((edge.x1 < 0 && edge.x2 < 0) ||
                (edge.y1 < 0 && edge.y2 < 0) ||
                (edge.x1 >= width && edge.x2 >= width) ||
                (edge.y1 >= height && edge.y2 >= height)) {
                continue;
            }
            if (Math.abs(edge.x1 - edge.x2) + Math.abs(edge.y1 - edge.y2) !== 1) {
                continue;
            }
            newEdges.push(edge);
        }
        if (newEdges.length === connections.edges.length) {
            return connections;
        }
        return new GridZones(newEdges);
    }
    insertColumn(index) {
        return new GridZones(this.edges.map(edge => {
            if (edge.x1 < index || edge.x2 < index) {
                return edge;
            }
            else {
                return { x1: edge.x1 + 1, y1: edge.y1, x2: edge.x2 + 1, y2: edge.y2 };
            }
        }));
    }
    insertRow(index) {
        return new GridZones(this.edges.map(edge => {
            if (edge.y1 < index || edge.y2 < index) {
                return edge;
            }
            else {
                return { x1: edge.x1, y1: edge.y1 + 1, x2: edge.x2, y2: edge.y2 + 1 };
            }
        }));
    }
    removeColumn(index) {
        return new GridZones(this.edges.map(edge => {
            if (edge.x1 > index || edge.x2 > index) {
                return { x1: edge.x1 - 1, y1: edge.y1, x2: edge.x2 - 1, y2: edge.y2 };
            }
            else {
                return edge;
            }
        }));
    }
    removeRow(index) {
        return new GridZones(this.edges.map(edge => {
            if (edge.y1 > index || edge.y2 > index) {
                return { x1: edge.x1, y1: edge.y1 - 1, x2: edge.x2, y2: edge.y2 - 1 };
            }
            else {
                return edge;
            }
        }));
    }
}