@antv/algorithm - npm Package Compare versions

Comparing version 0.1.8 to 0.1.9

es/index.d.ts

@@ -18,10 +18,7 @@ import getAdjMatrix from './adjacent-matrix';
 import { getNeighbors } from './util';
+import { IAlgorithm } from './types';
 declare const detectDirectedCycle: (graphData: import("./types").GraphData) => {
     [key: string]: string;
 };
-declare const detectDirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-    [key: string]: string;
-}>;
-import { getAdjMatrixAsync, connectedComponentAsync, getDegreeAsync, getInDegreeAsync, getOutDegreeAsync, detectCycleAsync, detectAllCyclesAsync, detectAllDirectedCycleAsync, detectAllUndirectedCycleAsync, dijkstraAsync, findAllPathAsync, findShortestPathAsync, floydWarshallAsync, labelPropagationAsync, louvainAsync, minimumSpanningTreeAsync, pageRankAsync, getNeighborsAsync, GADDIAsync } from './workers/index';
-export { getAdjMatrix, breadthFirstSearch, connectedComponent, getDegree, getInDegree, getOutDegree, detectCycle, detectDirectedCycle, detectAllCycles, detectAllDirectedCycle, detectAllUndirectedCycle, depthFirstSearch, dijkstra, findAllPath, findShortestPath, floydWarshall, labelPropagation, louvain, minimumSpanningTree, pageRank, getNeighbors, Stack, GADDI, getAdjMatrixAsync, connectedComponentAsync, getDegreeAsync, getInDegreeAsync, getOutDegreeAsync, detectCycleAsync, detectDirectedCycleAsync, detectAllCyclesAsync, detectAllDirectedCycleAsync, detectAllUndirectedCycleAsync, dijkstraAsync, findAllPathAsync, findShortestPathAsync, floydWarshallAsync, labelPropagationAsync, louvainAsync, minimumSpanningTreeAsync, pageRankAsync, getNeighborsAsync, GADDIAsync, };
+export { getAdjMatrix, breadthFirstSearch, connectedComponent, getDegree, getInDegree, getOutDegree, detectCycle, detectDirectedCycle, detectAllCycles, detectAllDirectedCycle, detectAllUndirectedCycle, depthFirstSearch, dijkstra, findAllPath, findShortestPath, floydWarshall, labelPropagation, louvain, minimumSpanningTree, pageRank, getNeighbors, Stack, GADDI, IAlgorithm };
 declare const _default: {
@@ -65,43 +62,3 @@ getAdjMatrix: (graphData: import("./types").GraphData, directed?: boolean) => import("./types").Matrix[];
     GADDI: (graphData: import("./types").GraphData, pattern: import("./types").GraphData, directed: boolean, k: number, length: number, nodeLabelProp?: string, edgeLabelProp?: string) => import("./types").GraphData[];
-    getAdjMatrixAsync: (graphData: import("./types").GraphData, directed?: boolean) => Promise<import("./types").Matrix[]>;
-    connectedComponentAsync: (graphData: import("./types").GraphData, directed?: boolean) => Promise<import("./types").NodeConfig[][]>;
-    getDegreeAsync: (graphData: import("./types").GraphData) => Promise<import("./types").DegreeType>;
-    getInDegreeAsync: (graphData: import("./types").GraphData, nodeId: string) => Promise<import("./types").DegreeType>;
-    getOutDegreeAsync: (graphData: import("./types").GraphData, nodeId: string) => Promise<import("./types").DegreeType>;
-    detectCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectDirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectAllCyclesAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectAllDirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectAllUndirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    dijkstraAsync: (graphData: import("./types").GraphData, source: string, directed?: boolean, weightPropertyName?: string) => Promise<{
-        length: number;
-        path: any;
-        allPath: any;
-    }>;
-    findAllPathAsync: (graphData: import("./types").GraphData, start: string, end: string, directed?: boolean) => Promise<string[][]>;
-    findShortestPathAsync: (graphData: import("./types").GraphData, start: string, end: string, directed?: boolean, weightPropertyName?: string) => Promise<{
-        length: number;
-        path: any;
-        allPath: any;
-    }>;
-    floydWarshallAsync: (graphData: import("./types").GraphData, directed?: boolean) => Promise<import("./types").Matrix[]>;
-    labelPropagationAsync: (graphData: import("./types").GraphData, directed: boolean, weightPropertyName: string, maxIteration?: number) => Promise<import("./types").ClusterData>;
-    louvainAsync: (graphData: import("./types").GraphData, directed: boolean, weightPropertyName: string, threshold: number) => Promise<import("./types").ClusterData>;
-    minimumSpanningTreeAsync: (graphData: import("./types").GraphData, weight?: boolean, algo?: string) => Promise<import("./types").EdgeConfig[]>;
-    pageRankAsync: (graphData: import("./types").GraphData, epsilon?: number, linkProb?: number) => Promise<{
-        [key: string]: number;
-    }>;
-    getNeighborsAsync: (nodeId: string, edges: import("./types").EdgeConfig[], type?: "source" | "target") => Promise<string[]>;
-    GADDIAsync: (graphData: import("./types").GraphData, pattern: import("./types").GraphData, directed: boolean, k: number, length: number, nodeLabelProp?: string, edgeLabelProp?: string) => Promise<import("./types").GraphData[]>;
 };
 export default _default;

