@terra-graph/core 1.0.0-rc.4

package/dist/esm/Graph/Rules/Rule.js

@@ -0,0 +1,85 @@
+import { NodeQuery } from '../Operations/Matchers/NodeQuery/NodeQuery.js';
+export class BaseRule {
+    config;
+    static registry = {};
+    lastMatch = false;
+    lastMatchNodeId;
+    static register(ruleClass) {
+        BaseRule.registry[ruleClass.name] = (config) => new ruleClass(config);
+    }
+    static fromSerialized(rule) {
+        if (!rule || typeof rule.id !== 'string' || rule.id.length === 0) {
+            const rendered = rule === undefined
+                ? 'undefined'
+                : JSON.stringify(rule, (_key, value) => typeof value === 'function' ? '[Function]' : value);
+            throw new Error(`Invalid serialized rule (missing id): ${rendered}`);
+        }
+        const factory = BaseRule.registry[rule.id];
+        if (!factory) {
+            throw new Error(`Rule '${rule.id}' is not registered`);
+        }
+        return factory(rule.config);
+    }
+    constructor(config) {
+        this.config = config;
+    }
+    describe(_nodeName, _node) {
+        return this.getId();
+    }
+    match(nodeId, node, graph) {
+        const result = this.matches(nodeId, node, graph);
+        this.lastMatch = result;
+        this.lastMatchNodeId = nodeId;
+        return result;
+    }
+    supports(_adapter) {
+        return true;
+    }
+    serialize() {
+        return {
+            id: this.getId(),
+            config: this.config,
+        };
+    }
+    getId() {
+        return this.constructor.name;
+    }
+    wasMatched(_nodeId) {
+        return this.lastMatchNodeId === _nodeId && this.lastMatch;
+    }
+}
+export class NodeRule extends BaseRule {
+    queryValue;
+    constructor(config) {
+        if (!('node' in config)) {
+            throw new Error(`Rule '${new.target.name}' requires a node config`);
+        }
+        super(config);
+        this.queryValue = NodeQuery.from(config.node);
+    }
+    get query() {
+        return this.queryValue;
+    }
+    matches(nodeId, node, graph) {
+        return this.query.match(nodeId, node, graph);
+    }
+}
+export class EdgeRule extends BaseRule {
+    queryValue;
+    constructor(config) {
+        if (!('edge' in config)) {
+            throw new Error(`Rule '${new.target.name}' requires an edge config`);
+        }
+        super(config);
+        this.queryValue = {
+            from: NodeQuery.from(config.edge.from),
+            to: NodeQuery.from(config.edge.to),
+        };
+    }
+    get query() {
+        return this.queryValue;
+    }
+    matches(nodeId, node, graph) {
+        return this.query.from.match(nodeId, node, graph);
+    }
+}

package/dist/esm/Graph/Rules/Rule.test.d.ts

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

package/dist/esm/Graph/Rules/Rule.test.js

