Press n or j to go to the next uncovered block, b, p or k for the previous block.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 | 35x 35x 35x 794x 452x 408x 360x 701x 84x 84x 84x 84x 617x 405x 405x 405x 405x 212x 212x 212x 212x 212x 262x 154x 99x 45x 38x 34x 27x 23x 14x 8x 17x 2x | import { Compared } from '../interfaces/enums' import type { IVersion } from '../interfaces/interfaces' import { isIVersion } from '../utils/typeguards' export class ComparableVersion implements IVersion { private _major: number private _minor: number private _branch: number private _patch: number public get major(): number { return this._major } public get minor(): number { return this._minor } public get branch(): number { return this._branch } public get patch(): number { return this._patch } public constructor(input: string) public constructor(major: number, minor: number, branch: number, patch: number) public constructor({ major, minor, branch, patch }: IVersion) public constructor(majorInput: number | string | IVersion, minor?: number, branch?: number, patch?: number) { if (isIVersion(majorInput)) { this._major = majorInput.major this._minor = majorInput.minor this._branch = majorInput.branch this._patch = majorInput.patch } else if (typeof majorInput === 'number') { this._major = majorInput this._minor = minor || 0 this._branch = branch || 0 this._patch = patch || 0 } else { const splitVersion = majorInput.split('.') this._major = parseInt(splitVersion[0], 10) || 0 this._minor = parseInt(splitVersion[1], 10) || 0 this._branch = parseInt(splitVersion[2], 10) || 0 this._patch = parseInt(splitVersion[3], 10) || 0 } } public toString(): string { return `${this.major}.${this.minor}.${this.branch}.${this.patch}` } /** * Compares two ComparableVersions with each other. * if version < other, the result is Compared.LESS * if version > other, the result is Compared.GREATER * if version === other, the result is Compared.EQUAL * * @param version * @param other */ public static compare(version: ComparableVersion, other: ComparableVersion): Compared { if (version.major > other.major) { return Compared.GREATER } if (version.major < other.major) { return Compared.LESS } if (version.minor > other.minor) { return Compared.GREATER } if (version.minor < other.minor) { return Compared.LESS } if (version.branch > other.branch) { return Compared.GREATER } if (version.branch < other.branch) { return Compared.LESS } if (version.patch > other.patch) { return Compared.GREATER } if (version.patch < other.patch) { return Compared.LESS } return Compared.EQUAL } public static max(...versions: ComparableVersion[]): ComparableVersion { return versions.reduce((currentMax, version) => ComparableVersion.compare(currentMax, version) === Compared.LESS ? version : currentMax) } public static nextMajorVersion(version: ComparableVersion, plus = 1): ComparableVersion { return new ComparableVersion({ major: version.major + plus, minor: 0, branch: 0, patch: 0, }) } } |