fineui/src/core/2.base.js

/**
 * 基本函数
 * Create By GUY 2014\11\17
 *
 */
var traverse = function (func, context) {
    return function (value, key, obj) {
        return func.call(context, key, value, obj);
    };
};
var _apply = function (name) {
    return function () {
        return BI._[name].apply(BI._, arguments);
    };
};
var _applyFunc = function (name) {
    return function () {
        var args = Array.prototype.slice.call(arguments, 0);
        args[1] = BI._.isFunction(args[1]) ? traverse(args[1], args[2]) : args[1];
        return BI._[name].apply(BI._, args);
    };
};

export function assert(v, is) {
    if (isFunction(is)) {
        if (!is(v)) {
            throw new Error(v + " error");
        } else {
            return true;
        }
    }
    if (!isArray(is)) {
        is = [is];
    }
    if (!deepContains(is, v)) {
        throw new Error(v + " error");
    }
    return true;
}

export function warn(message) {
    console.warn(message);
}

export function UUID() {
    var f = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
    var str = "";
    for (var i = 0; i < 16; i++) {
        var r = _global.parseInt(f.length * Math.random(), 10);
        str += f[r];
    }
    return str;
}

export function isWidget(widget) {
    return widget instanceof BI.Widget;
}

export function createWidgets(items, options, context) {
    if (!isArray(items)) {
        throw new Error("items必须是数组", items);
    }
    if (isWidget(options)) {
        context = options;
        options = {};
    } else {
        options || (options = {});
    }
    return map(flatten(items), function (i, item) {
        return BI.createWidget(item, deepClone(options), context);
    });
}

export function createItems(data, innerAttr, outerAttr) {
    innerAttr = isArray(innerAttr) ? innerAttr : makeArray(flatten(data).length, innerAttr || {});
    outerAttr = isArray(outerAttr) ? outerAttr : makeArray(flatten(data).length, outerAttr || {});
    return map(data, function (i, item) {
        if (isArray(item)) {
            return createItems(item, innerAttr, outerAttr);
        }
        if (item instanceof BI.Widget) {
            return extend({}, innerAttr.shift(), outerAttr.shift(), {
                type: null,
                el: item
            });
        }
        if (innerAttr[0] instanceof BI.Widget) {
            outerAttr.shift();
            return extend({}, item, {
                el: innerAttr.shift()
            });
        }
        if (item.el instanceof BI.Widget) {
            innerAttr.shift();
            return extend({}, outerAttr.shift(), { type: null }, item);
        }
        if (item.el) {
            return extend({}, outerAttr.shift(), item, {
                el: extend({}, innerAttr.shift(), item.el)
            });
        }
        return extend({}, outerAttr.shift(), {
            el: extend({}, innerAttr.shift(), item)
        });
    });
}

// 用容器包装items
export function packageItems(items, layouts) {
    for (var i = layouts.length - 1; i >= 0; i--) {
        items = map(items, function (k, it) {
            return extend({}, layouts[i], {
                items: [
                    extend({}, layouts[i].el, {
                        el: it
                    })
                ]
            });
        });
    }
    return items;
}

export function formatEL(obj) {
    if (obj && !obj.type && obj.el) {
        return obj;
    }
    return {
        el: obj
    };
}

// 剥开EL
export function stripEL(obj) {
    return obj.type && obj || obj.el || obj;
}

export function trans2Element(widgets) {
    return map(widgets, (i, wi) => wi.element);
}

// 集合相关方法
BI._.each(["where", "findWhere", "invoke", "pluck", "shuffle", "sample", "toArray", "size"], function (name) {
    BI[name] = _apply(name);
});
BI._.each([
    "get", "set", "each", "map", "reduce", "reduceRight", "find", "filter", "reject", "every", "all", "some", "any", "max", "min",
    "sortBy", "groupBy", "indexBy", "countBy", "partition", "clamp"
], function (name) {
    if (name === "any") {
        BI[name] = _applyFunc("some");
    } else {
        BI[name] = _applyFunc(name);
    }
});
export const where = BI.where;
export const findWhere = BI.findWhere;
export const invoke = BI.invoke;
export const pluck = BI.pluck;
export const shuffle = BI.shuffle;
export const sample = BI.sample;
export const toArray = BI.toArray;
export const size = BI.size;
export const get = BI.get;
export const set = BI.set;
export const each = BI.each;
export const map = BI.map;
export const reduce = BI.reduce;
export const reduceRight = BI.reduceRight;
export const find = BI.find;
export const filter = BI.filter;
export const reject = BI.reject;
export const every = BI.every;
export const all = BI.all;
export const some = BI.some;
export const any = BI.any;
export const max = BI.max;
export const min = BI.min;
export const sortBy = BI.sortBy;
export const groupBy = BI.groupBy;
export const indexBy = BI.indexBy;
export const countBy = BI.countBy;
export const partition = BI.partition;
export const clamp = BI.clamp;

