flow-typed/dist/lib/flowVersion.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.__parseVersion = _parseVersion;
exports.compareFlowVersionAsc = compareFlowVersionAsc;
exports.determineFlowSpecificVersion = determineFlowSpecificVersion;
exports.disjointVersionsAll = disjointVersionsAll;
exports.extractFlowDirFromFlowDirPath = void 0;
exports.parseDirString = parseDirString;
exports.parseFlowSpecificVer = parseFlowSpecificVer;
exports.toDirString = toDirString;
exports.toSemverString = toSemverString;

var _npmProjectUtils = require("./npm/npmProjectUtils");

var _ValidationError = require("./ValidationError");

function _parseVerNum(numStr, verName, context) {
  const num = parseInt(numStr, 10);

  if (String(num) !== numStr) {
    throw new _ValidationError.ValidationError(`'${context}': Invalid ${verName} number: '${numStr}'. Expected a number.`);
  }

  return num;
}

function _parseVerNumOrX(numStr, verName, context) {
  if (numStr == null) {
    return 'x';
  }

  if (numStr === 'x') {
    return numStr;
  }

  return _parseVerNum(numStr, verName, context);
}

function _parseVersion(verStr, expectPossibleRangeUpper) {
  if (verStr[0] !== 'v') {
    throw new _ValidationError.ValidationError('Flow version ranges must start with a `v`!');
  }

  const verParts = verStr.slice(1).match(/^([0-9]+)\.([0-9]+|x)(\.([0-9]+|x))?/);
  let majorStr, minorStr, patchStr;

  if (verParts == null) {
    if (verStr[1] === 'x') {
      throw new _ValidationError.ValidationError('The major version of a Flow version string cannot be `x`, it must ' + 'be a number!');
    } else {
      throw new _ValidationError.ValidationError('Flow versions must be a non-range semver with an exact major version ' + 'and either an exact minor version or an `x` minor ver. Instead got: ' + verStr);
    }
  } else {
    majorStr = verParts[1];
    minorStr = verParts[2];
    patchStr = verParts[4];
  }

  const [major, minor, patch] = [_parseVerNum(majorStr, 'major', verStr), _parseVerNumOrX(minorStr, 'minor', verStr), _parseVerNumOrX(patchStr, 'patch', verStr)];
  const verAfterParts = verStr.substr(verParts[0].length + 1);

  if (patchStr != null && verAfterParts[0] === '-' && verAfterParts[1] != null) {
    if (expectPossibleRangeUpper) {
      // A `-` could indicate either a range or a prerel. This is technically
      // a real ambiguity in our versioning syntax -- but luckily it's rarely
      // encountered.
      //
      // To deal with this, we try parsing as a version. If it parses we assume
      // a range. If it doesn't parse as a version, we assume a pre-rel
      // identifier.
      //
      // This is excitingly inefficient but because it operates on tiny inputs
      // (and only sometimes) it shouldn't be an issue in practice.
      try {
        _parseVersion(verAfterParts.substr(1), false);

        return [verParts[0].length + 1, {
          major,
          minor,
          patch,
          prerel: null
        }];
      } catch (e) {
        // It's possible that a prerel *and* a range co-exist!
        // v0.1.x-prerel-v0.2.x
        let prerelParts = verAfterParts.substr(1).split('-'); // ['prerel', 'v0.2.x']

        let prerel = prerelParts.shift(); // 'prerel'

        while (prerelParts.length > 0) {
          try {
            _parseVersion(prerelParts.join('-'), false);

            break;
          } catch (e) {
            prerel += '-' + prerelParts.shift();
          }
        }

        return [verParts[0].length + '-'.length + prerel.length + 1, {
          major,
          minor,
          patch,
          prerel
        }];
      }
    } else {
      // After the `-` must be a prerel
      return [verStr.length + 1, {
        major,
        minor,
        patch,
        prerel: verAfterParts.substr(1)
      }];
    }
  } else {
    return [verParts[0].length + 1, {
      major,
      minor,
      patch,
      prerel: null
    }];
  }
}