es/index.js

@@ -19,5 +19,3 @@ import getAdjMatrix from './adjacent-matrix';
 var detectDirectedCycle = detectCycle;
-var detectDirectedCycleAsync = detectCycleAsync;
-import { getAdjMatrixAsync, connectedComponentAsync, getDegreeAsync, getInDegreeAsync, getOutDegreeAsync, detectCycleAsync, detectAllCyclesAsync, detectAllDirectedCycleAsync, detectAllUndirectedCycleAsync, dijkstraAsync, findAllPathAsync, findShortestPathAsync, floydWarshallAsync, labelPropagationAsync, louvainAsync, minimumSpanningTreeAsync, pageRankAsync, getNeighborsAsync, GADDIAsync } from './workers/index';
-export { getAdjMatrix, breadthFirstSearch, connectedComponent, getDegree, getInDegree, getOutDegree, detectCycle, detectDirectedCycle, detectAllCycles, detectAllDirectedCycle, detectAllUndirectedCycle, depthFirstSearch, dijkstra, findAllPath, findShortestPath, floydWarshall, labelPropagation, louvain, minimumSpanningTree, pageRank, getNeighbors, Stack, GADDI, getAdjMatrixAsync, connectedComponentAsync, getDegreeAsync, getInDegreeAsync, getOutDegreeAsync, detectCycleAsync, detectDirectedCycleAsync, detectAllCyclesAsync, detectAllDirectedCycleAsync, detectAllUndirectedCycleAsync, dijkstraAsync, findAllPathAsync, findShortestPathAsync, floydWarshallAsync, labelPropagationAsync, louvainAsync, minimumSpanningTreeAsync, pageRankAsync, getNeighborsAsync, GADDIAsync };
+export { getAdjMatrix, breadthFirstSearch, connectedComponent, getDegree, getInDegree, getOutDegree, detectCycle, detectDirectedCycle, detectAllCycles, detectAllDirectedCycle, detectAllUndirectedCycle, depthFirstSearch, dijkstra, findAllPath, findShortestPath, floydWarshall, labelPropagation, louvain, minimumSpanningTree, pageRank, getNeighbors, Stack, GADDI };
 export default {
@@ -46,23 +44,3 @@ getAdjMatrix: getAdjMatrix,
   Stack: Stack,
-  GADDI: GADDI,
-  getAdjMatrixAsync: getAdjMatrixAsync,
-  connectedComponentAsync: connectedComponentAsync,
-  getDegreeAsync: getDegreeAsync,
-  getInDegreeAsync: getInDegreeAsync,
-  getOutDegreeAsync: getOutDegreeAsync,
-  detectCycleAsync: detectCycleAsync,
-  detectDirectedCycleAsync: detectDirectedCycleAsync,
-  detectAllCyclesAsync: detectAllCyclesAsync,
-  detectAllDirectedCycleAsync: detectAllDirectedCycleAsync,
-  detectAllUndirectedCycleAsync: detectAllUndirectedCycleAsync,
-  dijkstraAsync: dijkstraAsync,
-  findAllPathAsync: findAllPathAsync,
-  findShortestPathAsync: findShortestPathAsync,
-  floydWarshallAsync: floydWarshallAsync,
-  labelPropagationAsync: labelPropagationAsync,
-  louvainAsync: louvainAsync,
-  minimumSpanningTreeAsync: minimumSpanningTreeAsync,
-  pageRankAsync: pageRankAsync,
-  getNeighborsAsync: getNeighborsAsync,
-  GADDIAsync: GADDIAsync
+  GADDI: GADDI
 };

