@danielsimonjr/memory-mcp 11.0.1 → 11.1.1

package/dist/__tests__/file-path.test.js

@@ -1,119 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { ensureMemoryFilePath, defaultMemoryPath } from '../index.js';
-describe('ensureMemoryFilePath', () => {
-    const testDir = path.dirname(fileURLToPath(import.meta.url));
-    const oldMemoryPath = path.join(testDir, '..', 'memory.json');
-    const newMemoryPath = path.join(testDir, '..', 'memory.jsonl');
-    let originalEnv;
-    beforeEach(() => {
-        // Save original environment variable
-        originalEnv = process.env.MEMORY_FILE_PATH;
-        // Delete environment variable
-        delete process.env.MEMORY_FILE_PATH;
-    });
-    afterEach(async () => {
-        // Restore original environment variable
-        if (originalEnv !== undefined) {
-            process.env.MEMORY_FILE_PATH = originalEnv;
-        }
-        else {
-            delete process.env.MEMORY_FILE_PATH;
-        }
-        // Clean up test files
-        try {
-            await fs.unlink(oldMemoryPath);
-        }
-        catch {
-            // Ignore if file doesn't exist
-        }
-        try {
-            await fs.unlink(newMemoryPath);
-        }
-        catch {
-            // Ignore if file doesn't exist
-        }
-    });
-    describe('with MEMORY_FILE_PATH environment variable', () => {
-        it('should return absolute path when MEMORY_FILE_PATH is absolute', async () => {
-            const absolutePath = '/tmp/custom-memory.jsonl';
-            process.env.MEMORY_FILE_PATH = absolutePath;
-            const result = await ensureMemoryFilePath();
-            expect(result).toBe(absolutePath);
-        });
-        it('should convert relative path to absolute when MEMORY_FILE_PATH is relative', async () => {
-            const relativePath = 'custom-memory.jsonl';
-            process.env.MEMORY_FILE_PATH = relativePath;
-            const result = await ensureMemoryFilePath();
-            expect(path.isAbsolute(result)).toBe(true);
-            expect(result).toContain('custom-memory.jsonl');
-        });
-        it('should handle Windows absolute paths', async () => {
-            const windowsPath = 'C:\\temp\\memory.jsonl';
-            process.env.MEMORY_FILE_PATH = windowsPath;
-            const result = await ensureMemoryFilePath();
-            // On Windows, should return as-is; on Unix, will be treated as relative
-            if (process.platform === 'win32') {
-                expect(result).toBe(windowsPath);
-            }
-            else {
-                expect(path.isAbsolute(result)).toBe(true);
-            }
-        });
-    });
-    describe('without MEMORY_FILE_PATH environment variable', () => {
-        it('should return default path when no files exist', async () => {
-            const result = await ensureMemoryFilePath();
-            expect(result).toBe(defaultMemoryPath);
-        });
-        it('should migrate from memory.json to memory.jsonl when only old file exists', async () => {
-            // Create old memory.json file
-            await fs.writeFile(oldMemoryPath, '{"test":"data"}');
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const result = await ensureMemoryFilePath();
-            expect(result).toBe(defaultMemoryPath);
-            // Verify migration happened
-            const newFileExists = await fs.access(newMemoryPath).then(() => true).catch(() => false);
-            const oldFileExists = await fs.access(oldMemoryPath).then(() => true).catch(() => false);
-            expect(newFileExists).toBe(true);
-            expect(oldFileExists).toBe(false);
-            // Verify console messages
-            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('DETECTED: Found legacy memory.json file'));
-            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('COMPLETED: Successfully migrated'));
-            consoleErrorSpy.mockRestore();
-        });
-        it('should use new file when both old and new files exist', async () => {
-            // Create both files
-            await fs.writeFile(oldMemoryPath, '{"old":"data"}');
-            await fs.writeFile(newMemoryPath, '{"new":"data"}');
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const result = await ensureMemoryFilePath();
-            expect(result).toBe(defaultMemoryPath);
-            // Verify no migration happened (both files should still exist)
-            const newFileExists = await fs.access(newMemoryPath).then(() => true).catch(() => false);
-            const oldFileExists = await fs.access(oldMemoryPath).then(() => true).catch(() => false);
-            expect(newFileExists).toBe(true);
-            expect(oldFileExists).toBe(true);
-            // Verify no console messages about migration
-            expect(consoleErrorSpy).not.toHaveBeenCalled();
-            consoleErrorSpy.mockRestore();
-        });
-        it('should preserve file content during migration', async () => {
-            const testContent = '{"entities": [{"name": "test", "type": "person"}]}';
-            await fs.writeFile(oldMemoryPath, testContent);
-            await ensureMemoryFilePath();
-            const migratedContent = await fs.readFile(newMemoryPath, 'utf-8');
-            expect(migratedContent).toBe(testContent);
-        });
-    });
-    describe('defaultMemoryPath', () => {
-        it('should end with memory.jsonl', () => {
-            expect(defaultMemoryPath).toMatch(/memory\.jsonl$/);
-        });
-        it('should be an absolute path', () => {
-            expect(path.isAbsolute(defaultMemoryPath)).toBe(true);
-        });
-    });
-});

