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 | 4x 4x 4x 234x 88x 88x 84x 85x 4x 4x 4x 4x 81x 26x 26x 26x 26x 55x 55x 55x 55x 55x 80x 50x 27x 2x 2x 2x 2x 1x 1x | 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 }
Iif (version.minor > other.minor) { return Compared.GREATER }
Iif (version.minor < other.minor) { return Compared.LESS }
Iif (version.branch > other.branch) { return Compared.GREATER }
if (version.branch < other.branch) { return Compared.LESS }
Iif (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,
})
}
}
|