es/types.d.ts

@@ -51,1 +51,66 @@ export declare type Matrix = number[];
 }
+export interface IAlgorithm {
+    getAdjMatrix: (graphData: GraphData, directed?: boolean) => Matrix[];
+    breadthFirstSearch: (graphData: GraphData, startNodeId: string, originalCallbacks?: IAlgorithmCallbacks) => void;
+    connectedComponent: (graphData: GraphData, directed?: boolean) => NodeConfig[][];
+    getDegree: (graphData: GraphData) => DegreeType;
+    getInDegree: (graphData: GraphData, nodeId: string) => number;
+    getOutDegree: (graphData: GraphData, nodeId: string) => number;
+    detectCycle: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectDirectedCycle: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectAllCycles: (graphData: GraphData, directed?: boolean, nodeIds?: string[], include?: boolean) => any;
+    detectAllDirectedCycle: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    detectAllUndirectedCycle: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    depthFirstSearch: (graphData: GraphData, startNodeId: string, callbacks?: IAlgorithmCallbacks) => void;
+    dijkstra: (graphData: GraphData, source: string, directed?: boolean, weightPropertyName?: string) => {
+        length: object;
+        allPath: object;
+        path: object;
+    };
+    findAllPath: (graphData: GraphData, start: string, end: string, directed?: boolean) => any;
+    findShortestPath: (graphData: GraphData, start: string, end: string, directed?: boolean, weightPropertyName?: string) => any;
+    floydWarshall: (graphData: GraphData, directed?: boolean) => Matrix[];
+    labelPropagation: (graphData: GraphData, directed?: boolean, weightPropertyName?: string, maxIteration?: number) => ClusterData;
+    louvain: (graphData: GraphData, directed: boolean, weightPropertyName: string, threshold: number) => ClusterData;
+    minimumSpanningTree: (graphData: GraphData, weight?: string, algo?: string) => EdgeConfig[];
+    pageRank: (graphData: GraphData, epsilon?: number, linkProb?: number) => {
+        [key: string]: number;
+    };
+    getNeighbors: (nodeId: string, edges?: EdgeConfig[], type?: 'target' | 'source' | undefined) => string[];
+    Stack: any;
+    GADDI: (graphData: GraphData, pattern: GraphData, directed: boolean, k: number, length: number, nodeLabelProp: string, edgeLabelProp: string) => GraphData[];
+    getAdjMatrixAsync: (graphData: GraphData, directed?: boolean) => Matrix[];
+    connectedComponentAsync: (graphData: GraphData, directed?: boolean) => NodeConfig[][];
+    getDegreeAsync: (graphData: GraphData) => DegreeType;
+    getInDegreeAsync: (graphData: GraphData, nodeId: string) => number;
+    getOutDegreeAsync: (graphData: GraphData, nodeId: string) => number;
+    detectCycleAsync: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectDirectedCycleAsync: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectAllCyclesAsync: (graphData: GraphData, directed?: boolean, nodeIds?: string[], include?: boolean) => any;
+    detectAllDirectedCycleAsync: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    detectAllUndirectedCycleAsync: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    dijkstraAsync: (graphData: GraphData, source: string, directed?: boolean, weightPropertyName?: string) => {
+        length: object;
+        allPath: object;
+        path: object;
+    };
+    findAllPathAsync: (graphData: GraphData, start: string, end: string, directed?: boolean) => any;
+    findShortestPathAsync: (graphData: GraphData, start: string, end: string, directed?: boolean, weightPropertyName?: string) => any;
+    floydWarshallAsync: (graphData: GraphData, directed?: boolean) => Matrix[];
+    labelPropagationAsync: (graphData: GraphData, directed?: boolean, weightPropertyName?: string, maxIteration?: number) => ClusterData;
+    louvainAsync: (graphData: GraphData, directed: boolean, weightPropertyName: string, threshold: number) => ClusterData;
+    minimumSpanningTreeAsync: (graphData: GraphData, weight?: string, algo?: string) => EdgeConfig[];
+    pageRankAsync: (graphData: GraphData, epsilon?: number, linkProb?: number) => {
+        [key: string]: number;
+    };
+    getNeighborsAsync: (nodeId: string, edges?: EdgeConfig[], type?: 'target' | 'source' | undefined) => string[];
+    GADDIAsync: (graphData: GraphData, pattern: GraphData, directed: boolean, k: number, length: number, nodeLabelProp: string, edgeLabelProp: string) => GraphData[];
+}