package/dist/__tests__/knowledge-graph.test.js

@@ -1,318 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { KnowledgeGraphManager } from '../index.js';
-describe('KnowledgeGraphManager', () => {
-    let manager;
-    let testFilePath;
-    beforeEach(async () => {
-        // Create a temporary test file path
-        testFilePath = path.join(path.dirname(fileURLToPath(import.meta.url)), `test-memory-${Date.now()}.jsonl`);
-        manager = new KnowledgeGraphManager(testFilePath);
-    });
-    afterEach(async () => {
-        // Clean up test file
-        try {
-            await fs.unlink(testFilePath);
-        }
-        catch (error) {
-            // Ignore errors if file doesn't exist
-        }
-    });
-    describe('createEntities', () => {
-        it('should create new entities', async () => {
-            const entities = [
-                { name: 'Alice', entityType: 'person', observations: ['works at Acme Corp'] },
-                { name: 'Bob', entityType: 'person', observations: ['likes programming'] },
-            ];
-            const newEntities = await manager.createEntities(entities);
-            expect(newEntities).toHaveLength(2);
-            expect(newEntities).toEqual(entities);
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(2);
-        });
-        it('should not create duplicate entities', async () => {
-            const entities = [
-                { name: 'Alice', entityType: 'person', observations: ['works at Acme Corp'] },
-            ];
-            await manager.createEntities(entities);
-            const newEntities = await manager.createEntities(entities);
-            expect(newEntities).toHaveLength(0);
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(1);
-        });
-        it('should handle empty entity arrays', async () => {
-            const newEntities = await manager.createEntities([]);
-            expect(newEntities).toHaveLength(0);
-        });
-    });
-    describe('createRelations', () => {
-        it('should create new relations', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: [] },
-                { name: 'Bob', entityType: 'person', observations: [] },
-            ]);
-            const relations = [
-                { from: 'Alice', to: 'Bob', relationType: 'knows' },
-            ];
-            const newRelations = await manager.createRelations(relations);
-            expect(newRelations).toHaveLength(1);
-            expect(newRelations).toEqual(relations);
-            const graph = await manager.readGraph();
-            expect(graph.relations).toHaveLength(1);
-        });
-        it('should not create duplicate relations', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: [] },
-                { name: 'Bob', entityType: 'person', observations: [] },
-            ]);
-            const relations = [
-                { from: 'Alice', to: 'Bob', relationType: 'knows' },
-            ];
-            await manager.createRelations(relations);
-            const newRelations = await manager.createRelations(relations);
-            expect(newRelations).toHaveLength(0);
-            const graph = await manager.readGraph();
-            expect(graph.relations).toHaveLength(1);
-        });
-        it('should handle empty relation arrays', async () => {
-            const newRelations = await manager.createRelations([]);
-            expect(newRelations).toHaveLength(0);
-        });
-    });
-    describe('addObservations', () => {
-        it('should add observations to existing entities', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: ['works at Acme Corp'] },
-            ]);
-            const results = await manager.addObservations([
-                { entityName: 'Alice', contents: ['likes coffee', 'has a dog'] },
-            ]);
-            expect(results).toHaveLength(1);
-            expect(results[0].entityName).toBe('Alice');
-            expect(results[0].addedObservations).toHaveLength(2);
-            const graph = await manager.readGraph();
-            const alice = graph.entities.find(e => e.name === 'Alice');
-            expect(alice?.observations).toHaveLength(3);
-        });
-        it('should not add duplicate observations', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: ['works at Acme Corp'] },
-            ]);
-            await manager.addObservations([
-                { entityName: 'Alice', contents: ['likes coffee'] },
-            ]);
-            const results = await manager.addObservations([
-                { entityName: 'Alice', contents: ['likes coffee', 'has a dog'] },
-            ]);
-            expect(results[0].addedObservations).toHaveLength(1);
-            expect(results[0].addedObservations).toContain('has a dog');
-            const graph = await manager.readGraph();
-            const alice = graph.entities.find(e => e.name === 'Alice');
-            expect(alice?.observations).toHaveLength(3);
-        });
-        it('should throw error for non-existent entity', async () => {
-            await expect(manager.addObservations([
-                { entityName: 'NonExistent', contents: ['some observation'] },
-            ])).rejects.toThrow('Entity with name NonExistent not found');
-        });
-    });
-    describe('deleteEntities', () => {
-        it('should delete entities', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: [] },
-                { name: 'Bob', entityType: 'person', observations: [] },
-            ]);
-            await manager.deleteEntities(['Alice']);
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(1);
-            expect(graph.entities[0].name).toBe('Bob');
-        });
-        it('should cascade delete relations when deleting entities', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: [] },
-                { name: 'Bob', entityType: 'person', observations: [] },
-                { name: 'Charlie', entityType: 'person', observations: [] },
-            ]);
-            await manager.createRelations([
-                { from: 'Alice', to: 'Bob', relationType: 'knows' },
-                { from: 'Bob', to: 'Charlie', relationType: 'knows' },
-            ]);
-            await manager.deleteEntities(['Bob']);
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(2);
-            expect(graph.relations).toHaveLength(0);
-        });
-        it('should handle deleting non-existent entities', async () => {
-            await manager.deleteEntities(['NonExistent']);
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(0);
-        });
-    });
-    describe('deleteObservations', () => {
-        it('should delete observations from entities', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: ['works at Acme Corp', 'likes coffee'] },
-            ]);
-            await manager.deleteObservations([
-                { entityName: 'Alice', observations: ['likes coffee'] },
-            ]);
-            const graph = await manager.readGraph();
-            const alice = graph.entities.find(e => e.name === 'Alice');
-            expect(alice?.observations).toHaveLength(1);
-            expect(alice?.observations).toContain('works at Acme Corp');
-        });
-        it('should handle deleting from non-existent entities', async () => {
-            await manager.deleteObservations([
-                { entityName: 'NonExistent', observations: ['some observation'] },
-            ]);
-            // Should not throw error
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(0);
-        });
-    });
-    describe('deleteRelations', () => {
-        it('should delete specific relations', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: [] },
-                { name: 'Bob', entityType: 'person', observations: [] },
-            ]);
-            await manager.createRelations([
-                { from: 'Alice', to: 'Bob', relationType: 'knows' },
-                { from: 'Alice', to: 'Bob', relationType: 'works_with' },
-            ]);
-            await manager.deleteRelations([
-                { from: 'Alice', to: 'Bob', relationType: 'knows' },
-            ]);
-            const graph = await manager.readGraph();
-            expect(graph.relations).toHaveLength(1);
-            expect(graph.relations[0].relationType).toBe('works_with');
-        });
-    });
-    describe('readGraph', () => {
-        it('should return empty graph when file does not exist', async () => {
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(0);
-            expect(graph.relations).toHaveLength(0);
-        });
-        it('should return complete graph with entities and relations', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: ['works at Acme Corp'] },
-            ]);
-            await manager.createRelations([
-                { from: 'Alice', to: 'Alice', relationType: 'self' },
-            ]);
-            const graph = await manager.readGraph();
-            expect(graph.entities).toHaveLength(1);
-            expect(graph.relations).toHaveLength(1);
-        });
-    });
-    describe('searchNodes', () => {
-        beforeEach(async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: ['works at Acme Corp', 'likes programming'] },
-                { name: 'Bob', entityType: 'person', observations: ['works at TechCo'] },
-                { name: 'Acme Corp', entityType: 'company', observations: ['tech company'] },
-            ]);
-            await manager.createRelations([
-                { from: 'Alice', to: 'Acme Corp', relationType: 'works_at' },
-                { from: 'Bob', to: 'Acme Corp', relationType: 'competitor' },
-            ]);
-        });
-        it('should search by entity name', async () => {
-            const result = await manager.searchNodes('Alice');
-            expect(result.entities).toHaveLength(1);
-            expect(result.entities[0].name).toBe('Alice');
-        });
-        it('should search by entity type', async () => {
-            const result = await manager.searchNodes('company');
-            expect(result.entities).toHaveLength(1);
-            expect(result.entities[0].name).toBe('Acme Corp');
-        });
-        it('should search by observation content', async () => {
-            const result = await manager.searchNodes('programming');
-            expect(result.entities).toHaveLength(1);
-            expect(result.entities[0].name).toBe('Alice');
-        });
-        it('should be case insensitive', async () => {
-            const result = await manager.searchNodes('ALICE');
-            expect(result.entities).toHaveLength(1);
-            expect(result.entities[0].name).toBe('Alice');
-        });
-        it('should include relations between matched entities', async () => {
-            const result = await manager.searchNodes('Acme');
-            expect(result.entities).toHaveLength(2); // Alice and Acme Corp
-            expect(result.relations).toHaveLength(1); // Only Alice -> Acme Corp relation
-        });
-        it('should return empty graph for no matches', async () => {
-            const result = await manager.searchNodes('NonExistent');
-            expect(result.entities).toHaveLength(0);
-            expect(result.relations).toHaveLength(0);
-        });
-    });
-    describe('openNodes', () => {
-        beforeEach(async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: [] },
-                { name: 'Bob', entityType: 'person', observations: [] },
-                { name: 'Charlie', entityType: 'person', observations: [] },
-            ]);
-            await manager.createRelations([
-                { from: 'Alice', to: 'Bob', relationType: 'knows' },
-                { from: 'Bob', to: 'Charlie', relationType: 'knows' },
-            ]);
-        });
-        it('should open specific nodes by name', async () => {
-            const result = await manager.openNodes(['Alice', 'Bob']);
-            expect(result.entities).toHaveLength(2);
-            expect(result.entities.map(e => e.name)).toContain('Alice');
-            expect(result.entities.map(e => e.name)).toContain('Bob');
-        });
-        it('should include relations between opened nodes', async () => {
-            const result = await manager.openNodes(['Alice', 'Bob']);
-            expect(result.relations).toHaveLength(1);
-            expect(result.relations[0].from).toBe('Alice');
-            expect(result.relations[0].to).toBe('Bob');
-        });
-        it('should exclude relations to unopened nodes', async () => {
-            const result = await manager.openNodes(['Bob']);
-            expect(result.relations).toHaveLength(0);
-        });
-        it('should handle opening non-existent nodes', async () => {
-            const result = await manager.openNodes(['NonExistent']);
-            expect(result.entities).toHaveLength(0);
-        });
-        it('should handle empty node list', async () => {
-            const result = await manager.openNodes([]);
-            expect(result.entities).toHaveLength(0);
-            expect(result.relations).toHaveLength(0);
-        });
-    });
-    describe('file persistence', () => {
-        it('should persist data across manager instances', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: ['persistent data'] },
-            ]);
-            // Create new manager instance with same file path
-            const manager2 = new KnowledgeGraphManager(testFilePath);
-            const graph = await manager2.readGraph();
-            expect(graph.entities).toHaveLength(1);
-            expect(graph.entities[0].name).toBe('Alice');
-        });
-        it('should handle JSONL format correctly', async () => {
-            await manager.createEntities([
-                { name: 'Alice', entityType: 'person', observations: [] },
-            ]);
-            await manager.createRelations([
-                { from: 'Alice', to: 'Alice', relationType: 'self' },
-            ]);
-            // Read file directly
-            const fileContent = await fs.readFile(testFilePath, 'utf-8');
-            const lines = fileContent.split('\n').filter(line => line.trim());
-            expect(lines).toHaveLength(2);
-            expect(JSON.parse(lines[0])).toHaveProperty('type', 'entity');
-            expect(JSON.parse(lines[1])).toHaveProperty('type', 'relation');
-        });
-    });
-});

