refactor types (#5)

Author: zmitry

src/graph/compound-graph.ts

@@ -3,8 +3,7 @@ import { upsertSet } from './helpers';
 export const ROOT_NODE = '_____root_graph_node_____';
 
 export interface IHierarchy {
-  addNode(node: string): void;
-  setParent(node: string, parent: string): void;
+  setParent(node: string, parent?: string): void;
   getParent(node: string): string;
   removeHierarchyNode(node: string): void;
   getChildren(node?: string): string[];
@@ -15,9 +14,6 @@ export function createHierarchy(): IHierarchy {
   const hierarchyParent = new Map<string, string>();
 
   const hierarchy: IHierarchy = {
-    addNode(node: string) {
-      hierarchy.setParent(node, ROOT_NODE);
-    },
     setParent(node: string, parent: string = ROOT_NODE) {
       // todo make it optimal
       for (let [, v] of hierarchyChildren) {

src/graph/dot.ts

@@ -1,24 +1,16 @@
-import { IUndirectedGraph, meta } from './graph';
+import { IUndirectedGraph, GraphReturn } from './graph';
 import { IHierarchy, ROOT_NODE } from './compound-graph';
 
 type Writer = ReturnType<typeof makeWriter>;
-export function toDot<N, E>(
-  g: IUndirectedGraph<N, E> & IHierarchy,
-  args: { intend?: string; compound: true }
-): string;
-
-export function toDot<N, E>(
-  g: IUndirectedGraph<N, E>,
-  args: { intend?: string; compound?: false }
-): string;
+type Args = { intend?: string; compound?: boolean; directed?: boolean };
+export function toDot<N, E>(g: GraphReturn<N, E>, args: Args): string;
 
 export function toDot<N, E>(
   g: any,
-  { intend = ' ', compound }: { intend?: string; compound?: boolean }
+  { intend = ' ', compound, directed }: Args
 ) {
   const graph: IUndirectedGraph<N, E> & IHierarchy = g;
   const writer = makeWriter(intend);
-  const directed = g[meta]?.directed;
   const ec = directed ? '->' : '--';
   writer.writeBlock(directed ? 'digraph' : 'graph', () => {
     graph.nodes().forEach(([key, value]) => {

src/graph/graph.ts

@@ -1,9 +1,9 @@
 import { Optional } from 'utility-types';
 
 import { upsertSet, mapUnique } from './helpers';
+import { createHierarchy, IHierarchy } from './compound-graph';
 
 //#region types
-export const meta = Symbol();
 interface IBaseGraphApi<N, E> {
   /**
    * get list of all edges
@@ -54,9 +54,6 @@ export interface IUndirectedGraph<N, E> extends IBaseGraphApi<N, E> {
    * list of nodes without  edges
    */
   orphans(node: string): string[];
-  [meta]?: {
-    directed: boolean;
-  };
 }
 // type for basic graph implementation
 export interface IDirectedGraph<N, E> extends IUndirectedGraph<N, E> {
@@ -77,9 +74,6 @@ export interface IDirectedGraph<N, E> extends IUndirectedGraph<N, E> {
    * list of outgoing edges for particular node
    */
   successors(node: string): string[];
-  [meta]?: {
-    directed: boolean;
-  };
 }
 
 type GraphEdge<T> = { to: string; from: string; value?: T };
@@ -88,6 +82,11 @@ type Events = {
   onAddNode?: (k: string) => void;
   onRemoveNode?: (k: string) => void;
 };
+
+type ICompoundGraphApi = Pick<
+  IHierarchy,
+  'getChildren' | 'getParent' | 'setParent'
+>;
 //#endregion
 
 function createBaseGraph<N, E>(events: Events) {
@@ -200,26 +199,41 @@ function createBaseGraph<N, E>(events: Events) {
   return graph;
 }
 
+export type GraphReturn<N, E> =
+  | IDirectedGraph<N, E>
+  | IUndirectedGraph<N, E>
+  | (IUndirectedGraph<N, E> & ICompoundGraphApi)
+  | (IUndirectedGraph<N, E> & ICompoundGraphApi);
+
 export function createGraph<N, E>(arg: {
-  events: Events;
   directed: true;
 }): IDirectedGraph<N, E>;
 export function createGraph<N, E>(arg: {
-  events: Events;
   directed: false;
 }): IUndirectedGraph<N, E>;
+export function createGraph<N, E>(arg: {
+  directed?: false;
+  compound: true;
+}): IUndirectedGraph<N, E> & ICompoundGraphApi;
+export function createGraph<N, E>(arg: {
+  directed: true;
+  compound: true;
+}): IUndirectedGraph<N, E> & ICompoundGraphApi;
 
 export function createGraph<N, E>({
-  events = {},
   directed,
+  compound,
 }: {
   directed?: boolean;
-
-  events?: Events;
-}): IDirectedGraph<N, E> {
+  compound?: boolean;
+}): GraphReturn<N, E> {
   const inNodes = new Map<string, Set<string>>();
   const outNodes = new Map<string, Set<string>>();
-  const base = createBaseGraph<N, E>(events);
+  const hierarchy = createHierarchy();
+  const base = createBaseGraph<N, E>({
+    onAddNode: hierarchy.setParent,
+    onRemoveNode: hierarchy.removeHierarchyNode,
+  });
   function reorderEdge<T>(from: string, to: string, value?: T) {
     if (!directed && from < to) {
       let tmp = from;
@@ -228,7 +242,7 @@ export function createGraph<N, E>({
     }
     return { from, to, value };
   }
-  const graph: IUndirectedGraph<N, E> = {
+  const graph = {
     getNodeValue: base.getNodeValue,
     setNode: base.setNode,
     hasNode: base.hasNode,
@@ -287,24 +301,44 @@ export function createGraph<N, E>({
     orphans() {
       return base.filterNodes(k => !inNodes.has(k) && !outNodes.has(k));
     },
+    predecessors(n: string) {
+      return Array.from(inNodes.get(n)?.values() || []);
+    },
+    successors(n: string) {
+      return Array.from(outNodes.get(n)?.values() || []);
+    },
+    sources() {
+      return base.filterNodes(k => !inNodes.has(k));
+    },
+    sinks() {
+      return base.filterNodes(k => !outNodes.has(k));
+    },
   };
-  if (directed) {
-    Object.assign(graph, {
-      predecessors(n: string) {
-        return mapUnique(Array.from(inNodes.get(n)?.values() || []));
-      },
-      successors(n: string) {
-        return mapUnique(Array.from(outNodes.get(n)?.values() || []));
-      },
-      sources() {
-        return base.filterNodes(k => !inNodes.has(k));
-      },
-      sinks() {
-        return base.filterNodes(k => !outNodes.has(k));
-      },
-    } as Partial<IDirectedGraph<N, E>>);
+  const compoundApi = {
+    getChildren: hierarchy.getChildren,
+    setParent: (node, parent) => {
+      if (!base.hasNode(node)) {
+        base.setNode(node);
+      }
+      if (parent && !base.hasNode(parent)) {
+        base.setNode(parent);
+      }
+      return hierarchy.setParent(node, parent);
+    },
+    getParent: hierarchy.getParent,
+  } as ICompoundGraphApi;
+
+  if (directed && compound) {
+    return Object.assign(graph, compoundApi) as IDirectedGraph<N, E> &
+      ICompoundGraphApi;
+  } else if (compound) {
+    return Object.assign(graph, compoundApi) as IUndirectedGraph<N, E> &
+      ICompoundGraphApi;
+  } else if (directed) {
+    return Object.assign(graph) as IDirectedGraph<N, E>;
+  } else {
+    return graph as IUndirectedGraph<N, E>;
   }
-  return graph as IDirectedGraph<N, E>;
 }
 
 function edgeToString(from: string, to: string) {

src/graph/index.ts

@@ -1,24 +1 @@
-import { createHierarchy, IHierarchy } from './compound-graph';
-import { IDirectedGraph, IUndirectedGraph, createGraph } from './graph';
-export * from './compound-graph';
 export * from './graph';
-
-export function createCompoundGraph<N, E>(
-  type: 'graph'
-): IHierarchy & IUndirectedGraph<N, E>;
-export function createCompoundGraph<N, E>(
-  type: 'digraph'
-): IHierarchy & IDirectedGraph<N, E>;
-
-export function createCompoundGraph<N, E>(type: string): any {
-  const hierarchy = createHierarchy();
-  const events = {
-    onAddNode: hierarchy.addNode,
-    onRemoveNode: hierarchy.removeHierarchyNode,
-  };
-  const graph =
-    type === 'graph'
-      ? createGraph<N, E>({ events, directed: false })
-      : createGraph<N, E>({ events, directed: true });
-  return Object.assign({}, graph, hierarchy);
-}

src/graph/tests/Graph.test.ts

@@ -1,27 +1,17 @@
 import { createGraph, IDirectedGraph } from '../graph';
 
-const getEvents = () => ({
-  onAddNode: jest.fn(),
-  onRemoveNode: jest.fn(),
-});
-
 describe('Graph', () => {
-  let events = getEvents();
   let digraph: IDirectedGraph<unknown, unknown>;
 
   beforeEach(() => {
-    events = getEvents();
     digraph = createGraph({
-      events,
       directed: true,
     });
   });
 
   it('should have a correct initial state', function() {
     expect(digraph.nodesCount()).toBe(0);
     expect(digraph.edgesCount()).toBe(0);
-    expect(events.onAddNode.mock.calls.length).toBe(0);
-    expect(events.onRemoveNode.mock.calls.length).toBe(0);
   });
 
   describe('nodes', () => {
@@ -67,29 +57,25 @@ describe('Graph', () => {
       expect(digraph.hasNode('a')).toBe(true);
       expect(digraph.getNodeValue('a')).toBeUndefined();
       expect(digraph.nodesCount()).toBe(1);
-      expect(events.onAddNode.mock.calls.length).toBe(1);
     });
 
     it('should can set a value for the node', () => {
       digraph.setNode('a', 'foo');
 
       expect(digraph.getNodeValue('a')).toBe('foo');
-      expect(events.onAddNode.mock.calls.length).toBe(1);
     });
 
     it("should does not change the node's value with a 1-arg invocation", () => {
       digraph.setNode('a', 'foo');
       digraph.setNode('a');
 
       expect(digraph.getNodeValue('a')).toBe('foo');
-      expect(events.onAddNode.mock.calls.length).toBe(1);
     });
 
     it("should can remove the node's value by passing undefined", () => {
       digraph.setNode('a', undefined);
 
       expect(digraph.getNodeValue('a')).toBeUndefined();
-      expect(events.onAddNode.mock.calls.length).toBe(1);
     });
 
     it('should filter idempotent nodes', () => {
@@ -98,7 +84,6 @@ describe('Graph', () => {
 
       expect(digraph.getNodeValue('a')).toBe('foo');
       expect(digraph.nodesCount()).toBe(1);
-      expect(events.onAddNode.mock.calls.length).toBe(1);
     });
   });
 
@@ -150,7 +135,6 @@ describe('Graph', () => {
 
       expect(digraph.hasNode('a')).toBe(false);
       expect(digraph.nodesCount()).toBe(0);
-      expect(events.onRemoveNode.mock.calls.length).toBe(0);
     });
 
     it('should remove the node if it is in the graph', () => {
@@ -159,7 +143,6 @@ describe('Graph', () => {
 
       expect(digraph.hasNode('a')).toBe(false);
       expect(digraph.nodesCount()).toBe(0);
-      expect(events.onRemoveNode.mock.calls.length).toBe(1);
     });
 
     it('should is idempotent', () => {
@@ -169,7 +152,6 @@ describe('Graph', () => {
 
       expect(digraph.hasNode('a')).toBe(false);
       expect(digraph.nodesCount()).toBe(0);
-      expect(events.onRemoveNode.mock.calls.length).toBe(1);
     });
 
     it('should remove edges incident on the node', () => {
@@ -178,7 +160,6 @@ describe('Graph', () => {
       digraph.removeNode('b');
 
       expect(digraph.edgesCount()).toBe(0);
-      expect(events.onRemoveNode.mock.calls.length).toBe(1);
     });
   });
 
@@ -305,7 +286,6 @@ describe('Graph', () => {
 
     it('should handle undirected graph edges', () => {
       const graph = createGraph({
-        events,
         directed: false,
       });
 
@@ -335,7 +315,6 @@ describe('Graph', () => {
 
     it('should return an edge in either direction in an undirected graph', function() {
       const graph = createGraph({
-        events,
         directed: false,
       });
 
@@ -374,7 +353,6 @@ describe('Graph', () => {
 
     it('should works with undirected graphs', () => {
       const graph = createGraph({
-        events,
         directed: false,
       });
 
@@ -408,7 +386,6 @@ describe('Graph', () => {
 
     it('should works with undirected graphs', () => {
       const graph = createGraph({
-        events,
         directed: false,
       });
 

src/graph/tests/__snapshots__/dot.test.ts.snap

@@ -13,13 +13,13 @@ exports[`dot converted basic 1`] = `
 `;
 
 exports[`dot converted compound 1`] = `
-"graph {
+"digraph {
   \\"1\\"
   \\"2\\" [\\"color\\"=\\"red\\"]
   \\"3\\"
   \\"4\\"
-  \\"1\\"--\\"2\\"
-  \\"3\\"--\\"4\\"
+  \\"1\\"->\\"2\\"
+  \\"3\\"->\\"4\\"
   subgraph \\"3\\" {
     \\"4\\";'
   }