lib/index.d.ts

@@ -18,10 +18,7 @@ import getAdjMatrix from './adjacent-matrix';
 import { getNeighbors } from './util';
+import { IAlgorithm } from './types';
 declare const detectDirectedCycle: (graphData: import("./types").GraphData) => {
     [key: string]: string;
 };
-declare const detectDirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-    [key: string]: string;
-}>;
-import { getAdjMatrixAsync, connectedComponentAsync, getDegreeAsync, getInDegreeAsync, getOutDegreeAsync, detectCycleAsync, detectAllCyclesAsync, detectAllDirectedCycleAsync, detectAllUndirectedCycleAsync, dijkstraAsync, findAllPathAsync, findShortestPathAsync, floydWarshallAsync, labelPropagationAsync, louvainAsync, minimumSpanningTreeAsync, pageRankAsync, getNeighborsAsync, GADDIAsync } from './workers/index';
-export { getAdjMatrix, breadthFirstSearch, connectedComponent, getDegree, getInDegree, getOutDegree, detectCycle, detectDirectedCycle, detectAllCycles, detectAllDirectedCycle, detectAllUndirectedCycle, depthFirstSearch, dijkstra, findAllPath, findShortestPath, floydWarshall, labelPropagation, louvain, minimumSpanningTree, pageRank, getNeighbors, Stack, GADDI, getAdjMatrixAsync, connectedComponentAsync, getDegreeAsync, getInDegreeAsync, getOutDegreeAsync, detectCycleAsync, detectDirectedCycleAsync, detectAllCyclesAsync, detectAllDirectedCycleAsync, detectAllUndirectedCycleAsync, dijkstraAsync, findAllPathAsync, findShortestPathAsync, floydWarshallAsync, labelPropagationAsync, louvainAsync, minimumSpanningTreeAsync, pageRankAsync, getNeighborsAsync, GADDIAsync, };
+export { getAdjMatrix, breadthFirstSearch, connectedComponent, getDegree, getInDegree, getOutDegree, detectCycle, detectDirectedCycle, detectAllCycles, detectAllDirectedCycle, detectAllUndirectedCycle, depthFirstSearch, dijkstra, findAllPath, findShortestPath, floydWarshall, labelPropagation, louvain, minimumSpanningTree, pageRank, getNeighbors, Stack, GADDI, IAlgorithm };
 declare const _default: {
@@ -65,43 +62,3 @@ getAdjMatrix: (graphData: import("./types").GraphData, directed?: boolean) => import("./types").Matrix[];
     GADDI: (graphData: import("./types").GraphData, pattern: import("./types").GraphData, directed: boolean, k: number, length: number, nodeLabelProp?: string, edgeLabelProp?: string) => import("./types").GraphData[];
-    getAdjMatrixAsync: (graphData: import("./types").GraphData, directed?: boolean) => Promise<import("./types").Matrix[]>;
-    connectedComponentAsync: (graphData: import("./types").GraphData, directed?: boolean) => Promise<import("./types").NodeConfig[][]>;
-    getDegreeAsync: (graphData: import("./types").GraphData) => Promise<import("./types").DegreeType>;
-    getInDegreeAsync: (graphData: import("./types").GraphData, nodeId: string) => Promise<import("./types").DegreeType>;
-    getOutDegreeAsync: (graphData: import("./types").GraphData, nodeId: string) => Promise<import("./types").DegreeType>;
-    detectCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectDirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectAllCyclesAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectAllDirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    detectAllUndirectedCycleAsync: (graphData: import("./types").GraphData) => Promise<{
-        [key: string]: string;
-    }>;
-    dijkstraAsync: (graphData: import("./types").GraphData, source: string, directed?: boolean, weightPropertyName?: string) => Promise<{
-        length: number;
-        path: any;
-        allPath: any;
-    }>;
-    findAllPathAsync: (graphData: import("./types").GraphData, start: string, end: string, directed?: boolean) => Promise<string[][]>;
-    findShortestPathAsync: (graphData: import("./types").GraphData, start: string, end: string, directed?: boolean, weightPropertyName?: string) => Promise<{
-        length: number;
-        path: any;
-        allPath: any;
-    }>;
-    floydWarshallAsync: (graphData: import("./types").GraphData, directed?: boolean) => Promise<import("./types").Matrix[]>;
-    labelPropagationAsync: (graphData: import("./types").GraphData, directed: boolean, weightPropertyName: string, maxIteration?: number) => Promise<import("./types").ClusterData>;
-    louvainAsync: (graphData: import("./types").GraphData, directed: boolean, weightPropertyName: string, threshold: number) => Promise<import("./types").ClusterData>;
-    minimumSpanningTreeAsync: (graphData: import("./types").GraphData, weight?: boolean, algo?: string) => Promise<import("./types").EdgeConfig[]>;
-    pageRankAsync: (graphData: import("./types").GraphData, epsilon?: number, linkProb?: number) => Promise<{
-        [key: string]: number;
-    }>;
-    getNeighborsAsync: (nodeId: string, edges: import("./types").EdgeConfig[], type?: "source" | "target") => Promise<string[]>;
-    GADDIAsync: (graphData: import("./types").GraphData, pattern: import("./types").GraphData, directed: boolean, k: number, length: number, nodeLabelProp?: string, edgeLabelProp?: string) => Promise<import("./types").GraphData[]>;
 };
 export default _default;

