@proteinjs/reflection-build 1.1.1 → 1.2.1

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [1.1.3](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection@1.1.2...@proteinjs/reflection@1.1.3) (2024-05-10)
+
+
+### Bug Fixes
+
+* add .md file type to lint ignore files ([d7bdf6b](https://github.com/proteinjs/reflection/commit/d7bdf6baa50f93781e71abac3c2732e87cb21999))
+
+
+
+
+
+## [1.1.2](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection@1.1.1...@proteinjs/reflection@1.1.2) (2024-05-10)
+
+
+### Bug Fixes
+
+* add linter and lint files ([5d39eef](https://github.com/proteinjs/reflection/commit/5d39eef78a5a1d8ab24b188d23ff9220b595e885))
+
+
+
+
+
+## [1.1.1](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection@1.1.0...@proteinjs/reflection@1.1.1) (2024-05-08)
+
+### Bug Fixes
+
+- `SourceRepository.filterObjects` should omit objects for which any filter returns `false`, not `true`; this is inline with general filter semantics ([5f2f4c1](https://github.com/proteinjs/reflection/commit/5f2f4c133f47e447d08bc061f2b7177a767e977b))
+
+# [1.1.0](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection@1.0.7...@proteinjs/reflection@1.1.0) (2024-05-08)
+
+### Features
+
+- added `SourceRepositoryTypeFilter` to optionally filter out `Loadable`s from dependencies ([6cc0cda](https://github.com/proteinjs/reflection/commit/6cc0cdada9bb5e0d8fe8281582722bfb8aa7de64))
+
+## [1.0.6](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection@1.0.5...@proteinjs/reflection@1.0.6) (2024-04-23)
+
+### Bug Fixes
+
+- continue to fix to work for a runtime with multiple [dependency] copies of reflection ([6fea790](https://github.com/proteinjs/reflection/commit/6fea79006a60bd2719272cd061e373d3cdba1c49))
+
+## [1.0.3](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection@1.0.2...@proteinjs/reflection@1.0.3) (2024-04-21)
+
+### Bug Fixes
+
+- `SourceRepository` to store singleton in global memory so its truly a singleton even if multiple copies of @proteinjs/reflection exist at runtime ([36b5d09](https://github.com/proteinjs/reflection/commit/36b5d09139d337550f68f694d10b94cfd3c8b317))
+
+## [1.0.2](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection@1.0.1...@proteinjs/reflection@1.0.2) (2024-04-12)
+
+**Note:** Version bump only for package @proteinjs/reflection
+
+## 1.0.1 (2024-04-12)
+
+**Note:** Version bump only for package @proteinjs/reflection

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './src/Loadable';
+export * from './src/types';
+export * from './src/sourceGraphTypes';
+export * from './src/SourceRepository';
+export * from './src/SourceRepositoryFilter';

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/Loadable"), exports);
+__exportStar(require("./src/types"), exports);
+__exportStar(require("./src/sourceGraphTypes"), exports);
+__exportStar(require("./src/SourceRepository"), exports);
+__exportStar(require("./src/SourceRepositoryFilter"), exports);
+//# sourceMappingURL=index.js.map

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,iDAA+B;AAC/B,8CAA4B;AAC5B,yDAAuC;AACvC,yDAAuC;AACvC,+DAA6C"}

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/dist/src/FlattenedSourceGraph.d.ts

@@ -0,0 +1,19 @@
+import { Graph } from '@dagrejs/graphlib';
+import { Variable, TypeAlias, Class, Interface } from './types';
+export declare type FlattenedSourceGraph = {
+    variables: {
+        [qualifiedName: string]: Variable;
+    };
+    typeAliases: {
+        [qualifiedName: string]: TypeAlias;
+    };
+    classes: {
+        [qualifiedName: string]: Class;
+    };
+    interfaces: {
+        [qualifiedName: string]: Interface;
+    };
+};
+export declare function flattenSourceGraph(sourceGraph: Graph, sourceLinks: {
+    [qualifiedName: string]: any;
+}): FlattenedSourceGraph;

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/dist/src/FlattenedSourceGraph.js

@@ -0,0 +1,555 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenSourceGraph = void 0;
+var graphlib_1 = require("@dagrejs/graphlib");
+var types_1 = require("./types");
+var util_1 = require("@proteinjs/util");
+var Loadable_1 = require("./Loadable");
+var SourceRepositoryFilter_1 = require("./SourceRepositoryFilter");
+var sourceGraphTypes_1 = require("./sourceGraphTypes");
+function flattenSourceGraph(sourceGraph, sourceLinks) {
+    var flattenedSourceGraph = {
+        variables: {},
+        typeAliases: {},
+        classes: {},
+        interfaces: {},
+    };
+    var loadableInterfaceDeclaration = new types_1.InterfaceDeclaration('@proteinjs/reflection', 'Loadable', [], [], [], []);
+    sourceGraph.setNode(Loadable_1.LOADABLE_QUALIFIED_NAME, loadableInterfaceDeclaration);
+    if (!sourceGraph.hasNode(SourceRepositoryFilter_1.SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME)) {
+        sourceGraph.setNode(SourceRepositoryFilter_1.SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME, new types_1.InterfaceDeclaration('@proteinjs/reflection', 'SourceRepositoryFilter', [], [], [], [loadableInterfaceDeclaration]));
+        sourceGraph.setEdge(SourceRepositoryFilter_1.SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME, Loadable_1.LOADABLE_QUALIFIED_NAME, sourceGraphTypes_1.SourceRelationship.extendsInterface);
+    }
+    flattenParents(sourceGraph, sourceLinks, flattenedSourceGraph);
+    flattenChildren(sourceGraph, sourceLinks, flattenedSourceGraph);
+    addTypeParameters(flattenedSourceGraph, sourceGraph);
+    pruneNonLoadables(flattenedSourceGraph);
+    return flattenedSourceGraph;
+}
+exports.flattenSourceGraph = flattenSourceGraph;
+function flattenParents(sourceGraph, sourceLinks, flattenedSourceGraph) {
+    for (var _i = 0, _a = graphlib_1.alg.topsort(sourceGraph).reverse(); _i < _a.length; _i++) {
+        var nodeName = _a[_i];
+        var node = sourceGraph.node(nodeName);
+        if (!node) {
+            continue;
+        }
+        if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+            loadInterfaceAndParents(node, sourceGraph, sourceLinks, flattenedSourceGraph);
+        }
+        else if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+            loadTypeAliasAndParents(node, sourceGraph, sourceLinks, flattenedSourceGraph);
+        }
+        else if (util_1.isInstanceOf(node, types_1.ClassDeclaration)) {
+            loadClassAndParents(node, sourceGraph, sourceLinks, flattenedSourceGraph);
+        }
+        else if (util_1.isInstanceOf(node, types_1.VariableDeclaration)) {
+            loadVariableAndParents(node, sourceGraph, sourceLinks, flattenedSourceGraph);
+        }
+    }
+}
+function flattenChildren(sourceGraph, sourceLinks, flattenedSourceGraph) {
+    for (var _i = 0, _a = graphlib_1.alg.topsort(sourceGraph); _i < _a.length; _i++) {
+        var nodeName = _a[_i];
+        var node = sourceGraph.node(nodeName);
+        if (!node) {
+            continue;
+        }
+        if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+            loadTypeAliasAndChildren(node, sourceGraph, flattenedSourceGraph);
+        }
+        else if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+            loadInterfaceAndChildren(node, sourceGraph, flattenedSourceGraph);
+        }
+        else if (util_1.isInstanceOf(node, types_1.ClassDeclaration)) {
+            loadClassAndChildren(node, sourceGraph, sourceLinks, flattenedSourceGraph);
+        }
+        else if (util_1.isInstanceOf(node, types_1.VariableDeclaration)) {
+            getOrCreateVariable(node, sourceLinks, flattenedSourceGraph);
+        }
+    }
+}
+function isRootParent(type) {
+    if (Object.keys(type.directParents).length === 0 && type.directParents.constructor === Object) {
+        return true;
+    }
+    if (type.directParents[Loadable_1.LOADABLE_QUALIFIED_NAME]) {
+        return true;
+    }
+    return false;
+}
+function loadTypeAliasAndParents(typeAliasDeclaration, sourceGraph, sourceLinks, flattenedSourceGraph) {
+    if (!flattenedSourceGraph.typeAliases[typeAliasDeclaration.qualifiedName]) {
+        flattenedSourceGraph.typeAliases[typeAliasDeclaration.qualifiedName] = new types_1.TypeAlias(typeAliasDeclaration.packageName, typeAliasDeclaration.name, typeAliasDeclaration.filePath);
+    }
+    var typeAlias = flattenedSourceGraph.typeAliases[typeAliasDeclaration.qualifiedName];
+    var outEdges = sourceGraph.outEdges(typeAliasDeclaration.qualifiedName);
+    if (outEdges) {
+        for (var _i = 0, outEdges_1 = outEdges; _i < outEdges_1.length; _i++) {
+            var outEdge = outEdges_1[_i];
+            var node = sourceGraph.node(outEdge.w);
+            if (!node) {
+                continue;
+            }
+            if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+                var parentTypeAlias = flattenedSourceGraph.typeAliases[outEdge.w];
+                if (!parentTypeAlias) {
+                    continue;
+                }
+                typeAlias.directParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                typeAlias.allParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                typeAlias.allParents = Object.assign(typeAlias.allParents, parentTypeAlias.allParents);
+                if (isRootParent(parentTypeAlias)) {
+                    typeAlias.rootParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                }
+                else {
+                    typeAlias.rootParents = Object.assign(typeAlias.rootParents, parentTypeAlias.rootParents);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+                var parentInterface = flattenedSourceGraph.interfaces[outEdge.w];
+                if (!parentInterface) {
+                    continue;
+                }
+                typeAlias.directParents[parentInterface.qualifiedName] = parentInterface;
+                typeAlias.allParents[parentInterface.qualifiedName] = parentInterface;
+                typeAlias.allParents = Object.assign(typeAlias.allParents, parentInterface.allParents);
+                if (isRootParent(parentInterface)) {
+                    typeAlias.rootParents[parentInterface.qualifiedName] = parentInterface;
+                }
+                else {
+                    typeAlias.rootParents = Object.assign(typeAlias.rootParents, parentInterface.rootParents);
+                }
+            }
+        }
+    }
+}
+function loadInterfaceAndParents(interfaceDeclaration, sourceGraph, sourceLinks, flattenedSourceGraph) {
+    if (!flattenedSourceGraph.interfaces[interfaceDeclaration.qualifiedName]) {
+        flattenedSourceGraph.interfaces[interfaceDeclaration.qualifiedName] = new types_1.Interface(interfaceDeclaration.packageName, interfaceDeclaration.name, interfaceDeclaration.properties, interfaceDeclaration.methods, interfaceDeclaration.filePath);
+    }
+    var _interface = flattenedSourceGraph.interfaces[interfaceDeclaration.qualifiedName];
+    var outEdges = sourceGraph.outEdges(interfaceDeclaration.qualifiedName);
+    if (outEdges) {
+        for (var _i = 0, outEdges_2 = outEdges; _i < outEdges_2.length; _i++) {
+            var outEdge = outEdges_2[_i];
+            var node = sourceGraph.node(outEdge.w);
+            if (!node) {
+                continue;
+            }
+            if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+                var parentInterface = flattenedSourceGraph.interfaces[outEdge.w];
+                if (!parentInterface) {
+                    continue;
+                }
+                _interface.directParents[parentInterface.qualifiedName] = parentInterface;
+                _interface.allParents[parentInterface.qualifiedName] = parentInterface;
+                _interface.allParents = Object.assign(_interface.allParents, parentInterface.allParents);
+                if (isRootParent(parentInterface)) {
+                    _interface.rootParents[parentInterface.qualifiedName] = parentInterface;
+                }
+                else {
+                    _interface.rootParents = Object.assign(_interface.rootParents, parentInterface.rootParents);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+                var parentTypeAlias = flattenedSourceGraph.typeAliases[outEdge.w];
+                if (!parentTypeAlias) {
+                    continue;
+                }
+                _interface.directParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                _interface.allParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                _interface.allParents = Object.assign(_interface.allParents, parentTypeAlias.allParents);
+                if (isRootParent(parentTypeAlias)) {
+                    _interface.rootParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                }
+                else {
+                    _interface.rootParents = Object.assign(_interface.rootParents, parentTypeAlias.rootParents);
+                }
+            }
+        }
+    }
+}
+function loadClassAndParents(classDeclaration, sourceGraph, sourceLinks, flattenedSourceGraph) {
+    if (!flattenedSourceGraph.classes[classDeclaration.qualifiedName]) {
+        flattenedSourceGraph.classes[classDeclaration.qualifiedName] = new types_1.Class(classDeclaration.packageName, classDeclaration.name, classDeclaration.filePath, classDeclaration.isAbstract, classDeclaration.isStatic, classDeclaration.visibility, classDeclaration.properties, classDeclaration.methods, sourceLinks[classDeclaration.qualifiedName]);
+    }
+    var _class = flattenedSourceGraph.classes[classDeclaration.qualifiedName];
+    var outEdges = sourceGraph.outEdges(classDeclaration.qualifiedName);
+    if (outEdges) {
+        for (var _i = 0, outEdges_3 = outEdges; _i < outEdges_3.length; _i++) {
+            var outEdge = outEdges_3[_i];
+            var node = sourceGraph.node(outEdge.w);
+            if (!node) {
+                continue;
+            }
+            if (util_1.isInstanceOf(node, types_1.ClassDeclaration)) {
+                var parentClass = flattenedSourceGraph.classes[outEdge.w];
+                if (!parentClass) {
+                    continue;
+                }
+                _class.directParents[parentClass.qualifiedName] = parentClass;
+                _class.allParents[parentClass.qualifiedName] = parentClass;
+                _class.allParents = Object.assign(_class.allParents, parentClass.allParents);
+                if (isRootParent(parentClass)) {
+                    _class.rootParents[parentClass.qualifiedName] = parentClass;
+                }
+                else {
+                    _class.rootParents = Object.assign(_class.rootParents, parentClass.rootParents);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+                var parentInterface = flattenedSourceGraph.interfaces[outEdge.w];
+                if (!parentInterface) {
+                    continue;
+                }
+                _class.directParents[parentInterface.qualifiedName] = parentInterface;
+                _class.allParents[parentInterface.qualifiedName] = parentInterface;
+                _class.allParents = Object.assign(_class.allParents, parentInterface.allParents);
+                if (isRootParent(parentInterface)) {
+                    _class.rootParents[parentInterface.qualifiedName] = parentInterface;
+                }
+                else {
+                    _class.rootParents = Object.assign(_class.rootParents, parentInterface.rootParents);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+                var parentTypeAlias = flattenedSourceGraph.typeAliases[outEdge.w];
+                if (!parentTypeAlias) {
+                    continue;
+                }
+                _class.directParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                _class.allParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                _class.allParents = Object.assign(_class.allParents, parentTypeAlias.allParents);
+                if (isRootParent(parentTypeAlias)) {
+                    _class.rootParents[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                }
+                else {
+                    _class.rootParents = Object.assign(_class.rootParents, parentTypeAlias.rootParents);
+                }
+            }
+        }
+    }
+}
+function loadVariableAndParents(variableDeclaration, sourceGraph, sourceLinks, flattenedSourceGraph) {
+    var variable = getOrCreateVariable(variableDeclaration, sourceLinks, flattenedSourceGraph);
+    var outEdges = sourceGraph.outEdges(variableDeclaration.qualifiedName);
+    if (outEdges) {
+        for (var _i = 0, outEdges_4 = outEdges; _i < outEdges_4.length; _i++) {
+            var outEdge = outEdges_4[_i];
+            var node = sourceGraph.node(outEdge.w);
+            if (!node) {
+                continue;
+            }
+            if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+                var parentTypeAlias = flattenedSourceGraph.typeAliases[outEdge.w];
+                if (!parentTypeAlias) {
+                    continue;
+                }
+                variable.directParentTypes[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                variable.allParentTypes[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                variable.allParentTypes = Object.assign(variable.allParentTypes, parentTypeAlias.allParents);
+                if (isRootParent(parentTypeAlias)) {
+                    variable.rootParentTypes[parentTypeAlias.qualifiedName] = parentTypeAlias;
+                }
+                else {
+                    variable.rootParentTypes = Object.assign(variable.rootParentTypes, parentTypeAlias.rootParents);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+                var parentInterface = flattenedSourceGraph.interfaces[outEdge.w];
+                if (!parentInterface) {
+                    continue;
+                }
+                variable.directParentTypes[parentInterface.qualifiedName] = parentInterface;
+                variable.allParentTypes[parentInterface.qualifiedName] = parentInterface;
+                variable.allParentTypes = Object.assign(variable.allParentTypes, parentInterface.allParents);
+                if (isRootParent(parentInterface)) {
+                    variable.rootParentTypes[parentInterface.qualifiedName] = parentInterface;
+                }
+                else {
+                    variable.rootParentTypes = Object.assign(variable.rootParentTypes, parentInterface.rootParents);
+                }
+            }
+        }
+    }
+}
+function getOrCreateVariable(variableDeclaration, sourceLinks, flattenedSourceGraph) {
+    if (flattenedSourceGraph.variables[variableDeclaration.qualifiedName]) {
+        return flattenedSourceGraph.variables[variableDeclaration.qualifiedName];
+    }
+    var variable = new types_1.Variable(variableDeclaration.packageName, variableDeclaration.name, variableDeclaration.filePath, variableDeclaration.isExported, variableDeclaration.isConst, sourceLinks[variableDeclaration.qualifiedName]);
+    flattenedSourceGraph.variables[variableDeclaration.qualifiedName] = variable;
+    return variable;
+}
+function loadTypeAliasAndChildren(typeAliasDeclaration, sourceGraph, flattenedSourceGraph) {
+    if (!flattenedSourceGraph.typeAliases[typeAliasDeclaration.qualifiedName]) {
+        flattenedSourceGraph.typeAliases[typeAliasDeclaration.qualifiedName] = new types_1.TypeAlias(typeAliasDeclaration.packageName, typeAliasDeclaration.name, typeAliasDeclaration.filePath);
+    }
+    var typeAlias = flattenedSourceGraph.typeAliases[typeAliasDeclaration.qualifiedName];
+    var inEdges = sourceGraph.inEdges(typeAliasDeclaration.qualifiedName);
+    if (inEdges) {
+        for (var _i = 0, inEdges_1 = inEdges; _i < inEdges_1.length; _i++) {
+            var inEdge = inEdges_1[_i];
+            var node = sourceGraph.node(inEdge.v);
+            if (!node) {
+                continue;
+            }
+            if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+                var childTypeAlias = flattenedSourceGraph.typeAliases[node.qualifiedName];
+                if (!childTypeAlias) {
+                    continue;
+                }
+                typeAlias.directChildren[childTypeAlias.qualifiedName] = childTypeAlias;
+                typeAlias.allChildren[childTypeAlias.qualifiedName] = childTypeAlias;
+                typeAlias.allChildren = Object.assign(typeAlias.allChildren, childTypeAlias.allChildren);
+                if (Object.keys(childTypeAlias.directChildren).length === 0 &&
+                    childTypeAlias.directChildren.constructor === Object) {
+                    typeAlias.baseChildren[childTypeAlias.qualifiedName] = childTypeAlias;
+                }
+                else {
+                    typeAlias.baseChildren = Object.assign(typeAlias.baseChildren, childTypeAlias.baseChildren);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+                var childInterface = flattenedSourceGraph.interfaces[node.qualifiedName];
+                if (!childInterface) {
+                    continue;
+                }
+                typeAlias.directChildren[childInterface.qualifiedName] = childInterface;
+                typeAlias.allChildren[childInterface.qualifiedName] = childInterface;
+                typeAlias.allChildren = Object.assign(typeAlias.allChildren, childInterface.allChildren);
+                if (Object.keys(childInterface.directChildren).length === 0 &&
+                    childInterface.directChildren.constructor === Object) {
+                    typeAlias.baseChildren[childInterface.qualifiedName] = childInterface;
+                }
+                else {
+                    typeAlias.baseChildren = Object.assign(typeAlias.baseChildren, childInterface.baseChildren);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.VariableDeclaration)) {
+                var childVariable = flattenedSourceGraph.variables[node.qualifiedName];
+                if (!childVariable) {
+                    continue;
+                }
+                typeAlias.directChildren[childVariable.qualifiedName] = childVariable;
+                typeAlias.allChildren[childVariable.qualifiedName] = childVariable;
+                typeAlias.baseChildren[childVariable.qualifiedName] = childVariable;
+            }
+            else if (util_1.isInstanceOf(node, types_1.ClassDeclaration)) {
+                var childClass = flattenedSourceGraph.classes[node.qualifiedName];
+                if (!childClass) {
+                    continue;
+                }
+                typeAlias.directChildren[childClass.qualifiedName] = childClass;
+                typeAlias.allChildren[childClass.qualifiedName] = childClass;
+                typeAlias.baseChildren[childClass.qualifiedName] = childClass;
+            }
+        }
+    }
+}
+function loadInterfaceAndChildren(interfaceDeclaration, sourceGraph, flattenedSourceGraph) {
+    if (!flattenedSourceGraph.interfaces[interfaceDeclaration.qualifiedName]) {
+        flattenedSourceGraph.interfaces[interfaceDeclaration.qualifiedName] = new types_1.Interface(interfaceDeclaration.packageName, interfaceDeclaration.name, interfaceDeclaration.properties, interfaceDeclaration.methods, interfaceDeclaration.filePath);
+    }
+    var _interface = flattenedSourceGraph.interfaces[interfaceDeclaration.qualifiedName];
+    var inEdges = sourceGraph.inEdges(interfaceDeclaration.qualifiedName);
+    if (inEdges) {
+        for (var _i = 0, inEdges_2 = inEdges; _i < inEdges_2.length; _i++) {
+            var inEdge = inEdges_2[_i];
+            var node = sourceGraph.node(inEdge.v);
+            if (!node) {
+                continue;
+            }
+            if (util_1.isInstanceOf(node, types_1.InterfaceDeclaration)) {
+                var childInterface = flattenedSourceGraph.interfaces[node.qualifiedName];
+                if (!childInterface) {
+                    continue;
+                }
+                _interface.directChildren[childInterface.qualifiedName] = childInterface;
+                _interface.allChildren[childInterface.qualifiedName] = childInterface;
+                _interface.allChildren = Object.assign(_interface.allChildren, childInterface.allChildren);
+                if (Object.keys(childInterface.directChildren).length === 0 &&
+                    childInterface.directChildren.constructor === Object) {
+                    _interface.baseChildren[childInterface.qualifiedName] = childInterface;
+                }
+                else {
+                    _interface.baseChildren = Object.assign(_interface.baseChildren, childInterface.baseChildren);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.TypeAliasDeclaration)) {
+                var childTypeAlias = flattenedSourceGraph.typeAliases[node.qualifiedName];
+                if (!childTypeAlias) {
+                    continue;
+                }
+                _interface.directChildren[childTypeAlias.qualifiedName] = childTypeAlias;
+                _interface.allChildren[childTypeAlias.qualifiedName] = childTypeAlias;
+                _interface.allChildren = Object.assign(_interface.allChildren, childTypeAlias.allChildren);
+                if (Object.keys(childTypeAlias.directChildren).length === 0 &&
+                    childTypeAlias.directChildren.constructor === Object) {
+                    _interface.baseChildren[childTypeAlias.qualifiedName] = childTypeAlias;
+                }
+                else {
+                    _interface.baseChildren = Object.assign(_interface.baseChildren, childTypeAlias.baseChildren);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.ClassDeclaration)) {
+                var childClass = flattenedSourceGraph.classes[node.qualifiedName];
+                if (!childClass) {
+                    continue;
+                }
+                _interface.directChildren[childClass.qualifiedName] = childClass;
+                _interface.allChildren[childClass.qualifiedName] = childClass;
+                _interface.allChildren = Object.assign(_interface.allChildren, childClass.allChildren);
+                if (Object.keys(childClass.directChildren).length === 0 && childClass.directChildren.constructor === Object) {
+                    _interface.baseChildren[childClass.qualifiedName] = childClass;
+                }
+                else {
+                    _interface.baseChildren = Object.assign(_interface.baseChildren, childClass.baseChildren);
+                }
+            }
+            else if (util_1.isInstanceOf(node, types_1.VariableDeclaration)) {
+                var childVariable = flattenedSourceGraph.variables[node.qualifiedName];
+                if (!childVariable) {
+                    continue;
+                }
+                _interface.directChildren[childVariable.qualifiedName] = childVariable;
+                _interface.allChildren[childVariable.qualifiedName] = childVariable;
+                _interface.baseChildren[childVariable.qualifiedName] = childVariable;
+            }
+        }
+    }
+}
+function loadClassAndChildren(classDeclaration, sourceGraph, sourceLinks, flattenedSourceGraph) {
+    if (!flattenedSourceGraph.classes[classDeclaration.qualifiedName]) {
+        flattenedSourceGraph.classes[classDeclaration.qualifiedName] = new types_1.Class(classDeclaration.packageName, classDeclaration.name, classDeclaration.filePath, classDeclaration.isAbstract, classDeclaration.isStatic, classDeclaration.visibility, classDeclaration.properties, classDeclaration.methods, sourceLinks[classDeclaration.qualifiedName]);
+    }
+    var _class = flattenedSourceGraph.classes[classDeclaration.qualifiedName];
+    var inEdges = sourceGraph.inEdges(classDeclaration.qualifiedName);
+    if (inEdges) {
+        for (var _i = 0, inEdges_3 = inEdges; _i < inEdges_3.length; _i++) {
+            var inEdge = inEdges_3[_i];
+            var node = sourceGraph.node(inEdge.v);
+            if (!node) {
+                continue;
+            }
+            if (util_1.isInstanceOf(node, types_1.ClassDeclaration)) {
+                var childClass = flattenedSourceGraph.classes[node.qualifiedName];
+                if (!childClass) {
+                    continue;
+                }
+                _class.directChildren[childClass.qualifiedName] = childClass;
+                _class.allChildren[childClass.qualifiedName] = childClass;
+                _class.allChildren = Object.assign(_class.allChildren, childClass.allChildren);
+                if (Object.keys(childClass.directChildren).length === 0 && childClass.directChildren.constructor === Object) {
+                    _class.baseChildren[childClass.qualifiedName] = childClass;
+                }
+                else {
+                    _class.baseChildren = Object.assign(_class.baseChildren, childClass.baseChildren);
+                }
+            }
+        }
+    }
+}
+function addTypeParameters(flattenedSourceGraph, sourceGraph) {
+    for (var _i = 0, _a = Object.keys(flattenedSourceGraph.typeAliases); _i < _a.length; _i++) {
+        var typeAliasName = _a[_i];
+        var typeAlias = flattenedSourceGraph.typeAliases[typeAliasName];
+        var typeAliasDeclaration = sourceGraph.node(typeAliasName);
+        if (!typeAliasDeclaration) {
+            continue;
+        }
+        if (!typeAliasDeclaration.directParents) {
+            continue;
+        }
+        addTypeParametersToSource(typeAlias, typeAliasDeclaration.directParents, flattenedSourceGraph);
+    }
+    for (var _b = 0, _c = Object.keys(flattenedSourceGraph.interfaces); _b < _c.length; _b++) {
+        var interfaceName = _c[_b];
+        var _interface = flattenedSourceGraph.interfaces[interfaceName];
+        var interfaceDeclaration = sourceGraph.node(interfaceName);
+        if (!interfaceDeclaration) {
+            continue;
+        }
+        addTypeParametersToSource(_interface, interfaceDeclaration.directParents, flattenedSourceGraph);
+    }
+    for (var _d = 0, _e = Object.keys(flattenedSourceGraph.classes); _d < _e.length; _d++) {
+        var className = _e[_d];
+        var _class = flattenedSourceGraph.classes[className];
+        var classDeclaration = sourceGraph.node(className);
+        if (!classDeclaration) {
+            continue;
+        }
+        addTypeParametersToSource(_class, classDeclaration.directParentClasses, flattenedSourceGraph);
+        addTypeParametersToSource(_class, classDeclaration.directParentInterfaces, flattenedSourceGraph);
+    }
+    for (var _f = 0, _g = Object.keys(flattenedSourceGraph.variables); _f < _g.length; _f++) {
+        var variableName = _g[_f];
+        var variable = flattenedSourceGraph.variables[variableName];
+        var variableDeclaration = sourceGraph.node(variableName);
+        if (!variableDeclaration) {
+            continue;
+        }
+        if (!variableDeclaration.type) {
+            continue;
+        }
+        if (!variableDeclaration.type.directParents) {
+            continue;
+        }
+        addTypeParametersToSource(variable, variableDeclaration.type.directParents, flattenedSourceGraph);
+    }
+}
+function addTypeParametersToSource(source, parentDeclarations, flattenedSourceGraph) {
+    if (!parentDeclarations) {
+        return;
+    }
+    for (var _i = 0, parentDeclarations_1 = parentDeclarations; _i < parentDeclarations_1.length; _i++) {
+        var parentDeclaration = parentDeclarations_1[_i];
+        if (!parentDeclaration.typeParameters) {
+            continue;
+        }
+        for (var _a = 0, _b = parentDeclaration.typeParameters; _a < _b.length; _a++) {
+            var typeParameter = _b[_a];
+            if (!source.typeParameters[parentDeclaration.qualifiedName]) {
+                source.typeParameters[parentDeclaration.qualifiedName] = [];
+            }
+            if (flattenedSourceGraph.typeAliases[typeParameter]) {
+                source.typeParameters[parentDeclaration.qualifiedName].push(flattenedSourceGraph.typeAliases[typeParameter]);
+            }
+            else if (flattenedSourceGraph.interfaces[typeParameter]) {
+                source.typeParameters[parentDeclaration.qualifiedName].push(flattenedSourceGraph.interfaces[typeParameter]);
+            }
+        }
+    }
+}
+function pruneNonLoadables(flattenedSourceGraph) {
+    for (var _i = 0, _a = Object.keys(flattenedSourceGraph.variables); _i < _a.length; _i++) {
+        var variableQualifiedName = _a[_i];
+        var variable = flattenedSourceGraph.variables[variableQualifiedName];
+        if (!variable.allParentTypes[Loadable_1.LOADABLE_QUALIFIED_NAME]) {
+            delete flattenedSourceGraph.variables[variableQualifiedName];
+        }
+    }
+    for (var _b = 0, _c = Object.keys(flattenedSourceGraph.typeAliases); _b < _c.length; _b++) {
+        var qualifiedName = _c[_b];
+        var typeAlias = flattenedSourceGraph.typeAliases[qualifiedName];
+        if (!typeAlias.allParents[Loadable_1.LOADABLE_QUALIFIED_NAME]) {
+            delete flattenedSourceGraph.typeAliases[qualifiedName];
+        }
+    }
+    for (var _d = 0, _e = Object.keys(flattenedSourceGraph.classes); _d < _e.length; _d++) {
+        var qualifiedName = _e[_d];
+        var _class = flattenedSourceGraph.classes[qualifiedName];
+        if (!_class.allParents[Loadable_1.LOADABLE_QUALIFIED_NAME]) {
+            delete flattenedSourceGraph.classes[qualifiedName];
+        }
+    }
+    for (var _f = 0, _g = Object.keys(flattenedSourceGraph.interfaces); _f < _g.length; _f++) {
+        var qualifiedName = _g[_f];
+        var _interface = flattenedSourceGraph.interfaces[qualifiedName];
+        if (!_interface.allParents[Loadable_1.LOADABLE_QUALIFIED_NAME] && qualifiedName != Loadable_1.LOADABLE_QUALIFIED_NAME) {
+            delete flattenedSourceGraph.interfaces[qualifiedName];
+        }
+    }
+}
+//# sourceMappingURL=FlattenedSourceGraph.js.map