reclass-doc/dist/Util.js

Reclass model documentation generator.

"use strict";
/**
 * Reclass doc generator
 *
 * @author Jiri Hybek <jiri@hybek.cz>
 * @license Apache-2.0 (c) 2017 Jiri Hybek
 */
Object.defineProperty(exports, "__esModule", { value: true });
var meta2_logger_1 = require("meta2-logger");
/**
 * Clones and object
 *
 * @param obj Object to clone
 */
function clone(obj, exclude) {
    if (exclude === void 0) { exclude = null; }
    var copy;
    // Handle the 3 simple types, and null or undefined
    if (null === obj || "object" != typeof obj)
        return obj;
    // Handle Date
    if (obj instanceof Date) {
        copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }
    // Handle Array
    if (obj instanceof Array) {
        copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = clone(obj[i], exclude);
        }
        return copy;
    }
    // Handle Object
    if (obj instanceof Object) {
        copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) {
                if (exclude && exclude.indexOf(attr) >= 0)
                    copy[attr] = obj[attr];
                else
                    copy[attr] = clone(obj[attr], exclude);
            }
        }
        return copy;
    }
    throw new Error("Unable to copy obj! Its type isn't supported.");
}
exports.clone = clone;
;
/**
 * Deeply compares two objects
 *
 * @param a First object
 * @param b Second object
 */
function deepEqual(a, b, excludeProps) {
    if (!b)
        return false;
    for (var i in a) {
        if (excludeProps && excludeProps.indexOf(i) > 0)
            continue;
        if (a[i] === undefined)
            return false;
        if (a[i] instanceof Object) {
            if (!(b[i] instanceof Object))
                return false;
            var r = deepEqual(a[i], b[i]);
            if (!r)
                return false;
        }
        else {
            if (a[i] !== b[i])
                return false;
        }
    }
    return true;
}
exports.deepEqual = deepEqual;
/**
 * Returns if array deeply contains target object
 *
 * @param arr Array to traverse
 * @param target Target object to check existence
 */
function deepContains(arr, target, excludeProps) {
    if (target instanceof Object) {
        for (var i = 0; i < arr.length; i++) {
            if (!(arr[i] instanceof Object))
                if (arr[i] === target)
                    return true;
            if (deepEqual(arr[i], target, excludeProps))
                return true;
        }
        return false;
    }
    else {
        return arr.indexOf(target) >= 0 ? true : false;
    }
}
exports.deepContains = deepContains;
/**
 * Merges objects
 */
function merge() {
    var objs = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        objs[_i] = arguments[_i];
    }
    var res = {};
    for (var i = 0; i < objs.length; i++)
        for (var k in objs[i])
            res[k] = objs[i][k];
    return res;
}
exports.merge = merge;
/**
 * Class type
 */
var CLASS_TYPE;
(function (CLASS_TYPE) {
    CLASS_TYPE[CLASS_TYPE["CLASS"] = 0] = "CLASS";
    CLASS_TYPE[CLASS_TYPE["NODE"] = 1] = "NODE";
})(CLASS_TYPE = exports.CLASS_TYPE || (exports.CLASS_TYPE = {}));
/**
 * Parses class name from path
 *
 * @param path Path
 * @param delimiter Path delimiter
 */
function parseClassName(type, path, delimiter) {
    if (delimiter === void 0) { delimiter = "/"; }
    var parts = path.split(delimiter);
    var nameParts = [];
    var isInit = false;
    for (var i in parts)
        if (parts[i].trim() != "")
            nameParts.push(parts[i]);
    if (nameParts[nameParts.length - 1] == "init") {
        isInit = true;
        nameParts.pop();
    }
    return {
        path: path,
        fullName: nameParts.join("."),
        name: nameParts[nameParts.length - 1] || null,
        type: type,
        isInit: isInit
    };
}
exports.parseClassName = parseClassName;
/**
 * Parses log level from string to logger level
 *
 * @param level Log level
 */
function parseLogLevel(level) {
    switch (level.toLowerCase()) {
        case 'break':
            return meta2_logger_1.LOG_LEVEL.BREAK;
        case 'debug':
            return meta2_logger_1.LOG_LEVEL.DEBUG;
        case 'info':
            return meta2_logger_1.LOG_LEVEL.INFO;
        case 'warn':
        case 'warning':
            return meta2_logger_1.LOG_LEVEL.WARN;
        case 'error':
            return meta2_logger_1.LOG_LEVEL.ERROR;
        default:
            throw new Error("Unknown log level '" + level + "'.");
    }
}
exports.parseLogLevel = parseLogLevel;