package/dist/core/GraphEventEmitter.d.ts

@@ -1,202 +0,0 @@
-/**
- * Graph Event Emitter
- *
- * Phase 10 Sprint 2: Provides event-based notifications for graph changes.
- * Enables loose coupling between graph operations and dependent systems
- * like search indexes, analytics, and external integrations.
- *
- * @module core/GraphEventEmitter
- */
-import type { GraphEventType, GraphEvent, GraphEventListener, GraphEventMap, Entity, Relation } from '../types/index.js';
-/**
- * Phase 10 Sprint 2: Event emitter for graph change notifications.
- *
- * Provides a type-safe event system for subscribing to and emitting
- * graph change events. Supports wildcard listeners for all events.
- *
- * @example
- * ```typescript
- * const emitter = new GraphEventEmitter();
- *
- * // Listen to specific event types
- * emitter.on('entity:created', (event) => {
- *   console.log(`Entity ${event.entity.name} created`);
- * });
- *
- * // Listen to all events
- * emitter.onAny((event) => {
- *   console.log(`Event: ${event.type}`);
- * });
- *
- * // Emit an event
- * emitter.emitEntityCreated(entity);
- *
- * // Remove listener
- * const unsubscribe = emitter.on('entity:deleted', handler);
- * unsubscribe();
- * ```
- */
-export declare class GraphEventEmitter {
-    /**
-     * Map of event types to their registered listeners.
-     */
-    private listeners;
-    /**
-     * Listeners that receive all events regardless of type.
-     */
-    private wildcardListeners;
-    /**
-     * Whether to suppress errors from listeners (default: true).
-     * When true, listener errors are logged but don't stop event propagation.
-     */
-    private suppressListenerErrors;
-    /**
-     * Create a new GraphEventEmitter instance.
-     *
-     * @param options - Optional configuration
-     */
-    constructor(options?: {
-        suppressListenerErrors?: boolean;
-    });
-    /**
-     * Subscribe to a specific event type.
-     *
-     * @template K - The event type key
-     * @param eventType - The event type to listen for
-     * @param listener - Callback function to invoke when event occurs
-     * @returns Unsubscribe function to remove the listener
-     *
-     * @example
-     * ```typescript
-     * const unsubscribe = emitter.on('entity:created', (event) => {
-     *   console.log(`Created: ${event.entity.name}`);
-     * });
-     *
-     * // Later: unsubscribe();
-     * ```
-     */
-    on<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
-    /**
-     * Unsubscribe from a specific event type.
-     *
-     * @template K - The event type key
-     * @param eventType - The event type to unsubscribe from
-     * @param listener - The listener function to remove
-     */
-    off<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): void;
-    /**
-     * Subscribe to all event types.
-     *
-     * @param listener - Callback function to invoke for any event
-     * @returns Unsubscribe function to remove the listener
-     *
-     * @example
-     * ```typescript
-     * emitter.onAny((event) => {
-     *   console.log(`Event: ${event.type} at ${event.timestamp}`);
-     * });
-     * ```
-     */
-    onAny(listener: GraphEventListener<GraphEvent>): () => void;
-    /**
-     * Unsubscribe from all events.
-     *
-     * @param listener - The listener function to remove
-     */
-    offAny(listener: GraphEventListener<GraphEvent>): void;
-    /**
-     * Subscribe to an event type, but only receive the first occurrence.
-     *
-     * @template K - The event type key
-     * @param eventType - The event type to listen for once
-     * @param listener - Callback function to invoke once
-     * @returns Unsubscribe function to cancel before event occurs
-     */
-    once<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
-    /**
-     * Remove all listeners for all event types.
-     */
-    removeAllListeners(): void;
-    /**
-     * Get the count of listeners for a specific event type.
-     *
-     * @param eventType - The event type to count listeners for
-     * @returns Number of listeners registered
-     */
-    listenerCount(eventType?: GraphEventType): number;
-    /**
-     * Emit an event to all registered listeners.
-     *
-     * @param event - The event to emit
-     */
-    emit(event: GraphEvent): void;
-    /**
-     * Emit an entity:created event.
-     *
-     * @param entity - The entity that was created
-     */
-    emitEntityCreated(entity: Entity): void;
-    /**
-     * Emit an entity:updated event.
-     *
-     * @param entityName - Name of the updated entity
-     * @param changes - The changes that were applied
-     * @param previousValues - Optional previous values before update
-     */
-    emitEntityUpdated(entityName: string, changes: Partial<Entity>, previousValues?: Partial<Entity>): void;
-    /**
-     * Emit an entity:deleted event.
-     *
-     * @param entityName - Name of the deleted entity
-     * @param entity - Optional entity data before deletion
-     */
-    emitEntityDeleted(entityName: string, entity?: Entity): void;
-    /**
-     * Emit a relation:created event.
-     *
-     * @param relation - The relation that was created
-     */
-    emitRelationCreated(relation: Relation): void;
-    /**
-     * Emit a relation:deleted event.
-     *
-     * @param from - Source entity name
-     * @param to - Target entity name
-     * @param relationType - Type of the deleted relation
-     */
-    emitRelationDeleted(from: string, to: string, relationType: string): void;
-    /**
-     * Emit an observation:added event.
-     *
-     * @param entityName - Name of the entity
-     * @param observations - Observations that were added
-     */
-    emitObservationAdded(entityName: string, observations: string[]): void;
-    /**
-     * Emit an observation:deleted event.
-     *
-     * @param entityName - Name of the entity
-     * @param observations - Observations that were deleted
-     */
-    emitObservationDeleted(entityName: string, observations: string[]): void;
-    /**
-     * Emit a graph:saved event.
-     *
-     * @param entityCount - Number of entities in the saved graph
-     * @param relationCount - Number of relations in the saved graph
-     */
-    emitGraphSaved(entityCount: number, relationCount: number): void;
-    /**
-     * Emit a graph:loaded event.
-     *
-     * @param entityCount - Number of entities in the loaded graph
-     * @param relationCount - Number of relations in the loaded graph
-     */
-    emitGraphLoaded(entityCount: number, relationCount: number): void;
-    /**
-     * Safely invoke a listener, optionally catching errors.
-     * @private
-     */
-    private invokeListener;
-}
-//# sourceMappingURL=GraphEventEmitter.d.ts.map

