JezK

Edit File: config.js

"use strict";

//
  (0, _createClass2()["default"])(Config, [{
    key: "getCache",
    value:
    /**
     * Execute a promise produced by factory if it doesn't exist in our cache with
     * the associated key.
     */

/**
     * Get a config option from our yarn config.
     */
  }, {
    key: "getOption",
    value: function getOption(key) {
      var resolve = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      var value = this.registries.yarn.getOption(key);
      if (resolve && typeof value === 'string' && value.length) {
        return (0, _path().resolveWithHome)(value);
      }
      return value;
    }

/**
     * Reduce a list of versions to a single one based on an input range.
     */
  }, {
    key: "resolveConstraints",
    value: function resolveConstraints(versions, range) {
      return this.constraintResolver.reduce(versions, range);
    }

/**
     * Initialise config. Fetch registry options, find package roots.
     */
  }, {
    key: "init",
    value: function () {
      var _init2 = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee() {
        var _this2 = this;
        var opts,
          focusedWorkspaceManifest,
          linkedModules,
          _iterator,
          _step,
          _loop,
          _i,
          _Object$keys,
          _key,
          Registry,
          extraneousRcFiles,
          registry,
          httpProxy,
          httpsProxy,
          cacheRootFolder,
          preferredCacheFolders,
          preferredCacheFolder,
          cacheFolderQuery,
          _iterator2,
          _step2,
          skippedEntry,
          manifest,
          plugnplayByEnv,
          cacheRootFolderDrive,
          lockfileFolderDrive,
          _args2 = arguments;
        return _regenerator()["default"].wrap(function _callee$(_context2) {
          while (1) switch (_context2.prev = _context2.next) {
            case 0:
              opts = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {};
              this._init(opts);
              _context2.next = 4;
              return this.findWorkspaceRoot(this.cwd);
            case 4:
              this.workspaceRootFolder = _context2.sent;
              this.lockfileFolder = this.workspaceRootFolder || this.cwd;

// using focus in a workspace root is not allowed
              if (!(this.focus && (!this.workspaceRootFolder || this.cwd === this.workspaceRootFolder))) {
                _context2.next = 8;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('workspacesFocusRootCheck'));
            case 8:
              if (!this.focus) {
                _context2.next = 13;
                break;
              }
              _context2.next = 11;
              return this.readRootManifest();
            case 11:
              focusedWorkspaceManifest = _context2.sent;
              this.focusedWorkspaceName = focusedWorkspaceManifest.name;
            case 13:
              this.linkedModules = [];
              _context2.prev = 14;
              _context2.next = 17;
              return fs().readdir(this.linkFolder);
            case 17:
              linkedModules = _context2.sent;
              _context2.next = 27;
              break;
            case 20:
              _context2.prev = 20;
              _context2.t0 = _context2["catch"](14);
              if (!(_context2.t0.code === 'ENOENT')) {
                _context2.next = 26;
                break;
              }
              linkedModules = [];
              _context2.next = 27;
              break;
            case 26:
              throw _context2.t0;
            case 27:
              _iterator = _createForOfIteratorHelper(linkedModules);
              _context2.prev = 28;
              _loop = /*#__PURE__*/_regenerator()["default"].mark(function _loop() {
                var dir, linkedPath, _this2$linkedModules, scopedLinked;
                return _regenerator()["default"].wrap(function _loop$(_context) {
                  while (1) switch (_context.prev = _context.next) {
                    case 0:
                      dir = _step.value;
                      linkedPath = path.join(_this2.linkFolder, dir);
                      if (!(dir[0] === '@')) {
                        _context.next = 9;
                        break;
                      }
                      _context.next = 5;
                      return fs().readdir(linkedPath);
                    case 5:
                      scopedLinked = _context.sent;
                      (_this2$linkedModules = _this2.linkedModules).push.apply(_this2$linkedModules, (0, _toConsumableArray2()["default"])(scopedLinked.map(function (scopedDir) {
                        return path.join(dir, scopedDir);
                      })));
                      _context.next = 10;
                      break;
                    case 9:
                      _this2.linkedModules.push(dir);
                    case 10:
                    case "end":
                      return _context.stop();
                  }
                }, _loop);
              });
              _iterator.s();
            case 31:
              if ((_step = _iterator.n()).done) {
                _context2.next = 35;
                break;
              }
              return _context2.delegateYield(_loop(), "t1", 33);
            case 33:
              _context2.next = 31;
              break;
            case 35:
              _context2.next = 40;
              break;
            case 37:
              _context2.prev = 37;
              _context2.t2 = _context2["catch"](28);
              _iterator.e(_context2.t2);
            case 40:
              _context2.prev = 40;
              _iterator.f();
              return _context2.finish(40);
            case 43:
              _i = 0, _Object$keys = Object.keys(_index2().registries);
            case 44:
              if (!(_i < _Object$keys.length)) {
                _context2.next = 56;
                break;
              }
              _key = _Object$keys[_i];
              Registry = _index2().registries[_key];
              extraneousRcFiles = Registry === _index2().registries.yarn ? this.extraneousYarnrcFiles : []; // instantiate registry
              registry = new Registry(this.cwd, this.registries, this.requestManager, this.reporter, this.enableDefaultRc, extraneousRcFiles);
              _context2.next = 51;
              return registry.init({
                registry: opts.registry
              });
            case 51:
              this.registries[_key] = registry;
              if (this.registryFolders.indexOf(registry.folder) === -1) {
                this.registryFolders.push(registry.folder);
              }
            case 53:
              _i++;
              _context2.next = 44;
              break;
            case 56:
              if (this.modulesFolder) {
                this.registryFolders = [this.modulesFolder];
              }
              this.networkConcurrency = opts.networkConcurrency || Number(this.getOption('network-concurrency')) || constants().NETWORK_CONCURRENCY;
              this.childConcurrency = opts.childConcurrency || Number(this.getOption('child-concurrency')) || Number(process.env.CHILD_CONCURRENCY) || constants().CHILD_CONCURRENCY;
              this.networkTimeout = opts.networkTimeout || Number(this.getOption('network-timeout')) || constants().NETWORK_TIMEOUT;
              httpProxy = opts.httpProxy || this.getOption('proxy');
              httpsProxy = opts.httpsProxy || this.getOption('https-proxy');
              this.requestManager.setOptions({
                userAgent: String(this.getOption('user-agent')),
                httpProxy: httpProxy === false ? false : String(httpProxy || ''),
                httpsProxy: httpsProxy === false ? false : String(httpsProxy || ''),
                strictSSL: Boolean(this.getOption('strict-ssl')),
                ca: Array.prototype.concat(opts.ca || this.getOption('ca') || []).map(String),
                cafile: String(opts.cafile || this.getOption('cafile', true) || ''),
                cert: String(opts.cert || this.getOption('cert') || ''),
                key: String(opts.key || this.getOption('key') || ''),
                networkConcurrency: this.networkConcurrency,
                networkTimeout: this.networkTimeout
              });
              this.globalFolder = opts.globalFolder || String(this.getOption('global-folder', true));
              if (this.globalFolder === 'undefined') {
                this.globalFolder = constants().GLOBAL_MODULE_DIRECTORY;
              }
              cacheRootFolder = opts.cacheFolder || this.getOption('cache-folder', true);
              if (cacheRootFolder) {
                _context2.next = 77;
                break;
              }
              preferredCacheFolders = constants().PREFERRED_MODULE_CACHE_DIRECTORIES;
              preferredCacheFolder = opts.preferredCacheFolder || this.getOption('preferred-cache-folder', true);
              if (preferredCacheFolder) {
                preferredCacheFolders = [String(preferredCacheFolder)].concat(preferredCacheFolders);
              }
              _context2.next = 72;
              return fs().getFirstSuitableFolder(preferredCacheFolders, fs().constants.W_OK | fs().constants.X_OK | fs().constants.R_OK // eslint-disable-line no-bitwise
              );
            case 72:
              cacheFolderQuery = _context2.sent;
              _iterator2 = _createForOfIteratorHelper(cacheFolderQuery.skipped);
              try {
                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
                  skippedEntry = _step2.value;
                  this.reporter.warn(this.reporter.lang('cacheFolderSkipped', skippedEntry.folder));
                }
              } catch (err) {
                _iterator2.e(err);
              } finally {
                _iterator2.f();
              }
              cacheRootFolder = cacheFolderQuery.folder;
              if (cacheRootFolder && cacheFolderQuery.skipped.length > 0) {
                this.reporter.warn(this.reporter.lang('cacheFolderSelected', cacheRootFolder));
              }
            case 77:
              if (cacheRootFolder) {
                _context2.next = 81;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('cacheFolderMissing'));
            case 81:
              this._cacheRootFolder = String(cacheRootFolder);
            case 82:
              _context2.next = 84;
              return this.maybeReadManifest(this.lockfileFolder);
            case 84:
              manifest = _context2.sent;
              plugnplayByEnv = this.getOption('plugnplay-override');
              if (plugnplayByEnv != null) {
                this.plugnplayEnabled = plugnplayByEnv !== 'false' && plugnplayByEnv !== '0';
                this.plugnplayPersist = false;
              } else if (opts.enablePnp || opts.disablePnp) {
                this.plugnplayEnabled = !!opts.enablePnp;
                this.plugnplayPersist = true;
              } else if (manifest && manifest.installConfig && manifest.installConfig.pnp) {
                this.plugnplayEnabled = !!manifest.installConfig.pnp;
                this.plugnplayPersist = false;
              } else {
                this.plugnplayEnabled = false;
                this.plugnplayPersist = false;
              }
              if (process.platform === 'win32') {
                cacheRootFolderDrive = path.parse(this._cacheRootFolder).root.toLowerCase();
                lockfileFolderDrive = path.parse(this.lockfileFolder).root.toLowerCase();
                if (cacheRootFolderDrive !== lockfileFolderDrive) {
                  if (this.plugnplayEnabled) {
                    this.reporter.warn(this.reporter.lang('plugnplayWindowsSupport'));
                  }
                  this.plugnplayEnabled = false;
                  this.plugnplayPersist = false;
                }
              }
              this.plugnplayShebang = String(this.getOption('plugnplay-shebang') || '') || '/usr/bin/env node';
              this.plugnplayBlacklist = String(this.getOption('plugnplay-blacklist') || '') || null;
              this.ignoreScripts = opts.ignoreScripts || Boolean(this.getOption('ignore-scripts', false));
              this.workspacesEnabled = this.getOption('workspaces-experimental') !== false;
              this.workspacesNohoistEnabled = this.getOption('workspaces-nohoist-experimental') !== false;
              this.offlineCacheFolder = String(this.getOption('offline-cache-folder') || '') || null;
              this.pruneOfflineMirror = Boolean(this.getOption('yarn-offline-mirror-pruning'));
              this.enableMetaFolder = Boolean(this.getOption('enable-meta-folder'));
              this.enableLockfileVersions = Boolean(this.getOption('yarn-enable-lockfile-versions'));
              this.linkFileDependencies = Boolean(this.getOption('yarn-link-file-dependencies'));
              this.packBuiltPackages = Boolean(this.getOption('experimental-pack-script-packages-in-mirror'));
              this.autoAddIntegrity = !(0, _conversion().boolifyWithDefault)(String(this.getOption('unsafe-disable-integrity-migration')), true);

//init & create cacheFolder, tempFolder
              this.cacheFolder = path.join(this._cacheRootFolder, 'v' + String(constants().CACHE_VERSION));
              this.tempFolder = opts.tempFolder || path.join(this.cacheFolder, '.tmp');
              _context2.next = 104;
              return fs().mkdirp(this.cacheFolder);
            case 104:
              _context2.next = 106;
              return fs().mkdirp(this.tempFolder);
            case 106:
              if (opts.production !== undefined) {
                this.production = Boolean(opts.production);
              } else {
                this.production = Boolean(this.getOption('production')) || process.env.NODE_ENV === 'production' && process.env.NPM_CONFIG_PRODUCTION !== 'false' && process.env.YARN_PRODUCTION !== 'false';
              }
              if (!(this.workspaceRootFolder && !this.workspacesEnabled)) {
                _context2.next = 109;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('workspacesDisabled'));
            case 109:
            case "end":
              return _context2.stop();
          }
        }, _callee, this, [[14, 20], [28, 37, 40, 43]]);
      }));
      function init() {
        return _init2.apply(this, arguments);
      }
      return init;
    }()
  }, {
    key: "_init",
    value: function _init(opts) {
      this.registryFolders = [];
      this.linkedModules = [];
      this.registries = (0, _map()["default"])();
      this.cache = (0, _map()["default"])();

// Ensure the cwd is always an absolute path.
      this.cwd = path.resolve(opts.cwd || this.cwd || process.cwd());
      this.looseSemver = opts.looseSemver == undefined ? true : opts.looseSemver;
      this.commandName = opts.commandName || '';
      this.enableDefaultRc = opts.enableDefaultRc !== false;
      this.extraneousYarnrcFiles = opts.extraneousYarnrcFiles || [];
      this.preferOffline = !!opts.preferOffline;
      this.modulesFolder = opts.modulesFolder;
      this.linkFolder = opts.linkFolder || constants().LINK_REGISTRY_DIRECTORY;
      this.offline = !!opts.offline;
      this.binLinks = !!opts.binLinks;
      this.updateChecksums = !!opts.updateChecksums;
      this.plugnplayUnplugged = [];
      this.plugnplayPurgeUnpluggedPackages = false;
      this.ignorePlatform = !!opts.ignorePlatform;
      this.ignoreScripts = !!opts.ignoreScripts;
      this.disablePrepublish = !!opts.disablePrepublish;

// $FlowFixMe$
      this.nonInteractive = !!opts.nonInteractive || isCi || !process.stdout.isTTY;
      this.requestManager.setOptions({
        offline: !!opts.offline && !opts.preferOffline,
        captureHar: !!opts.captureHar
      });
      this.focus = !!opts.focus;
      this.focusedWorkspaceName = '';
      this.otp = opts.otp || '';
    }

/**
     * Generate a name suitable as unique filesystem identifier for the specified package.
     */
  }, {
    key: "generateUniquePackageSlug",
    value: function generateUniquePackageSlug(pkg) {
      var slug = pkg.name;
      slug = slug.replace(/[^@a-z0-9]+/g, '-');
      slug = slug.replace(/^-+|-+$/g, '');
      if (pkg.registry) {
        slug = "".concat(pkg.registry, "-").concat(slug);
      } else {
        slug = "unknown-".concat(slug);
      }
      var hash = pkg.remote.hash;
      if (pkg.version) {
        slug += "-".concat(pkg.version);
      }
      if (pkg.uid && pkg.version !== pkg.uid) {
        slug += "-".concat(pkg.uid);
      } else if (hash) {
        slug += "-".concat(hash);
      }
      if (pkg.remote.integrity) {
        slug += "-integrity";
      }
      return slug;
    }

/**
     * Generate an absolute module path.
     */
  }, {
    key: "generateModuleCachePath",
    value: function generateModuleCachePath(pkg) {
      invariant(this.cacheFolder, 'No package root');
      invariant(pkg, 'Undefined package');
      var slug = this.generateUniquePackageSlug(pkg);
      return path.join(this.cacheFolder, slug, 'node_modules', pkg.name);
    }

/**
     */
  }, {
    key: "getUnpluggedPath",
    value: function getUnpluggedPath() {
      return path.join(this.lockfileFolder, '.pnp', 'unplugged');
    }

/**
      */
  }, {
    key: "generatePackageUnpluggedPath",
    value: function generatePackageUnpluggedPath(pkg) {
      var slug = this.generateUniquePackageSlug(pkg);
      return path.join(this.getUnpluggedPath(), slug, 'node_modules', pkg.name);
    }

/**
     */
  }, {
    key: "listUnpluggedPackageFolders",
    value: function () {
      var _listUnpluggedPackageFolders = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee2() {
        var unpluggedPackages, unpluggedPath, _iterator3, _step3, unpluggedName, nmListing, target;
        return _regenerator()["default"].wrap(function _callee2$(_context3) {
          while (1) switch (_context3.prev = _context3.next) {
            case 0:
              unpluggedPackages = new Map();
              unpluggedPath = this.getUnpluggedPath();
              _context3.next = 4;
              return fs().exists(unpluggedPath);
            case 4:
              if (_context3.sent) {
                _context3.next = 6;
                break;
              }
              return _context3.abrupt("return", unpluggedPackages);
            case 6:
              _context3.t0 = _createForOfIteratorHelper;
              _context3.next = 9;
              return fs().readdir(unpluggedPath);
            case 9:
              _context3.t1 = _context3.sent;
              _iterator3 = (0, _context3.t0)(_context3.t1);
              _context3.prev = 11;
              _iterator3.s();
            case 13:
              if ((_step3 = _iterator3.n()).done) {
                _context3.next = 23;
                break;
              }
              unpluggedName = _step3.value;
              _context3.next = 17;
              return fs().readdir(path.join(unpluggedPath, unpluggedName, 'node_modules'));
            case 17:
              nmListing = _context3.sent;
              invariant(nmListing.length === 1, 'A single folder should be in the unplugged directory');
              target = path.join(unpluggedPath, unpluggedName, "node_modules", nmListing[0]);
              unpluggedPackages.set(unpluggedName, target);
            case 21:
              _context3.next = 13;
              break;
            case 23:
              _context3.next = 28;
              break;
            case 25:
              _context3.prev = 25;
              _context3.t2 = _context3["catch"](11);
              _iterator3.e(_context3.t2);
            case 28:
              _context3.prev = 28;
              _iterator3.f();
              return _context3.finish(28);
            case 31:
              return _context3.abrupt("return", unpluggedPackages);
            case 32:
            case "end":
              return _context3.stop();
          }
        }, _callee2, this, [[11, 25, 28, 31]]);
      }));
      function listUnpluggedPackageFolders() {
        return _listUnpluggedPackageFolders.apply(this, arguments);
      }
      return listUnpluggedPackageFolders;
    }()
    /**
     * Execute lifecycle scripts in the specified directory. Ignoring when the --ignore-scripts flag has been
     * passed.
     */
  }, {
    key: "executeLifecycleScript",
    value: function executeLifecycleScript(commandName, cwd) {
      if (this.ignoreScripts) {
        return Promise.resolve();
      } else {
        return (0, _executeLifecycleScript().execFromManifest)(this, commandName, cwd || this.cwd);
      }
    }

/**
     * Generate an absolute temporary filename location based on the input filename.
     */
  }, {
    key: "getTemp",
    value: function getTemp(filename) {
      invariant(this.tempFolder, 'No temp folder');
      return path.join(this.tempFolder, filename);
    }

/**
     * Remote packages may be cached in a file system to be available for offline installation.
     * Second time the same package needs to be installed it will be loaded from there.
     * Given a package's filename, return a path in the offline mirror location.
     */
  }, {
    key: "getOfflineMirrorPath",
    value: function getOfflineMirrorPath(packageFilename) {
      var mirrorPath;
      for (var _i2 = 0, _arr = ['npm', 'yarn']; _i2 < _arr.length; _i2++) {
        var _key2 = _arr[_i2];
        var registry = this.registries[_key2];
        if (registry == null) {
          continue;
        }
        var registryMirrorPath = registry.config['yarn-offline-mirror'];
        if (registryMirrorPath === false) {
          return null;
        }
        if (registryMirrorPath == null) {
          continue;
        }
        mirrorPath = registryMirrorPath;
      }
      if (mirrorPath == null) {
        return null;
      }
      if (packageFilename == null) {
        return mirrorPath;
      }
      return path.join(mirrorPath, path.basename(packageFilename));
    }

/**
     * Checker whether the folder input is a valid module folder. We output a yarn metadata
     * file when we've successfully setup a folder so use this as a marker.
     */
  }, {
    key: "isValidModuleDest",
    value: function () {
      var _isValidModuleDest = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee3(dest) {
        return _regenerator()["default"].wrap(function _callee3$(_context4) {
          while (1) switch (_context4.prev = _context4.next) {
            case 0:
              _context4.next = 2;
              return fs().exists(dest);
            case 2:
              if (_context4.sent) {
                _context4.next = 4;
                break;
              }
              return _context4.abrupt("return", false);
            case 4:
              _context4.next = 6;
              return fs().exists(path.join(dest, constants().METADATA_FILENAME));
            case 6:
              if (_context4.sent) {
                _context4.next = 8;
                break;
              }
              return _context4.abrupt("return", false);
            case 8:
              return _context4.abrupt("return", true);
            case 9:
            case "end":
              return _context4.stop();
          }
        }, _callee3);
      }));
      function isValidModuleDest(_x) {
        return _isValidModuleDest.apply(this, arguments);
      }
      return isValidModuleDest;
    }()
    /**
     * Read package metadata and normalized package info.
     */
  }, {
    key: "readPackageMetadata",
    value: function readPackageMetadata(dir) {
      var _this3 = this;
      return this.getCache("metadata-".concat(dir), /*#__PURE__*/(0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee4() {
        var metadata, pkg;
        return _regenerator()["default"].wrap(function _callee4$(_context5) {
          while (1) switch (_context5.prev = _context5.next) {
            case 0:
              _context5.next = 2;
              return _this3.readJson(path.join(dir, constants().METADATA_FILENAME));
            case 2:
              metadata = _context5.sent;
              _context5.next = 5;
              return _this3.readManifest(dir, metadata.registry);
            case 5:
              pkg = _context5.sent;
              return _context5.abrupt("return", {
                "package": pkg,
                artifacts: metadata.artifacts || [],
                hash: metadata.hash,
                remote: metadata.remote,
                registry: metadata.registry
              });
            case 7:
            case "end":
              return _context5.stop();
          }
        }, _callee4);
      })));
    }

