semver 0.0.1-preview.1
Semantic versions and npm's version ranges
semver#
Semantic versions (https://semver.org) and npm's version ranges (https://github.com/npm/node-semver#ranges), for Zena.
import {Range, Version} from 'zena-lang:semver';
let range = Range.parse('^1.4.2 || ^2.0.0');
range.includes(Version.parse('1.7.0')); // true
range.includes(Version.parse('3.0.0')); // false
range.toString(); // '>=1.4.2 <2.0.0-0 || >=2.0.0 <3.0.0-0'
| Range | Means |
|---|---|
^1.4.2 |
>=1.4.2 <2.0.0-0 |
^0.3.1 |
>=0.3.1 <0.4.0-0 |
~1.4.2 |
>=1.4.2 <1.5.0-0 |
1.4.2 |
exactly 1.4.2 |
1.x, 1 |
>=1.0.0 <2.0.0-0 |
1.2.3 - 2.3 |
>=1.2.3 <2.4.0-0 |
>=1.4.2 <1.7.0 |
both comparators |
a || b |
either range |
A pre-release is in a range only when the range names a pre-release of
the same major.minor.patch, as in npm: ^2.0.0 does not include
2.1.0-rc.1. Pass includePrerelease to includes to include them.
highest and lowest pick from a list of versions, and intervals
gives each comparator set as a pair of bounds.
7.7 KiB
Raw
/**
* Semantic versions (https://semver.org): `1.4.2`, `2.0.0-rc.1`,
* `1.0.0+build.5`.
*
* `compareTo` orders versions by semver precedence, which ignores build
* metadata, so `1.0.0+a` and `1.0.0+b` are equal in order and different
* in text.
*/
/** Text that is not a version or a range. */
export class VersionError extends Error {
new(message: String) : super(message);
}
/** 2^53 - 1, so that every version number reads the same in JSON. */
let MAX_NUMBER: i64 = 0x1fffffffffffff;
/** A semantic version. */
export final class Version {
major: i64;
minor: i64;
patch: i64;
/**
* The pre-release identifiers: `['rc', '1']` for `2.0.0-rc.1`, and none
* for a release.
*/
prerelease: FixedArray<String>;
/** The build metadata's identifiers: `['build', '5']` for `1.0.0+build.5`. */
build: FixedArray<String>;
new(major: i64, minor: i64, patch: i64, prerelease: FixedArray<String>,
build: FixedArray<String> = new FixedArray<String>(0, ''))
: major = major, minor = minor, patch = patch, prerelease = prerelease, build = build;
/**
* Reads a version such as `1.4.2`, `2.0.0-rc.1` or `1.0.0+build.5`.
* Throws `VersionError` for anything else.
*/
static parse(text: String): Version {
var coreEnd = text.length;
var buildStart = text.length;
for (var i = 0; i < text.length; i += 1) {
let b = text.getByteAt(i);
if (b == 43 && buildStart == text.length) { // the first '+'
buildStart = i;
if (coreEnd == text.length) {
coreEnd = i;
}
}
if (b == 45 && coreEnd == text.length) { // the first '-'
coreEnd = i;
}
}
let core = text.sliceBytes(0, coreEnd).split('.');
if (core.length != 3) {
throw new VersionError(`'${text}' is not a version: expected major.minor.patch`);
}
var prerelease = new FixedArray<String>(0, '');
if (coreEnd < buildStart) {
prerelease = parsePrerelease(text.sliceBytes(coreEnd + 1, buildStart), text);
}
var build = new FixedArray<String>(0, '');
if (buildStart < text.length) {
build = parseBuild(text.sliceBytes(buildStart + 1, text.length), text);
}
return new Version(parseVersionNumber(core[0], text), parseVersionNumber(core[1], text),
parseVersionNumber(core[2], text), prerelease, build);
}
/** Whether this is a pre-release, such as `2.0.0-rc.1`. */
isPrerelease: boolean {
get {
return this.prerelease.length > 0;
}
}
/**
* The line of versions semver lets replace this one without a breaking
* change, as `^` reads it: the major version, `1` for `1.4.2`; or, before
* 1.0, the first number that is not zero and those before it, `0.2` for
* `0.2.3` and `0.0.3` for `0.0.3`, since a breaking change may raise the
* minor version then, or the patch version before 0.1. Two versions on
* one line are one dependency at two versions; on two lines, two
* dependencies.
*/
compatibleLine(): String {
if (this.major != (0 as i64)) {
return `${this.major}`;
}
if (this.minor != (0 as i64)) {
return `0.${this.minor}`;
}
return `0.0.${this.patch}`;
}
/**
* Negative when this version has lower precedence than `other`, zero
* when they are equal, and positive when it has higher precedence. Build
* metadata does not count.
*/
compareTo(other: Version): i32 {
if (this.major != other.major) {
return if (this.major < other.major) -1 else 1;
}
if (this.minor != other.minor) {
return if (this.minor < other.minor) -1 else 1;
}
if (this.patch != other.patch) {
return if (this.patch < other.patch) -1 else 1;
}
let a = this.prerelease;
let b = other.prerelease;
// A release has higher precedence than its pre-releases.
if (a.length == 0 || b.length == 0) {
return b.length - a.length;
}
let n = if (a.length < b.length) a.length else b.length;
for (var i = 0; i < n; i += 1) {
let order = compareIdentifiers(a[i], b[i]);
if (order != 0) {
return order;
}
}
return a.length - b.length;
}
/** Whether this version and `other` have the same major, minor and patch numbers. */
hasSameCore(other: Version): boolean {
return this.major == other.major && this.minor == other.minor && this.patch == other.patch;
}
toString(): String {
var text = `${this.major}.${this.minor}.${this.patch}`;
for (var i = 0; i < this.prerelease.length; i += 1) {
text = `${text}${if (i == 0) '-' else '.'}${this.prerelease[i]}`;
}
for (var i = 0; i < this.build.length; i += 1) {
text = `${text}${if (i == 0) '+' else '.'}${this.build[i]}`;
}
return text;
}
}
/** Reads a major, minor or patch number of `text`: digits without a leading zero. */
export function parseVersionNumber(part: String, text: String): i64 {
if (!isNumeric(part) || (part.length > 1 && part.getByteAt(0) == 48)) {
throw new VersionError(`'${text}' is not a version: '${part}' is not a number without leading zeros`);
}
if (part.length > 16) {
throw new VersionError(`'${text}' is not a version: '${part}' is too large`);
}
var n: i64 = 0;
for (var i = 0; i < part.length; i += 1) {
n = n * 10 + (part.getByteAt(i) - 48);
}
if (n > MAX_NUMBER) {
throw new VersionError(`'${text}' is not a version: '${part}' is too large`);
}
return n;
}
/** Reads the pre-release identifiers `part` of `text`, after its `-`. */
export function parsePrerelease(part: String, text: String): FixedArray<String> {
let identifiers = part.split('.');
for (let identifier in identifiers) {
checkIdentifier(identifier, text);
if (isNumeric(identifier) && identifier.length > 1 && identifier.getByteAt(0) == 48) {
throw new VersionError(`'${text}' is not a version: '${identifier}' has a leading zero`);
}
}
return identifiers;
}
/**
* Reads the build metadata `part` of `text`, after its `+`. Unlike
* pre-release identifiers, these may have leading zeros.
*/
export function parseBuild(part: String, text: String): FixedArray<String> {
let identifiers = part.split('.');
for (let identifier in identifiers) {
checkIdentifier(identifier, text);
}
return identifiers;
}
/** Checks that an identifier of `text` is ASCII letters, digits and `-`, and not empty. */
function checkIdentifier(identifier: String, text: String): void {
if (identifier.length == 0) {
throw new VersionError(`'${text}' is not a version: an identifier is empty`);
}
for (var i = 0; i < identifier.length; i += 1) {
let b = identifier.getByteAt(i);
let alphanumeric = (b >= 48 && b <= 57) || (b >= 65 && b <= 90) || (b >= 97 && b <= 122);
if (!alphanumeric && b != 45) {
throw new VersionError(`'${text}' is not a version: '${identifier}' has a character other than letters, digits and '-'`);
}
}
}
/** Whether `text` is one or more ASCII digits. */
export function isNumeric(text: String): boolean {
if (text.length == 0) {
return false;
}
for (var i = 0; i < text.length; i += 1) {
let b = text.getByteAt(i);
if (b < 48 || b > 57) {
return false;
}
}
return true;
}
/**
* Semver precedence between two pre-release identifiers: numeric ones
* compare as numbers and come before alphanumeric ones, which compare
* byte by byte.
*/
function compareIdentifiers(a: String, b: String): i32 {
let aNumeric = isNumeric(a);
let bNumeric = isNumeric(b);
if (aNumeric != bNumeric) {
return if (aNumeric) -1 else 1;
}
// Numeric identifiers have no leading zeros, so the longer is larger.
if (aNumeric && a.length != b.length) {
return a.length - b.length;
}
let n = if (a.length < b.length) a.length else b.length;
for (var i = 0; i < n; i += 1) {
let diff = a.getByteAt(i) - b.getByteAt(i);
if (diff != 0) {
return diff;
}
}
return a.length - b.length;
}
| Version | Published | Dependencies | Approved by |
|---|---|---|---|
| 0.0.1-preview.1 | 2026-11-19 | none |
|