@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Runtime/RuntimeProviderLoader/ModuleRuntimeProviderLoader.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleRuntimeProviderLoader = exports.__test__ = void 0;
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const isRuntimeProvider = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isRuntimeProviderFactory = (value) => typeof value === 'function';
+const toProvider = async (value) => {
+    const candidate = isRuntimeProvider(value) &&
+        ('runtimeProvider' in value || 'default' in value)
+        ? (value.runtimeProvider ??
+            value.default)
+        : value;
+    if (isRuntimeProviderFactory(candidate)) {
+        const resolved = await candidate();
+        if (!isRuntimeProvider(resolved)) {
+            throw new Error('Module does not export a valid runtime provider');
+        }
+        return resolved;
+    }
+    if (!isRuntimeProvider(candidate)) {
+        throw new Error('Module does not export a valid runtime provider');
+    }
+    return candidate;
+};
+const resolveImportSpecifier = (specifier, sourceReference) => {
+    if (specifier.startsWith('.') ||
+        specifier.startsWith('/') ||
+        specifier.startsWith('file:')) {
+        if (specifier.startsWith('file:')) {
+            return specifier;
+        }
+        if ((0, node_path_1.isAbsolute)(specifier)) {
+            return (0, node_url_1.pathToFileURL)(specifier).href;
+        }
+        if (!sourceReference) {
+            return (0, node_url_1.pathToFileURL)((0, node_path_1.resolve)(specifier)).href;
+        }
+        return (0, node_url_1.pathToFileURL)((0, node_path_1.resolve)((0, node_path_1.dirname)(sourceReference), specifier)).href;
+    }
+    return specifier;
+};
+exports.__test__ = {
+    toProvider,
+    resolveImportSpecifier,
+};
+class ModuleRuntimeProviderLoader {
+    async load(input) {
+        const resolvedSpecifier = resolveImportSpecifier(input.specifier, input.sourceReference);
+        const loaded = await Promise.resolve(`${resolvedSpecifier}`).then(s => __importStar(require(s)));
+        return toProvider(loaded);
+    }
+}
+exports.ModuleRuntimeProviderLoader = ModuleRuntimeProviderLoader;

package/dist/cjs/Runtime/RuntimeProviderLoader/ModuleRuntimeProviderLoader.test.d.ts

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

