JezK

Edit File: package-request.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _typeof = require("@babel/runtime/helpers/typeof");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
function _regenerator() {
  var data = _interopRequireDefault(require("@babel/runtime/regenerator"));
  _regenerator = function _regenerator() {
    return data;
  };
  return data;
}
function _toConsumableArray2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
  _toConsumableArray2 = function _toConsumableArray2() {
    return data;
  };
  return data;
}
function _asyncToGenerator2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
  _asyncToGenerator2 = function _asyncToGenerator2() {
    return data;
  };
  return data;
}
function _classCallCheck2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
  _classCallCheck2 = function _classCallCheck2() {
    return data;
  };
  return data;
}
function _createClass2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
  _createClass2 = function _createClass2() {
    return data;
  };
  return data;
}
function _defineProperty2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
  _defineProperty2 = function _defineProperty2() {
    return data;
  };
  return data;
}
function _path() {
  var data = _interopRequireDefault(require("path"));
  _path = function _path() {
    return data;
  };
  return data;
}
function _invariant() {
  var data = _interopRequireDefault(require("invariant"));
  _invariant = function _invariant() {
    return data;
  };
  return data;
}
function _semver() {
  var data = _interopRequireDefault(require("semver"));
  _semver = function _semver() {
    return data;
  };
  return data;
}
function _validate() {
  var data = require("./util/normalize-manifest/validate.js");
  _validate = function _validate() {
    return data;
  };
  return data;
}
function _lockfile() {
  var data = _interopRequireDefault(require("./lockfile"));
  _lockfile = function _lockfile() {
    return data;
  };
  return data;
}
function _packageReference() {
  var data = _interopRequireDefault(require("./package-reference.js"));
  _packageReference = function _packageReference() {
    return data;
  };
  return data;
}
function _index() {
  var data = require("./resolvers/index.js");
  _index = function _index() {
    return data;
  };
  return data;
}
function _errors() {
  var data = require("./errors.js");
  _errors = function _errors() {
    return data;
  };
  return data;
}
function constants() {
  var data = _interopRequireWildcard(require("./constants.js"));
  constants = function constants() {
    return data;
  };
  return data;
}
function versionUtil() {
  var data = _interopRequireWildcard(require("./util/version.js"));
  versionUtil = function versionUtil() {
    return data;
  };
  return data;
}
function _workspaceResolver() {
  var data = _interopRequireDefault(require("./resolvers/contextual/workspace-resolver.js"));
  _workspaceResolver = function _workspaceResolver() {
    return data;
  };
  return data;
}
function fs() {
  var data = _interopRequireWildcard(require("./util/fs.js"));
  fs = function fs() {
    return data;
  };
  return data;
}
function _normalizePattern4() {
  var data = require("./util/normalize-pattern.js");
  _normalizePattern4 = function _normalizePattern4() {
    return data;
  };
  return data;
}
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
var micromatch = require('micromatch');
var PackageRequest = /*#__PURE__*/function () {
  function PackageRequest(req, resolver) {
    (0, _classCallCheck2()["default"])(this, PackageRequest);
    (0, _defineProperty2()["default"])(this, "parentRequest", void 0);
    (0, _defineProperty2()["default"])(this, "parentNames", void 0);
    (0, _defineProperty2()["default"])(this, "lockfile", void 0);
    (0, _defineProperty2()["default"])(this, "reporter", void 0);
    (0, _defineProperty2()["default"])(this, "resolver", void 0);
    (0, _defineProperty2()["default"])(this, "pattern", void 0);
    (0, _defineProperty2()["default"])(this, "config", void 0);
    (0, _defineProperty2()["default"])(this, "registry", void 0);
    (0, _defineProperty2()["default"])(this, "optional", void 0);
    (0, _defineProperty2()["default"])(this, "hint", void 0);
    (0, _defineProperty2()["default"])(this, "foundInfo", void 0);
    this.parentRequest = req.parentRequest;
    this.parentNames = req.parentNames || [];
    this.lockfile = resolver.lockfile;
    this.registry = req.registry;
    this.reporter = resolver.reporter;
    this.resolver = resolver;
    this.optional = req.optional;
    this.hint = req.hint;
    this.pattern = req.pattern;
    this.config = resolver.config;
    this.foundInfo = null;
  }
  (0, _createClass2()["default"])(PackageRequest, [{
    key: "init",
    value: function init() {
      this.resolver.usedRegistries.add(this.registry);
    }
  }, {
    key: "getLocked",
    value: function getLocked(remoteType) {
      // always prioritise root lockfile
      var shrunk = this.lockfile.getLocked(this.pattern);
      if (shrunk && shrunk.resolved) {
        var resolvedParts = versionUtil().explodeHashedUrl(shrunk.resolved);

// Detect Git protocols (git://HOST/PATH or git+PROTOCOL://HOST/PATH)
        var preferredRemoteType = /^git(\+[a-z0-9]+)?:\/\//.test(resolvedParts.url) ? 'git' : remoteType;
        return {
          name: shrunk.name,
          version: shrunk.version,
          _uid: shrunk.uid,
          _remote: {
            resolved: shrunk.resolved,
            type: preferredRemoteType,
            reference: resolvedParts.url,
            hash: resolvedParts.hash,
            integrity: shrunk.integrity,
            registry: shrunk.registry,
            packageName: shrunk.name
          },
          optionalDependencies: shrunk.optionalDependencies || {},
          dependencies: shrunk.dependencies || {},
          prebuiltVariants: shrunk.prebuiltVariants || {}
        };
      } else {
        return null;
      }
    }

/**
     * If the input pattern matches a registry one then attempt to find it on the registry.
     * Otherwise fork off to an exotic resolver if one matches.
     */
  }, {
    key: "findVersionOnRegistry",
    value: function () {
      var _findVersionOnRegistry = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee(pattern) {
        var _yield$this$normalize, range, name, exoticResolver, data, Resolver, resolver;
        return _regenerator()["default"].wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return this.normalize(pattern);
            case 2:
              _yield$this$normalize = _context.sent;
              range = _yield$this$normalize.range;
              name = _yield$this$normalize.name;
              exoticResolver = (0, _index().getExoticResolver)(range);
              if (!exoticResolver) {
                _context.next = 13;
                break;
              }
              _context.next = 9;
              return this.findExoticVersionInfo(exoticResolver, range);
            case 9:
              data = _context.sent;
              // clone data as we're manipulating it in place and this could be resolved multiple
              // times
              data = Object.assign({}, data);

// this is so the returned package response uses the overridden name. ie. if the
              // package's actual name is `bar`, but it's been specified in the manifest like:
              //   "foo": "http://foo.com/bar.tar.gz"
              // then we use the foo name
              data.name = name;
              return _context.abrupt("return", data);
            case 13:
              Resolver = this.getRegistryResolver();
              resolver = new Resolver(this, name, range);
              _context.prev = 15;
              _context.next = 18;
              return resolver.resolve();
            case 18:
              return _context.abrupt("return", _context.sent);
            case 21:
              _context.prev = 21;
              _context.t0 = _context["catch"](15);
              if (!(!(_context.t0 instanceof _errors().MessageError) && this.parentRequest && this.parentRequest.pattern)) {
                _context.next = 25;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('requiredPackageNotFoundRegistry', pattern, this.parentRequest.pattern, this.registry));
            case 25:
              throw _context.t0;
            case 26:
            case "end":
              return _context.stop();
          }
        }, _callee, this, [[15, 21]]);
      }));
      function findVersionOnRegistry(_x) {
        return _findVersionOnRegistry.apply(this, arguments);
      }
      return findVersionOnRegistry;
    }()
    /**
     * Get the registry resolver associated with this package request.
     */
  }, {
    key: "getRegistryResolver",
    value: function getRegistryResolver() {
      var Resolver = _index().registries[this.registry];
      if (Resolver) {
        return Resolver;
      } else {
        throw new (_errors().MessageError)(this.reporter.lang('unknownRegistryResolver', this.registry));
      }
    }
  }, {
    key: "normalizeRange",
    value: function () {
      var _normalizeRange = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee2(pattern) {
        return _regenerator()["default"].wrap(function _callee2$(_context2) {
          while (1) switch (_context2.prev = _context2.next) {
            case 0:
              if (!(pattern.indexOf(':') > -1 || pattern.indexOf('@') > -1 || (0, _index().getExoticResolver)(pattern))) {
                _context2.next = 2;
                break;
              }
              return _context2.abrupt("return", pattern);
            case 2:
              if (_semver()["default"].validRange(pattern)) {
                _context2.next = 13;
                break;
              }
              _context2.prev = 3;
              _context2.next = 6;
              return fs().exists(_path()["default"].join(this.config.cwd, pattern, constants().NODE_PACKAGE_JSON));
            case 6:
              if (!_context2.sent) {
                _context2.next = 9;
                break;
              }
              this.reporter.warn(this.reporter.lang('implicitFileDeprecated', pattern));
              return _context2.abrupt("return", "file:".concat(pattern));
            case 9:
              _context2.next = 13;
              break;
            case 11:
              _context2.prev = 11;
              _context2.t0 = _context2["catch"](3);
            case 13:
              return _context2.abrupt("return", pattern);
            case 14:
            case "end":
              return _context2.stop();
          }
        }, _callee2, this, [[3, 11]]);
      }));
      function normalizeRange(_x2) {
        return _normalizeRange.apply(this, arguments);
      }
      return normalizeRange;
    }()
  }, {
    key: "normalize",
    value: function () {
      var _normalize = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee3(pattern) {
        var _normalizePattern, name, range, hasVersion, newRange;
        return _regenerator()["default"].wrap(function _callee3$(_context3) {
          while (1) switch (_context3.prev = _context3.next) {
            case 0:
              _normalizePattern = (0, _normalizePattern4().normalizePattern)(pattern), name = _normalizePattern.name, range = _normalizePattern.range, hasVersion = _normalizePattern.hasVersion;
              _context3.next = 3;
              return this.normalizeRange(range);
            case 3:
              newRange = _context3.sent;
              return _context3.abrupt("return", {
                name: name,
                range: newRange,
                hasVersion: hasVersion
              });
            case 5:
            case "end":
              return _context3.stop();
          }
        }, _callee3, this);
      }));
      function normalize(_x3) {
        return _normalize.apply(this, arguments);
      }
      return normalize;
    }()
    /**
     * Construct an exotic resolver instance with the input `ExoticResolver` and `range`.
     */
  }, {
    key: "findExoticVersionInfo",
    value: function findExoticVersionInfo(ExoticResolver, range) {
      var resolver = new ExoticResolver(this, range);
      return resolver.resolve();
    }

/**
     * If the current pattern matches an exotic resolver then delegate to it or else try
     * the registry.
     */
  }, {
    key: "findVersionInfo",
    value: function () {
      var _findVersionInfo = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee4() {
        var exoticResolver, resolver, manifest, localInfo, localManifest, requestPattern;
        return _regenerator()["default"].wrap(function _callee4$(_context4) {
          while (1) switch (_context4.prev = _context4.next) {
            case 0:
              exoticResolver = (0, _index().getExoticResolver)(this.pattern);
              if (!exoticResolver) {
                _context4.next = 5;
                break;
              }
              return _context4.abrupt("return", this.findExoticVersionInfo(exoticResolver, this.pattern));
            case 5:
              if (!_workspaceResolver()["default"].isWorkspace(this.pattern, this.resolver.workspaceLayout)) {
                _context4.next = 19;
                break;
              }
              (0, _invariant()["default"])(this.resolver.workspaceLayout, 'expected workspaceLayout');
              resolver = new (_workspaceResolver()["default"])(this, this.pattern, this.resolver.workspaceLayout);
              if (!(this.config.focus && !this.pattern.includes(this.resolver.workspaceLayout.virtualManifestName) && !this.pattern.startsWith(this.config.focusedWorkspaceName + '@'))) {
                _context4.next = 16;
                break;
              }
              localInfo = this.resolver.workspaceLayout.getManifestByPattern(this.pattern);
              (0, _invariant()["default"])(localInfo, 'expected local info for ' + this.pattern);
              localManifest = localInfo.manifest;
              requestPattern = localManifest.name + '@' + localManifest.version;
              _context4.next = 15;
              return this.findVersionOnRegistry(requestPattern);
            case 15:
              manifest = _context4.sent;
            case 16:
              return _context4.abrupt("return", resolver.resolve(manifest));
            case 19:
              return _context4.abrupt("return", this.findVersionOnRegistry(this.pattern));
            case 20:
            case "end":
              return _context4.stop();
          }
        }, _callee4, this);
      }));
      function findVersionInfo() {
        return _findVersionInfo.apply(this, arguments);
      }
      return findVersionInfo;
    }()
  }, {
    key: "reportResolvedRangeMatch",
    value: function reportResolvedRangeMatch(info, resolved) {}

/**
     * Do the final resolve of a package that had a match with an existing version.
     * After all unique versions have been discovered, so the best available version
     * is found.
     */
  }, {
    key: "resolveToExistingVersion",
    value: function resolveToExistingVersion(info) {
      // get final resolved version
      var _normalizePattern2 = (0, _normalizePattern4().normalizePattern)(this.pattern),
        range = _normalizePattern2.range,
        name = _normalizePattern2.name;
      var solvedRange = _semver()["default"].validRange(range) ? info.version : range;
      var resolved = this.resolver.getHighestRangeVersionMatch(name, solvedRange, info);
      (0, _invariant()["default"])(resolved, 'should have a resolved reference');
      this.reportResolvedRangeMatch(info, resolved);
      var ref = resolved._reference;
      (0, _invariant()["default"])(ref, 'Resolved package info has no package reference');
      ref.addRequest(this);
      ref.addPattern(this.pattern, resolved);
      ref.addOptional(this.optional);
    }

/**
     * TODO description
     */
  }, {
    key: "find",
    value: function () {
      var _find = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee5(_ref) {
        var fresh, frozen, info, _normalizePattern3, range, name, solvedRange, resolved, remote, ref, promises, deps, parentNames, depName, depPattern, _depName, _depPattern, _depName2, _depPattern2, _i, _promises, promise, _iterator, _step, otherRequest;
        return _regenerator()["default"].wrap(function _callee5$(_context5) {
          while (1) switch (_context5.prev = _context5.next) {
            case 0:
              fresh = _ref.fresh, frozen = _ref.frozen;
              _context5.next = 3;
              return this.findVersionInfo();
            case 3:
              info = _context5.sent;
              if (_semver()["default"].valid(info.version)) {
                _context5.next = 6;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('invalidPackageVersion', info.name, info.version));
            case 6:
              info.fresh = fresh;
              (0, _validate().cleanDependencies)(info, false, this.reporter, function () {
                // swallow warnings
              });

// check if while we were resolving this dep we've already resolved one that satisfies
              // the same range
              _normalizePattern3 = (0, _normalizePattern4().normalizePattern)(this.pattern), range = _normalizePattern3.range, name = _normalizePattern3.name;
              solvedRange = _semver()["default"].validRange(range) ? info.version : range;
              resolved = !info.fresh || frozen ? this.resolver.getExactVersionMatch(name, solvedRange, info) : this.resolver.getHighestRangeVersionMatch(name, solvedRange, info);
              if (!resolved) {
                _context5.next = 14;
                break;
              }
              this.resolver.reportPackageWithExistingVersion(this, info);
              return _context5.abrupt("return");
            case 14:
              if (!(info.flat && !this.resolver.flat)) {
                _context5.next = 16;
                break;
              }
              throw new (_errors().MessageError)(this.reporter.lang('flatGlobalError', "".concat(info.name, "@").concat(info.version)));
            case 16:
              // validate version info
              PackageRequest.validateVersionInfo(info, this.reporter);

//
              remote = info._remote;
              (0, _invariant()["default"])(remote, 'Missing remote');

// set package reference
              ref = new (_packageReference()["default"])(this, info, remote);
              ref.addPattern(this.pattern, info);
              ref.addOptional(this.optional);
              ref.setFresh(fresh);
              info._reference = ref;
              info._remote = remote;
              // start installation of dependencies
              promises = [];
              deps = [];
              parentNames = [].concat((0, _toConsumableArray2()["default"])(this.parentNames), [name]); // normal deps
              for (depName in info.dependencies) {
                depPattern = depName + '@' + info.dependencies[depName];
                deps.push(depPattern);
                promises.push(this.resolver.find({
                  pattern: depPattern,
                  registry: remote.registry,
                  // dependencies of optional dependencies should themselves be optional
                  optional: this.optional,
                  parentRequest: this,
                  parentNames: parentNames
                }));
              }

// optional deps
              for (_depName in info.optionalDependencies) {
                _depPattern = _depName + '@' + info.optionalDependencies[_depName];
                deps.push(_depPattern);
                promises.push(this.resolver.find({
                  hint: 'optional',
                  pattern: _depPattern,
                  registry: remote.registry,
                  optional: true,
                  parentRequest: this,
                  parentNames: parentNames
                }));
              }
              if (remote.type === 'workspace' && !this.config.production) {
                // workspaces support dev dependencies
                for (_depName2 in info.devDependencies) {
                  _depPattern2 = _depName2 + '@' + info.devDependencies[_depName2];
                  deps.push(_depPattern2);
                  promises.push(this.resolver.find({
                    hint: 'dev',
                    pattern: _depPattern2,
                    registry: remote.registry,
                    optional: false,
                    parentRequest: this,
                    parentNames: parentNames
                  }));
                }
              }
              _i = 0, _promises = promises;
            case 32:
              if (!(_i < _promises.length)) {
                _context5.next = 39;
                break;
              }
              promise = _promises[_i];
              _context5.next = 36;
              return promise;
            case 36:
              _i++;
              _context5.next = 32;
              break;
            case 39:
              ref.addDependencies(deps);

// Now that we have all dependencies, it's safe to propagate optional
              _iterator = _createForOfIteratorHelper(ref.requests.slice(1));
              try {
                for (_iterator.s(); !(_step = _iterator.n()).done;) {
                  otherRequest = _step.value;
                  ref.addOptional(otherRequest.optional);
                }
              } catch (err) {
                _iterator.e(err);
              } finally {
                _iterator.f();
              }
            case 42:
            case "end":
              return _context5.stop();
          }
        }, _callee5, this);
      }));
      function find(_x4) {
        return _find.apply(this, arguments);
      }
      return find;
    }()
    /**
     * TODO description
     */
  }], [{
    key: "validateVersionInfo",
    value: function validateVersionInfo(info, reporter) {
      // human readable name to use in errors
      var human = "".concat(info.name, "@").concat(info.version);
      info.version = PackageRequest.getPackageVersion(info);
      var _iterator2 = _createForOfIteratorHelper(constants().REQUIRED_PACKAGE_KEYS),
        _step2;
      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var key = _step2.value;
          if (!info[key]) {
            throw new (_errors().MessageError)(reporter.lang('missingRequiredPackageKey', human, key));
          }
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
    }

/**
     * Returns the package version if present, else defaults to the uid
     */
  }, {
    key: "getPackageVersion",
    value: function getPackageVersion(info) {
      // TODO possibly reconsider this behaviour
      return info.version === undefined ? info._uid : info.version;
    }

/**
     * Gets all of the outdated packages and sorts them appropriately
     */
  }, {
    key: "getOutdatedPackages",
    value: function () {
      var _getOutdatedPackages = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee7(lockfile, install, config, reporter, filterByPatterns, flags) {
        var _yield$install$fetchR, reqPatterns, workspaceLayout, depReqPatterns, filterByNames, deps, isDepOld, orderByName;
        return _regenerator()["default"].wrap(function _callee7$(_context7) {
          while (1) switch (_context7.prev = _context7.next) {
            case 0:
              _context7.next = 2;
              return install.fetchRequestFromCwd();
            case 2:
              _yield$install$fetchR = _context7.sent;
              reqPatterns = _yield$install$fetchR.requests;
              workspaceLayout = _yield$install$fetchR.workspaceLayout;
              // Filter out workspace patterns if necessary
              depReqPatterns = workspaceLayout ? reqPatterns.filter(function (p) {
                return !workspaceLayout.getManifestByPattern(p.pattern);
              }) : reqPatterns; // filter the list down to just the packages requested.
              // prevents us from having to query the metadata for all packages.
              if (filterByPatterns && filterByPatterns.length || flags && flags.pattern) {
                filterByNames = filterByPatterns && filterByPatterns.length ? filterByPatterns.map(function (pattern) {
                  return (0, _normalizePattern4().normalizePattern)(pattern).name;
                }) : [];
                depReqPatterns = depReqPatterns.filter(function (dep) {
                  return filterByNames.indexOf((0, _normalizePattern4().normalizePattern)(dep.pattern).name) >= 0 || flags && flags.pattern && micromatch.contains((0, _normalizePattern4().normalizePattern)(dep.pattern).name, flags.pattern);
                });
              }
              _context7.next = 9;
              return Promise.all(depReqPatterns.map( /*#__PURE__*/function () {
                var _ref3 = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee6(_ref2) {
                  var pattern, hint, workspaceName, workspaceLoc, locked, name, current, latest, wanted, url, normalized, registry, _yield$registry$check;
                  return _regenerator()["default"].wrap(function _callee6$(_context6) {
                    while (1) switch (_context6.prev = _context6.next) {
                      case 0:
                        pattern = _ref2.pattern, hint = _ref2.hint, workspaceName = _ref2.workspaceName, workspaceLoc = _ref2.workspaceLoc;
                        locked = lockfile.getLocked(pattern);
                        if (locked) {
                          _context6.next = 4;
                          break;
                        }
                        throw new (_errors().MessageError)(reporter.lang('lockfileOutdated'));
                      case 4:
                        name = locked.name, current = locked.version;
                        latest = '';
                        wanted = '';
                        url = '';
                        normalized = (0, _normalizePattern4().normalizePattern)(pattern);
                        if (!((0, _index().getExoticResolver)(pattern) || (0, _index().getExoticResolver)(normalized.range))) {
                          _context6.next = 14;
                          break;
                        }
                        latest = wanted = 'exotic';
                        url = normalized.range;
                        _context6.next = 21;
                        break;
                      case 14:
                        registry = config.registries[locked.registry];
                        _context6.next = 17;
                        return registry.checkOutdated(config, name, normalized.range);
                      case 17:
                        _yield$registry$check = _context6.sent;
                        latest = _yield$registry$check.latest;
                        wanted = _yield$registry$check.wanted;
                        url = _yield$registry$check.url;
                      case 21:
                        return _context6.abrupt("return", {
                          name: name,
                          current: current,
                          wanted: wanted,
                          latest: latest,
                          url: url,
                          hint: hint,
                          range: normalized.range,
                          upgradeTo: '',
                          workspaceName: workspaceName || '',
                          workspaceLoc: workspaceLoc || ''
                        });
                      case 22:
                      case "end":
                        return _context6.stop();
                    }
                  }, _callee6);
                }));
                return function (_x11) {
                  return _ref3.apply(this, arguments);
                };
              }()));
            case 9:
              deps = _context7.sent;
              // Make sure to always output `exotic` versions to be compatible with npm
              isDepOld = function isDepOld(_ref4) {
                var current = _ref4.current,
                  latest = _ref4.latest,
                  wanted = _ref4.wanted;
                return latest === 'exotic' || _semver()["default"].lt(current, wanted) || _semver()["default"].lt(current, latest);
              };
              orderByName = function orderByName(depA, depB) {
                return depA.name.localeCompare(depB.name);
              };
              return _context7.abrupt("return", deps.filter(isDepOld).sort(orderByName));
            case 13:
            case "end":
              return _context7.stop();
          }
        }, _callee7);
      }));
      function getOutdatedPackages(_x5, _x6, _x7, _x8, _x9, _x10) {
        return _getOutdatedPackages.apply(this, arguments);
      }
      return getOutdatedPackages;
    }()
  }]);
  return PackageRequest;
}();
exports["default"] = PackageRequest;
//# sourceMappingURL=package-request.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.