Add extracted source directory and README navigation

extracted-source/node_modules/flora-colossus/lib/Walker.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Walker = void 0;
+const debug = require("debug");
+const fs = require("fs-extra");
+const path = require("path");
+const depTypes_1 = require("./depTypes");
+const nativeModuleTypes_1 = require("./nativeModuleTypes");
+const d = debug('flora-colossus');
+class Walker {
+    constructor(modulePath) {
+        this.modules = [];
+        this.walkHistory = new Set();
+        this.cache = null;
+        if (!modulePath || typeof modulePath !== 'string') {
+            throw new Error('modulePath must be provided as a string');
+        }
+        d(`creating walker with rootModule=${modulePath}`);
+        this.rootModule = modulePath;
+    }
+    relativeModule(rootPath, moduleName) {
+        return path.resolve(rootPath, 'node_modules', moduleName);
+    }
+    async loadPackageJSON(modulePath) {
+        const pJPath = path.resolve(modulePath, 'package.json');
+        if (await fs.pathExists(pJPath)) {
+            const pJ = await fs.readJson(pJPath);
+            if (!pJ.dependencies)
+                pJ.dependencies = {};
+            if (!pJ.devDependencies)
+                pJ.devDependencies = {};
+            if (!pJ.optionalDependencies)
+                pJ.optionalDependencies = {};
+            return pJ;
+        }
+        return null;
+    }
+    async walkDependenciesForModuleInModule(moduleName, modulePath, depType) {
+        let testPath = modulePath;
+        let discoveredPath = null;
+        let lastRelative = null;
+        // Try find it while searching recursively up the tree
+        while (!discoveredPath && this.relativeModule(testPath, moduleName) !== lastRelative) {
+            lastRelative = this.relativeModule(testPath, moduleName);
+            if (await fs.pathExists(lastRelative)) {
+                discoveredPath = lastRelative;
+            }
+            else {
+                if (path.basename(path.dirname(testPath)) !== 'node_modules') {
+                    testPath = path.dirname(testPath);
+                }
+                testPath = path.dirname(path.dirname(testPath));
+            }
+        }
+        // If we can't find it the install is probably buggered
+        if (!discoveredPath && depType !== depTypes_1.DepType.OPTIONAL && depType !== depTypes_1.DepType.DEV_OPTIONAL) {
+            throw new Error(`Failed to locate module "${moduleName}" from "${modulePath}"
+
+        This normally means that either you have deleted this package already somehow (check your ignore settings if using electron-packager).  Or your module installation failed.`);
+        }
+        // If we can find it let's do the same thing for that module
+        if (discoveredPath) {
+            await this.walkDependenciesForModule(discoveredPath, depType);
+        }
+    }
+    async detectNativeModuleType(modulePath, pJ) {
+        if (pJ.dependencies['prebuild-install']) {
+            return nativeModuleTypes_1.NativeModuleType.PREBUILD;
+        }
+        else if (await fs.pathExists(path.join(modulePath, 'binding.gyp'))) {
+            return nativeModuleTypes_1.NativeModuleType.NODE_GYP;
+        }
+        return nativeModuleTypes_1.NativeModuleType.NONE;
+    }
+    async walkDependenciesForModule(modulePath, depType) {
+        d('walk reached:', modulePath, ' Type is:', depTypes_1.DepType[depType]);
+        // We have already traversed this module
+        if (this.walkHistory.has(modulePath)) {
+            d('already walked this route');
+            // Find the existing module reference
+            const existingModule = this.modules.find(module => module.path === modulePath);
+            // If the depType we are traversing with now is higher than the
+            // last traversal then update it (prod superseeds dev for instance)
+            if ((0, depTypes_1.depTypeGreater)(depType, existingModule.depType)) {
+                d(`existing module has a type of "${existingModule.depType}", new module type would be "${depType}" therefore updating`);
+                existingModule.depType = depType;
+            }
+            return;
+        }
+        const pJ = await this.loadPackageJSON(modulePath);
+        // If the module doesn't have a package.json file it is probably a
+        // dead install from yarn (they dont clean up for some reason)
+        if (!pJ) {
+            d('walk hit a dead end, this module is incomplete');
+            return;
+        }
+        // Record this module as being traversed
+        this.walkHistory.add(modulePath);
+        this.modules.push({
+            depType,
+            nativeModuleType: await this.detectNativeModuleType(modulePath, pJ),
+            path: modulePath,
+            name: pJ.name,
+        });
+        // For every prod dep
+        for (const moduleName in pJ.dependencies) {
+            // npm decides it's a funny thing to put optional dependencies in the "dependencies" section
+            // after install, because that makes perfect sense
+            if (moduleName in pJ.optionalDependencies) {
+                d(`found ${moduleName} in prod deps of ${modulePath} but it is also marked optional`);
+                continue;
+            }
+            await this.walkDependenciesForModuleInModule(moduleName, modulePath, (0, depTypes_1.childDepType)(depType, depTypes_1.DepType.PROD));
+        }
+        // For every optional dep
+        for (const moduleName in pJ.optionalDependencies) {
+            await this.walkDependenciesForModuleInModule(moduleName, modulePath, (0, depTypes_1.childDepType)(depType, depTypes_1.DepType.OPTIONAL));
+        }
+        // For every dev dep, but only if we are in the root module
+        if (depType === depTypes_1.DepType.ROOT) {
+            d('we\'re still at the beginning, walking down the dev route');
+            for (const moduleName in pJ.devDependencies) {
+                await this.walkDependenciesForModuleInModule(moduleName, modulePath, (0, depTypes_1.childDepType)(depType, depTypes_1.DepType.DEV));
+            }
+        }
+    }
+    async walkTree() {
+        d('starting tree walk');
+        if (!this.cache) {
+            this.cache = new Promise(async (resolve, reject) => {
+                this.modules = [];
+                try {
+                    await this.walkDependenciesForModule(this.rootModule, depTypes_1.DepType.ROOT);
+                }
+                catch (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(this.modules);
+            });
+        }
+        else {
+            d('tree walk in progress / completed already, waiting for existing walk to complete');
+        }
+        return await this.cache;
+    }
+    getRootModule() {
+        return this.rootModule;
+    }
+}
+exports.Walker = Walker;
+//# sourceMappingURL=Walker.js.map