@@ -0,0 +1,125 @@
+import { mock } from 'jest-mock-extended';
+import { asNodeId } from '../TgGraph.js';
+import { BaseRule, EdgeRule, NodeRule } from './Rule.js';
+describe('BaseRule.fromSerialized', () => {
+    class SerializableRule extends BaseRule {
+        get query() {
+            return {};
+        }
+        matches(_nodeId, _node, _graph) {
+            return false;
+        }
+        apply(_nodeId, _node, graph) {
+            return graph;
+        }
+    }
+    BaseRule.register(SerializableRule);
+    it('shoud deserialize a registered rule', () => {
+        const serialized = {
+            id: 'SerializableRule',
+            config: {
+                node: { any: true },
+                options: { value: 'ok' },
+            },
+        };
+        const rule = BaseRule.fromSerialized(serialized);
+        expect(rule).toBeInstanceOf(SerializableRule);
+        expect(rule.serialize()).toEqual(serialized);
+    });
+    it('shoud throw when resolving an unregistered rule', () => {
+        expect(() => BaseRule.fromSerialized({
+            id: 'UnknownRule',
+            config: { node: { any: true } },
+        })).toThrow("Rule 'UnknownRule' is not registered");
+    });
+});
+describe('NodeRule.match and apply', () => {
+    class MatchAwareNodeRule extends NodeRule {
+        applyCount = 0;
+        apply(nodeId, _node, graph) {
+            if (!this.wasMatched(nodeId)) {
+                return graph;
+            }
+            this.applyCount += 1;
+            return graph;
+        }
+    }
+    it('shoud require node configuration', () => {
+        expect(() => new MatchAwareNodeRule({})).toThrow("Rule 'MatchAwareNodeRule' requires a node config");
+    });
+    it('shoud match and apply only after a successful match', () => {
+        const nodeA = asNodeId('node.a');
+        const nodeB = asNodeId('node.b');
+        const graph = mock();
+        const rule = new MatchAwareNodeRule({
+            node: { nodeId: { eq: String(nodeA) } },
+        });
+        expect(rule.match(nodeA, { label: 'node.a' }, graph)).toBe(true);
+        const afterFirstMatch = rule.apply(nodeA, { label: 'node.a' }, graph);
+        expect(rule.match(nodeB, { label: 'node.b' }, graph)).toBe(false);
+        const afterSecondMatch = rule.apply(nodeB, { label: 'node.b' }, graph);
+        expect(afterFirstMatch).toBe(graph);
+        expect(afterSecondMatch).toBe(graph);
+        expect(rule.applyCount).toBe(1);
+    });
+});
+describe('EdgeRule.match', () => {
+    class MatchAwareEdgeRule extends EdgeRule {
+        applyCount = 0;
+        apply(nodeId, _node, graph) {
+            if (!this.wasMatched(nodeId)) {
+                return graph;
+            }
+            this.applyCount += 1;
+            return graph;
+        }
+    }
+    it('shoud require edge configuration', () => {
+        expect(() => new MatchAwareEdgeRule({})).toThrow("Rule 'MatchAwareEdgeRule' requires an edge config");
+    });
+    it('shoud match only from-node for edge rules', () => {
+        const from = asNodeId('edge.from');
+        const to = asNodeId('edge.to');
+        const graph = mock();
+        const rule = new MatchAwareEdgeRule({
+            edge: {
+                from: { nodeId: { eq: String(from) } },
+                to: { nodeId: { eq: String(to) } },
+            },
+        });
+        expect(rule.match(from, { label: 'from' }, graph)).toBe(true);
+        expect(rule.match(to, { label: 'to' }, graph)).toBe(false);
+        expect(rule.applyCount).toBe(0);
+    });
+});
+describe('BaseRule.fromSerialized (invalid inputs)', () => {
+    it('shoud throw when serialized rule is undefined', () => {
+        expect(() => BaseRule.fromSerialized(undefined)).toThrow('Invalid serialized rule');
+    });
+    it('shoud throw when serialized rule has an empty id', () => {
+        expect(() => BaseRule.fromSerialized({
+            id: '',
+            config: {
+                node: { any: true },
+                options: { render: () => 'x' },
+            },
+        })).toThrow('Invalid serialized rule');
+    });
+});
+describe('BaseRule.describe and supports', () => {
+    class DescribeRule extends NodeRule {
+        apply(_nodeId, _node, graph) {
+            return graph;
+        }
+    }
+    it('shoud default describe to the rule id', () => {
+        const rule = new DescribeRule({ node: { any: true } });
+        const nodeId = asNodeId('node.describe');
+        expect(rule.describe(nodeId, { label: 'node.describe' })).toBe('DescribeRule');
+    });
+    it('shoud default supports to true', () => {
+        const rule = new DescribeRule({ node: { any: true } });
+        const graph = mock();
+        expect(rule.supports(graph)).toBe(true);
+    });
+});

package/dist/esm/Graph/Rules/RuleConfig.d.ts

