@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Graph/Rules/Edge/EdgeDirectionSemantic.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeDirectionSemantic = void 0;
+const TgGraph_js_1 = require("../../TgGraph.js");
+const Rule_js_1 = require("../Rule.js");
+class EdgeDirectionSemantic extends Rule_js_1.EdgeRule {
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' requires options in config`);
+        }
+        const options = config.options;
+        if (!(0, TgGraph_js_1.isTgEdgeDirectionSemantic)(options.semantic)) {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' requires options.semantic`);
+        }
+        if (options.overwrite !== undefined &&
+            typeof options.overwrite !== 'boolean') {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' options.overwrite must be a boolean when provided`);
+        }
+        if (options.enforceDirection !== undefined &&
+            typeof options.enforceDirection !== 'boolean') {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' options.enforceDirection must be a boolean when provided`);
+        }
+        super(config);
+    }
+    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 options = this.config.options;
+        const shouldOverwrite = options.overwrite ?? false;
+        const shouldEnforceDirection = options.enforceDirection ?? false;
+        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;
+            }
+            const current = updated.getEdgeAttributes(edgeId);
+            if (!shouldOverwrite && current.directionSemantic !== undefined) {
+                continue;
+            }
+            updated = updated.setEdge(edgeId, nodeId, targetId, {
+                ...current,
+                directionSemantic: options.semantic,
+            });
+        }
+        if (!shouldEnforceDirection) {
+            return updated;
+        }
+        const inboundEdgeIds = updated.inEdges(nodeId);
+        for (const edgeId of inboundEdgeIds) {
+            const sourceId = updated.edgeSource(edgeId);
+            const source = updated.getNodeAttributes(sourceId);
+            if (!source || !to.match(sourceId, source, updated)) {
+                continue;
+            }
+            const current = updated.getEdgeAttributes(edgeId);
+            if (!shouldOverwrite &&
+                current.directionSemantic !== undefined &&
+                current.directionSemantic !== options.semantic) {
+                continue;
+            }
+            updated = updated.removeEdge(edgeId).setEdge(edgeId, nodeId, sourceId, {
+                ...current,
+                directionSemantic: options.semantic,
+            });
+        }
+        return updated;
+    }
+}
+exports.EdgeDirectionSemantic = EdgeDirectionSemantic;
+Rule_js_1.EdgeRule.register(EdgeDirectionSemantic);

package/dist/cjs/Graph/Rules/Edge/EdgeDirectionSemantic.test.d.ts

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

package/dist/cjs/Graph/Rules/Edge/EdgeDirectionSemantic.test.js

@@ -0,0 +1,454 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphology_1 = require("graphology");
+const GraphologyAdapter_js_1 = require("../../Adapters/GraphologyAdapter.js");
+const TgGraph_js_1 = require("../../TgGraph.js");
+const EdgeDirectionSemantic_js_1 = require("./EdgeDirectionSemantic.js");
+describe('EdgeDirectionSemantic.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: { from: { any: true }, to: { any: true } },
+        })).toThrow(`Rule 'EdgeDirectionSemantic' requires options in config`);
+    });
+    it('shoud require a valid semantic option', () => {
+        expect(() => new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                semantic: 'invalid',
+            },
+        })).toThrow(`Rule 'EdgeDirectionSemantic' requires options.semantic`);
+    });
+    it('shoud require overwrite to be a boolean when provided', () => {
+        expect(() => new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+                overwrite: 'yes',
+            },
+        })).toThrow(`Rule 'EdgeDirectionSemantic' options.overwrite must be a boolean when provided`);
+    });
+    it('shoud require enforceDirection to be a boolean when provided', () => {
+        expect(() => new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+                enforceDirection: 'yes',
+            },
+        })).toThrow(`Rule 'EdgeDirectionSemantic' options.enforceDirection must be a boolean when provided`);
+    });
+});
+describe('EdgeDirectionSemantic.apply', () => {
+    it('shoud set edge direction semantic for matching edges', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+        });
+    });
+    it('shoud preserve existing direction semantic by default', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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,
+                        directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Accesses,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Accesses,
+        });
+    });
+    it('shoud overwrite existing direction semantic when configured', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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,
+                        directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Accesses,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+                overwrite: true,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+        });
+    });
+    it('shoud keep inbound matching edges unchanged when enforceDirection is false', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-b-a');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeB,
+                    to: nodeA,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeB);
+        expect(result.edgeTarget(edgeId)).toBe(nodeA);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud reverse inbound matching edges when enforceDirection is true', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-b-a');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeB,
+                    to: nodeA,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+                enforceDirection: true,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeA);
+        expect(result.edgeTarget(edgeId)).toBe(nodeB);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+        });
+    });
+    it('shoud skip reversing inbound edges with conflicting semantics when overwrite is false', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-b-a');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeB,
+                    to: nodeA,
+                    attributes: {
+                        directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Accesses,
+                    },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+                enforceDirection: true,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeB);
+        expect(result.edgeTarget(edgeId)).toBe(nodeA);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            directionSemantic: TgGraph_js_1.TgEdgeDirectionSemantics.Accesses,
+        });
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = rule.apply(nodeA, mismatchedNode, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({});
+    });
+    it('shoud skip outbound edges when the target does not match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({});
+    });
+    it('shoud ignore inbound edges when the source does not match the target query', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-b-a');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeB,
+                    to: nodeA,
+                    attributes: {},
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+                enforceDirection: true,
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeB);
+        expect(result.edgeTarget(edgeId)).toBe(nodeA);
+    });
+    it('shoud keep graph unchanged when apply is called without a match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeDirectionSemantic_js_1.EdgeDirectionSemantic({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                semantic: TgGraph_js_1.TgEdgeDirectionSemantics.Invokes,
+            },
+        });
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({});
+    });
+});

package/dist/cjs/Graph/Rules/Edge/EdgeDotProperties.d.ts

@@ -0,0 +1,9 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+import { EdgeRuleConfig } from '../RuleConfig.js';
+export declare class EdgeDotProperties extends EdgeRule {
+    constructor(config: EdgeRuleConfig);
+    supports(adapter: AdapterOperations): boolean;
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/cjs/Graph/Rules/Edge/EdgeDotProperties.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeDotProperties = void 0;
+const DotAdapter_js_1 = require("../../Adapters/DotAdapter.js");
+const Rule_js_1 = require("../Rule.js");
+class EdgeDotProperties extends Rule_js_1.EdgeRule {
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${EdgeDotProperties.name}' requires options in config`);
+        }
+        super(config);
+    }
+    supports(adapter) {
+        return adapter instanceof DotAdapter_js_1.DotAdapter;
+    }
+    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 adapterKey = DotAdapter_js_1.DotAdapter.name;
+        const properties = this.config.options ?? {};
+        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;
+            }
+            const current = updated.getEdgeAttributes(edgeId);
+            updated = updated.setEdge(edgeId, nodeId, targetId, {
+                ...current,
+                adapter: {
+                    ...(current.adapter ?? {}),
+                    [adapterKey]: {
+                        ...(current.adapter?.[adapterKey] ?? {}),
+                        ...properties,
+                    },
+                },
+            });
+        }
+        return updated;
+    }
+}
+exports.EdgeDotProperties = EdgeDotProperties;
+Rule_js_1.EdgeRule.register(EdgeDotProperties);

package/dist/cjs/Graph/Rules/Edge/EdgeDotProperties.test.d.ts

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