lib/index.js

@@ -140,117 +140,3 @@ "use strict";
 });
-Object.defineProperty(exports, "getAdjMatrixAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.getAdjMatrixAsync;
-  }
-});
-Object.defineProperty(exports, "connectedComponentAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.connectedComponentAsync;
-  }
-});
-Object.defineProperty(exports, "getDegreeAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.getDegreeAsync;
-  }
-});
-Object.defineProperty(exports, "getInDegreeAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.getInDegreeAsync;
-  }
-});
-Object.defineProperty(exports, "getOutDegreeAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.getOutDegreeAsync;
-  }
-});
-Object.defineProperty(exports, "detectCycleAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.detectCycleAsync;
-  }
-});
-Object.defineProperty(exports, "detectAllCyclesAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.detectAllCyclesAsync;
-  }
-});
-Object.defineProperty(exports, "detectAllDirectedCycleAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.detectAllDirectedCycleAsync;
-  }
-});
-Object.defineProperty(exports, "detectAllUndirectedCycleAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.detectAllUndirectedCycleAsync;
-  }
-});
-Object.defineProperty(exports, "dijkstraAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.dijkstraAsync;
-  }
-});
-Object.defineProperty(exports, "findAllPathAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.findAllPathAsync;
-  }
-});
-Object.defineProperty(exports, "findShortestPathAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.findShortestPathAsync;
-  }
-});
-Object.defineProperty(exports, "floydWarshallAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.floydWarshallAsync;
-  }
-});
-Object.defineProperty(exports, "labelPropagationAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.labelPropagationAsync;
-  }
-});
-Object.defineProperty(exports, "louvainAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.louvainAsync;
-  }
-});
-Object.defineProperty(exports, "minimumSpanningTreeAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.minimumSpanningTreeAsync;
-  }
-});
-Object.defineProperty(exports, "pageRankAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.pageRankAsync;
-  }
-});
-Object.defineProperty(exports, "getNeighborsAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.getNeighborsAsync;
-  }
-});
-Object.defineProperty(exports, "GADDIAsync", {
-  enumerable: true,
-  get: function get() {
-    return _index.GADDIAsync;
-  }
-});
-exports.default = exports.detectDirectedCycleAsync = exports.detectDirectedCycle = void 0;
+exports.default = exports.detectDirectedCycle = void 0;
 
