@freemework/common/lib/cjs/f_ensure.js

Common library of the Freemework Project.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.FEnsure = exports.FEnsureException = void 0;
const index_js_1 = require("./exception/index.js");
class FEnsureException extends index_js_1.FException {
    data;
    constructor(message, data) {
        super(message);
        this.data = data;
    }
}
exports.FEnsureException = FEnsureException;
var FEnsure;
(function (FEnsure) {
    function create(errorFactory) {
        function throwEnsureError(typeMsg, throwData, userErrorMessage) {
            const errorMessage = `Expected data to be "${typeMsg}".`;
            const message = userErrorMessage !== undefined ? `${userErrorMessage} ${errorMessage}` : errorMessage;
            if (errorFactory !== undefined) {
                errorFactory(message, throwData); // throws an user's error
            }
            throw new FEnsureException(message, throwData);
        }
        function Type(data, checker, typeMsg, userErrorMessage) {
            if (!checker(data)) {
                throwEnsureError(typeMsg, data, userErrorMessage);
            }
            return data;
        }
        function NullableType(data, checker, typeMsg, userErrorMessage) {
            if (data === undefined || (data !== null && !checker(data))) {
                throwEnsureError(typeMsg, data, userErrorMessage);
            }
            return data;
        }
        return {
            array: (data, errorMessage) => {
                return Type(data, Array.isArray, "Array", errorMessage);
            },
            arrayBuffer: (data, errorMessage) => {
                return Type(data, isArrayBuffer, "ArrayBuffer", errorMessage);
            },
            boolean: (data, errorMessage) => {
                return Type(data, isBoolean, "boolean", errorMessage);
            },
            date: (data, errorMessage) => {
                return Type(data, isDate, "Date", errorMessage);
            },
            defined: (data, errorMessage) => {
                if (data === undefined || data === null) {
                    const message = errorMessage !== undefined ? errorMessage : "Expected data to be defined";
                    if (errorFactory !== undefined) {
                        errorFactory(message, data); // throws an user's error
                    }
                    throw new FEnsureException(message, data);
                }
                return data;
            },
            integer: (data, errorMessage) => {
                return Type(data, Number.isInteger, "integer", errorMessage);
            },
            number: (data, errorMessage) => {
                return Type(data, isNumber, "number", errorMessage);
            },
            string: (data, errorMessage) => {
                return Type(data, isString, "string", errorMessage);
            },
            undefined: (data, errorMessage) => {
                if (data !== undefined) {
                    const message = errorMessage !== undefined ? errorMessage : "Expected data to be undefined";
                    if (errorFactory !== undefined) {
                        errorFactory(message, data); // throws an user's error
                    }
                    throw new FEnsureException(message, data);
                }
                return data;
            },
            arrayNullable: (data, errorMessage) => {
                return NullableType(data, Array.isArray, "Array", errorMessage);
            },
            arrayBufferNullable: (data, errorMessage) => {
                return NullableType(data, isArrayBuffer, "ArrayBuffer", errorMessage);
            },
            booleanNullable: (data, errorMessage) => {
                return NullableType(data, isBoolean, "boolean", errorMessage);
            },
            dateNullable: (data, errorMessage) => {
                return NullableType(data, isDate, "Date", errorMessage);
            },
            definedNullable: (data, errorMessage) => {
                if (data === undefined) {
                    const message = errorMessage !== undefined ? errorMessage : "Expected data to be defined";
                    if (errorFactory !== undefined) {
                        errorFactory(message, data); // throws an user's error
                    }
                    throw new FEnsureException(message, data);
                }
                return data;
            },
            integerNullable: (data, errorMessage) => {
                return NullableType(data, Number.isInteger, "integer", errorMessage);
            },
            numberNullable: (data, errorMessage) => {
                return NullableType(data, isNumber, "number", errorMessage);
            },
            stringNullable: (data, errorMessage) => {
                return NullableType(data, isString, "string", errorMessage);
            }
        };
    }
    FEnsure.create = create;
})(FEnsure || (exports.FEnsure = FEnsure = {}));
// Copied from lodash@4.17.21
function isObjectLike(value) {
    return value != null && typeof value == 'object';
}
function isNumber(value) {
    return typeof value == 'number' ||
        (isObjectLike(value) && value.toString() == '[object Number]');
}
function isString(value) {
    return typeof value == 'string' ||
        (!Array.isArray(value) && isObjectLike(value) && value.toString() == '[object String]');
}
function isDate(value) {
    return value instanceof Date ||
        (isObjectLike(value) && value.toString() == '[object Date]');
}
function isBoolean(value) {
    return value === true || value === false ||
        (isObjectLike(value) && value.toString() == '[object Boolean]');
}
function isArrayBuffer(value) {
    return isObjectLike(value) && value.toString() == '[object ArrayBuffer]';
}
//# sourceMappingURL=f_ensure.js.map