// 数数
export function count(from, to, predicate) {
    var t;
    if (predicate) {
        for (t = from; t < to; t++) {
            predicate(t);
        }
    }
    return to - from;
}

// 倒数
export function inverse(from, to, predicate) {
    return count(to, from, predicate);
}

export function firstKey(obj) {
    let res = undefined;
    any(obj, function (key, value) {
        res = key;
        return true;
    });
    return res;
}

export function lastKey(obj) {
    let res = undefined;
    each(obj, function (key, value) {
        res = key;
        return true;
    });
    return res;
}

export function firstObject(obj) {
    let res = undefined;
    any(obj, function (key, value) {
        res = value;
        return true;
    });
    return res;
}

export function lastObject(obj) {
    let res = undefined;
    each(obj, function (key, value) {
        res = value;
        return true;
    });
    return res;
}

export function concat(obj1, obj2) {
    if (isKey(obj1)) {
        return map([].slice.apply(arguments), function (idx, v) {
            return v;
        }).join("");
    }
    if (isArray(obj1)) {
        return BI._.concat.apply([], arguments);
    }
    if (isObject(obj1)) {
        return extend.apply({}, arguments);
    }
}

export function backEach(obj, predicate, context) {
    predicate = iteratee(predicate, context);
    for (let index = obj.length - 1; index >= 0; index--) {
        predicate(index, obj[index], obj);
    }
    return false;
}

export function backAny(obj, predicate, context) {
    predicate = iteratee(predicate, context);
    for (let index = obj.length - 1; index >= 0; index--) {
        if (predicate(index, obj[index], obj)) {
            return true;
        }
    }
    return false;
}

export function backEvery(obj, predicate, context) {
    predicate = iteratee(predicate, context);
    for (let index = obj.length - 1; index >= 0; index--) {
        if (!predicate(index, obj[index], obj)) {
            return false;
        }
    }
    return true;
}

export function backFindKey(obj, predicate, context) {
    predicate = iteratee(predicate, context);
    let objKeys = keys(obj), key;
    for (let i = objKeys.length - 1; i >= 0; i--) {
        key = objKeys[i];
        if (predicate(obj[key], key, obj)) {
            return key;
        }
    }
}

export function backFind(obj, predicate, context) {
    let key;
    if (isArray(obj)) {
        key = findLastIndex(obj, predicate, context);
    } else {
        key = backFindKey(obj, predicate, context);
    }
    if (key !== void 0 && key !== -1) {
        return obj[key];
    }
}

export function remove(obj, target, context) {
    const targetIsFunction = isFunction(target);
    target = targetIsFunction || isArray(target) ? target : [target];
    let i;
    if (isArray(obj)) {
        for (i = 0; i < obj.length; i++) {
            if ((targetIsFunction && (target === obj[i] || target.apply(context, [i, obj[i]]) === true)) || (!targetIsFunction && contains(target, obj[i]))) {
                obj.splice(i--, 1);
            }
        }
    } else {
        each(obj, function (i, v) {
            if ((targetIsFunction && (target === obj[i] || target.apply(context, [i, obj[i]]) === true)) || (!targetIsFunction && contains(target, obj[i]))) {
                delete obj[i];
            }
        });
    }
}

export function removeAt(obj, index) {
    index = isArray(index) ? index : [index];
    let objIsArray = isArray(obj), i;
    for (i = 0; i < index.length; i++) {
        if (objIsArray) {
            obj[index[i]] = "$deleteIndex";
        } else {
            delete obj[index[i]];
        }
    }
    if (objIsArray) {
        remove(obj, "$deleteIndex");
    }
}

export function string2Array(str) {
    return str.split("&-&");
}

export function array2String(array) {
    return array.join("&-&");
}

export function abc2Int(string) {
    let idx = 0, start = "A", str = string.toUpperCase();
    for (let i = 0, len = str.length; i < len; ++i) {
        idx = str.charAt(i).charCodeAt(0) - start.charCodeAt(0) + 26 * idx + 1;
        if (idx > (2147483646 - str.charAt(i).charCodeAt(0) + start.charCodeAt(0)) / 26) {
            return 0;
        }
    }
    return idx;
}