function parseDirString(verStr) {
  const prefix = 'flow_';

  if (!verStr.startsWith(prefix)) {
    throw new _ValidationError.ValidationError(`Flow versions must start with \`${prefix}\` but instead got ${verStr}`);
  }

  const afterPrefix = verStr.substr(verStr.indexOf(prefix) + prefix.length);

  if (afterPrefix === 'all' || afterPrefix === 'vx.x.x') {
    return {
      kind: 'all'
    };
  } else if (afterPrefix[0] === '-') {
    return {
      kind: 'ranged',
      lower: null,
      upper: _parseVersion(verStr.substr(`${prefix}-`.length), false)[1]
    };
  } else {
    const [offset, lowerVer] = _parseVersion(afterPrefix, true);

    if (offset === afterPrefix.length) {
      return {
        kind: 'specific',
        ver: lowerVer
      };
    } else if (afterPrefix[offset] === '-') {
      const upperVer = offset + 1 === afterPrefix.length ? null : _parseVersion(afterPrefix.substr(offset + 1), false)[1];
      return {
        kind: 'ranged',
        lower: lowerVer,
        upper: upperVer
      };
    } else {
      throw new _ValidationError.ValidationError(`Unexpected trailing characters: ${afterPrefix.substr(offset)}`);
    }
  }
}

function parseFlowSpecificVer(verStr) {
  const flowVer = parseDirString(`flow_${verStr}`);

  switch (flowVer.kind) {
    case 'specific':
      return flowVer.ver;

    case 'all':
    case 'ranged':
      throw new _ValidationError.ValidationError(`This is not a specific Flow version.`);

    default:
      flowVer;
  }

  return {
    major: -1,
    minor: 'x',
    patch: 'x',
    prerel: null
  };
}

async function determineFlowSpecificVersion(cwd, flowVersionArg) {
  if (flowVersionArg && typeof flowVersionArg === 'string') {
    // Be permissive if the prefix 'v' is left off
    let flowVersionStr = flowVersionArg[0] === 'v' ? flowVersionArg : `v${flowVersionArg}`;

    if (/^v[0-9]+\.[0-9]+$/.test(flowVersionStr)) {
      flowVersionStr = `${flowVersionStr}.0`;
    }

    return {
      kind: 'specific',
      ver: parseFlowSpecificVer(flowVersionStr)
    };
  } else {
    return {
      kind: 'specific',
      ver: await (0, _npmProjectUtils.findFlowSpecificVer)(cwd)
    };
  }
}
/**
 * Given two version ranges a and b, determine whether a is before b.
 */


function lt(n1, n2) {
  if (n1 === 'x' || n2 === 'x') return false;
  if (n1 < n2) return true;
  if (n1 > n2) return false;
  return 'maybe';
}

function before(a, b) {
  let test = lt(a.major, b.major);
  if (test !== 'maybe') return test;
  test = lt(a.minor, b.minor);
  if (test !== 'maybe') return test;
  test = lt(a.patch, b.patch);
  if (test !== 'maybe') return test;
  return false;
}
/**
 * Given a version range, returns the max version satisfying the range.
 */


function maxSat(ver) {
  switch (ver.kind) {
    case 'all':
      return null;

    case 'ranged':
      return ver.upper;

    case 'specific':
      return ver.ver;

    default:
      ver;
      throw new Error('Unexpected FlowVersion kind!');
  }
}
/**
 * Given a version range, returns the min version satisfying the range.
 */


function minSat(ver) {
  switch (ver.kind) {
    case 'all':
      return null;

    case 'ranged':
      return ver.lower;

    case 'specific':
      return ver.ver;

    default:
      ver;
      throw new Error('Unexpected FlowVersion kind!');
  }
}
/**
 * Given two versions, returns whether they are disjoint.
 */


function _before(a, b) {
  // If a is undefined, it denotes the maximum version. If b is undefined, it
  // denotes the minimum version.
  if (a && b) return before(a, b);
  return false;
}

