@microphi/json-db 2.2.0

package/README.md

@@ -0,0 +1,12 @@
+# @microphi/json-db [![npm version](https://badge.fury.io/js/%40microphi%2Fjsob-db.svg)](https://badge.fury.io/js/%40microphi%2Fjson-db)
+
+> Small, fast and simple file based json-db
+
+## Install
+With your preferend package manager install
+```
+@microphi/json-db
+```
+
+## How to use
+> TBD

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/list/list';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/lib/index.js

@@ -0,0 +1,2 @@
+export * from './lib/list/list';
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC","sourcesContent":["export * from './lib/list/list';\n"]}

package/lib/lib/aspects/after.decorator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Runs the `fn` after the annotated method
+ *
+ * @remarks
+ * Decorate a method to execute `fn` after it.
+ * `fn` params will be the same type as the decorated return type and it __must__ return this same type.
+ * To have type checking you need to provide type information into this decorator generics.
+ * `fn` can __must__ return that same type or void.
+ *
+ * @example
+ * ```typescript
+ * class TestClass {
+ *
+ *   @After<string>((salutation) => {
+ *     return salutation.toUpperCase();
+ *   })
+ *   public testA(name: string): string {
+ *     return `Hello ${name}!`;
+ *   }
+ *
+ *   @After<string>((salutation) => {
+ *     return salutation.toLowerCase();
+ *   })
+ *   public testB(name: string, nickname: string): string {
+ *     return `Hello ${name} aka ${nickname}!`;
+ *   }
+ *
+ * }
+ *
+ * ```
+ *
+ * @param fn
+ */
+export declare function After<I, O = I>(fn: (args: I) => O): MethodDecorator;
+//# sourceMappingURL=after.decorator.d.ts.map

package/lib/lib/aspects/after.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"after.decorator.d.ts","sourceRoot":"","sources":["../../../src/lib/aspects/after.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,eAAe,CAqBnE"}

package/lib/lib/aspects/after.decorator.js