export function int2Abc(num) {
    const DIGITS = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"];
    let idx = num, str = "";
    if (num === 0) {
        return "";
    }
    while (idx !== 0) {
        let t = idx % 26;
        if (t === 0) {
            t = 26;
        }
        str = DIGITS[t - 1] + str;
        idx = (idx - t) / 26;
    }
    return str;
}

// 数组相关的方法
BI._.each([
    "first", "initial", "last", "rest", "compact", "flatten", "without", "union", "intersection",
    "difference", "zip", "unzip", "object", "indexOf", "lastIndexOf", "sortedIndex", "range", "take", "takeRight", "uniqBy"
], function (name) {
    BI[name] = _apply(name);
});
BI._.each(["findIndex", "findLastIndex"], function (name) {
    BI[name] = _applyFunc(name);
});
export const first = BI.first;
export const initial = BI.initial;
export const last = BI.last;
export const rest = BI.rest;
export const compact = BI.compact;
export const flatten = BI.flatten;
export const without = BI.without;
export const union = BI.union;
export const intersection = BI.intersection;
export const difference = BI.difference;
export const zip = BI.zip;
export const unzip = BI.unzip;
export const object = BI.object;
export const indexOf = BI.indexOf;
export const lastIndexOf = BI.lastIndexOf;
export const sortedIndex = BI.sortedIndex;
export const range = BI.range;
export const take = BI.take;
export const takeRight = BI.takeRight;
export const uniqBy = BI.uniqBy;
export const findIndex = BI.findIndex;
export const findLastIndex = BI.findLastIndex;

// 构建一个长度为length的数组
export function makeArray(length, value) {
    let res = [];
    for (let i = 0; i < length; i++) {
        if (isNull(value)) {
            res.push(i);
        } else {
            res.push(deepClone(value));
        }
    }
    return res;
}

export function makeObject(array, value) {
    let map = {};
    for (let i = 0; i < array.length; i++) {
        if (isNull(value)) {
            map[array[i]] = array[i];
        } else if (isFunction(value)) {
            map[array[i]] = value(i, array[i]);
        } else {
            map[array[i]] = deepClone(value);
        }
    }
    return map;
}

export function makeArrayByArray(array, value) {
    let res = [];
    if (!array) {
        return res;
    }
    for (let i = 0, len = array.length; i < len; i++) {
        if (isArray(array[i])) {
            res.push(makeArrayByArray(array[i], value));
        } else {
            res.push(deepClone(value));
        }
    }
    return res;
}

export function uniq(array, isSorted, iteratee, context) {
    if (array == null) {
        return [];
    }
    if (!isBoolean(isSorted)) {
        context = iteratee;
        iteratee = isSorted;
        isSorted = false;
    }
    iteratee && (iteratee = traverse(iteratee, context));
    return uniq.call(BI._, array, isSorted, iteratee, context);
}

// 对象相关方法
BI._.each([
    "keys", "allKeys", "values", "pairs", "invert", "create", "functions", "extend", "extendOwn",
    "defaults", "clone", "property", "propertyOf", "matcher", "isEqual", "isMatch", "isEmpty",
    "isElement", "isNumber", "isString", "isArray", "isObject", "isPlainObject", "isArguments", "isFunction", "isFinite",
    "isBoolean", "isDate", "isRegExp", "isError", "isNaN", "isUndefined", "zipObject", "cloneDeep"
], function (name) {
    BI[name] = _apply(name);
});
export const keys = BI.keys;
export const allKeys = BI.allKeys;
export const values = BI.values;
export const pairs = BI.pairs;
export const invert = BI.invert;
export const create = BI.create;
export const functions = BI.functions;
export const extend = BI.extend;
export const extendOwn = BI.extendOwn;
export const defaults = BI.defaults;
export const clone = BI.clone;
export const property = BI.property;
export const propertyOf = BI.propertyOf;
export const matcher = BI.matcher;
export const isEqual = BI.isEqual;
export const isMatch = BI.isMatch;
export const isEmpty = BI.isEmpty;
export const isElement = BI.isElement;
export const isNumber = BI.isNumber;
export const isString = BI.isString;
export const isArray = BI.isArray;
export const isObject = BI.isObject;
export const isPlainObject = BI.isPlainObject;
export const isArguments = BI.isArguments;
export const isFunction = BI.isFunction;
export const isFinite = BI.isFinite;
export const isBoolean = BI.isBoolean;
export const isDate = BI.isDate;
export const isRegExp = BI.isRegExp;
export const isError = BI.isError;
export const isNaN = BI.isNaN;
export const isUndefined = BI.isUndefined;
export const zipObject = BI.zipObject;
export const cloneDeep = BI.cloneDeep;