/**
     * Read normalized package info according yarn-metadata.json
     * throw an error if package.json was not found
     */
  }, {
    key: "readManifest",
    value: function readManifest(dir, priorityRegistry) {
      var _this4 = this;
      var isRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      return this.getCache("manifest-".concat(dir), /*#__PURE__*/(0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee5() {
        var manifest;
        return _regenerator()["default"].wrap(function _callee5$(_context6) {
          while (1) switch (_context6.prev = _context6.next) {
            case 0:
              _context6.next = 2;
              return _this4.maybeReadManifest(dir, priorityRegistry, isRoot);
            case 2:
              manifest = _context6.sent;
              if (!manifest) {
                _context6.next = 7;
                break;
              }
              return _context6.abrupt("return", manifest);
            case 7:
              throw new (_errors().MessageError)(_this4.reporter.lang('couldntFindPackagejson', dir), 'ENOENT');
            case 8:
            case "end":
              return _context6.stop();
          }
        }, _callee5);
      })));
    }

/**
     * try get the manifest file by looking
     * 1. manifest file in cache
     * 2. manifest file in registry
     */
  }, {
    key: "maybeReadManifest",
    value: function () {
      var _maybeReadManifest = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee6(dir, priorityRegistry) {
        var isRoot,
          metadataLoc,
          metadata,
          file,
          _i3,
          _Object$keys2,
          registry,
          _file,
          _args7 = arguments;
        return _regenerator()["default"].wrap(function _callee6$(_context7) {
          while (1) switch (_context7.prev = _context7.next) {
            case 0:
              isRoot = _args7.length > 2 && _args7[2] !== undefined ? _args7[2] : false;
              metadataLoc = path.join(dir, constants().METADATA_FILENAME);
              _context7.next = 4;
              return fs().exists(metadataLoc);
            case 4:
              if (!_context7.sent) {
                _context7.next = 11;
                break;
              }
              _context7.next = 7;
              return this.readJson(metadataLoc);
            case 7:
              metadata = _context7.sent;
              if (!priorityRegistry) {
                priorityRegistry = metadata.priorityRegistry;
              }
              if (!(typeof metadata.manifest !== 'undefined')) {
                _context7.next = 11;
                break;
              }
              return _context7.abrupt("return", metadata.manifest);
            case 11:
              if (!priorityRegistry) {
                _context7.next = 17;
                break;
              }
              _context7.next = 14;
              return this.tryManifest(dir, priorityRegistry, isRoot);
            case 14:
              file = _context7.sent;
              if (!file) {
                _context7.next = 17;
                break;
              }
              return _context7.abrupt("return", file);
            case 17:
              _i3 = 0, _Object$keys2 = Object.keys(_index2().registries);
            case 18:
              if (!(_i3 < _Object$keys2.length)) {
                _context7.next = 30;
                break;
              }
              registry = _Object$keys2[_i3];
              if (!(priorityRegistry === registry)) {
                _context7.next = 22;
                break;
              }
              return _context7.abrupt("continue", 27);
            case 22:
              _context7.next = 24;
              return this.tryManifest(dir, registry, isRoot);
            case 24:
              _file = _context7.sent;
              if (!_file) {
                _context7.next = 27;
                break;
              }
              return _context7.abrupt("return", _file);
            case 27:
              _i3++;
              _context7.next = 18;
              break;
            case 30:
              return _context7.abrupt("return", null);
            case 31:
            case "end":
              return _context7.stop();
          }
        }, _callee6, this);
      }));
      function maybeReadManifest(_x2, _x3) {
        return _maybeReadManifest.apply(this, arguments);
      }
      return maybeReadManifest;
    }()
    /**
     * Read the root manifest.
     */
  }, {
    key: "readRootManifest",
    value: function readRootManifest() {
      return this.readManifest(this.cwd, 'npm', true);
    }

/**
     * Try and find package info with the input directory and registry.
     */
  }, {
    key: "tryManifest",
    value: function () {
      var _tryManifest = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee7(dir, registry, isRoot) {
        var filename, loc, data;
        return _regenerator()["default"].wrap(function _callee7$(_context8) {
          while (1) switch (_context8.prev = _context8.next) {
            case 0:
              filename = _index2().registries[registry].filename;
              loc = path.join(dir, filename);
              _context8.next = 4;
              return fs().exists(loc);
            case 4:
              if (!_context8.sent) {
                _context8.next = 13;
                break;
              }
              _context8.next = 7;
              return this.readJson(loc);
            case 7:
              data = _context8.sent;
              data._registry = registry;
              data._loc = loc;
              return _context8.abrupt("return", (0, _index()["default"])(data, dir, this, isRoot));
            case 13:
              return _context8.abrupt("return", null);
            case 14:
            case "end":
              return _context8.stop();
          }
        }, _callee7, this);
      }));
      function tryManifest(_x4, _x5, _x6) {
        return _tryManifest.apply(this, arguments);
      }
      return tryManifest;
    }()
  }, {
    key: "findManifest",
    value: function () {
      var _findManifest = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee8(dir, isRoot) {
        var _iterator4, _step4, registry, manifest;
        return _regenerator()["default"].wrap(function _callee8$(_context9) {
          while (1) switch (_context9.prev = _context9.next) {
            case 0:
              _iterator4 = _createForOfIteratorHelper(_index2().registryNames);
              _context9.prev = 1;
              _iterator4.s();
            case 3:
              if ((_step4 = _iterator4.n()).done) {
                _context9.next = 12;
                break;
              }
              registry = _step4.value;
              _context9.next = 7;
              return this.tryManifest(dir, registry, isRoot);
            case 7:
              manifest = _context9.sent;
              if (!manifest) {
                _context9.next = 10;
                break;
              }
              return _context9.abrupt("return", manifest);
            case 10:
              _context9.next = 3;
              break;
            case 12:
              _context9.next = 17;
              break;
            case 14:
              _context9.prev = 14;
              _context9.t0 = _context9["catch"](1);
              _iterator4.e(_context9.t0);
            case 17:
              _context9.prev = 17;
              _iterator4.f();
              return _context9.finish(17);
            case 20:
              return _context9.abrupt("return", null);
            case 21:
            case "end":
              return _context9.stop();
          }
        }, _callee8, this, [[1, 14, 17, 20]]);
      }));
      function findManifest(_x7, _x8) {
        return _findManifest.apply(this, arguments);
      }
      return findManifest;
    }()
  }, {
    key: "findWorkspaceRoot",
    value: function () {
      var _findWorkspaceRoot = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee9(initial) {
        var previous, current, manifest, ws, relativePath;
        return _regenerator()["default"].wrap(function _callee9$(_context10) {
          while (1) switch (_context10.prev = _context10.next) {
            case 0:
              previous = null;
              current = path.normalize(initial);
              _context10.next = 4;
              return fs().exists(current);
            case 4:
              if (_context10.sent) {
                _context10.next = 6;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('folderMissing', current));
            case 6:
              _context10.next = 8;
              return this.findManifest(current, true);
            case 8:
              manifest = _context10.sent;
              ws = extractWorkspaces(manifest);
              if (!(ws && ws.packages)) {
                _context10.next = 17;
                break;
              }
              relativePath = path.relative(current, initial);
              if (!(relativePath === '' || micromatch([relativePath], ws.packages).length > 0)) {
                _context10.next = 16;
                break;
              }
              return _context10.abrupt("return", current);
            case 16:
              return _context10.abrupt("return", null);
            case 17:
              previous = current;
              current = path.dirname(current);
            case 19:
              if (current !== previous) {
                _context10.next = 6;
                break;
              }
            case 20:
              return _context10.abrupt("return", null);
            case 21:
            case "end":
              return _context10.stop();
          }
        }, _callee9, this);
      }));
      function findWorkspaceRoot(_x9) {
        return _findWorkspaceRoot.apply(this, arguments);
      }
      return findWorkspaceRoot;
    }()
  }, {
    key: "resolveWorkspaces",
    value: function () {
      var _resolveWorkspaces = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee10(root, rootManifest) {
        var _this5 = this,
          _ref3;
        var workspaces, ws, patterns, registryFilenames, trailingPattern, ignorePatterns, files, _iterator5, _step5, file, loc, manifest;
        return _regenerator()["default"].wrap(function _callee10$(_context11) {
          while (1) switch (_context11.prev = _context11.next) {
            case 0:
              workspaces = {};
              if (this.workspacesEnabled) {
                _context11.next = 3;
                break;
              }
              return _context11.abrupt("return", workspaces);
            case 3:
              ws = this.getWorkspaces(rootManifest, true);
              patterns = ws && ws.packages ? ws.packages : [];
              if (Array.isArray(patterns)) {
                _context11.next = 7;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('workspacesSettingMustBeArray'));
            case 7:
              registryFilenames = _index2().registryNames.map(function (registryName) {
                return _this5.registries[registryName].constructor.filename;
              }).join('|');
              trailingPattern = "/+(".concat(registryFilenames, ")"); // anything under folder (node_modules) should be ignored, thus use the '**' instead of shallow match "*"
              ignorePatterns = this.registryFolders.map(function (folder) {
                return "/".concat(folder, "/**/+(").concat(registryFilenames, ")");
              });
              _context11.next = 12;
              return Promise.all(patterns.map(function (pattern) {
                return fs().glob(pattern.replace(/\/?$/, trailingPattern), {
                  cwd: root,
                  ignore: ignorePatterns.map(function (ignorePattern) {
                    return pattern.replace(/\/?$/, ignorePattern);
                  })
                });
              }));
            case 12:
              files = _context11.sent;
              _iterator5 = _createForOfIteratorHelper(new Set((_ref3 = []).concat.apply(_ref3, (0, _toConsumableArray2()["default"])(files))));
              _context11.prev = 14;
              _iterator5.s();
            case 16:
              if ((_step5 = _iterator5.n()).done) {
                _context11.next = 35;
                break;
              }
              file = _step5.value;
              loc = path.join(root, path.dirname(file));
              _context11.next = 21;
              return this.findManifest(loc, false);
            case 21:
              manifest = _context11.sent;
              if (manifest) {
                _context11.next = 24;
                break;
              }
              return _context11.abrupt("continue", 33);
            case 24:
              if (manifest.name) {
                _context11.next = 27;
                break;
              }
              this.reporter.warn(this.reporter.lang('workspaceNameMandatory', loc));
              return _context11.abrupt("continue", 33);
            case 27:
              if (manifest.version) {
                _context11.next = 30;
                break;
              }
              this.reporter.warn(this.reporter.lang('workspaceVersionMandatory', loc));
              return _context11.abrupt("continue", 33);
            case 30:
              if (!Object.prototype.hasOwnProperty.call(workspaces, manifest.name)) {
                _context11.next = 32;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('workspaceNameDuplicate', manifest.name));
            case 32:
              workspaces[manifest.name] = {
                loc: loc,
                manifest: manifest
              };
            case 33:
              _context11.next = 16;
              break;
            case 35:
              _context11.next = 40;
              break;
            case 37:
              _context11.prev = 37;
              _context11.t0 = _context11["catch"](14);
              _iterator5.e(_context11.t0);
            case 40:
              _context11.prev = 40;
              _iterator5.f();
              return _context11.finish(40);
            case 43:
              return _context11.abrupt("return", workspaces);
            case 44:
            case "end":
              return _context11.stop();
          }
        }, _callee10, this, [[14, 37, 40, 43]]);
      }));
      function resolveWorkspaces(_x10, _x11) {
        return _resolveWorkspaces.apply(this, arguments);
      }
      return resolveWorkspaces;
    }() // workspaces functions
  }, {
    key: "getWorkspaces",
    value: function getWorkspaces(manifest) {
      var shouldThrow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      if (!manifest || !this.workspacesEnabled) {
        return undefined;
      }
      var ws = extractWorkspaces(manifest);
      if (!ws) {
        return ws;
      }

// validate eligibility
      var wsCopy = _objectSpread({}, ws);
      var warnings = [];
      var errors = [];

// packages
      if (wsCopy.packages && wsCopy.packages.length > 0 && !manifest["private"]) {
        errors.push(this.reporter.lang('workspacesRequirePrivateProjects'));
        wsCopy = undefined;
      }
      // nohoist
      if (wsCopy && wsCopy.nohoist && wsCopy.nohoist.length > 0) {
        if (!this.workspacesNohoistEnabled) {
          warnings.push(this.reporter.lang('workspacesNohoistDisabled', manifest.name));
          wsCopy.nohoist = undefined;
        } else if (!manifest["private"]) {
          errors.push(this.reporter.lang('workspacesNohoistRequirePrivatePackages', manifest.name));
          wsCopy.nohoist = undefined;
        }
      }
      if (errors.length > 0 && shouldThrow) {
        throw new (_errors().MessageError)(errors.join('\n'));
      }
      var msg = errors.concat(warnings).join('\n');
      if (msg.length > 0) {
        this.reporter.warn(msg);
      }
      return wsCopy;
    }

/**
     * Description
     */
  }, {
    key: "getFolder",
    value: function getFolder(pkg) {
      var registryName = pkg._registry;
      if (!registryName) {
        var ref = pkg._reference;
        invariant(ref, 'expected reference');
        registryName = ref.registry;
      }
      return this.registries[registryName].folder;
    }

/**
     * Get root manifests.
     */
  }, {
    key: "getRootManifests",
    value: function () {
      var _getRootManifests = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee11() {
        var manifests, _iterator6, _step6, _registryName, registry, jsonLoc, object, exists, indent, info;
        return _regenerator()["default"].wrap(function _callee11$(_context12) {
          while (1) switch (_context12.prev = _context12.next) {
            case 0:
              manifests = {};
              _iterator6 = _createForOfIteratorHelper(_index2().registryNames);
              _context12.prev = 2;
              _iterator6.s();
            case 4:
              if ((_step6 = _iterator6.n()).done) {
                _context12.next = 23;
                break;
              }
              _registryName = _step6.value;
              registry = _index2().registries[_registryName];
              jsonLoc = path.join(this.cwd, registry.filename);
              object = {};
              exists = false;
              indent = void 0;
              _context12.next = 13;
              return fs().exists(jsonLoc);
            case 13:
              if (!_context12.sent) {
                _context12.next = 20;
                break;
              }
              exists = true;
              _context12.next = 17;
              return this.readJson(jsonLoc, fs().readJsonAndFile);
            case 17:
              info = _context12.sent;
              object = info.object;
              indent = detectIndent(info.content).indent || undefined;
            case 20:
              manifests[_registryName] = {
                loc: jsonLoc,
                object: object,
                exists: exists,
                indent: indent
              };
            case 21:
              _context12.next = 4;
              break;
            case 23:
              _context12.next = 28;
              break;
            case 25:
              _context12.prev = 25;
              _context12.t0 = _context12["catch"](2);
              _iterator6.e(_context12.t0);
            case 28:
              _context12.prev = 28;
              _iterator6.f();
              return _context12.finish(28);
            case 31:
              return _context12.abrupt("return", manifests);
            case 32:
            case "end":
              return _context12.stop();
          }
        }, _callee11, this, [[2, 25, 28, 31]]);
      }));
      function getRootManifests() {
        return _getRootManifests.apply(this, arguments);
      }
      return getRootManifests;
    }()
    /**
     * Save root manifests.
     */
  }, {
    key: "saveRootManifests",
    value: function () {
      var _saveRootManifests = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee12(manifests) {
        var _iterator7, _step7, _registryName2, _manifests$_registryN, loc, object, exists, indent, _iterator8, _step8, field;
        return _regenerator()["default"].wrap(function _callee12$(_context13) {
          while (1) switch (_context13.prev = _context13.next) {
            case 0:
              _iterator7 = _createForOfIteratorHelper(_index2().registryNames);
              _context13.prev = 1;
              _iterator7.s();
            case 3:
              if ((_step7 = _iterator7.n()).done) {
                _context13.next = 14;
                break;
              }
              _registryName2 = _step7.value;
              _manifests$_registryN = manifests[_registryName2], loc = _manifests$_registryN.loc, object = _manifests$_registryN.object, exists = _manifests$_registryN.exists, indent = _manifests$_registryN.indent;
              if (!(!exists && !Object.keys(object).length)) {
                _context13.next = 8;
                break;
              }
              return _context13.abrupt("continue", 12);
            case 8:
              _iterator8 = _createForOfIteratorHelper(constants().DEPENDENCY_TYPES);
              try {
                for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
                  field = _step8.value;
                  if (object[field]) {
                    object[field] = sortObject(object[field]);
                  }
                }
              } catch (err) {
                _iterator8.e(err);
              } finally {
                _iterator8.f();
              }
              _context13.next = 12;
              return fs().writeFilePreservingEol(loc, JSON.stringify(object, null, indent || constants().DEFAULT_INDENT) + '\n');
            case 12:
              _context13.next = 3;
              break;
            case 14:
              _context13.next = 19;
              break;
            case 16:
              _context13.prev = 16;
              _context13.t0 = _context13["catch"](1);
              _iterator7.e(_context13.t0);
            case 19:
              _context13.prev = 19;
              _iterator7.f();
              return _context13.finish(19);
            case 22:
            case "end":
              return _context13.stop();
          }
        }, _callee12, null, [[1, 16, 19, 22]]);
      }));
      function saveRootManifests(_x12) {
        return _saveRootManifests.apply(this, arguments);
      }
      return saveRootManifests;
    }()
    /**
     * Call the passed factory (defaults to fs.readJson) and rethrow a pretty error message if it was the result
     * of a syntax error.
     */
  }, {
    key: "readJson",
    value: function readJson(loc) {
      var factory = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : fs().readJson;
      try {
        return factory(loc);
      } catch (err) {
        if (err instanceof SyntaxError) {
          throw new (_errors().MessageError)(this.reporter.lang('jsonError', loc, err.message));
        } else {
          throw err;
        }
      }
    }
  }], [{
    key: "create",
    value: function () {
      var _create = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee13() {
        var opts,
          reporter,
          config,
          _args14 = arguments;
        return _regenerator()["default"].wrap(function _callee13$(_context14) {
          while (1) switch (_context14.prev = _context14.next) {
            case 0:
              opts = _args14.length > 0 && _args14[0] !== undefined ? _args14[0] : {};
              reporter = _args14.length > 1 && _args14[1] !== undefined ? _args14[1] : new (_index3().NoopReporter)();
              config = new Config(reporter);
              _context14.next = 5;
              return config.init(opts);
            case 5:
              return _context14.abrupt("return", config);
            case 6:
            case "end":
              return _context14.stop();
          }
        }, _callee13);
      }));
      function create() {
        return _create.apply(this, arguments);
      }
      return create;
    }()
  }]);
  return Config;
}();
exports["default"] = Config;
function extractWorkspaces(manifest) {
  if (!manifest || !manifest.workspaces) {
    return undefined;
  }
  if (Array.isArray(manifest.workspaces)) {
    return {
      packages: manifest.workspaces
    };
  }
  if (manifest.workspaces.packages && Array.isArray(manifest.workspaces.packages) || manifest.workspaces.nohoist && Array.isArray(manifest.workspaces.nohoist)) {
    return manifest.workspaces;
  }
  return undefined;
}
//# sourceMappingURL=config.js.map

