indexed/lib/utils.js

database-like indexed array that always returns a new array

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.isInvalidObject = isInvalidObject;
exports.isPlainObject = isPlainObject;
exports.isMap = isMap;
exports.anythingToMap = anythingToMap;
exports.copyMap = copyMap;
exports.slice = slice;
exports.assign = assign;
exports.hasOwnProperty = hasOwnProperty;
exports.define = define;
exports.makeDefine = makeDefine;
exports.isArrayLike = isArrayLike;

var _constants = require("./constants");

function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; }

function isInvalidObject(obj) {
	var type = typeof obj === "undefined" ? "undefined" : _typeof(obj);
	return (/number|string|boolean/.test(type) || !obj || obj instanceof Date || obj instanceof RegExp || Array.isArray(obj)
	);
}

function isPlainObject(obj) {
	if (!obj) {
		return false;
	}
	if (obj.constructor && !hasOwnProperty(obj, "constructor") && !hasOwnProperty(obj.constructor.prototype, "isPrototypeOf")) {
		return false;
	}
	for (var key in obj) {}
	return key === undefined || hasOwnProperty(obj, key);
}

function isMap(obj) {
	return obj && obj instanceof Map;
}

function anythingToMap(obj) {
	var recursion = arguments.length <= 1 || arguments[1] === undefined ? 2 : arguments[1];

	if (typeof obj == 'string') {
		var map = new Map();
		map.set(obj, new Map());
		return map;
	}
	if (Array.isArray(obj)) {
		var _ret = (function () {
			var map = new Map();
			obj.forEach(function (key) {
				map.set(key, new Map());
			});
			return {
				v: map
			};
		})();

		if ((typeof _ret === "undefined" ? "undefined" : _typeof(_ret)) === "object") return _ret.v;
	}
	return copyMap(obj, recursion);
}

function copyMap(obj) {
	var recursion = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];

	if (recursion && isMap(obj)) {
		var _ret2 = (function () {
			var ret = new Map();
			obj.forEach(function (map, name) {
				ret.set(name, copyMap(map, recursion - 1));
			});
			return {
				v: ret
			};
		})();

		if ((typeof _ret2 === "undefined" ? "undefined" : _typeof(_ret2)) === "object") return _ret2.v;
	} else if (recursion && isPlainObject(obj)) {
		var ret = new Map();
		for (var name in obj) {
			ret.set(name, copyMap(obj[name], recursion - 1));
		}
		return ret;
	}
	return obj;
}

function slice(arr, start, end) {
	return _constants.arrProto.slice.call(arr, start, end);
}

function assign() {
	var _Object;

	for (var _len = arguments.length, els = Array(_len), _key = 0; _key < _len; _key++) {
		els[_key] = arguments[_key];
	}

	return (_Object = Object).assign.apply(_Object, [{}].concat(els));
}

function hasOwnProperty(obj, prop) {
	return Object.prototype.hasOwnProperty.call(obj, prop);
}

function define(obj, prop, value, enumerable) {
	Object.defineProperty(obj, prop, {
		enumerable: !!enumerable,
		value: value,
		configurable: true,
		writable: true
	});
}

function makeDefine(obj) {
	return function boundDefine(prop, value, enumerable) {
		define(obj, prop, value, enumerable);
	};
}

function isArrayLike(item) {
	return item && (Array.isArray(item) || typeof item !== "function" && typeof item !== "string" && hasOwnProperty(item, "length") && typeof item.length === "number" && (item.length === 0 ||
	//(typeof(item.__indexedProps)!=='undefined') ||
	item.length > 0 && item.length - 1 in item));
}