@@ -0,0 +1,20 @@
+import { QueryDsl } from '../Operations/Matchers/NodeQuery/QuerySchema.js';
+export type NodeRuleConfig = {
+    node: QueryDsl;
+    options?: Record<string, unknown>;
+};
+export type EdgeRuleQuery = {
+    from: QueryDsl;
+    to: QueryDsl;
+};
+export type EdgeRuleConfig = {
+    edge: EdgeRuleQuery;
+    options?: Record<string, unknown>;
+};
+export type RuleConfig = NodeRuleConfig | EdgeRuleConfig;
+export type SerializedRule = {
+    id: string;
+    config: RuleConfig;
+};
+export type SerializedRulePhase = SerializedRule[];
+export type SerializedRulePlan = SerializedRulePhase[];

package/dist/esm/Graph/Rules/RuleConfig.js

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

package/dist/esm/Graph/Rules/RulePlan.d.ts

@@ -0,0 +1,27 @@
+import { BaseRule } from './Rule.js';
+import { SerializedRule } from './RuleConfig.js';
+export type NamedRuleRef = {
+    namedRule: string;
+};
+export type NamedRuleSetRef = {
+    namedRuleSet: string;
+};
+export type PhaseRule = BaseRule | SerializedRule | NamedRuleRef | NamedRuleSetRef;
+export type SerializedPhaseRule = SerializedRule | NamedRuleRef | NamedRuleSetRef;
+export declare const NAMED_PHASES: readonly ["pre", "normalize", "semantics", "main", "cleanup"];
+export type NamedPhase = (typeof NAMED_PHASES)[number];
+export type PhaseStep = {
+    phase: NamedPhase;
+    rules: PhaseRule[];
+};
+export type SerializedPhaseStep = {
+    phase: NamedPhase;
+    rules: SerializedPhaseRule[];
+};
+export type PhasePlan = PhaseStep[];
+export type SerializedPhasePlan = SerializedPhaseStep[];
+export type NamedRuleDefinition = SerializedRule | BaseRule | (() => BaseRule);
+export type NamedRuleDefinitions = Record<string, NamedRuleDefinition>;
+export declare const isNamedRuleRef: (rule: PhaseRule) => rule is NamedRuleRef;
+export declare const isNamedRuleSetRef: (rule: PhaseRule) => rule is NamedRuleSetRef;
+export declare const isNamedPhase: (value: unknown) => value is NamedPhase;

package/dist/esm/Graph/Rules/RulePlan.js

@@ -0,0 +1,22 @@
+export const NAMED_PHASES = [
+    'pre',
+    'normalize',
+    'semantics',
+    'main',
+    'cleanup',
+];
+export const isNamedRuleRef = (rule) => {
+    return (typeof rule === 'object' &&
+        rule !== null &&
+        'namedRule' in rule &&
+        typeof rule.namedRule === 'string');
+};
+export const isNamedRuleSetRef = (rule) => {
+    return (typeof rule === 'object' &&
+        rule !== null &&
+        'namedRuleSet' in rule &&
+        typeof rule.namedRuleSet === 'string');
+};
+export const isNamedPhase = (value) => {
+    return (typeof value === 'string' && NAMED_PHASES.includes(value));
+};

package/dist/esm/Graph/Rules/RuleSet.d.ts

@@ -0,0 +1,25 @@
+import { NamedRuleRegistry } from './NamedRuleRegistry.js';
+import type { NamedRuleSetRegistry } from './NamedRuleSetRegistry.js';
+import { BaseRule } from './Rule.js';
+import { PhasePlan, PhaseRule, SerializedPhaseRule } from './RulePlan.js';
+export type RuleSetOptions = {
+    rules?: PhaseRule[];
+};
+export type SerializedRuleSet = {
+    name?: string;
+    rules?: SerializedPhaseRule[];
+};
+export declare class RuleSet {
+    private readonly rules;
+    constructor(options?: RuleSetOptions);
+    addRules(rules: PhaseRule[]): RuleSet;
+    toPhases(): PhasePlan;
+    resolvePhases(namedRules?: NamedRuleRegistry, namedRuleSets?: NamedRuleSetRegistry): BaseRule[][];
+    serialize(): SerializedRuleSet;
+    static deseriaize(json: SerializedRuleSet): RuleSet;
+    private resolveRule;
+    private static isRuleInstance;
+    private serializeRules;
+    private static deserializeRules;
+    private static deserializeRule;
+}