function disjointVersions(a, b) {
  return _before(maxSat(a), minSat(b)) || _before(maxSat(b), minSat(a));
}
/**
 * Given an array of versions, returns whether they are mutually disjoint.
 */


function _disjointVersionsAll(vers, len, i) {
  if (i + 1 >= len) return true;

  for (let j = i + 1; j < len; j++) {
    if (!disjointVersions(vers[i], vers[j])) {
      return false;
    }
  }

  return _disjointVersionsAll(vers, len, i + 1);
}

function disjointVersionsAll(vers) {
  return _disjointVersionsAll(vers, vers.length, 0);
}

function toDirString(ver) {
  switch (ver.kind) {
    case 'all':
      return 'flow_all';

    case 'specific':
      {
        let str = `flow_v${ver.ver.major}.${ver.ver.minor}`;

        if (ver.ver.patch !== null) {
          str += `.${ver.ver.patch}`;

          if (ver.ver.prerel) {
            str += `-${ver.ver.prerel}`;
          }
        }

        return str;
      }

    case 'ranged':
      {
        const {
          lower,
          upper
        } = ver;
        let str = 'flow_';

        if (lower !== null) {
          str += `v${lower.major}.${lower.minor}`;

          if (lower.patch !== null) {
            str += `.${lower.patch}`;

            if (lower.prerel !== null) {
              str += `-${lower.prerel}`;
            }
          }
        }

        str += '-';

        if (upper !== null) {
          str += `v${upper.major}.${upper.minor}`;

          if (upper.patch !== null) {
            str += `.${upper.patch}`;

            if (upper.prerel !== null) {
              str += `-${upper.prerel}`;
            }
          }
        }

        return str;
      }

    default:
      ver;
      throw new Error('Unexpected FlowVersion kind!');
  }
}

function toSemverString(ver) {
  switch (ver.kind) {
    case 'all':
      return 'vx.x.x';

    case 'specific':
      return toDirString(ver).substr('flow_'.length);

    case 'ranged':
      {
        const {
          upper,
          lower
        } = ver;
        let str = '';

        if (lower !== null) {
          str += `>=v${lower.major}.${lower.minor}`;

          if (lower.patch !== null) {
            str += `.${lower.patch}`;

            if (lower.prerel !== null) {
              str += `-${lower.prerel}`;
            }
          }

          if (upper !== null) {
            str += ' ';
          }
        }

        if (upper !== null) {
          str += `<=v${upper.major}.${upper.minor}`;

          if (upper.patch !== null) {
            str += `.${upper.patch}`;

            if (upper.prerel !== null) {
              str += `-${upper.prerel}`;
            }
          }
        }

        return str;
      }

    default:
      ver;
      throw new Error('Unexpected FlowVersion kind!');
  }
}

function compareFlowVersionAsc(a, b) {
  if (a.kind === 'all') {
    return b.kind === 'all' ? 0 : -1;
  }

  if (b.kind === 'all') {
    return 1;
  }

  const aLowerVer = a.kind === 'specific' ? a.ver : a.lower;
  const bLowerVer = b.kind === 'specific' ? b.ver : b.lower;

  if (aLowerVer === null) {
    return bLowerVer === null ? 0 : 1;
  }

  if (bLowerVer === null) {
    return -1;
  }

  const compareMajor = lt(aLowerVer.major, bLowerVer.major);

  if (compareMajor !== 'maybe') {
    return compareMajor ? 1 : -1;
  }

  const compareMinor = lt(aLowerVer.minor, bLowerVer.minor);

  if (compareMinor !== 'maybe') {
    return compareMinor ? 1 : -1;
  }

  const comparePatch = lt(aLowerVer.patch, bLowerVer.patch);

  if (comparePatch !== 'maybe') {
    return comparePatch ? 1 : -1;
  }

  return 0;
}

const extractFlowDirFromFlowDirPath = path => {
  const split = path.split('/');
  return split[split.length - 1];
}; // Exported for tests


exports.extractFlowDirFromFlowDirPath = extractFlowDirFromFlowDirPath;