auto-translatr/dist/utils.js

An automatic translation library

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.left = left;
exports.right = right;
exports.isLeft = isLeft;
exports.isRight = isRight;
exports.lift = lift;
exports.liftAsync = liftAsync;
function left(value) {
    return { type: 'left', value };
}
function right(value) {
    return { type: 'right', value };
}
function isLeft(either) {
    return either.type === 'left';
}
function isRight(either) {
    return either.type === 'right';
}
function lift(fn) {
    return {
        flatMap: (fn2) => {
            return lift((value) => {
                const result = fn(value);
                if (isLeft(result))
                    return result;
                return fn2(result.value);
            });
        },
        flatMapVoid: (fn2) => {
            return lift((value) => {
                const result = fn(value);
                if (isLeft(result))
                    return result;
                const voidResult = fn2(result.value);
                if (isLeft(voidResult))
                    return voidResult;
                return right(result.value); // Pass through the original value
            });
        },
        map: (fn2) => {
            return lift((value) => {
                const result = fn(value);
                if (isLeft(result))
                    return result;
                return right(fn2(result.value));
            });
        },
        mapError: (fn2) => {
            return lift((value) => {
                const result = fn(value);
                if (isLeft(result))
                    return left(fn2(result.value));
                return result;
            });
        },
        result: (value) => {
            try {
                return fn(value);
            }
            catch (error) {
                return left(error);
            }
        }
    };
}
function liftAsync(fn) {
    return {
        flatMap: (fn2) => {
            return liftAsync((value) => __awaiter(this, void 0, void 0, function* () {
                const result = yield fn(value);
                if (isLeft(result))
                    return result;
                return yield fn2(result.value);
            }));
        },
        flatMapAll: (fn2) => {
            return liftAsync((value) => __awaiter(this, void 0, void 0, function* () {
                const result = yield fn(value);
                if (isLeft(result))
                    return left(result.value);
                const promises = fn2(result.value);
                const results = yield Promise.all(promises);
                const leftResult = results.find(isLeft);
                if (leftResult)
                    return left(leftResult.value);
                return right(results.map(r => r.value));
            }));
        },
        flatMapVoid: (fn2) => {
            return liftAsync((value) => __awaiter(this, void 0, void 0, function* () {
                const result = yield fn(value);
                if (isLeft(result))
                    return result;
                const voidResult = yield fn2(result.value);
                if (isLeft(voidResult))
                    return voidResult;
                return right(result.value); // Pass through the original value
            }));
        },
        flatMapAllVoid: (fn2) => {
            return liftAsync((value) => __awaiter(this, void 0, void 0, function* () {
                const result = yield fn(value);
                if (isLeft(result))
                    return left(result.value);
                const promises = fn2(result.value);
                const results = yield Promise.all(promises);
                const leftResult = results.find(isLeft);
                if (leftResult)
                    return left(leftResult.value);
                return right(result.value); // Pass through the original value
            }));
        },
        map: (fn2) => {
            return liftAsync((value) => __awaiter(this, void 0, void 0, function* () {
                const result = yield fn(value);
                if (isLeft(result))
                    return result;
                return right(fn2(result.value));
            }));
        },
        mapError: (fn2) => {
            return liftAsync((value) => __awaiter(this, void 0, void 0, function* () {
                const result = yield fn(value);
                if (isLeft(result))
                    return left(fn2(result.value));
                return result;
            }));
        },
        result: (value) => __awaiter(this, void 0, void 0, function* () {
            try {
                return yield fn(value);
            }
            catch (error) {
                return left(error);
            }
        })
    };
}