package/dist/core/GraphEventEmitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GraphEventEmitter.d.ts","sourceRoot":"","sources":["../../src/core/GraphEventEmitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,aAAa,EACb,MAAM,EACN,QAAQ,EAUT,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,OAAO,CAAC,SAAS,CAAgE;IAEjF;;OAEG;IACH,OAAO,CAAC,iBAAiB,CAAkD;IAE3E;;;OAGG;IACH,OAAO,CAAC,sBAAsB,CAAiB;IAE/C;;;;OAIG;gBACS,OAAO,CAAC,EAAE;QAAE,sBAAsB,CAAC,EAAE,OAAO,CAAA;KAAE;IAQ1D;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,CAAC,CAAC,SAAS,cAAc,EACzB,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAC7C,MAAM,IAAI;IAYb;;;;;;OAMG;IACH,GAAG,CAAC,CAAC,SAAS,cAAc,EAC1B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAC7C,IAAI;IAOP;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,GAAG,MAAM,IAAI;IAO3D;;;;OAIG;IACH,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,GAAG,IAAI;IAItD;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,SAAS,cAAc,EAC3B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAC7C,MAAM,IAAI;IASb;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAK1B;;;;;OAKG;IACH,aAAa,CAAC,SAAS,CAAC,EAAE,cAAc,GAAG,MAAM;IAcjD;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAe7B;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASvC;;;;;;OAMG;IACH,iBAAiB,CACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,EACxB,cAAc,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,GAC/B,IAAI;IAWP;;;;;OAKG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAU5D;;;;OAIG;IACH,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAS7C;;;;;;OAMG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAWzE;;;;;OAKG;IACH,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI;IAYtE;;;;;OAKG;IACH,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI;IAYxE;;;;;OAKG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAUhE;;;;;OAKG;IACH,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAYjE;;;OAGG;IACH,OAAO,CAAC,cAAc;CAYvB"}