vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-10-07 08:17:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[semver] upgrade to 5.4, correct typings, add strict null checks

Browse Source
This commit is contained in:
Dimitri Benin
2017-08-07 02:24:19 +02:00
parent e4aa15b7b3
commit 96a772d948
3 changed files with 111 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files
types/semver/index.d.ts
Vendored
+67 -33
View File
@@ -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 <https://github.com/Bartvds>
// BendingBender <https://github.com/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<string | SemVer>, loose?: boolean): Array<string | SemVer>;
/**
* Sorts an array of semver entries in descending order.
*/
export function rsort(list: Array<string | SemVer>, loose?: boolean): Array<string | SemVer>;
/**
* 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<string | SemVer>, 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<string | SemVer>, 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;
}
types/semver/semver-tests.ts
+42 -29
View File
@@ -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<string | semver.SemVer>;
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;
types/semver/tsconfig.json
+2 -2
View File
@@ -6,7 +6,7 @@
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
@@ -19,4 +19,4 @@
"index.d.ts",
"semver-tests.ts"
]
}
}