arch-unit-ts/dist/common/domain/Optional.js

arch-unit-ts

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Optional = void 0;
class Optional {
    static empty() {
        return new EmptyOptional();
    }
    static of(value) {
        return new ValuatedOptional(value);
    }
    static ofUndefinable(value) {
        if (value === undefined) {
            return Optional.empty();
        }
        return Optional.of(value);
    }
}
exports.Optional = Optional;
class EmptyOptional extends Optional {
    map() {
        return Optional.empty();
    }
    flatMap() {
        return Optional.empty();
    }
    or(factory) {
        return factory();
    }
    orElse(value) {
        return value;
    }
    orElseGet(factory) {
        return factory();
    }
    orElseThrow(throwable) {
        if (throwable === undefined) {
            throw new Error("Can't get value from an empty optional");
        }
        throw throwable();
    }
    filter() {
        return this;
    }
    isEmpty() {
        return true;
    }
    isPresent() {
        return false;
    }
    ifPresent() {
    }
    toArray() {
        return [];
    }
}
class ValuatedOptional extends Optional {
    value;
    constructor(value) {
        super();
        this.value = value;
    }
    map(mapper) {
        return Optional.of(mapper(this.value));
    }
    flatMap(mapper) {
        return mapper(this.value);
    }
    or() {
        return Optional.of(this.value);
    }
    orElse() {
        return this.value;
    }
    orElseGet() {
        return this.value;
    }
    orElseThrow() {
        return this.value;
    }
    filter(predicate) {
        if (predicate(this.value)) {
            return this;
        }
        return Optional.empty();
    }
    isEmpty() {
        return false;
    }
    isPresent() {
        return true;
    }
    ifPresent(consumer) {
        consumer(this.value);
    }
    toArray() {
        return [this.value];
    }
}
//# sourceMappingURL=Optional.js.map