@terra-graph/core 1.0.0-rc.4

package/dist/esm/Graph/Rules/Edge/EdgeSemanticLegend.test.js

@@ -0,0 +1,509 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, TgEdgeDirectionSemantics, asEdgeId, asNodeId, } from '../../TgGraph.js';
+import { EdgeSemanticLegend } from './EdgeSemanticLegend.js';
+describe('EdgeSemanticLegend.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new EdgeSemanticLegend({
+            edge: { from: { any: true }, to: { any: true } },
+        })).toThrow(`Rule 'EdgeSemanticLegend' requires options in config`);
+    });
+    it('shoud require legendBySemantic to be an object', () => {
+        expect(() => new EdgeSemanticLegend({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                legendBySemantic: null,
+            },
+        })).toThrow(`Rule 'EdgeSemanticLegend' requires options.legendBySemantic`);
+    });
+    it('shoud reject invalid semantic keys', () => {
+        expect(() => new EdgeSemanticLegend({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                legendBySemantic: {
+                    invalid: { title: 'Invalid', colour: '#000000' },
+                },
+            },
+        })).toThrow(`Rule 'EdgeSemanticLegend' has an invalid semantic key 'invalid'`);
+    });
+    it('shoud require title and colour for each semantic entry', () => {
+        expect(() => new EdgeSemanticLegend({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: { title: 'Invokes' },
+                },
+            },
+        })).toThrow(`Rule 'EdgeSemanticLegend' requires title and colour for semantic 'invokes'`);
+    });
+    it('shoud require overwrite to be a boolean when provided', () => {
+        expect(() => new EdgeSemanticLegend({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+                overwrite: 'yes',
+            },
+        })).toThrow(`Rule 'EdgeSemanticLegend' options.overwrite must be a boolean when provided`);
+    });
+});
+describe('EdgeSemanticLegend.apply', () => {
+    it('shoud set legend values for mapped edge semantics', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const invokesEdgeId = asEdgeId('edge-a-b');
+        const accessesEdgeId = asEdgeId('edge-a-c');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+            },
+            edges: [
+                {
+                    id: invokesEdgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Invokes,
+                    },
+                },
+                {
+                    id: accessesEdgeId,
+                    from: nodeA,
+                    to: nodeC,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Accesses,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { any: true },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(invokesEdgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Invokes,
+            legend: {
+                title: 'Invokes',
+                colour: '#1f77b4',
+            },
+        });
+        expect(result.getEdgeAttributes(accessesEdgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Accesses,
+        });
+    });
+    it('shoud keep existing legend when overwrite is false', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Invokes,
+                        legend: {
+                            title: 'Existing',
+                            colour: '#999999',
+                        },
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { any: true },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Invokes,
+            legend: {
+                title: 'Existing',
+                colour: '#999999',
+            },
+        });
+    });
+    it('shoud overwrite existing legend when configured', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Invokes,
+                        legend: {
+                            title: 'Existing',
+                            colour: '#999999',
+                        },
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { any: true },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+                overwrite: true,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Invokes,
+            legend: {
+                title: 'Invokes',
+                colour: '#1f77b4',
+            },
+        });
+    });
+    it('shoud ignore edges without a direction semantic', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { any: true },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud ignore edges with invalid direction semantics', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: 'invalid',
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { any: true },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: 'invalid',
+        });
+    });
+    it('shoud ignore edges when no legend is mapped for the semantic', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Accesses,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { any: true },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Accesses,
+        });
+    });
+    it('shoud keep graph unchanged when apply is called without a match', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Invokes,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { any: true },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Invokes,
+        });
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Invokes,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = rule.apply(nodeA, mismatchedNode, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Invokes,
+        });
+    });
+    it('shoud skip targets that do not match the query', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        directionSemantic: TgEdgeDirectionSemantics.Invokes,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeSemanticLegend({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+            options: {
+                legendBySemantic: {
+                    [TgEdgeDirectionSemantics.Invokes]: {
+                        title: 'Invokes',
+                        colour: '#1f77b4',
+                    },
+                },
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: TgEdgeDirectionSemantics.Invokes,
+        });
+    });
+});