Fairnetzt-Hochrhein | Vernetzung . Nachhaltigkeit . Gemeinschaft

VERNETZUNG

NACHHALTIGKEIT

GEMEINSCHAFT

VERANTWORTUNG

Willkommen auf Fairnetzt-Hochrhein,

Auf beiden Seiten der Rheingrenze gibt es viele Initiativen, Organisationen, Vereine und auch engagierte Einzelpersonen, welche sich für eine nachhaltige, lebenswerte Zukunft in unserer Region und darüber hinaus einsetzen.

Mit Fairnetzt-Hochrhein.de wollen wir eine Plattform bieten, welche auf lebendige und unkomplizierte Weise es Gruppen aus dem Landkreis Waldshut und aus den Kantonen Aargau und Schaffhausen ermöglicht, Veranstaltungen zu veröffentlichen und andererseits interessierte Menschen erfahren können, was wo stattfindet.

Wir wünschen Euch und uns allen
Ein Gutes Leben und Freude am Abenteuer der Mitgestaltung unserer eigenen Zukunft.

Das Redaktionsteam von Fairnetzt Hochrhein

Direktlink zu: Ihre Veranstaltungen einstellen? oder Anmeldung zum Newsletter?

Veranstaltungen

Dritter Nachhaltigkeitsstammtisch in Dogern

Ziel der Treffen ist, miteinander und voneinander zu lernen, wie man sich in verschiedenen Alltagsbereichen nachhaltiger verhalten kann:
• Einkauf von Dingen des täglichen und langfristigen Bedarfs
• Essen
• Energie sparen und erzeugen
• Unterwegs sein und Reisen, Mobilität
• Informationsaustausch
• …………
Jede*r ist willkommen, sich mit seinen und ihren Fragen und Erfahrungen einzubringen.
Grundidee: wir sind alle in bestimmten Lebensbereichen „Expert*innen“ und können so andere mit unserem Wissen bereichern und bei der Umsetzung im Alltag unterstützen.