diff options
Diffstat (limited to 'desktop/node_modules/flora-colossus/lib/Walker.js')
| -rw-r--r-- | desktop/node_modules/flora-colossus/lib/Walker.js | 152 |
1 files changed, 152 insertions, 0 deletions
diff --git a/desktop/node_modules/flora-colossus/lib/Walker.js b/desktop/node_modules/flora-colossus/lib/Walker.js new file mode 100644 index 0000000..084dd69 --- /dev/null +++ b/desktop/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
\ No newline at end of file |