BI._.each(["mapObject", "findKey", "pick", "omit", "tap"], function (name) {
    BI[name] = _applyFunc(name);
});
export const mapObject = BI.mapObject;
export const findKey = BI.findKey;
export const pick = BI.pick;
export const omit = BI.omit;
export const tap = BI.tap;

export function inherit(sp, overrides) {
    let sb = function () {
        return sp.apply(this, arguments);
    };
    let F = function () {
    }, spp = sp.prototype;
    F.prototype = spp;
    sb.prototype = new F();
    sb.superclass = spp;
    extend(sb.prototype, overrides, {
        superclass: sp
    });
    return sb;
}

export function init() {
    // 先把准备环境准备好
    while (BI.prepares && BI.prepares.length > 0) {
        BI.prepares.shift()();
    }
    while (_global.___fineuiExposedFunction && _global.___fineuiExposedFunction.length > 0) {
        _global.___fineuiExposedFunction.shift()();
    }
    BI.initialized = true;
}

export function has(obj, keys) {
    if (isArray(keys)) {
        if (keys.length === 0) {
            return false;
        }
        return every(keys, function (i, key) {
            return BI._.has(obj, key);
        });
    }
    return BI._.has.apply(BI._, arguments);
}

export function freeze(value) {
    // 在ES5中，如果这个方法的参数不是一个对象（一个原始值），那么它会导致 TypeError
    // 在ES2015中，非对象参数将被视为要被冻结的普通对象，并被简单地返回
    if (Object.freeze && isObject(value)) {
        return Object.freeze(value);
    }
    return value;
}

// 数字和字符串可以作为key
export function isKey(key) {
    return isNumber(key) || (isString(key) && key.length > 0);
}

// 忽略大小写的等于
export function isCapitalEqual(a, b) {
    a = isNull(a) ? a : ("" + a).toLowerCase();
    b = isNull(b) ? b : ("" + b).toLowerCase();
    return isEqual(a, b);
}

export function isWidthOrHeight(w) {
    if (typeof w === "number") {
        return w >= 0;
    } else if (typeof w === "string") {
        return /^\d{1,3}(\.\d)?%$/.test(w) || w === "auto" || /^\d+(\.\d+)?px$/.test(w) || /^calc/.test(w);
    }
}

export function isNotNull(obj) {
    return !isNull(obj);
}

export function isNull(obj) {
    return typeof obj === "undefined" || obj === null;
}

export function isEmptyArray(arr) {
    return isArray(arr) && isEmpty(arr);
}

export function isNotEmptyArray(arr) {
    return isArray(arr) && !isEmpty(arr);
}

export function isEmptyObject(obj) {
    return isEqual(obj, {});
}

export function isNotEmptyObject(obj) {
    return isPlainObject(obj) && !isEmptyObject(obj);
}

export function isWindow(obj) {
    return obj != null && obj == obj.window;
}

export function isPromise(obj) {
    return !!obj && (isObject(obj) || isFunction(obj)) && isFunction(obj.then);
}

export const deepClone = BI._.cloneDeep;
export const deepExtend = BI._.deepExtend;

export function isDeepMatch(object, attrs) {
    let attrsKeys = keys(attrs), length = attrsKeys.length;
    if (object == null) {
        return !length;
    }
    const obj = Object(object);
    for (let i = 0; i < length; i++) {
        const key = attrsKeys[i];
        if (!isEqual(attrs[key], obj[key]) || !(key in obj)) {
            return false;
        }
    }
    return true;
}

export function contains(obj, target, fromIndex) {
    if (!BI._.isArrayLike(obj)) obj = values(obj);
    return indexOf(obj, target, typeof fromIndex === "number" && fromIndex) >= 0;
}

export function deepContains(obj, copy) {
    if (isObject(copy)) {
        return any(obj, (i, v) => isEqual(v, copy));
    }
    return contains(obj, copy);
}

export function deepIndexOf(obj, target) {
    for (let i = 0; i < obj.length; i++) {
        if (isEqual(target, obj[i])) {
            return i;
        }
    }
    return -1;
}

