'use strict';
exports.__esModule = true;
exports.extend = extend;
exports.clone = clone;
exports.memoize = memoize;
exports.delve = delve;
exports.toArray = toArray;
exports.isFunction = isFunction;
exports.isString = isString;
exports.empty = empty;
exports.falsey = falsey;
exports.styleObjToCss = styleObjToCss;
exports.hashToClassName = hashToClassName;
var _constants = require('./constants');
var createObject = function createObject() {
return {};
};
try {
(function () {
var Obj = function Obj() {} // eslint-disable-line
;
Obj.prototype = Object.create(null);
exports.createObject = createObject = function () {
return new Obj();
};
})();
} catch (e) {}
exports.createObject = createObject;
/** Copy own-properties from `props` onto `obj`.
* @returns obj
* @private
*/
function extend(obj, props) {
for (var i in props) {
Eif (hasOwnProperty.call(props, i)) {
obj[i] = props[i];
}
}return obj;
}
/** Fast clone. Note: does not filter out non-own properties. */
function clone(obj) {
var out = {};
/*eslint guard-for-in:0*/
for (var i in obj) {
out[i] = obj[i];
}return out;
}
/** Create a caching wrapper for the given function.
* @private
*/
function memoize(fn, mem) {
mem = mem || createObject();
// @TODO: if createObject is able to return objects without a prototype, we should use `in`:
// return k => k in mem ? mem[k] : (mem[k] = fn(k));
return function (k) {
return hasOwnProperty.call(mem, k) ? mem[k] : mem[k] = fn(k);
};
}
/** Get a deep property value from the given object, expressed in dot-notation.
* @private
*/
function delve(obj, key) {
for (var p = key.split('.'), i = 0; i < p.length && obj; i++) {
obj = obj[p[i]];
}
return obj;
}
/** Convert an Array-like object to an Array
* @private
*/
function toArray(obj) {
var arr = [],
i = obj.length;
while (i--) arr[i] = obj[i];
return arr;
}
/** @private is the given object a Function? */
function isFunction(obj) {
return 'function' === typeof obj;
}
/** @private is the given object a String? */
function isString(obj) {
return 'string' === typeof obj;
}
/** @private Safe reference to builtin hasOwnProperty */
var hasOwnProperty = ({}).hasOwnProperty;
exports.hasOwnProperty = hasOwnProperty;
/** Check if a value is `null` or `undefined`.
* @private
*/
function empty(x) {
return x === undefined || x === null;
}
/** Check if a value is `null`, `undefined`, or explicitly `false`. */
function falsey(value) {
return value === false || empty(value);
}
/** Convert a hashmap of styles to CSSText
* @private
*/
function styleObjToCss(s) {
var str = '';
/* eslint guard-for-in:0 */
for (var prop in s) {
var val = s[prop];
Eif (!empty(val)) {
if (str) str += ' ';
str += jsToCss(prop);
str += ': ';
str += val;
if (typeof val === 'number' && !_constants.NON_DIMENSION_PROPS[prop]) {
str += 'px';
}
str += ';';
}
}
return str;
}
/** Convert a hashmap of CSS classes to a space-delimited className string
* @private
*/
function hashToClassName(c) {
var str = '';
for (var prop in c) {
if (c[prop]) {
if (str) str += ' ';
str += prop;
}
}
return str;
}
/** Convert a JavaScript camel-case CSS property name to a CSS property name
* @private
* @function
*/
var jsToCss = memoize(function (s) {
return toLowerCase(s.replace(/([A-Z])/g, '-$1'));
});
exports.jsToCss = jsToCss;
/** Just a memoized String.prototype.toLowerCase */
var toLowerCase = memoize(function (s) {
return s.toLowerCase();
});
exports.toLowerCase = toLowerCase;
// For animations, rAF is vastly superior. However, it scores poorly on benchmarks :(
// export const setImmediate = typeof requestAnimationFrame==='function' ? requestAnimationFrame : setTimeout;
var ch = undefined;
try {
ch = new MessageChannel();
} catch (e) {}
/** Call a function asynchronously, as soon as possible.
* @param {Function} callback
*/
var setImmediate = ch ? function (f) {
ch.port1.onmessage = f;
ch.port2.postMessage('');
} : setTimeout;
exports.setImmediate = setImmediate;
|