@@ -289,4 +175,2 @@ var _adjacentMatrix = _interopRequireDefault(require("./adjacent-matrix"));
 
-var _index = require("./workers/index");
-
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
@@ -300,4 +184,2 @@
 exports.detectDirectedCycle = detectDirectedCycle;
-var detectDirectedCycleAsync = _index.detectCycleAsync;
-exports.detectDirectedCycleAsync = detectDirectedCycleAsync;
 var _default = {
@@ -326,24 +208,4 @@ getAdjMatrix: _adjacentMatrix.default,
   Stack: _stack.default,
-  GADDI: _gaddi.default,
-  getAdjMatrixAsync: _index.getAdjMatrixAsync,
-  connectedComponentAsync: _index.connectedComponentAsync,
-  getDegreeAsync: _index.getDegreeAsync,
-  getInDegreeAsync: _index.getInDegreeAsync,
-  getOutDegreeAsync: _index.getOutDegreeAsync,
-  detectCycleAsync: _index.detectCycleAsync,
-  detectDirectedCycleAsync: detectDirectedCycleAsync,
-  detectAllCyclesAsync: _index.detectAllCyclesAsync,
-  detectAllDirectedCycleAsync: _index.detectAllDirectedCycleAsync,
-  detectAllUndirectedCycleAsync: _index.detectAllUndirectedCycleAsync,
-  dijkstraAsync: _index.dijkstraAsync,
-  findAllPathAsync: _index.findAllPathAsync,
-  findShortestPathAsync: _index.findShortestPathAsync,
-  floydWarshallAsync: _index.floydWarshallAsync,
-  labelPropagationAsync: _index.labelPropagationAsync,
-  louvainAsync: _index.louvainAsync,
-  minimumSpanningTreeAsync: _index.minimumSpanningTreeAsync,
-  pageRankAsync: _index.pageRankAsync,
-  getNeighborsAsync: _index.getNeighborsAsync,
-  GADDIAsync: _index.GADDIAsync
+  GADDI: _gaddi.default
 };
 exports.default = _default;

lib/types.d.ts

@@ -51,1 +51,66 @@ export declare type Matrix = number[];
 }
