From 96a772d948cdb4eed397e9104c6cb5de0bfb9781 Mon Sep 17 00:00:00 2001 From: Dimitri Benin Date: Mon, 7 Aug 2017 02:24:19 +0200 Subject: [PATCH] [semver] upgrade to 5.4, correct typings, add strict null checks --- types/semver/index.d.ts | 100 +++++++++++++++++++++++------------ types/semver/semver-tests.ts | 71 +++++++++++++++---------- types/semver/tsconfig.json | 4 +- 3 files changed, 111 insertions(+), 64 deletions(-) diff --git a/types/semver/index.d.ts b/types/semver/index.d.ts index 725e6d523f..069ad46da4 100644 --- a/types/semver/index.d.ts +++ b/types/semver/index.d.ts @@ -1,118 +1,149 @@ -// Type definitions for semver 5.3 +// Type definitions for semver 5.4 // Project: https://github.com/npm/node-semver // Definitions by: Bart van der Schoor +// BendingBender // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/semver export const SEMVER_SPEC_VERSION: "2.0.0"; export type ReleaseType = "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease"; +/** + * Return an instance of SemVer, or null if it's not valid. + */ +export function parse(v: string | SemVer, loose?: boolean): SemVer | null; /** * Return the parsed version, or null if it's not valid. */ -export function valid(v: string, loose?: boolean): string; +export function valid(v: string | SemVer, loose?: boolean): string | null; /** * Returns cleaned (removed leading/trailing whitespace, remove '=v' prefix) and parsed version, or null if version is invalid. */ -export function clean(version: string, loose?: boolean): string; +export function clean(version: string, loose?: boolean): string | null; /** * Return the version incremented by the release type (major, minor, patch, or prerelease), or null if it's not valid. */ -export function inc(v: string, release: ReleaseType, loose?: boolean, identifier?: string): string; +export function inc(v: string | SemVer, release: ReleaseType, loose?: boolean, identifier?: string): string | null; /** * Return the major version number. */ -export function major(v: string, loose?: boolean): number; +export function major(v: string | SemVer, loose?: boolean): number; /** * Return the minor version number. */ -export function minor(v: string, loose?: boolean): number; +export function minor(v: string | SemVer, loose?: boolean): number; /** * Return the patch version number. */ -export function patch(v: string, loose?: boolean): number; +export function patch(v: string | SemVer, loose?: boolean): number; /** * Returns an array of prerelease components, or null if none exist. */ -export function prerelease(v: string, loose?: boolean): string[]; +export function prerelease(v: string | SemVer, loose?: boolean): string[] | null; // Comparison /** * v1 > v2 */ -export function gt(v1: string, v2: string, loose?: boolean): boolean; +export function gt(v1: string | SemVer, v2: string | SemVer, loose?: boolean): boolean; /** * v1 >= v2 */ -export function gte(v1: string, v2: string, loose?: boolean): boolean; +export function gte(v1: string | SemVer, v2: string | SemVer, loose?: boolean): boolean; /** * v1 < v2 */ -export function lt(v1: string, v2: string, loose?: boolean): boolean; +export function lt(v1: string | SemVer, v2: string | SemVer, loose?: boolean): boolean; /** * v1 <= v2 */ -export function lte(v1: string, v2: string, loose?: boolean): boolean; +export function lte(v1: string | SemVer, v2: string | SemVer, loose?: boolean): boolean; /** * v1 == v2 This is true if they're logically equivalent, even if they're not the exact same string. You already know how to compare strings. */ -export function eq(v1: string, v2: string, loose?: boolean): boolean; +export function eq(v1: string | SemVer, v2: string | SemVer, loose?: boolean): boolean; /** * v1 != v2 The opposite of eq. */ -export function neq(v1: string, v2: string, loose?: boolean): boolean; +export function neq(v1: string | SemVer, v2: string | SemVer, loose?: boolean): boolean; + /** * Pass in a comparison string, and it'll call the corresponding semver comparison function. * "===" and "!==" do simple string comparison, but are included for completeness. * Throws if an invalid comparison string is provided. */ -export function cmp(v1: string, comparator: any, v2: string, loose?: boolean): boolean; +export function cmp(v1: string | SemVer, operator: Operator, v2: string | SemVer, loose?: boolean): boolean; +export type Operator = '===' | '!==' | '' | '=' | '==' | '!=' | '>' | '>=' | '<' | '<='; + /** * Return 0 if v1 == v2, or 1 if v1 is greater, or -1 if v2 is greater. Sorts in ascending order if passed to Array.sort(). */ -export function compare(v1: string, v2: string, loose?: boolean): number; +export function compare(v1: string | SemVer, v2: string | SemVer, loose?: boolean): 1 | 0 | -1; /** * The reverse of compare. Sorts an array of versions in descending order when passed to Array.sort(). */ -export function rcompare(v1: string, v2: string, loose?: boolean): number; +export function rcompare(v1: string | SemVer, v2: string | SemVer, loose?: boolean): 1 | 0 | -1; + +/** + * Compares two identifiers, must be numeric strings or truthy/falsy values. Sorts in ascending order if passed to Array.sort(). + */ +export function compareIdentifiers(a: string | null, b: string | null): 1 | 0 | -1; +/** + * The reverse of compareIdentifiers. Sorts in descending order when passed to Array.sort(). + */ +export function rcompareIdentifiers(a: string | null, b: string | null): 1 | 0 | -1; + +/** + * Sorts an array of semver entries in ascending order. + */ +export function sort(list: Array, loose?: boolean): Array; +/** + * Sorts an array of semver entries in descending order. + */ +export function rsort(list: Array, loose?: boolean): Array; + /** * Returns difference between two versions by the release type (major, premajor, minor, preminor, patch, prepatch, or prerelease), or null if the versions are the same. */ -export function diff(v1: string, v2: string, loose?: boolean): ReleaseType; +export function diff(v1: string, v2: string, loose?: boolean): ReleaseType | null; // Ranges /** * Return the valid range or null if it's not valid */ -export function validRange(range: string, loose?: boolean): string; +export function validRange(range: string | Range, loose?: boolean): string; /** * Return true if the version satisfies the range. */ -export function satisfies(version: string, range: string, loose?: boolean): boolean; +export function satisfies(version: string | SemVer, range: string | Range, loose?: boolean): boolean; /** * Return the highest version in the list that satisfies the range, or null if none of them do. */ -export function maxSatisfying(versions: string[], range: string, loose?: boolean): string; +export function maxSatisfying(versions: Array, range: string | Range, loose?: boolean): string; /** * Return the lowest version in the list that satisfies the range, or null if none of them do. */ -export function minSatisfying(versions: string[], range: string, loose?: boolean): string; +export function minSatisfying(versions: Array, range: string, loose?: boolean): string; /** * Return true if version is greater than all the versions possible in the range. */ -export function gtr(version: string, range: string, loose?: boolean): boolean; +export function gtr(version: string | SemVer, range: string | Range, loose?: boolean): boolean; /** * Return true if version is less than all the versions possible in the range. */ -export function ltr(version: string, range: string, loose?: boolean): boolean; +export function ltr(version: string | SemVer, range: string | Range, loose?: boolean): boolean; /** * Return true if the version is outside the bounds of the range in either the high or low direction. * The hilo argument must be either the string '>' or '<'. (This is the function called by gtr and ltr.) */ -export function outside(version: string, range: string, hilo: string, loose?: boolean): boolean; +export function outside(version: string | SemVer, range: string | Range, hilo: '>' | '<', loose?: boolean): boolean; +/** + * Return true if any of the ranges comparators intersect + */ +export function intersects(range1: string | Range, range2: string | Range, loose?: boolean): boolean; export class SemVer { - constructor(version: string, loose?: boolean); + constructor(version: string | SemVer, loose?: boolean); raw: string; loose: boolean; @@ -126,25 +157,27 @@ export class SemVer { build: string[]; prerelease: string[]; - compare(other: SemVer): number; - compareMain(other: SemVer): number; - comparePre(other: SemVer): number; + compare(other: string | SemVer): 1 | 0 | -1; + compareMain(other: string | SemVer): 1 | 0 | -1; + comparePre(other: string | SemVer): 1 | 0 | -1; inc(release: ReleaseType, identifier?: string): SemVer; } export class Comparator { - constructor(comp: string, loose?: boolean); + constructor(comp: string | Comparator, loose?: boolean); semver: SemVer; operator: string; value: boolean; parse(comp: string): void; - test(version: SemVer): boolean; + test(version: string | SemVer): boolean; + intersects(comp: Comparator, loose?: boolean): boolean; } export class Range { - constructor(range: string, loose?: boolean); + constructor(range: string | Range, loose?: boolean); + range: string; raw: string; loose: boolean; format(): string; @@ -152,5 +185,6 @@ export class Range { set: Comparator[][]; parseRange(range: string): Comparator[]; - test(version: SemVer): boolean; + test(version: string | SemVer): boolean; + intersects(range: Range, loose?: boolean): boolean; } diff --git a/types/semver/semver-tests.ts b/types/semver/semver-tests.ts index 039e70f023..02ff3f056a 100644 --- a/types/semver/semver-tests.ts +++ b/types/semver/semver-tests.ts @@ -3,33 +3,38 @@ import * as semver from "semver"; let obj: {}; let bool: boolean; let num: number; -let str: string; -let diff: semver.ReleaseType; -let x: any = null; +let str: string = ''; +let strn: string | null = ''; +let diff: semver.ReleaseType | null; +let op: semver.Operator = ''; let arr: any[]; let exp: RegExp; -let strArr: string[]; +let strArr: string[] | null; let numArr: string[]; +let comparatorResult: -1 | 0 | 1; +let versionsArr: Array; -let v1: string; -let v2: string; -let version: string; -let versions: string[]; -let loose: boolean; +let v1: string = ''; +let v2: string = ''; +let version: string = ''; +let versions: string[] = []; +let loose: boolean = true; +let sem: semver.SemVer | null; -str = semver.valid(str); -str = semver.clean(str); +sem = semver.parse(str); +strn = semver.valid(str); +strn = semver.clean(str); -str = semver.valid(str, loose); -str = semver.clean(str, loose); -str = semver.inc(str, "major", loose); -str = semver.inc(str, "premajor", loose); -str = semver.inc(str, "minor", loose); -str = semver.inc(str, "preminor", loose); -str = semver.inc(str, "patch", loose); -str = semver.inc(str, "prepatch", loose); -str = semver.inc(str, "prerelease", loose); -str = semver.inc(str, "prerelease", loose, "alpha"); +strn = semver.valid(str, loose); +strn = semver.clean(str, loose); +strn = semver.inc(str, "major", loose); +strn = semver.inc(str, "premajor", loose); +strn = semver.inc(str, "minor", loose); +strn = semver.inc(str, "preminor", loose); +strn = semver.inc(str, "patch", loose); +strn = semver.inc(str, "prepatch", loose); +strn = semver.inc(str, "prerelease", loose); +strn = semver.inc(str, "prerelease", loose, "alpha"); num = semver.major(str, loose); num = semver.minor(str, loose); num = semver.patch(str, loose); @@ -42,9 +47,13 @@ bool = semver.lt(v1, v2, loose); bool = semver.lte(v1, v2, loose); bool = semver.eq(v1, v2, loose); bool = semver.neq(v1, v2, loose); -bool = semver.cmp(v1, x, v2, loose); -num = semver.compare(v1, v2, loose); -num = semver.rcompare(v1, v2, loose); +bool = semver.cmp(v1, op, v2, loose); +comparatorResult = semver.compare(v1, v2, loose); +comparatorResult = semver.rcompare(v1, v2, loose); +comparatorResult = semver.compareIdentifiers(str, str); +comparatorResult = semver.rcompareIdentifiers(str, str); +versionsArr = semver.sort(['', new semver.SemVer('')]); +versionsArr = semver.rsort(['', new semver.SemVer('')]); diff = semver.diff(v1, v2, loose); // Ranges @@ -54,7 +63,8 @@ str = semver.maxSatisfying(versions, str, loose); str = semver.minSatisfying(versions, str, loose); bool = semver.gtr(version, str, loose); bool = semver.ltr(version, str, loose); -bool = semver.outside(version, str, str, loose); +bool = semver.outside(version, str, '<', loose); +bool = semver.intersects(str, str, loose); let ver = new semver.SemVer(str, bool); str = ver.raw; @@ -70,9 +80,9 @@ str = ver.version; strArr = ver.build; strArr = ver.prerelease; -num = ver.compare(ver); -num = ver.compareMain(ver); -num = ver.comparePre(ver); +comparatorResult = ver.compare(ver); +comparatorResult = ver.compareMain(ver); +comparatorResult = ver.comparePre(ver); ver = ver.inc("major"); ver = ver.inc("premajor"); ver = ver.inc("minor"); @@ -90,6 +100,8 @@ str = comp.operator; bool = comp.value; comp.parse(str); bool = comp.test(ver); +bool = comp.intersects(new semver.Comparator(str)); +bool = comp.intersects(new semver.Comparator(str), bool); const range = new semver.Range(str, bool); str = range.raw; @@ -97,8 +109,9 @@ bool = range.loose; str = range.format(); str = range.inspect(); str = range.toString(); - bool = range.test(ver); +bool = range.intersects(new semver.Range('')); +bool = range.intersects(new semver.Range(''), bool); let sets: semver.Comparator[][]; sets = range.set; diff --git a/types/semver/tsconfig.json b/types/semver/tsconfig.json index 5a1f0a742c..1139cc58c5 100644 --- a/types/semver/tsconfig.json +++ b/types/semver/tsconfig.json @@ -6,7 +6,7 @@ ], "noImplicitAny": true, "noImplicitThis": true, - "strictNullChecks": false, + "strictNullChecks": true, "baseUrl": "../", "typeRoots": [ "../" @@ -19,4 +19,4 @@ "index.d.ts", "semver-tests.ts" ] -} \ No newline at end of file +}