package/dist/cjs/Runtime/RuntimeProviderLoader/ModuleRuntimeProviderLoader.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const ModuleRuntimeProviderLoader_js_1 = require("./ModuleRuntimeProviderLoader.js");
+describe('ModuleRuntimeProviderLoader.load', () => {
+    it('shoud load a provider from a module default object export', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { ExternalAdapter: class ExternalAdapter {} } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: providerPath });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('ExternalAdapter');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud load a provider from a runtimeProvider named export', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = { runtimeProvider: { supportedAdapterOperationsRegistry: { NamedExport: class NamedExport {} } } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: providerPath });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('NamedExport');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud accept raw runtime providers without module export markers', async () => {
+        const provider = {};
+        await expect(ModuleRuntimeProviderLoader_js_1.__test__.toProvider(provider)).resolves.toBe(provider);
+    });
+    it('shoud load a provider from a default function export', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = () => ({ supportedAdapterOperationsRegistry: { FromDefault: class FromDefault {} } });', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: providerPath });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('FromDefault');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud load a provider from a file URL specifier', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { FileUrlProvider: class FileUrlProvider {} } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            const provider = await loader.load({
+                specifier: (0, node_url_1.pathToFileURL)(providerPath).href,
+            });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('FileUrlProvider');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud resolve relative provider specifiers from cwd when no reference is provided', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        const originalCwd = process.cwd();
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { CwdProvider: class CwdProvider {} } };', 'utf8');
+        try {
+            process.chdir(dir);
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: './provider.cjs' });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('CwdProvider');
+        }
+        finally {
+            process.chdir(originalCwd);
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud resolve relative provider specifiers from sourceReference', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const configPath = (0, node_path_1.join)(dir, 'runtime.yaml');
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { RelativeProvider: class RelativeProvider {} } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            const provider = await loader.load({
+                specifier: './provider.cjs',
+                sourceReference: configPath,
+            });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('RelativeProvider');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud accept non-file specifiers unchanged', async () => {
+        const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+        const provider = await loader.load({ specifier: 'node:fs' });
+        expect(provider).toBeDefined();
+        expect(provider.readFile).toBeDefined();
+    });
+    it('shoud throw when module does not export a runtime provider', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = 1;', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            await expect(loader.load({ specifier: providerPath })).rejects.toThrow('Module does not export a valid runtime provider');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud throw when a provider factory resolves to an invalid value', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-provider-loader-'));
+        const providerPath = (0, node_path_1.join)(dir, 'provider.cjs');
+        await (0, promises_1.writeFile)(providerPath, 'module.exports = { runtimeProvider: () => 1 };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+            await expect(loader.load({ specifier: providerPath })).rejects.toThrow('Module does not export a valid runtime provider');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/cjs/Runtime/RuntimeProviderLoader/index.d.ts

@@ -0,0 +1 @@
+export * from './ModuleRuntimeProviderLoader.js';

package/dist/cjs/Runtime/RuntimeProviderLoader/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ModuleRuntimeProviderLoader.js"), exports);

package/dist/cjs/Runtime/RuntimeProviderLoader.d.ts

@@ -0,0 +1,8 @@
+import { RuntimeProvider } from './RuntimeProvider.js';
+export type RuntimeProviderLoadInput = {
+    specifier: string;
+    sourceReference?: string;
+};
+export interface RuntimeProviderLoader {
+    load(input: RuntimeProviderLoadInput): Promise<RuntimeProvider>;
+}

package/dist/cjs/Runtime/RuntimeProviderLoader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/Runtime/RuntimeProviderLoader.test.d.ts

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

package/dist/cjs/Runtime/RuntimeProviderLoader.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('RuntimeProviderLoader.load', () => {
+    it('shoud allow implementations to load runtime providers from a specifier', async () => {
+        class CaptureRuntimeProviderLoader {
+            captured;
+            async load(input) {
+                this.captured = input;
+                return {
+                    supportedAdapterOperationsRegistry: {},
+                };
+            }
+        }
+        const loader = new CaptureRuntimeProviderLoader();
+        const input = {
+            specifier: '@example/runtime-provider',
+            sourceReference: '/tmp/runtime.yaml',
+        };
+        const result = await loader.load(input);
+        expect(loader.captured).toEqual(input);
+        expect(result).toEqual({
+            supportedAdapterOperationsRegistry: {},
+        });
+    });
+});

package/dist/cjs/Runtime/index.d.ts

@@ -0,0 +1,15 @@
+export * from './RuntimeCatalog.js';
+export * from './RuntimeCatalogLoader.js';
+export * from './RuntimeCatalogBuilder.js';
+export * from './RuntimeCatalogBuilder/index.js';
+export * from './RuntimeConfigLoader.js';
+export * from './RuntimeConfigParser.js';
+export * from './RuntimeConfigParserRegistry.js';
+export * from './RuntimeConfigParser/index.js';
+export * from './RuntimeConfigSource.js';
+export * from './RuntimeConfigSource/index.js';
+export * from './RuntimeConfigValidator.js';
+export * from './RuntimeConfigValidator/index.js';
+export * from './RuntimeProvider.js';
+export * from './RuntimeProviderLoader.js';
+export * from './RuntimeProviderLoader/index.js';

package/dist/cjs/Runtime/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RuntimeCatalog.js"), exports);
+__exportStar(require("./RuntimeCatalogLoader.js"), exports);
+__exportStar(require("./RuntimeCatalogBuilder.js"), exports);
+__exportStar(require("./RuntimeCatalogBuilder/index.js"), exports);
+__exportStar(require("./RuntimeConfigLoader.js"), exports);
+__exportStar(require("./RuntimeConfigParser.js"), exports);
+__exportStar(require("./RuntimeConfigParserRegistry.js"), exports);
+__exportStar(require("./RuntimeConfigParser/index.js"), exports);
+__exportStar(require("./RuntimeConfigSource.js"), exports);
+__exportStar(require("./RuntimeConfigSource/index.js"), exports);
+__exportStar(require("./RuntimeConfigValidator.js"), exports);
+__exportStar(require("./RuntimeConfigValidator/index.js"), exports);
+__exportStar(require("./RuntimeProvider.js"), exports);
+__exportStar(require("./RuntimeProviderLoader.js"), exports);
+__exportStar(require("./RuntimeProviderLoader/index.js"), exports);

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Graph/index.js';
+export * from './Output/index.js';
+export * from './Runtime/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Graph/index.js"), exports);
+__exportStar(require("./Output/index.js"), exports);
+__exportStar(require("./Runtime/index.js"), exports);

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/esm/Graph/Adapter.d.ts

@@ -0,0 +1,8 @@
+import { AdapterOperations } from './Operations/Operations.js';
+import type { Renderer } from './Renderer.js';
+import { TgGraph } from './TgGraph.js';
+export interface Adapter {
+    toTgGraph(): TgGraph;
+    withTgGraph(tg: TgGraph): AdapterOperations;
+    getRenderer<TOptions = unknown>(options?: TOptions): Renderer<this>;
+}

package/dist/esm/Graph/Adapter.js

@@ -0,0 +1,4 @@
+export {};
+// export type AdapterFactory<A extends Adapter> = {
+//   fromTgGraph(tg: TgGraph): A;
+// };

package/dist/esm/Graph/Adapters/DotAdapter.d.ts

@@ -0,0 +1,17 @@
+import type { Renderer } from '../Renderer.js';
+import { type DotRendererOptions } from '../Renderers/DotRenderer.js';
+import { NodeId } from '../TgGraph.js';
+import { GraphologyAdapter } from './GraphologyAdapter.js';
+type DotRank = {
+    mode: 'same' | 'min' | 'max';
+    nodes: NodeId[];
+};
+export declare class DotAdapter extends GraphologyAdapter {
+    private static readonly RankAttr;
+    getRenderer<TOptions = DotRendererOptions>(options?: TOptions): Renderer<this>;
+    addRank(nodes: NodeId[], mode?: DotRank['mode']): this;
+    getRanks(): DotRank[];
+    clearRanks(): this;
+    private setRanks;
+}
+export {};

package/dist/esm/Graph/Adapters/DotAdapter.js

@@ -0,0 +1,27 @@
+import { DotRenderer, } from '../Renderers/DotRenderer.js';
+import { GraphologyAdapter } from './GraphologyAdapter.js';
+export class DotAdapter extends GraphologyAdapter {
+    static RankAttr = 'tg:dot:ranks';
+    getRenderer(options) {
+        const dotOptions = options && typeof options === 'object'
+            ? options
+            : undefined;
+        return new DotRenderer(dotOptions);
+    }
+    addRank(nodes, mode = 'same') {
+        const ranks = this.getRanks();
+        ranks.push({ mode, nodes });
+        return this.setRanks(ranks);
+    }
+    getRanks() {
+        return this.readGraphAttribute(DotAdapter.RankAttr, []);
+    }
+    clearRanks() {
+        return this.setRanks([]);
+    }
+    setRanks(ranks) {
+        return this.mutateGraph((graph) => {
+            graph.setAttribute(DotAdapter.RankAttr, ranks);
+        });
+    }
+}

package/dist/esm/Graph/Adapters/DotAdapter.test.d.ts

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

package/dist/esm/Graph/Adapters/DotAdapter.test.js

@@ -0,0 +1,43 @@
+import { DirectedGraph } from 'graphology';
+import { DotRenderer } from '../Renderers/DotRenderer.js';
+import { asNodeId } from '../TgGraph.js';
+import { DotAdapter } from './DotAdapter.js';
+describe('DotAdapter.addRank', () => {
+    it('shoud add and return ranks', () => {
+        const adapter = new DotAdapter(new DirectedGraph());
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const updated = adapter.addRank([nodeA, nodeB], 'same');
+        expect(updated.getRanks()).toEqual([
+            { mode: 'same', nodes: [nodeA, nodeB] },
+        ]);
+    });
+    it('shoud default the rank mode to same', () => {
+        const adapter = new DotAdapter(new DirectedGraph());
+        const nodeA = asNodeId('node-a');
+        const updated = adapter.addRank([nodeA]);
+        expect(updated.getRanks()).toEqual([{ mode: 'same', nodes: [nodeA] }]);
+    });
+});
+describe('DotAdapter.getRenderer', () => {
+    it('shoud return a DotRenderer when options are provided', () => {
+        const adapter = new DotAdapter(new DirectedGraph());
+        const renderer = adapter.getRenderer({
+            graph: { rankdir: 'TB' },
+        });
+        expect(renderer).toBeInstanceOf(DotRenderer);
+    });
+    it('shoud ignore non-object options', () => {
+        const adapter = new DotAdapter(new DirectedGraph());
+        const renderer = adapter.getRenderer('invalid');
+        expect(renderer).toBeInstanceOf(DotRenderer);
+    });
+});
+describe('DotAdapter.clearRanks', () => {
+    it('shoud clear ranks', () => {
+        const adapter = new DotAdapter(new DirectedGraph());
+        const nodeA = asNodeId('node-a');
+        const updated = adapter.addRank([nodeA], 'min').clearRanks();
+        expect(updated.getRanks()).toEqual([]);
+    });
+});

package/dist/esm/Graph/Adapters/GraphologyAdapter.d.ts

@@ -0,0 +1,36 @@
+import type { AbstractGraph as Graphology } from 'graphology-types';
+import { AdapterOperations } from '../Operations/Operations.js';
+import { JsonRenderer } from '../Renderers/JsonRenderer.js';
+import { EdgeId, NodeId, type TgEdgeAttributes, TgGraph, TgNodeAttributes } from '../TgGraph.js';
+export declare enum GraphAttributeKey {
+    Description = "tg:description",
+    SchemaVersion = "tg:schemaVersion"
+}
+export declare class GraphologyAdapter implements AdapterOperations {
+    protected readonly graph: Graphology;
+    constructor(graph?: Graphology);
+    withTgGraph(tg: TgGraph): this;
+    toTgGraph(): TgGraph;
+    getRenderer<TOptions = unknown>(_options?: TOptions): JsonRenderer<this>;
+    getGraph(): Graphology;
+    getNodeAttributes(nodeId: NodeId): TgNodeAttributes | undefined;
+    getEdgeAttributes(edgeId: EdgeId): TgEdgeAttributes;
+    edgeSource(edgeId: EdgeId): NodeId;
+    edgeTarget(edgeId: EdgeId): NodeId;
+    nodeIds(): NodeId[];
+    neighbors(nodeId: NodeId): NodeId[];
+    predecessors(nodeId: NodeId): NodeId[];
+    successors(nodeId: NodeId): NodeId[];
+    inEdges(nodeId: NodeId): EdgeId[];
+    outEdges(nodeId: NodeId): EdgeId[];
+    edgesBetween(source: NodeId, target: NodeId): EdgeId[];
+    setNodeAttributes(nodeId: NodeId, attributes: TgNodeAttributes): this;
+    setEdge(edgeId: EdgeId, source: NodeId, target: NodeId, attributes: TgEdgeAttributes): this;
+    removeNode(nodeId: NodeId): this;
+    removeEdge(edgeId: EdgeId): this;
+    protected readGraphAttribute<T>(key: string, fallback: T): T;
+    protected mutateGraph(mutate: (graph: Graphology) => void): this;
+    private describeNode;
+    private resolveTerraform;
+    private parentModuleHelpers;
+}