export function deepRemove(obj, target) {
    let done = false;
    let i;
    if (isArray(obj)) {
        for (i = 0; i < obj.length; i++) {
            if (isEqual(target, obj[i])) {
                obj.splice(i--, 1);
                done = true;
            }
        }
    } else {
        each(obj, (i, v) => {
            if (isEqual(target, obj[i])) {
                delete obj[i];
                done = true;
            }
        });
    }
    return done;
}

export function deepWithout(obj, target) {
    if (isArray(obj)) {
        let result = [];
        for (let i = 0; i < obj.length; i++) {
            if (!isEqual(target, obj[i])) {
                result.push(obj[i]);
            }
        }
        return result;
    }
    let result = {};
    each(obj, (i, v) => {
        if (!isEqual(target, obj[i])) {
            result[i] = v;
        }
    });
    return result;
}

export function deepUnique(array) {
    let result = [];
    each(array, (i, item) => {
        if (!deepContains(result, item)) {
            result.push(item);
        }
    });
    return result;
}

// 比较两个对象得出不一样的key值
export function deepDiff(object, other) {
    object || (object = {});
    other || (other = {});
    let result = [];
    let used = [];
    for (let b in object) {
        if (has(object, b)) {
            if (!isEqual(object[b], other[b])) {
                result.push(b);
            }
            used.push(b);
        }
    }
    for (let b in other) {
        if (has(other, b) && !contains(used, b)) {
            result.push(b);
        }
    }
    return result;
}

// 通用方法
BI._.each(["uniqueId", "result", "chain", "iteratee", "unescape", "before", "after", "chunk"], function (name) {
    BI[name] = function () {
        return BI._[name].apply(BI._, arguments);
    };
});
export const uniqueId = BI.uniqueId;
export const result = BI.result;
export const chain = BI.chain;
export const iteratee = BI.iteratee;
export const unescape = BI.unescape;
export const before = BI.before;
export const after = BI.after;
export const chunk = BI.chunk;

// 事件相关方法
BI._.each(["bind", "once", "partial", "debounce", "throttle", "delay", "defer", "wrap"], function (name) {
    BI[name] = function () {
        return BI._[name].apply(BI._, arguments);
    };
});
export const bind = BI.bind;
export const once = BI.once;
export const partial = BI.partial;
export const debounce = BI.debounce;
export const throttle = BI.throttle;
export const delay = BI.delay;
export const defer = BI.defer;
export const wrap = BI.wrap;

export const nextTick = (function () {
    let callbacks = [];
    let pending = false;
    let timerFunc = void 0;

    function nextTickHandler() {
        pending = false;
        let copies = callbacks.slice(0);
        callbacks.length = 0;
        for (let i = 0; i < copies.length; i++) {
            copies[i]();
        }
    }

    if (typeof Promise !== "undefined") {
        let p = Promise.resolve();
        timerFunc = function timerFunc() {
            p.then(nextTickHandler);
        };
    } else if (typeof MutationObserver !== "undefined") {
        let counter = 1;
        let observer = new MutationObserver(nextTickHandler);
        let textNode = document.createTextNode(String(counter));
        observer.observe(textNode, {
            characterData: true
        });
        timerFunc = function timerFunc() {
            counter = (counter + 1) % 2;
            textNode.data = String(counter);
        };
    } else if (typeof setImmediate !== "undefined") {
        timerFunc = function timerFunc() {
            setImmediate(nextTickHandler);
        };
    } else {
        // Fallback to setTimeout.
        timerFunc = function timerFunc() {
            setTimeout(nextTickHandler, 0);
        };
    }

    return function queueNextTick(cb) {
        let _resolve = void 0;
        let args = [].slice.call(arguments, 1);
        callbacks.push(function () {
            if (cb) {
                try {
                    cb.apply(null, args);
                } catch (e) {
                    console.error(e);
                }
            } else if (_resolve) {
                _resolve.apply(null, args);
            }
        });
        if (!pending) {
            pending = true;
            timerFunc();
        }
        // $flow-disable-line
        if (!cb && typeof Promise !== 'undefined') {
            return new Promise(function (resolve, reject) {
                _resolve = resolve;
            });
        }
    };
})();

// 数字相关方法
BI._.each(["random"], function (name) {
    BI[name] = _apply(name);
});
export const random = BI.random;

export function parseInt(number) {
    let radix = 10;
    if (/^0x/g.test(number)) {
        radix = 16;
    }
    try {
        return _global.parseInt(number, radix);
    } catch (e) {
        throw new Error(number + "parse int error");
        return NaN;
    }
}

