JezK

Edit File: package-fetcher.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _typeof = require("@babel/runtime/helpers/typeof");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.fetch = fetch;
exports.fetchOneRemote = fetchOneRemote;
function _regenerator() {
  var data = _interopRequireDefault(require("@babel/runtime/regenerator"));
  _regenerator = function _regenerator() {
    return data;
  };
  return data;
}
function _asyncToGenerator2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
  _asyncToGenerator2 = function _asyncToGenerator2() {
    return data;
  };
  return data;
}
function _errors() {
  var data = require("./errors.js");
  _errors = function _errors() {
    return data;
  };
  return data;
}
function fetchers() {
  var data = _interopRequireWildcard(require("./fetchers/index.js"));
  fetchers = function fetchers() {
    return data;
  };
  return data;
}
function fs() {
  var data = _interopRequireWildcard(require("./util/fs.js"));
  fs = function fs() {
    return data;
  };
  return data;
}
function promise() {
  var data = _interopRequireWildcard(require("./util/promise.js"));
  promise = function promise() {
    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; }
var ssri = require('ssri');
function fetchCache(_x, _x2, _x3, _x4) {
  return _fetchCache.apply(this, arguments);
}
function _fetchCache() {
  _fetchCache = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee2(dest, fetcher, config, remote) {
    var _yield$config$readPac, hash, pkg, cacheRemote, cacheIntegrity, cacheHash;
    return _regenerator()["default"].wrap(function _callee2$(_context2) {
      while (1) switch (_context2.prev = _context2.next) {
        case 0:
          _context2.next = 2;
          return config.readPackageMetadata(dest);
        case 2:
          _yield$config$readPac = _context2.sent;
          hash = _yield$config$readPac.hash;
          pkg = _yield$config$readPac["package"];
          cacheRemote = _yield$config$readPac.remote;
          cacheIntegrity = cacheRemote.cacheIntegrity || cacheRemote.integrity;
          cacheHash = cacheRemote.hash;
          if (!remote.integrity) {
            _context2.next = 11;
            break;
          }
          if (!(!cacheIntegrity || !ssri.parse(cacheIntegrity).match(remote.integrity))) {
            _context2.next = 11;
            break;
          }
          throw new (_errors().SecurityError)(config.reporter.lang('fetchBadIntegrityCache', pkg.name, cacheIntegrity, remote.integrity));
        case 11:
          if (!remote.hash) {
            _context2.next = 14;
            break;
          }
          if (!(!cacheHash || cacheHash !== remote.hash)) {
            _context2.next = 14;
            break;
          }
          throw new (_errors().SecurityError)(config.reporter.lang('fetchBadHashCache', pkg.name, cacheHash, remote.hash));
        case 14:
          _context2.next = 16;
          return fetcher.setupMirrorFromCache();
        case 16:
          return _context2.abrupt("return", {
            "package": pkg,
            hash: hash,
            dest: dest,
            cached: true
          });
        case 17:
        case "end":
          return _context2.stop();
      }
    }, _callee2);
  }));
  return _fetchCache.apply(this, arguments);
}
function fetchOneRemote(_x5, _x6, _x7, _x8, _x9) {
  return _fetchOneRemote.apply(this, arguments);
}
function _fetchOneRemote() {
  _fetchOneRemote = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee3(remote, name, version, dest, config) {
    var mockPkg, Fetcher, fetcher;
    return _regenerator()["default"].wrap(function _callee3$(_context3) {
      while (1) switch (_context3.prev = _context3.next) {
        case 0:
          if (!(remote.type === 'link')) {
            _context3.next = 3;
            break;
          }
          mockPkg = {
            _uid: '',
            name: '',
            version: '0.0.0'
          };
          return _context3.abrupt("return", Promise.resolve({
            resolved: null,
            hash: '',
            dest: dest,
            "package": mockPkg,
            cached: false
          }));
        case 3:
          Fetcher = fetchers()[remote.type];
          if (Fetcher) {
            _context3.next = 6;
            break;
          }
          throw new (_errors().MessageError)(config.reporter.lang('unknownFetcherFor', remote.type));
        case 6:
          fetcher = new Fetcher(dest, remote, config);
          _context3.next = 9;
          return config.isValidModuleDest(dest);
        case 9:
          if (!_context3.sent) {
            _context3.next = 11;
            break;
          }
          return _context3.abrupt("return", fetchCache(dest, fetcher, config, remote));
        case 11:
          _context3.next = 13;
          return fs().unlink(dest);
        case 13:
          _context3.prev = 13;
          _context3.next = 16;
          return fetcher.fetch({
            name: name,
            version: version
          });
        case 16:
          return _context3.abrupt("return", _context3.sent);
        case 19:
          _context3.prev = 19;
          _context3.t0 = _context3["catch"](13);
          _context3.prev = 21;
          _context3.next = 24;
          return fs().unlink(dest);
        case 24:
          _context3.next = 28;
          break;
        case 26:
          _context3.prev = 26;
          _context3.t1 = _context3["catch"](21);
        case 28:
          throw _context3.t0;
        case 29:
        case "end":
          return _context3.stop();
      }
    }, _callee3, null, [[13, 19], [21, 26]]);
  }));
  return _fetchOneRemote.apply(this, arguments);
}
function fetchOne(ref, config) {
  var dest = config.generateModuleCachePath(ref);
  return fetchOneRemote(ref.remote, ref.name, ref.version, dest, config);
}
function maybeFetchOne(_x10, _x11) {
  return _maybeFetchOne.apply(this, arguments);
}
function _maybeFetchOne() {
  _maybeFetchOne = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee4(ref, config) {
    return _regenerator()["default"].wrap(function _callee4$(_context4) {
      while (1) switch (_context4.prev = _context4.next) {
        case 0:
          _context4.prev = 0;
          _context4.next = 3;
          return fetchOne(ref, config);
        case 3:
          return _context4.abrupt("return", _context4.sent);
        case 6:
          _context4.prev = 6;
          _context4.t0 = _context4["catch"](0);
          if (!ref.optional) {
            _context4.next = 13;
            break;
          }
          config.reporter.error(_context4.t0.message);
          return _context4.abrupt("return", null);
        case 13:
          throw _context4.t0;
        case 14:
        case "end":
          return _context4.stop();
      }
    }, _callee4, null, [[0, 6]]);
  }));
  return _maybeFetchOne.apply(this, arguments);
}
function fetch(pkgs, config) {
  var pkgsPerDest = new Map();
  pkgs = pkgs.filter(function (pkg) {
    var ref = pkg._reference;
    if (!ref) {
      return false;
    }
    var dest = config.generateModuleCachePath(ref);
    var otherPkg = pkgsPerDest.get(dest);
    if (otherPkg) {
      config.reporter.warn(config.reporter.lang('multiplePackagesCantUnpackInSameDestination', ref.patterns, dest, otherPkg.patterns));
      return false;
    }
    pkgsPerDest.set(dest, ref);
    return true;
  });
  var tick = config.reporter.progress(pkgs.length);
  return promise().queue(pkgs, /*#__PURE__*/function () {
    var _ref = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee(pkg) {
      var ref, res, newPkg, oldHash;
      return _regenerator()["default"].wrap(function _callee$(_context) {
        while (1) switch (_context.prev = _context.next) {
          case 0:
            ref = pkg._reference;
            if (ref) {
              _context.next = 3;
              break;
            }
            return _context.abrupt("return", pkg);
          case 3:
            _context.next = 5;
            return maybeFetchOne(ref, config);
          case 5:
            res = _context.sent;
            if (res) {
              newPkg = res["package"];

// update with new remote
              // but only if there was a hash previously as the tarball fetcher does not provide a hash.
              if (ref.remote.hash) {
                // if the checksum was updated, also update resolved and cache
                if (ref.remote.hash !== res.hash && config.updateChecksums) {
                  oldHash = ref.remote.hash;
                  if (ref.remote.resolved) {
                    ref.remote.resolved = ref.remote.resolved.replace(oldHash, res.hash);
                  }
                  ref.config.cache = Object.keys(ref.config.cache).reduce(function (cache, entry) {
                    var entryWithNewHash = entry.replace(oldHash, res.hash);
                    cache[entryWithNewHash] = ref.config.cache[entry];
                    return cache;
                  }, {});
                }
                ref.remote.hash = res.hash || ref.remote.hash;
              }
            }
            if (tick) {
              tick();
            }
            if (!newPkg) {
              _context.next = 14;
              break;
            }
            newPkg._reference = ref;
            newPkg._remote = ref.remote;
            newPkg.name = pkg.name;
            newPkg.fresh = pkg.fresh;
            return _context.abrupt("return", newPkg);
          case 14:
            return _context.abrupt("return", pkg);
          case 15:
          case "end":
            return _context.stop();
        }
      }, _callee);
    }));
    return function (_x12) {
      return _ref.apply(this, arguments);
    };
  }(), config.networkConcurrency);
}
//# sourceMappingURL=package-fetcher.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.