package/dist/esm/Graph/Rules/RuleSet.js

@@ -0,0 +1,85 @@
+import { BaseRule } from './Rule.js';
+import { isNamedRuleRef, isNamedRuleSetRef, } from './RulePlan.js';
+export class RuleSet {
+    rules;
+    constructor(options = {}) {
+        this.rules = options.rules ?? [];
+    }
+    addRules(rules) {
+        return new RuleSet({
+            rules: [...this.rules, ...rules],
+        });
+    }
+    toPhases() {
+        return [
+            {
+                phase: 'main',
+                rules: [...this.rules],
+            },
+        ];
+    }
+    resolvePhases(namedRules, namedRuleSets) {
+        return [
+            this.rules.flatMap((rule) => this.resolveRule(rule, namedRules, namedRuleSets)),
+        ];
+    }
+    serialize() {
+        return {
+            rules: this.serializeRules(this.rules),
+        };
+    }
+    static deseriaize(json) {
+        return new RuleSet({
+            rules: RuleSet.deserializeRules(json.rules ?? []),
+        });
+    }
+    resolveRule(rule, namedRules, namedRuleSets) {
+        if (RuleSet.isRuleInstance(rule)) {
+            return [RuleSet.deserializeRule(rule.serialize())];
+        }
+        if (isNamedRuleRef(rule)) {
+            if (!namedRules) {
+                throw new Error('RuleSet contains named rules but no NamedRuleRegistry was provided');
+            }
+            return [namedRules.resolve(rule.namedRule)];
+        }
+        if (isNamedRuleSetRef(rule)) {
+            if (!namedRuleSets) {
+                throw new Error('RuleSet contains named rule sets but no NamedRuleSetRegistry was provided');
+            }
+            const resolved = namedRuleSets
+                .resolve(rule.namedRuleSet)
+                .resolvePhases(namedRules, namedRuleSets);
+            return resolved[0] ?? [];
+        }
+        return [RuleSet.deserializeRule(rule)];
+    }
+    static isRuleInstance(rule) {
+        if (rule instanceof BaseRule) {
+            return true;
+        }
+        if (isNamedRuleRef(rule) || isNamedRuleSetRef(rule)) {
+            return false;
+        }
+        return (
+        /* istanbul ignore next */
+        typeof rule === 'object' &&
+            rule !== null &&
+            'serialize' in rule &&
+            typeof rule.serialize === 'function');
+    }
+    serializeRules(rules) {
+        return rules.map((rule) => {
+            if (rule instanceof BaseRule) {
+                return rule.serialize();
+            }
+            return rule;
+        });
+    }
+    static deserializeRules(rules) {
+        return rules.map((rule) => rule);
+    }
+    static deserializeRule(rule) {
+        return BaseRule.fromSerialized(rule);
+    }
+}

package/dist/esm/Graph/Rules/RuleSet.test.d.ts

@@ -0,0 +1 @@
+import './Node/RemoveNode.js';

package/dist/esm/Graph/Rules/RuleSet.test.js