@@ -0,0 +1,45 @@
+/**
+ * Runs the `fn` after the annotated method
+ *
+ * @remarks
+ * Decorate a method to execute `fn` after it.
+ * `fn` params will be the same type as the decorated return type and it __must__ return this same type.
+ * To have type checking you need to provide type information into this decorator generics.
+ * `fn` can __must__ return that same type or void.
+ *
+ * @example
+ * ```typescript
+ * class TestClass {
+ *
+ *   @After<string>((salutation) => {
+ *     return salutation.toUpperCase();
+ *   })
+ *   public testA(name: string): string {
+ *     return `Hello ${name}!`;
+ *   }
+ *
+ *   @After<string>((salutation) => {
+ *     return salutation.toLowerCase();
+ *   })
+ *   public testB(name: string, nickname: string): string {
+ *     return `Hello ${name} aka ${nickname}!`;
+ *   }
+ *
+ * }
+ *
+ * ```
+ *
+ * @param fn
+ */
+export function After(fn) {
+    return (target, key, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = function () {
+            // eslint-disable-next-line prefer-rest-params
+            const retValue = originalMethod.apply(this, arguments);
+            return fn.apply(this, [retValue]);
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=after.decorator.js.map

package/lib/lib/aspects/after.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"after.decorator.js","sourceRoot":"","sources":["../../../src/lib/aspects/after.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,KAAK,CAAW,EAAkB;IAGhD,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,UAA8B,EAAE,EAAE;QAGrD,MAAM,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC;QAExC,UAAU,CAAC,KAAK,GAAG;YAGjB,8CAA8C;YAC9C,MAAM,QAAQ,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAEvD,OAAO,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;QAGpC,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Runs the `fn` after the annotated method\n *\n * @remarks\n * Decorate a method to execute `fn` after it.\n * `fn` params will be the same type as the decorated return type and it __must__ return this same type.\n * To have type checking you need to provide type information into this decorator generics.\n * `fn` can __must__ return that same type or void.\n *\n * @example\n * ```typescript\n * class TestClass {\n *\n *   @After<string>((salutation) => {\n *     return salutation.toUpperCase();\n *   })\n *   public testA(name: string): string {\n *     return `Hello ${name}!`;\n *   }\n *\n *   @After<string>((salutation) => {\n *     return salutation.toLowerCase();\n *   })\n *   public testB(name: string, nickname: string): string {\n *     return `Hello ${name} aka ${nickname}!`;\n *   }\n *\n * }\n *\n * ```\n *\n * @param fn\n */\nexport function After<I, O = I>(fn: (args: I) => O): MethodDecorator {\n\n\n  return (target, key, descriptor: PropertyDescriptor) => {\n\n\n    const originalMethod = descriptor.value;\n\n    descriptor.value = function() {\n\n\n      // eslint-disable-next-line prefer-rest-params\n      const retValue = originalMethod.apply(this, arguments);\n\n      return fn.apply(this, [retValue]);\n\n\n    };\n\n    return descriptor;\n  };\n}\n"]}

package/lib/lib/aspects/before.decorator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Runs the `fn` before the annotated method
+ *
+ * @remarks
+ * Decorate a method to execute `fn` before it.
+ * `fn` params will be the same type as the decorated function and it __must__ return the same type.
+ * To have type checking you need to provide type information into this decorator generics.
+ * `fn` can __must__ return this same type or void.
+ *
+ * @example
+ * ```typescript
+ * // basic example
+ * class TestClass {
+ *
+ *   @Before<string>((name) => {
+ *     return name.toUpperCase();
+ *   })
+ *   public simpleParamSimpleType(name: string) {
+ *     return `hello ${name}`;
+ *   }
+ * }
+ * ```
+ * For more example see `before.decorator.spec.ts`
+ *
+ * @param fn
+ */
+export declare function Before<P>(fn: (args: P) => P): MethodDecorator;
+//# sourceMappingURL=before.decorator.d.ts.map

package/lib/lib/aspects/before.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.decorator.d.ts","sourceRoot":"","sources":["../../../src/lib/aspects/before.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,eAAe,CAyB7D"}

package/lib/lib/aspects/before.decorator.js

@@ -0,0 +1,46 @@
+/**
+ * Runs the `fn` before the annotated method
+ *
+ * @remarks
+ * Decorate a method to execute `fn` before it.
+ * `fn` params will be the same type as the decorated function and it __must__ return the same type.
+ * To have type checking you need to provide type information into this decorator generics.
+ * `fn` can __must__ return this same type or void.
+ *
+ * @example
+ * ```typescript
+ * // basic example
+ * class TestClass {
+ *
+ *   @Before<string>((name) => {
+ *     return name.toUpperCase();
+ *   })
+ *   public simpleParamSimpleType(name: string) {
+ *     return `hello ${name}`;
+ *   }
+ * }
+ * ```
+ * For more example see `before.decorator.spec.ts`
+ *
+ * @param fn
+ */
+export function Before(fn) {
+    return (target, key, descriptor) => {
+        const originalMethod = descriptor.value;
+        // use function() to keep original `this`
+        descriptor.value = function () {
+            // @ts-ignore
+            // eslint-disable-next-line prefer-rest-params
+            const retValue = fn.bind(this).apply(this, arguments);
+            // so here we can call originalMethod with retValue
+            // doing so beforeFn has the ability to change original arguments's values
+            if (retValue === undefined) {
+                // eslint-disable-next-line prefer-rest-params
+                return originalMethod.apply(this, arguments);
+            }
+            return originalMethod.apply(this, [].concat(retValue));
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=before.decorator.js.map

package/lib/lib/aspects/before.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.decorator.js","sourceRoot":"","sources":["../../../src/lib/aspects/before.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,MAAM,CAAI,EAAkB;IAE1C,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,UAA8B,EAAE,EAAE;QAErD,MAAM,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC;QAExC,yCAAyC;QACzC,UAAU,CAAC,KAAK,GAAG;YAEjB,aAAa;YACb,8CAA8C;YAC9C,MAAM,QAAQ,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAQ,CAAC;YAE7D,mDAAmD;YACnD,0EAA0E;YAC1E,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,8CAA8C;gBAC9C,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAC/C,CAAC;YAED,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QACzD,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Runs the `fn` before the annotated method\n *\n * @remarks\n * Decorate a method to execute `fn` before it.\n * `fn` params will be the same type as the decorated function and it __must__ return the same type.\n * To have type checking you need to provide type information into this decorator generics.\n * `fn` can __must__ return this same type or void.\n *\n * @example\n * ```typescript\n * // basic example\n * class TestClass {\n *\n *   @Before<string>((name) => {\n *     return name.toUpperCase();\n *   })\n *   public simpleParamSimpleType(name: string) {\n *     return `hello ${name}`;\n *   }\n * }\n * ```\n * For more example see `before.decorator.spec.ts`\n *\n * @param fn\n */\nexport function Before<P>(fn: (args: P) => P): MethodDecorator {\n\n  return (target, key, descriptor: PropertyDescriptor) => {\n\n    const originalMethod = descriptor.value;\n\n    // use function() to keep original `this`\n    descriptor.value = function() {\n\n      // @ts-ignore\n      // eslint-disable-next-line prefer-rest-params\n      const retValue = fn.bind(this).apply(this, arguments) as any;\n\n      // so here we can call originalMethod with retValue\n      // doing so beforeFn has the ability to change original arguments's values\n      if (retValue === undefined) {\n        // eslint-disable-next-line prefer-rest-params\n        return originalMethod.apply(this, arguments);\n      }\n\n      return originalMethod.apply(this, [].concat(retValue));\n    };\n\n    return descriptor;\n  };\n}\n"]}

package/lib/lib/container/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { Instance, Klass } from '../types';
+export declare function bootstrap(app: Klass): Instance;
+//# sourceMappingURL=bootstrap.d.ts.map

package/lib/lib/container/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/lib/container/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAO3C,wBAAgB,SAAS,CAAC,GAAG,EAAE,KAAK,GAAG,QAAQ,CAc9C"}

package/lib/lib/container/bootstrap.js

@@ -0,0 +1,15 @@
+import { getDIMetadata, providers } from '../container/di.decorator';
+import { getDebugger } from '@microphi/debug';
+import { injector } from '../injctable/injector';
+const d = getDebugger('microphi:di:bootstrap');
+export function bootstrap(app) {
+    const options = getDIMetadata(app);
+    d('adding', app, 'to providers');
+    providers.addInjectable(app);
+    options.providers?.forEach((provider) => {
+        d('configuring provider', provider);
+        providers.addInjectable(provider);
+    });
+    return injector(app);
+}
+//# sourceMappingURL=bootstrap.js.map

package/lib/lib/container/bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../../src/lib/container/bootstrap.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,MAAM,CAAC,GAAG,WAAW,CAAC,uBAAuB,CAAC,CAAC;AAE/C,MAAM,UAAU,SAAS,CAAC,GAAU;IAClC,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAEnC,CAAC,CAAC,QAAQ,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC;IAGjC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAE7B,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;QACtC,CAAC,CAAC,sBAAsB,EAAE,QAAQ,CAAC,CAAC;QACpC,SAAS,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;AACvB,CAAC","sourcesContent":["import { Instance, Klass } from '../types';\nimport { getDIMetadata, providers } from '../container/di.decorator';\nimport { getDebugger } from '@microphi/debug';\nimport { injector } from '../injctable/injector';\n\nconst d = getDebugger('microphi:di:bootstrap');\n\nexport function bootstrap(app: Klass): Instance {\n  const options = getDIMetadata(app);\n\n  d('adding', app, 'to providers');\n\n\n  providers.addInjectable(app);\n\n  options.providers?.forEach((provider) => {\n    d('configuring provider', provider);\n    providers.addInjectable(provider);\n  });\n\n  return injector(app);\n}\n"]}

package/lib/lib/container/di.decorator.d.ts

@@ -0,0 +1,10 @@
+import { Klass, Provider } from '../types';
+import { Providers } from '../provider/providers';
+export declare const providers: Providers;
+export interface DIOptions {
+    providers: Provider[];
+}
+export declare const DISymbol: unique symbol;
+export declare function DI(options: DIOptions): (target: any) => any;
+export declare function getDIMetadata(target: Klass): DIOptions;
+//# sourceMappingURL=di.decorator.d.ts.map

package/lib/lib/container/di.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"di.decorator.d.ts","sourceRoot":"","sources":["../../../src/lib/container/di.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGlD,eAAO,MAAM,SAAS,WAAkB,CAAC;AAEzC,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,QAAQ,EAAE,CAAC;CACvB;AAED,eAAO,MAAM,QAAQ,eAAgB,CAAC;AAEtC,wBAAgB,EAAE,CAAC,OAAO,EAAE,SAAS,wBAMpC;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,KAAK,GAAG,SAAS,CAEtD"}

package/lib/lib/container/di.decorator.js

@@ -0,0 +1,15 @@
+import { Providers } from '../provider/providers';
+import { ClassNameSymbol, InjectableDecorator } from '../injctable/injectable.decorator';
+export const providers = new Providers();
+export const DISymbol = Symbol('@DI');
+export function DI(options) {
+    return (target) => {
+        target[ClassNameSymbol] = 'root';
+        Reflect.metadata(DISymbol, options)(target);
+        return InjectableDecorator(target);
+    };
+}
+export function getDIMetadata(target) {
+    return Reflect.getMetadata(DISymbol, target);
+}
+//# sourceMappingURL=di.decorator.js.map

package/lib/lib/container/di.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"di.decorator.js","sourceRoot":"","sources":["../../../src/lib/container/di.decorator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAEzF,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;AAMzC,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;AAEtC,MAAM,UAAU,EAAE,CAAC,OAAkB;IACnC,OAAO,CAAC,MAAM,EAAE,EAAE;QAChB,MAAM,CAAC,eAAe,CAAC,GAAG,MAAM,CAAC;QACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;QAC5C,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,MAAa;IACzC,OAAO,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC/C,CAAC","sourcesContent":["import { Klass, Provider } from '../types';\nimport { Providers } from '../provider/providers';\nimport { ClassNameSymbol, InjectableDecorator } from '../injctable/injectable.decorator';\n\nexport const providers = new Providers();\n\nexport interface DIOptions {\n  providers: Provider[];\n}\n\nexport const DISymbol = Symbol('@DI');\n\nexport function DI(options: DIOptions) {\n  return (target) => {\n    target[ClassNameSymbol] = 'root';\n    Reflect.metadata(DISymbol, options)(target);\n    return InjectableDecorator(target);\n  };\n}\n\nexport function getDIMetadata(target: Klass): DIOptions {\n  return Reflect.getMetadata(DISymbol, target);\n}\n"]}

package/lib/lib/container/graph.d.ts

@@ -0,0 +1,171 @@
+export type NodeId = string;
+export type EdgeWeight = number;
+export type EncodedEdge = string;
+export interface Serialized {
+    nodes: {
+        id: NodeId;
+    }[];
+    links: {
+        source: NodeId;
+        target: NodeId;
+        weight: EdgeWeight;
+    }[];
+}
+export declare class CycleError extends Error {
+    constructor(message: string);
+}
+/**
+ * A graph data structure with depth-first search and topological sort.
+ */
+export declare class Graph {
+    /**
+     * The adjacency list of the graph.
+     * Keys are node ids.
+     * Values are adjacent node id arrays.
+     */
+    edges: Record<NodeId, NodeId[]>;
+    /**
+     * The weights of edges.
+     * Keys are string encodings of edges.
+     * Values are weights (numbers).
+     */
+    edgeWeights: Record<EncodedEdge, EdgeWeight>;
+    constructor(serialized?: Serialized);
+    /**
+     * Deserializes the given serialized graph.
+     * @param serialized
+     */
+    deserialize(serialized: Serialized): this;
+    /**
+     * Gets the adjacent node list for the given node.
+     * Returns an empty array for unknown nodes.
+     * @param node
+     */
+    adjacent(node: NodeId): NodeId[];
+    /**
+     * Adds a node to the graph.
+     * If node was already added, this function does nothing.
+     * If node was not already added, this function sets up an empty adjacency list.
+     * @param node
+     */
+    addNode(node: NodeId): this;
+    /**
+     * Adds an edge from node u to node v.
+     * Implicitly adds the nodes if they were not already added.
+     * @param u
+     * @param v
+     * @param weight
+     */
+    addEdge(u: NodeId, v: NodeId, weight?: EdgeWeight): this;
+    /**
+     * Sets the weight of the given edge.
+     * @param u
+     * @param v
+     * @param weight
+     */
+    setEdgeWeight(u: NodeId, v: NodeId, weight: EdgeWeight): this;
+    /**
+     * Computes a string encoding of an edge,
+     * for use as a key in an object.
+     * @param u
+     * @param v
+     */
+    encodeEdge(u: NodeId, v: NodeId): EncodedEdge;
+    /**
+     * Removes a node from the graph.
+     * Also removes incoming and outgoing edges.
+     * @param node
+     */
+    removeNode(node: NodeId): this;
+    /**
+     * Gets the list of nodes that have been added to the graph.
+     */
+    nodes(): NodeId[];
+    /**
+     * Gets the weight of the given edge.
+     * Returns 1 if no weight was previously set.
+     * @param u
+     * @param v
+     */
+    getEdgeWeight(u: NodeId, v: NodeId): EdgeWeight;
+    /**
+     * Removes the edge from node u to node v.
+     * Does not remove the nodes.
+     * Does nothing if the edge does not exist.
+     * @param u
+     * @param v
+     */
+    removeEdge(u: NodeId, v: NodeId): this;
+    /**
+     * Returns true if there is an edge from node u to node v.
+     * @param u
+     * @param v
+     */
+    hasEdge(u: NodeId, v: NodeId): boolean;
+    /**
+     * Computes the indegree for the given node.
+     * Not very efficient, costs O(E) where E = number of edges.
+     *
+     * @param node
+     */
+    inDegree(node: NodeId): number;
+    /**
+     * Computes the outdegree for the given node.
+     *
+     * @param node
+     */
+    outDegree(node: NodeId): number;
+    /**
+     * Depth First Search algorithm, inspired by
+     * Cormen et al. 'Introduction to Algorithms' 3rd Ed. p. 604
+     * The additional option `includeSourceNodes` specifies whether to
+     * include or exclude the source nodes from the result (true by default).
+     * If `sourceNodes` is not specified, all nodes in the graph
+     * are used as source nodes.
+     *
+     * @param sourceNodes
+     * @param includeSourceNodes
+     * @param errorOnCycle
+     */
+    depthFirstSearch(sourceNodes: NodeId[] | undefined, includeSourceNodes?: boolean, errorOnCycle?: boolean): string[];
+    /**
+     * Returns true if the graph has one or more cycles and false otherwise
+     */
+    hasCycle(): boolean;
+    /**
+     * Least Common Ancestors
+     * Inspired by https://github.com/relaxedws/lca/blob/master/src/LowestCommonAncestor.php code
+     * but uses depth search instead of breadth. Also uses some optimizations
+     *
+     * @param node1
+     * @param node2
+     */
+    lowestCommonAncestors(node1: NodeId, node2: NodeId): string[];
+    /**
+     * The topological sort algorithm yields a list of visited nodes
+     * such that for each visited edge (u, v), u comes before v in the list.
+     * Amazingly, this comes from just reversing the result from depth first search.
+     * Cormen et al. 'Introduction to Algorithms' 3rd Ed. p. 613
+     *
+     * @param sourceNodes
+     * @param includeSourceNodes
+     */
+    topologicalSort(sourceNodes?: NodeId[], includeSourceNodes?: boolean): string[];
+    /**
+     * Dijkstra's Shortest Path Algorithm.
+     * Cormen et al. 'Introduction to Algorithms' 3rd Ed. p. 658
+     * Variable and function names correspond to names in the book.
+     *
+     * @param source
+     * @param destination
+     */
+    shortestPath(source: NodeId, destination: NodeId): {
+        path: NodeId[];
+        weight: EdgeWeight;
+    };
+    /**
+     * Serializes the graph.
+     */
+    serialize(): Serialized;
+}
+//# sourceMappingURL=graph.d.ts.map

package/lib/lib/container/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/lib/container/graph.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAC5B,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAChC,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxB,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,EAAE,CAAC;CACjE;AAED,qBAAa,UAAW,SAAQ,KAAK;gBACvB,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,KAAK;IAChB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAM;IAErC;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC,CAAM;gBAEtC,UAAU,CAAC,EAAE,UAAU;IAMnC;;;OAGG;IACH,WAAW,CAAC,UAAU,EAAE,UAAU;IAUlC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAIhC;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM;IAKpB;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU;IAYjD;;;;;OAKG;IACH,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU;IAKtD;;;;;OAKG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW;IAI7C;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM;IAgBvB;;OAEG;IACH,KAAK,IAAI,MAAM,EAAE;IAajB;;;;;OAKG;IACH,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU;IAK/C;;;;;;OAMG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAS/B;;;;OAIG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAI5B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM;IAarB;;;;OAIG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM;IAKtB;;;;;;;;;;;OAWG;IACH,gBAAgB,CACd,WAAW,EAAE,MAAM,EAAE,GAAC,SAAS,EAC/B,kBAAkB,GAAE,OAAc,EAClC,YAAY,GAAE,OAAe;IA0C/B;;OAEG;IACH,QAAQ,IAAI,OAAO;IAgBnB;;;;;;;OAOG;IACH,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IA4ClD;;;;;;;;OAQG;IACH,eAAe,CACb,WAAW,CAAC,EAAE,MAAM,EAAE,EACtB,kBAAkB,GAAE,OAAc;IAKpC;;;;;;;OAOG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;cA6EpB,MAAM,EAAE;gBAAU,UAAU;;IAwBxD;;OAEG;IACH,SAAS;CAqBV"}