package/dist/esm/Graph/Rules/Edge/ExplicitEdge.d.ts

@@ -0,0 +1,6 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+export declare class ExplicitEdge extends EdgeRule {
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/esm/Graph/Rules/Edge/ExplicitEdge.js

@@ -0,0 +1,24 @@
+import { edgeIdFrom } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+export class ExplicitEdge extends EdgeRule {
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        let updated = graph;
+        const { from, to } = this.query;
+        if (!from.match(nodeId, node, updated)) {
+            return updated;
+        }
+        for (const targetId of updated.nodeIds()) {
+            const target = updated.getNodeAttributes(targetId);
+            if (!target || !to.match(targetId, target, updated)) {
+                continue;
+            }
+            const edgeId = edgeIdFrom(nodeId, targetId);
+            updated = updated.setEdge(edgeId, nodeId, targetId, {});
+        }
+        return updated;
+    }
+}
+EdgeRule.register(ExplicitEdge);

package/dist/esm/Graph/Rules/Edge/ExplicitEdge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/Graph/Rules/Edge/ExplicitEdge.test.js

@@ -0,0 +1,123 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asNodeId, edgeIdFrom, } from '../../TgGraph.js';
+import { ExplicitEdge } from './ExplicitEdge.js';
+describe('ExplicitEdge.apply', () => {
+    it('shoud add edges from matching source nodes to matching target nodes', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+            },
+            edges: [],
+        };
+        const hook = new ExplicitEdge({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { in: ['node-b', 'node-c'] } },
+            },
+        });
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        const edgeAB = edgeIdFrom(nodeA, nodeB);
+        const edgeAC = edgeIdFrom(nodeA, nodeC);
+        expect(result.edgeSource(edgeAB)).toBe(nodeA);
+        expect(result.edgeTarget(edgeAB)).toBe(nodeB);
+        expect(result.edgeSource(edgeAC)).toBe(nodeA);
+        expect(result.edgeTarget(edgeAC)).toBe(nodeC);
+        expect(result.getEdgeAttributes(edgeAB)).toEqual({});
+    });
+    it('shoud keep graph unchanged when the hook does not match', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [],
+        };
+        const hook = new ExplicitEdge({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+        });
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.outEdges(nodeA)).toEqual([]);
+    });
+    it('shoud skip targets that do not match the query', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [],
+        };
+        const hook = new ExplicitEdge({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+        });
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.outEdges(nodeA)).toEqual([]);
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [],
+        };
+        const hook = new ExplicitEdge({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+        });
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        hook.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = hook.apply(nodeA, mismatchedNode, adapter);
+        expect(result.outEdges(nodeA)).toEqual([]);
+    });
+});

package/dist/esm/Graph/Rules/Edge/RemoveEdge.d.ts

@@ -0,0 +1,6 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+export declare class RemoveEdge extends EdgeRule {
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/esm/Graph/Rules/Edge/RemoveEdge.js

@@ -0,0 +1,24 @@
+import { EdgeRule } from '../Rule.js';
+export class RemoveEdge extends EdgeRule {
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        let updated = graph;
+        const { from, to } = this.query;
+        if (!from.match(nodeId, node, updated)) {
+            return updated;
+        }
+        const edges = updated.outEdges(nodeId);
+        for (const edgeId of edges) {
+            const targetId = updated.edgeTarget(edgeId);
+            const target = updated.getNodeAttributes(targetId);
+            if (!target || !to.match(targetId, target, updated)) {
+                continue;
+            }
+            updated = updated.removeEdge(edgeId);
+        }
+        return updated;
+    }
+}
+EdgeRule.register(RemoveEdge);