start-sdk/emvar-lite/mod.ts

const starSub = /((\d+\.)*\d+)\.\*/

function incrementLastNumber(list: number[]) {
    const newList = [...list]
    newList[newList.length - 1]++
    return newList
}
/**
 * Will take in a range, like `>1.2` or `<1.2.3.4` or `=1.2` or `1.*`
 * and return a checker, that has the check function for checking that a version is in the valid
 * @param range 
 * @returns 
 */
export function rangeOf(range: string | Checker): Checker {
    if (range instanceof Checker) {
        return range
    }
    if (range === '*') return new Checker((version) => {
        EmVar.from(version)
        return true
    });
    const starSubMatches = starSub.exec(range)
    if (starSubMatches != null) {
        const emVarLower = EmVar.parse(starSubMatches[1])
        const emVarUpper = emVarLower.withLastIncremented()

        return new Checker((version) => {
            const v = EmVar.from(version);
            return (v.greaterThan(emVarLower) || v.equals(emVarLower)) && !v.greaterThan(emVarUpper) && !v.equals(emVarUpper);
        })
    }

    switch (range.substring(0, 2)) {
        case '>=': {
            const emVar = EmVar.parse(range.substring(2));
            return new Checker((version) => {
                const v = EmVar.from(version);
                return v.greaterThanOrEqual(emVar)
            })
        }
        case '<=': {
            const emVar = EmVar.parse(range.substring(2));
            return new Checker((version) => {
                const v = EmVar.from(version);
                return v.lessThanOrEqual(emVar);
            })
        }

    }

    switch (range.substring(0, 1)) {
        case '>': {
            console.log('greaterThan')
            const emVar = EmVar.parse(range.substring(1));
            return new Checker((version) => {
                const v = EmVar.from(version);
                return v.greaterThan(emVar);
            })
        }
        case '<': {
            const emVar = EmVar.parse(range.substring(1));
            return new Checker((version) => {
                const v = EmVar.from(version);
                return v.lessThan(emVar)
            })
        }
        case '=': {
            const emVar = EmVar.parse(range.substring(1));
            return new Checker((version) => {
                const v = EmVar.from(version);
                return v.equals(emVar);
            })
        }

    }
    throw new Error("Couldn't parse range: " + range);
}

/**
 * Used to create a checker that will `and` all the ranges passed in
 * @param ranges
 * @returns 
 */
export function rangeAnd(...ranges: (string | Checker)[]): Checker {
    if (ranges.length === 0) {
        throw new Error('No ranges given');
    }
    let [firstCheck, ...rest] = ranges.map(rangeOf);
    for (const checker of rest) {
        firstCheck = firstCheck.and(checker);
    }
    return firstCheck;
}

/**
 * Used to create a checker that will `or` all the ranges passed in
 * @param ranges
 * @returns 
 */
export function rangeOr(...ranges: (string | Checker)[]): Checker {
    if (ranges.length === 0) {
        throw new Error('No ranges given');
    }
    let [firstCheck, ...rest] = ranges.map(rangeOf);
    for (const checker of rest) {
        firstCheck = firstCheck.or(checker);
    }
    return firstCheck;
}

/**
 * This will negate the checker, so given a checker that checks for >= 1.0.0, it will check for < 1.0.0
 * @param range 
 * @returns 
 */
export function notRange(range: string | Checker): Checker {
    return rangeOf(range).not();
}


/**
 * EmVar is a set of versioning of any pattern like 1 or 1.2 or 1.2.3 or 1.2.3.4 or ..
 */
export class EmVar {
    /**
     * Convert the range, should be 1.2.* or * into a emvar
     * Or an already made emvar
     * IsUnsafe
     */
    static from(range: string | EmVar): EmVar {
        if (range instanceof EmVar) {
            return range
        }
        return EmVar.parse(range)
    }
    /**
     * Convert the range, should be 1.2.* or * into a emvar
     * IsUnsafe
     */
    static parse(range: string): EmVar {
        const values = range.split('.').map(x => parseInt(x));
        for (const value of values) {
            if (isNaN(value)) {
                throw new Error(`Couldn't parse range: ${range}`);
            }
        }
        return new EmVar(values);
    }
    private constructor(public readonly values: number[]) { }

    /**
     * Used when we need a new emvar that has the last number incremented, used in the 1.* like things
     */
    public withLastIncremented() {
        return new EmVar(incrementLastNumber(this.values))
    }

    public greaterThan(other: EmVar): boolean {
        for (const i in this.values) {
            if (other.values[i] == null) {
                return true
            }
            if (this.values[i] > other.values[i]) {
                return true;
            }

            if (this.values[i] < other.values[i]) {
                return false;
            }
        }
        return false;
    }

    public equals(other: EmVar): boolean {
        if (other.values.length !== this.values.length) {
            return false
        }
        for (const i in this.values) {
            if (this.values[i] !== other.values[i]) {
                return false;
            }
        }
        return true;
    }
    public greaterThanOrEqual(other: EmVar): boolean {
        return this.greaterThan(other) || this.equals(other);
    }
    public lessThanOrEqual(other: EmVar): boolean {
        return !this.greaterThan(other);
    }
    public lessThan(other: EmVar): boolean {
        return !this.greaterThanOrEqual(other);
    }
}

/**
 * A checker is a function that takes a version and returns true if the version matches the checker.
 * Used when we are doing range checking, like saying ">=1.0.0".check("1.2.3") will be true
 */
export class Checker {
    constructor(
        /**
         * Check is the function that will be given a emvar or unparsed emvar and should give if it follows
         * a pattern
         */
        public readonly check: (value: string | EmVar) => boolean
    ) { }

    public and(other: Checker): Checker {
        return new Checker((value) => this.check(value) && other.check(value));
    }
    public or(other: Checker): Checker {
        return new Checker((value) => this.check(value) || other.check(value));
    }
    public not(): Checker {
        return new Checker((value) => !this.check(value));
    }
}