@@ -0,0 +1,220 @@
+import { Profile } from '../Profile.js';
+import { NamedRuleRegistry } from './NamedRuleRegistry.js';
+import { NamedRuleSetRegistry } from './NamedRuleSetRegistry.js';
+import { BaseRule } from './Rule.js';
+import { RuleSet } from './RuleSet.js';
+import './Node/RemoveNode.js';
+describe('RuleSet.resolvePhases', () => {
+    it('shoud resolve named rules when a registry is provided', () => {
+        const registry = new NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const ruleSet = new RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        const phases = ruleSet.resolvePhases(registry);
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+    });
+    it('shoud throw when named rules are used without a registry', () => {
+        const ruleSet = new RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        expect(() => ruleSet.resolvePhases()).toThrow('RuleSet contains named rules but no NamedRuleRegistry was provided');
+    });
+    it('shoud resolve named rule sets when a registry is provided', () => {
+        const namedRules = new NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const namedRuleSets = new NamedRuleSetRegistry({
+            baseSet: new RuleSet({
+                rules: [{ namedRule: 'removeDataNodes' }],
+            }),
+        });
+        const ruleSet = new RuleSet({
+            rules: [{ namedRuleSet: 'baseSet' }],
+        });
+        const phases = ruleSet.resolvePhases(namedRules, namedRuleSets);
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+    });
+    it('shoud throw when named rule sets are used without a registry', () => {
+        const ruleSet = new RuleSet({
+            rules: [{ namedRuleSet: 'baseSet' }],
+        });
+        expect(() => ruleSet.resolvePhases()).toThrow('RuleSet contains named rule sets but no NamedRuleSetRegistry was provided');
+    });
+    it('shoud handle named rule sets that resolve to no phases', () => {
+        const namedRuleSets = new NamedRuleSetRegistry({
+            empty: () => ({ resolvePhases: () => [] }),
+        });
+        const ruleSet = new RuleSet({
+            rules: [{ namedRuleSet: 'empty' }],
+        });
+        const phases = ruleSet.resolvePhases(undefined, namedRuleSets);
+        expect(phases).toEqual([[]]);
+    });
+    it('shoud resolve named rule sets via the internal resolver path', () => {
+        const namedRuleSets = new NamedRuleSetRegistry({
+            empty: new RuleSet(),
+        });
+        const ruleSet = new RuleSet();
+        const resolveRule = ruleSet;
+        const resolved = resolveRule.resolveRule({ namedRuleSet: 'empty' }, undefined, namedRuleSets);
+        expect(resolved).toEqual([]);
+    });
+    it('shoud resolve concrete rules by serializing and rehydrating', () => {
+        const rule = BaseRule.fromSerialized({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+        const ruleSet = new RuleSet({
+            rules: [rule],
+        });
+        const phases = ruleSet.resolvePhases();
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual(rule.serialize());
+    });
+    it('shoud resolve serialized rules without registries', () => {
+        const serializedRule = {
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        };
+        const ruleSet = new RuleSet({
+            rules: [serializedRule],
+        });
+        const phases = ruleSet.resolvePhases();
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual(serializedRule);
+    });
+});
+describe('RuleSet.serialize', () => {
+    it('shoud serialize and deserialize phases', () => {
+        const ruleSet = new RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        const serialized = ruleSet.serialize();
+        const restored = RuleSet.deseriaize(serialized);
+        expect(restored.serialize()).toStrictEqual(serialized);
+    });
+    it('shoud serialize concrete rules with their serialized form', () => {
+        const rule = BaseRule.fromSerialized({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+        const ruleSet = new RuleSet({
+            rules: [rule],
+        });
+        expect(ruleSet.serialize()).toEqual({
+            rules: [rule.serialize()],
+        });
+    });
+});
+describe('RuleSet.deseriaize', () => {
+    it('shoud default to empty rules when none are provided', () => {
+        const restored = RuleSet.deseriaize({});
+        expect(restored.toPhases()).toEqual([{ phase: 'main', rules: [] }]);
+    });
+});
+describe('RuleSet.toPhases', () => {
+    it('shoud provide phases that can be consumed by a profile', () => {
+        const ruleSet = new RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        const profile = new Profile('overview', { phases: ruleSet.toPhases() });
+        const phases = profile.serialize().phases ?? [];
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toEqual({
+            phase: 'main',
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+    });
+});
+describe('RuleSet.constructor', () => {
+    it('shoud default to empty rules when options are omitted', () => {
+        const ruleSet = new RuleSet();
+        expect(ruleSet.toPhases()).toEqual([{ phase: 'main', rules: [] }]);
+    });
+});
+describe('RuleSet.addRules', () => {
+    it('shoud return a new ruleset with appended rules', () => {
+        const ruleSet = new RuleSet({
+            rules: [{ namedRule: 'firstRule' }],
+        });
+        const next = ruleSet.addRules([{ namedRule: 'secondRule' }]);
+        expect(next).not.toBe(ruleSet);
+        expect(ruleSet.toPhases()[0]).toEqual({
+            phase: 'main',
+            rules: [{ namedRule: 'firstRule' }],
+        });
+        expect(next.toPhases()[0]).toEqual({
+            phase: 'main',
+            rules: [{ namedRule: 'firstRule' }, { namedRule: 'secondRule' }],
+        });
+    });
+});

package/dist/esm/Graph/Rules/index.d.ts

@@ -0,0 +1,8 @@
+export * from './Rule.js';
+export * from './RuleConfig.js';
+export * from './RulePlan.js';
+export * from './RuleSet.js';
+export * from './NamedRuleRegistry.js';
+export * from './NamedRuleSetRegistry.js';
+export * from './Node/index.js';
+export * from './Edge/index.js';

package/dist/esm/Graph/Rules/index.js

@@ -0,0 +1,8 @@
+export * from './Rule.js';
+export * from './RuleConfig.js';
+export * from './RulePlan.js';
+export * from './RuleSet.js';
+export * from './NamedRuleRegistry.js';
+export * from './NamedRuleSetRegistry.js';
+export * from './Node/index.js';
+export * from './Edge/index.js';

package/dist/esm/Graph/Rules/registerAll.d.ts

@@ -0,0 +1,14 @@
+import './Node/ConvertNodeToEdge.js';
+import './Node/NodeDotProperties.js';
+import './Node/NodeProperties.js';
+import './Node/RemoveLeafChain.js';
+import './Node/RemoveNode.js';
+import './Node/RemoveNodeAndReconnectEdges.js';
+import './Edge/AlignNodes.js';
+import './Edge/EdgeDirectionSemantic.js';
+import './Edge/EdgeDotProperties.js';
+import './Edge/EdgeLegend.js';
+import './Edge/EdgeReverse.js';
+import './Edge/EdgeSemanticLegend.js';
+import './Edge/ExplicitEdge.js';
+import './Edge/RemoveEdge.js';

package/dist/esm/Graph/Rules/registerAll.js

@@ -0,0 +1,14 @@
+import './Node/ConvertNodeToEdge.js';
+import './Node/NodeDotProperties.js';
+import './Node/NodeProperties.js';
+import './Node/RemoveLeafChain.js';
+import './Node/RemoveNode.js';
+import './Node/RemoveNodeAndReconnectEdges.js';
+import './Edge/AlignNodes.js';
+import './Edge/EdgeDirectionSemantic.js';
+import './Edge/EdgeDotProperties.js';
+import './Edge/EdgeLegend.js';
+import './Edge/EdgeReverse.js';
+import './Edge/EdgeSemanticLegend.js';
+import './Edge/ExplicitEdge.js';
+import './Edge/RemoveEdge.js';

package/dist/esm/Graph/Serialization/Registry.d.ts

@@ -0,0 +1,5 @@
+import { AdapterOperationsConstructor } from '../Operations/Operations.js';
+import { BaseRule } from '../Rules/Rule.js';
+import { SerializedRule } from '../Rules/RuleConfig.js';
+export type RuleRegistry = Record<string, (config: SerializedRule['config']) => BaseRule>;
+export type SupportedAdapterOperationsRegistry = Record<string, AdapterOperationsConstructor>;

package/dist/esm/Graph/Serialization/Registry.js

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