alwz/build/cjs/models/Converter.cjs

Extendable library for typecasting

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Converter = exports.assertConversion = exports.isConversion = exports.assertFallback = exports.isFallback = exports.assertIS = exports.isIS = void 0;
const ErrorValue_js_1 = __importDefault(require("./ErrorValue.cjs"));
function isIS(input) {
    return typeof input === 'function';
}
exports.isIS = isIS;
function assertIS(input) {
    if (isIS(input))
        return true;
    throw new Converter.InvalidTypeCheckFunction('type check must be a function', input);
}
exports.assertIS = assertIS;
function isFallback(input) {
    return typeof input === 'function';
}
exports.isFallback = isFallback;
function assertFallback(input) {
    if (isFallback(input))
        return true;
    throw new Converter.InvalidFallbackFunction('fallback must be a function', input);
}
exports.assertFallback = assertFallback;
function isConversion(input) {
    return typeof input === 'function';
}
exports.isConversion = isConversion;
function assertConversion(input) {
    if (isConversion(input))
        return true;
    throw new Converter.InvalidConversionFunction('conversion must be a function', input);
}
exports.assertConversion = assertConversion;
class Converter {
    constructor(is, fallback) {
        this.convert = (input) => {
            if (this._is(input))
                return input;
            const type = (typeof input);
            if (type in this._types) {
                const conversion = this._types[type];
                return conversion.call(this, input);
            }
            else {
                for (const is of this._conversions.keys()) {
                    if (is(input)) {
                        const conversion = this._conversions.get(is);
                        return conversion.call(this, input);
                    }
                }
            }
            return this._fallback(input);
        };
        this.is = is;
        this.fallback = fallback;
        this._types = {};
        this._conversions = new Map();
        Object.seal(this);
    }
    get is() {
        return this._is;
    }
    set is(is) {
        assertIS(is);
        this._is = is;
    }
    get fallback() {
        return this._fallback;
    }
    set fallback(fallback) {
        assertFallback(fallback);
        this._fallback = fallback;
    }
    get types() {
        return Object.assign({}, this._types);
    }
    get conversions() {
        return Array.from(this._conversions);
    }
    register(is, conversion) {
        assertIS(is);
        assertConversion(conversion);
        this._conversions.set(is, conversion);
        return this;
    }
    unregister(is) {
        assertIS(is);
        this._conversions.delete(is);
        return this;
    }
    type(name, conversion) {
        if (conversion === undefined) {
            delete this._types[name];
        }
        else {
            assertConversion(conversion);
            this._types[name] = conversion;
        }
        return this;
    }
    undefined(conversion) {
        return this.type('undefined', conversion);
    }
    boolean(conversion) {
        return this.type('boolean', conversion);
    }
    number(conversion) {
        return this.type('number', conversion);
    }
    bigint(conversion) {
        return this.type('bigint', conversion);
    }
    string(conversion) {
        return this.type('string', conversion);
    }
    symbol(conversion) {
        return this.type('symbol', conversion);
    }
    clone() {
        return Converter.build(this._is, this._fallback, this._types, this._conversions);
    }
    static build(is, fallback, types = {}, conversions = []) {
        const converter = new Converter(is, fallback);
        for (const type in types) {
            converter.type(type, types[type]);
        }
        for (const [is, conversion] of conversions) {
            converter.register(is, conversion);
        }
        return converter;
    }
    static assert(input) {
        if (Converter.is(input))
            return true;
        throw new Converter.InvalidConverter('input is not a Converter', input);
    }
}
exports.Converter = Converter;
Converter.InvalidTypeCheckFunction = class extends ErrorValue_js_1.default {
};
Converter.InvalidFallbackFunction = class extends ErrorValue_js_1.default {
};
Converter.InvalidConversionFunction = class extends ErrorValue_js_1.default {
};
Converter.InvalidConverter = class extends ErrorValue_js_1.default {
};
Converter.is = (input) => input instanceof Converter;
exports.default = Converter;
//# sourceMappingURL=Converter.cjs.map