export function parseSafeInt(value) {
    let MAX_SAFE_INTEGER = 9007199254740991;
    return value
        ? clamp(parseInt(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
        : (value === 0 ? value : 0);
}

export function parseFloat(number) {
    try {
        return _global.parseFloat(number);
    } catch (e) {
        throw new Error(number + "parse float error");
        return NaN;
    }
}

export function isNaturalNumber(number) {
    return /^\d+$/.test(number);
}

export function isPositiveInteger(number) {
    return /^\+?[1-9][0-9]*$/.test(number);
}

export function isNegativeInteger(number) {
    return /^\-[1-9][0-9]*$/.test(number);
}

export function isInteger(number) {
    return /^\-?\d+$/.test(number);
}

export function isNumeric(number) {
    return !_global.isNaN(_global.parseFloat(number)) && _global.isFinite(number);
}

export function isFloat(number) {
    return /^([+-]?)\d*\.\d+$/.test(number);
}

export function isOdd(number) {
    if (!isInteger(number)) {
        return false;
    }
    return (number & 1) === 1;
}

export function isEven(number) {
    if (!isInteger(number)) {
        return false;
    }
    return (number & 1) === 0;
}

export function sum(array, iteratee, context) {
    let sum = 0;
    each(array, (i, item) => {
        if (iteratee) {
            sum += Number(iteratee.apply(context, [i, item]));
        } else {
            sum += Number(item);
        }
    });
    return sum;
}

export function average(array, iteratee, context) {
    const sumResult = sum(array, iteratee, context);
    return sumResult / array.length;
}

export function trim() {
    return BI._.trim.apply(BI._, arguments);
}

export function toUpperCase(string) {
    return (string + "").toLocaleUpperCase();
}

export function toLowerCase(string) {
    return (string + "").toLocaleLowerCase();
}

export function isEndWithBlank(string) {
    return /(\s|\u00A0)$/.test(string);
}

export function isLiteral(exp) {
    return /^\s?(true|false|-?[\d\.]+|'[^']*'|"[^"]*")\s?$/.test(exp);
}

export function stripQuotes(str) {
    const a = str.charCodeAt(0);
    const b = str.charCodeAt(str.length - 1);
    return a === b && (a === 0x22 || a === 0x27)
        ? str.slice(1, -1)
        : str;
}

// background-color => backgroundColor
export function camelize(str) {
    return str.replace(/-(.)/g, (_, character) => character.toUpperCase());
}

// backgroundColor => background-color
export function hyphenate(str) {
    return str.replace(/([A-Z])/g, "-$1").toLowerCase();
}

export function isNotEmptyString(str) {
    return isString(str) && !isEmpty(str);
}

export function isEmptyString(str) {
    return isString(str) && isEmpty(str);
}

/**
 * 通用解密方法
 * @param type 解密方式
 * @param text 文本
 * @param key 种子
 * @return {*}
 */
export function encrypt(type, text, key) {
    switch (type) {
        case BI.CRYPT_TYPE.AES:
        default:
            return BI.aesEncrypt(text, key);
    }
}

/**
 * 通用解密方法
 * @param type 解密方式
 * @param text 文本
 * @param key 种子
 * @return {*}
 */
export function decrypt(type, text, key) {
    switch (type) {
        case BI.CRYPT_TYPE.AES:
        default:
            return BI.aesDecrypt(text, key);
    }
}

/**
 * 对字符串中的'和\做编码处理
 * @static
 * @param {String} string 要做编码处理的字符串
 * @return {String} 编码后的字符串
 */
export function escape(string) {
    return string.replace(/('|\\)/g, "\\$1");
}


/**
 * 让字符串通过指定字符做补齐的函数
 *
 *      var s = BI.leftPad('123', 5, '0');//s的值为：'00123'
 *
 * @static
 * @param {String} val 原始值
 * @param {Number} size 总共需要的位数
 * @param {String} ch 用于补齐的字符
 * @return {String}  补齐后的字符串
 */
export function leftPad(val, size, ch) {
    let result = String(val);
    if (!ch) {
        ch = " ";
    }
    while (result.length < size) {
        result = ch + result;
    }
    return result.toString();
}

/**
 * 对字符串做替换的函数
 *
 *      var cls = 'my-class', text = 'Some text';
 *      var res = BI.format('<div class="{0}">{1}</div>', cls, text);
 *      //res的值为：'<div class="my-class">Some text</div>';
 *
 * @static
 * @param {String} format 要做替换的字符串，替换字符串1，替换字符串2...
 * @return {String} 做了替换后的字符串
 */
export function format(format) {
    var args = Array.prototype.slice.call(arguments, 1);
    return format.replace(/\{(\d+)\}/g, (m, i) => args[i]);
}

/**
 * 是否是闰年
 * @param year
 * @returns {boolean}
 */
export function isLeapYear(year) {
    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
}

/**
 * 检测是否在有效期
 *
 * @param YY 年
 * @param MM 月
 * @param DD 日
 * @param minDate '1900-01-01'
 * @param maxDate '2099-12-31'
 * @returns {Array} 若无效返回无效状态,数组第一位为无效属性,第二位缺省为超下限,1为超上限
 */
export function checkDateVoid(YY, MM, DD, minDate, maxDate) {
    let back = [];
    YY = YY | 0;
    MM = MM | 0;
    DD = DD | 0;
    minDate = isString(minDate) ? minDate.match(/\d+/g) : minDate;
    maxDate = isString(maxDate) ? maxDate.match(/\d+/g) : maxDate;
    if (YY < minDate[0]) {
        back = ["y"];
    } else if (YY > maxDate[0]) {
        back = ["y", 1];
    } else if (YY >= minDate[0] && YY <= maxDate[0]) {
        if (YY == minDate[0]) {
            if (MM < minDate[1]) {
                back = ["m"];
            } else if (MM == minDate[1]) {
                if (DD < minDate[2]) {
                    back = ["d"];
                }
            }
        }
        if (YY == maxDate[0]) {
            if (MM > maxDate[1]) {
                back = ["m", 1];
            } else if (MM == maxDate[1]) {
                if (DD > maxDate[2]) {
                    back = ["d", 1];
                }
            }
        }
    }
    return back;
}

export function checkDateLegal(str) {
    const ar = str.match(/\d+/g);
    const YY = ar[0] | 0, MM = ar[1] | 0, DD = ar[2] | 0;
    if (ar.length <= 1) {
        return true;
    }
    if (ar.length <= 2) {
        return MM >= 1 && MM <= 12;
    }
    let MD = BI.Date._MD.slice(0);
    MD[1] = isLeapYear(YY) ? 29 : 28;
    return MM >= 1 && MM <= 12 && DD <= MD[MM - 1];
}

/** 解析日期时间字符串
 *
 * @param str
 * @param fmt
 * @returns {Date|Date}
 * 年月日缺省值为当前日期, 时分秒缺省值为0
 */
export function parseDateTime(str, fmt) {
    const today = BI.getDate();
    let y;
    let m;
    let d;
    // wei : 对于fmt为‘YYYYMM’或者‘YYYYMMdd’的格式，str的值为类似'201111'的形式，因为年月之间没有分隔符，所以正则表达式分割无效，导致bug7376。
    let a = str.split(/\W+/);
    if (fmt.toLowerCase() == "%y%x" || fmt.toLowerCase() == "%y%x%d") {
        let yearlength = 4;
        let otherlength = 2;
        a[0] = str.substring(0, yearlength);
        a[1] = str.substring(yearlength, yearlength + otherlength);
        a[2] = str.substring(yearlength + otherlength, yearlength + otherlength * 2);
    }
    let b = fmt.match(/%./g);
    let i = 0, j = 0;
    let hr = 0;
    let min = 0;
    let sec = 0;
    for (i = 0; i < a.length; ++i) {
        switch (b[i]) {
            case "%d":
            case "%e":
                d = _global.parseInt(a[i], 10);
                break;

            case "%X":
                m = _global.parseInt(a[i], 10) - 1;
                break;
            case "%x":
                m = _global.parseInt(a[i], 10) - 1;
                break;

            case "%Y":
            case "%y":
                y = _global.parseInt(a[i], 10);
                (y < 100) && (y += (y > 29) ? 1900 : 2000);
                break;

            case "%b":
            case "%B":
                for (j = 0; j < 12; ++j) {
                    if (BI.getMonthName(j).substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) {
                        m = j;
                        break;
                    }
                }
                break;

            case "%H":
            case "%I":
            case "%k":
            case "%l":
                hr = _global.parseInt(a[i], 10);
                break;

            case "%P":
            case "%p":
                if (/pm/i.test(a[i]) && hr < 12) {
                    hr += 12;
                } else if (/am/i.test(a[i]) && hr >= 12) {
                    hr -= 12;
                }
                break;
            case "%Q":
            case "%q":
                m = (_global.parseInt(a[i], 10) - 1) * 3;
                break;
            case "%M":
                min = _global.parseInt(a[i], 10);
                break;
            case "%S":
                sec = _global.parseInt(a[i], 10);
                break;
        }
    }
    //    if (!a[i]) {
    //        continue;
    //	}
    if (isNaN(y)) {
        y = today.getFullYear();
    }
    if (isNaN(m)) {
        m = today.getMonth();
    }
    if (isNaN(d)) {
        d = today.getDate();
    }
    if (isNaN(hr)) {
        hr = today.getHours();
    }
    if (isNaN(min)) {
        min = today.getMinutes();
    }
    if (isNaN(sec)) {
        sec = today.getSeconds();
    }
    if (y != 0) {
        return BI.getDate(y, m, d, hr, min, sec);
    }
    y = 0;
    m = -1;
    d = 0;
    for (i = 0; i < a.length; ++i) {
        if (a[i].search(/[a-zA-Z]+/) != -1) {
            let t = -1;
            for (j = 0; j < 12; ++j) {
                if (BI.getMonthName(j).substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) {
                    t = j;
                    break;
                }
            }
            if (t != -1) {
                if (m != -1) {
                    d = m + 1;
                }
                m = t;
            }
        } else if (_global.parseInt(a[i], 10) <= 12 && m == -1) {
            m = a[i] - 1;
        } else if (_global.parseInt(a[i], 10) > 31 && y == 0) {
            y = _global.parseInt(a[i], 10);
            (y < 100) && (y += (y > 29) ? 1900 : 2000);
        } else if (d == 0) {
            d = a[i];
        }
    }
    if (y == 0) {
        y = today.getFullYear();
    }
    if (m === -1) {
        m = today.getMonth();
    }
    if (m != -1 && d != 0) {
        return BI.getDate(y, m, d, hr, min, sec);
    }
    return today;
}

export function getDate(...args) {
    const length = args.length;
    let dt;
    switch (length) {
        // new Date()
        case 0:
            dt = new Date();
            break;
        // new Date(long)
        case 1:
            dt = new Date(args[0]);
            break;
        // new Date(year, month)
        case 2:
            dt = new Date(args[0], args[1]);
            break;
        // new Date(year, month, day)
        case 3:
            dt = new Date(args[0], args[1], args[2]);
            break;
        // new Date(year, month, day, hour)
        case 4:
            dt = new Date(args[0], args[1], args[2], args[3]);
            break;
        // new Date(year, month, day, hour, minute)
        case 5:
            dt = new Date(args[0], args[1], args[2], args[3], args[4]);
            break;
        // new Date(year, month, day, hour, minute, second)
        case 6:
            dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5]);
            break;
        // new Date(year, month, day, hour, minute, second, millisecond)
        case 7:
            dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
            break;
        default:
            dt = new Date();
            break;
    }
    if (isNotNull(BI.timeZone) && (arguments.length === 0 || (arguments.length === 1 && isNumber(arguments[0])))) {
        const localTime = dt.getTime();
        // BI-33791 1901年以前的东8区标准是GMT+0805, 统一无论是什么时间，都以整的0800这样的为基准
        const localOffset = dt.getTimezoneOffset() * 60000; // 获得当地时间偏移的毫秒数
        const utc = localTime + localOffset; // utc即GMT时间标准时区
        return new Date(utc + BI.timeZone);// + Pool.timeZone.offset);
    }
    return dt;
}

export function getTime() {
    const length = arguments.length;
    const args = arguments;
    let dt;
    switch (length) {
        // new Date()
        case 0:
            dt = new Date();
            break;
        // new Date(long)
        case 1:
            dt = new Date(args[0]);
            break;
        // new Date(year, month)
        case 2:
            dt = new Date(args[0], args[1]);
            break;
        // new Date(year, month, day)
        case 3:
            dt = new Date(args[0], args[1], args[2]);
            break;
        // new Date(year, month, day, hour)
        case 4:
            dt = new Date(args[0], args[1], args[2], args[3]);
            break;
        // new Date(year, month, day, hour, minute)
        case 5:
            dt = new Date(args[0], args[1], args[2], args[3], args[4]);
            break;
        // new Date(year, month, day, hour, minute, second)
        case 6:
            dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5]);
            break;
        // new Date(year, month, day, hour, minute, second, millisecond)
        case 7:
            dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
            break;
        default:
            dt = new Date();
            break;
    }
    if (isNotNull(BI.timeZone)) {
        // BI-33791 1901年以前的东8区标准是GMT+0805, 统一无论是什么时间，都以整的0800这样的为基准
        return dt.getTime() - BI.timeZone - new Date().getTimezoneOffset() * 60000;
    }
    return dt.getTime();
}