+export interface IAlgorithm {
+    getAdjMatrix: (graphData: GraphData, directed?: boolean) => Matrix[];
+    breadthFirstSearch: (graphData: GraphData, startNodeId: string, originalCallbacks?: IAlgorithmCallbacks) => void;
+    connectedComponent: (graphData: GraphData, directed?: boolean) => NodeConfig[][];
+    getDegree: (graphData: GraphData) => DegreeType;
+    getInDegree: (graphData: GraphData, nodeId: string) => number;
+    getOutDegree: (graphData: GraphData, nodeId: string) => number;
+    detectCycle: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectDirectedCycle: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectAllCycles: (graphData: GraphData, directed?: boolean, nodeIds?: string[], include?: boolean) => any;
+    detectAllDirectedCycle: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    detectAllUndirectedCycle: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    depthFirstSearch: (graphData: GraphData, startNodeId: string, callbacks?: IAlgorithmCallbacks) => void;
+    dijkstra: (graphData: GraphData, source: string, directed?: boolean, weightPropertyName?: string) => {
+        length: object;
+        allPath: object;
+        path: object;
+    };
+    findAllPath: (graphData: GraphData, start: string, end: string, directed?: boolean) => any;
+    findShortestPath: (graphData: GraphData, start: string, end: string, directed?: boolean, weightPropertyName?: string) => any;
+    floydWarshall: (graphData: GraphData, directed?: boolean) => Matrix[];
+    labelPropagation: (graphData: GraphData, directed?: boolean, weightPropertyName?: string, maxIteration?: number) => ClusterData;
+    louvain: (graphData: GraphData, directed: boolean, weightPropertyName: string, threshold: number) => ClusterData;
+    minimumSpanningTree: (graphData: GraphData, weight?: string, algo?: string) => EdgeConfig[];
+    pageRank: (graphData: GraphData, epsilon?: number, linkProb?: number) => {
+        [key: string]: number;
+    };
+    getNeighbors: (nodeId: string, edges?: EdgeConfig[], type?: 'target' | 'source' | undefined) => string[];
+    Stack: any;
+    GADDI: (graphData: GraphData, pattern: GraphData, directed: boolean, k: number, length: number, nodeLabelProp: string, edgeLabelProp: string) => GraphData[];
+    getAdjMatrixAsync: (graphData: GraphData, directed?: boolean) => Matrix[];
+    connectedComponentAsync: (graphData: GraphData, directed?: boolean) => NodeConfig[][];
+    getDegreeAsync: (graphData: GraphData) => DegreeType;
+    getInDegreeAsync: (graphData: GraphData, nodeId: string) => number;
+    getOutDegreeAsync: (graphData: GraphData, nodeId: string) => number;
+    detectCycleAsync: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectDirectedCycleAsync: (graphData: GraphData) => {
+        [key: string]: string;
+    };
+    detectAllCyclesAsync: (graphData: GraphData, directed?: boolean, nodeIds?: string[], include?: boolean) => any;
+    detectAllDirectedCycleAsync: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    detectAllUndirectedCycleAsync: (graphData: GraphData, nodeIds?: string[], include?: boolean) => any;
+    dijkstraAsync: (graphData: GraphData, source: string, directed?: boolean, weightPropertyName?: string) => {
+        length: object;
+        allPath: object;
+        path: object;
+    };
+    findAllPathAsync: (graphData: GraphData, start: string, end: string, directed?: boolean) => any;
+    findShortestPathAsync: (graphData: GraphData, start: string, end: string, directed?: boolean, weightPropertyName?: string) => any;
+    floydWarshallAsync: (graphData: GraphData, directed?: boolean) => Matrix[];
+    labelPropagationAsync: (graphData: GraphData, directed?: boolean, weightPropertyName?: string, maxIteration?: number) => ClusterData;
+    louvainAsync: (graphData: GraphData, directed: boolean, weightPropertyName: string, threshold: number) => ClusterData;
+    minimumSpanningTreeAsync: (graphData: GraphData, weight?: string, algo?: string) => EdgeConfig[];
+    pageRankAsync: (graphData: GraphData, epsilon?: number, linkProb?: number) => {
+        [key: string]: number;
+    };
+    getNeighborsAsync: (nodeId: string, edges?: EdgeConfig[], type?: 'target' | 'source' | undefined) => string[];
+    GADDIAsync: (graphData: GraphData, pattern: GraphData, directed: boolean, k: number, length: number, nodeLabelProp: string, edgeLabelProp: string) => GraphData[];
+}

package.json

 {
   "name": "@antv/algorithm",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "graph algorithm",
@@ -5,0 +5,0 @@ "keywords": [

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1005728

increased by1.2%

Number of package files

128

increased by4.92%

Lines of code

10275

increased by1.49%

No dependency changes