mvdom/dist/utils.js

deprecated - Moved to dom-native package

export function isEmpty(v) {
    const tof = typeof v;
    if (v == null) {
        return true;
    }
    if (v instanceof Array || tof === 'string') {
        return (v.length === 0) ? true : false;
    }
    if (tof === 'object') {
        for (const x in v) {
            return false;
        }
        return true;
    }
    return false;
}
export function val(rootObj, pathToValue, value) {
    const setMode = (typeof value !== "undefined");
    if (!rootObj) {
        return rootObj;
    }
    if (!pathToValue) {
        return rootObj;
    }
    const names = (pathToValue instanceof Array) ? pathToValue : pathToValue.split(".");
    let name, currentNode = rootObj, currentIsMap, nextNode;
    let i = 0, l = names.length, lIdx = l - 1;
    for (i; i < l; i++) {
        name = names[i];
        currentIsMap = (currentNode instanceof Map);
        nextNode = currentIsMap ? currentNode.get(name) : currentNode[name];
        if (setMode) {
            if (i === lIdx) {
                if (currentIsMap) {
                    currentNode.set(name, value);
                }
                else {
                    currentNode[name] = value;
                }
                currentNode = value;
            }
            else {
                if (typeof nextNode === "undefined") {
                    nextNode = {};
                }
                currentNode[name] = nextNode;
                currentNode = nextNode;
            }
        }
        else {
            currentNode = nextNode;
            if (typeof currentNode === "undefined") {
                currentNode = undefined;
                break;
            }
        }
    }
    if (setMode) {
        return rootObj;
    }
    else {
        return currentNode;
    }
}
export function listAsArray(list) {
    const arr = new Array(list.length);
    for (let i = list.length - 1; i >= 0; i--) {
        arr[i] = list[i];
    }
    return arr;
}
export function ensureObject(obj, propName) {
    return _ensure(obj, propName);
}
export function ensureMap(obj, propName) {
    return _ensure(obj, propName, Map);
}
export function ensureSet(obj, propName) {
    return _ensure(obj, propName, Set);
}
export function ensureArray(obj, propName) {
    return _ensure(obj, propName, Array);
}
function _ensure(obj, propName, type) {
    const isMap = (obj instanceof Map);
    let v = (isMap) ? obj.get(propName) : obj[propName];
    if (v == null) {
        v = (type == null) ? {} : (type === Array) ? [] : (new type);
        if (isMap) {
            obj.set(propName, v);
        }
        else {
            obj[propName] = v;
        }
    }
    return v;
}
export function asArray(value) {
    if (value != null) {
        if (value instanceof Array) {
            return value;
        }
        else if (value.constructor && value.constructor.name === "NodeList") {
            return Array.prototype.slice.call(value);
        }
        else if (value.toString() === "[object Arguments]") {
            return Array.prototype.slice.call(value);
        }
        else {
            return [value];
        }
    }
    return [];
}
const emptyArray = Object.freeze([]);
export function asNodeArray(value) {
    if (value != null) {
        if (value instanceof Array) {
            return value;
        }
        else if (value.constructor && value.constructor.name === "NodeList") {
            return Array.prototype.slice.call(value);
        }
        else {
            return [value];
        }
    }
    return emptyArray;
}
export function splitAndTrim(str, sep) {
    if (str == null) {
        return [];
    }
    if (str.indexOf(sep) === -1) {
        return [str.trim()];
    }
    return str.split(sep).map(trim);
}
function trim(str) {
    return str.trim();
}
const _printOnceDone = {};
export function printOnce(msg) {
    if (!_printOnceDone[msg]) {
        console.log(msg);
        _printOnceDone[msg] = true;
    }
}
//# sourceMappingURL=utils.js.map