node-semvers/dist/cjs/NodeVersions.js

Utilities for managing versions of node including looking up codenames

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "default", {
    enumerable: true,
    get: function() {
        return NodeVersions;
    }
});
var _fetchjsoncache = /*#__PURE__*/ _interop_require_default(require("fetch-json-cache"));
var _semver = /*#__PURE__*/ _interop_require_default(require("semver"));
var _constantsts = require("./constants.js");
var _keyFunctionsts = require("./lib/keyFunctions.js");
var _lineFunctionsts = require("./lib/lineFunctions.js");
var _matchts = /*#__PURE__*/ _interop_require_default(require("./lib/match.js"));
var _normalizeSchedulets = /*#__PURE__*/ _interop_require_default(require("./lib/normalizeSchedule.js"));
var _normalizeVersionts = /*#__PURE__*/ _interop_require_default(require("./lib/normalizeVersion.js"));
var _indexts = /*#__PURE__*/ _interop_require_default(require("./parseExpression/index.js"));
function _class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function _interop_require_default(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
var NodeVersions = /*#__PURE__*/ function() {
    "use strict";
    function NodeVersions(versions, schedule) {
        _class_call_check(this, NodeVersions);
        if (!versions) throw new Error('Missing option: versions');
        if (!schedule) throw new Error('Missing option: schedule');
        this.schedules = [];
        for(var name in schedule)this.schedules.push((0, _normalizeSchedulets.default)(name, schedule[name]));
        this.schedules = this.schedules.sort(function(a, b) {
            return _semver.default.gt(_semver.default.coerce(a.semver), _semver.default.coerce(b.semver)) ? 1 : -1;
        });
        this.versions = [];
        for(var index = 0; index < versions.length; index++)this.versions.push((0, _normalizeVersionts.default)(versions[index], this.schedules));
        this.versions = this.versions.sort(function(a, b) {
            return _semver.default.gt(a.semver, b.semver) ? -1 : 1;
        });
    }
    var _proto = NodeVersions.prototype;
    _proto.resolve = function resolve(expression, options) {
        options = options || {};
        var path = options.path || 'version';
        // normalize
        if (typeof expression === 'number') expression = "".concat(expression);
        if (typeof expression !== 'string') return null;
        expression = expression.trim();
        // single result, try a match
        var query = _indexts.default.call(this, expression, options.now || new Date());
        if (query) {
            var version = null;
            for(var index = 0; index < this.versions.length; index++){
                var test = this.versions[index];
                if (options.now && options.now < test.date) continue;
                if (!(0, _matchts.default)(test, query)) continue;
                version = test;
                break;
            }
            if (version) return version[path];
        }
        // filtered expression
        var range = options.range || '';
        var filters = {
            lts: !!~range.indexOf('lts'),
            key: undefined,
            line: undefined
        };
        filters.key = ~range.indexOf('major') ? _keyFunctionsts.major : ~range.indexOf('minor') ? _keyFunctionsts.minor : undefined;
        filters.line = ~range.indexOf('even') ? _lineFunctionsts.even : ~range.indexOf('odd') ? _lineFunctionsts.odd : undefined;
        var results = [];
        var founds = {};
        for(var index1 = 0; index1 < this.versions.length; index1++){
            var test1 = this.versions[index1];
            if (options.now && options.now < test1.date) continue;
            if (filters.lts && !test1.lts) continue;
            if (filters.line && !filters.line(test1)) continue;
            if (!_semver.default.satisfies(test1.semver, expression)) continue;
            if (filters.key) {
                if (founds[filters.key(test1)]) continue;
                founds[filters.key(test1)] = true;
            }
            results.unshift(test1[path]);
        }
        return results;
    };
    NodeVersions.load = function load(options, callback) {
        if (typeof options === 'function') {
            callback = options;
            options = null;
        }
        options = options || {};
        function worker(options, callback) {
            var cache = new _fetchjsoncache.default(options.cachePath || _constantsts.CACHE_PATH);
            cache.get(_constantsts.DISTS_URL, function(err, versions) {
                if (err) return callback(err);
                cache.get(_constantsts.SCHEDULES_URL, function(err, schedule) {
                    err ? callback(err) : callback(null, new NodeVersions(versions, schedule));
                });
            });
        }
        if (typeof callback === 'function') return worker(options, callback);
        return new Promise(function(resolve, reject) {
            return worker(options, function(err, versions) {
                return err ? reject(err) : resolve(versions);
            });
        });
    };
    NodeVersions.loadSync = function loadSync(options) {
        options = options || {};
        var cache = new _fetchjsoncache.default(options.cachePath || _constantsts.CACHE_PATH);
        var versions = cache.getSync(_constantsts.DISTS_URL);
        var schedule = cache.getSync(_constantsts.SCHEDULES_URL);
        if (!versions || !schedule) return null;
        return new NodeVersions(versions, schedule);
    };
    return NodeVersions;
}();
/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }