widjet-utils/lib/index.js

JS utilities for widjet widgets

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.merge = merge;
exports.clone = clone;
exports.curry = curry;
exports.curryN = curryN;
exports.compose = compose;
exports.pipe = pipe;
exports.clearNodeCache = clearNodeCache;
exports.getNode = getNode;
exports.getNodes = getNodes;
exports.cloneNode = cloneNode;
exports.nodeIndex = nodeIndex;
exports.detachNode = detachNode;
exports.animate = animate;
exports.eachParent = eachParent;
exports.parents = parents;
exports.parent = parent;
exports.nodeAndParents = nodeAndParents;
exports.addDelegatedEventListener = addDelegatedEventListener;
exports.domEvent = exports.createEventObject = exports.createEvent = exports.newEvent = exports.mapEach = exports.fill = exports.log = exports.inputName = exports.asDataAttributes = exports.asPair = exports.asArray = exports.when = exports.init = exports.tail = exports.last = exports.head = exports.never = exports.always = exports.identity = exports.apply = exports.curry4 = exports.curry3 = exports.curry2 = exports.curry1 = void 0;

var _widjetDisposables = require("widjet-disposables");

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

//  ######  ######## ########
// ##    ##    ##    ##     ##
// ##          ##    ##     ##
//  ######     ##    ##     ##
//       ##    ##    ##     ##
// ##    ##    ##    ##     ##
//  ######     ##    ########
function merge(a, b) {
  var c = {};

  for (var k in a) {
    c[k] = a[k];
  }

  for (var _k in b) {
    c[_k] = b[_k];
  }

  return c;
}

function clone(object) {
  var copy = {};

  for (var k in object) {
    copy[k] = object[k];
  }

  return copy;
}

var slice = Array.prototype.slice;

var _curry = function _curry(n, fn) {
  var curryArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
  return function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    var concatArgs = curryArgs.concat(args);
    return n > concatArgs.length ? _curry(n, fn, concatArgs) : fn.apply(null, concatArgs);
  };
};

function curry(fn) {
  return _curry(fn.length, fn);
}

function curryN(n, fn) {
  return _curry(n, fn);
}

var curry1 = curryN(2, curryN)(1);
exports.curry1 = curry1;
var curry2 = curryN(2, curryN)(2);
exports.curry2 = curry2;
var curry3 = curryN(2, curryN)(3);
exports.curry3 = curry3;
var curry4 = curryN(2, curryN)(4);
exports.curry4 = curry4;
var apply = curry2(function (fn, args) {
  return fn.apply(null, args);
});
exports.apply = apply;

var identity = function identity(a) {
  return a;
};

exports.identity = identity;

var always = function always(a) {
  return true;
};

exports.always = always;

var never = function never(a) {
  return false;
};

exports.never = never;

var head = function head(a) {
  return a[0];
};

exports.head = head;

var last = function last(a) {
  return a[a.length - 1];
};

exports.last = last;

var tail = function tail(a) {
  return a.slice(1);
};

exports.tail = tail;

var init = function init(a) {
  return a.slice(0, -1);
};

exports.init = init;
var when = curry2(function (predicates) {
  for (var _len2 = arguments.length, values = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
    values[_key2 - 1] = arguments[_key2];
  }

  var doWhen = function doWhen(a) {
    var _head = head(a),
        _head2 = _slicedToArray(_head, 2),
        predicate = _head2[0],
        resolve = _head2[1];

    return predicate.apply(void 0, values) ? resolve.apply(void 0, values) : doWhen(tail(a));
  };

  return doWhen(predicates);
});
exports.when = when;

function compose() {
  for (var _len3 = arguments.length, fns = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    fns[_key3] = arguments[_key3];
  }

  fns.push(apply(fns.pop()));
  return function () {
    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
      args[_key4] = arguments[_key4];
    }

    return fns.reduceRight(function (memo, fn) {
      return fn(memo);
    }, args);
  };
}

function pipe() {
  for (var _len5 = arguments.length, fns = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
    fns[_key5] = arguments[_key5];
  }

  fns[0] = apply(fns[0]);
  return function () {
    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
      args[_key6] = arguments[_key6];
    }

    return fns.reduce(function (memo, fn) {
      return fn(memo);
    }, args);
  };
}

var asArray = function asArray(collection) {
  return slice.call(collection);
};

exports.asArray = asArray;

var asPair = function asPair(object) {
  return Object.keys(object).map(function (k) {
    return [k, object[k]];
  });
};

exports.asPair = asPair;

var asDataAttributes = function asDataAttributes(o) {
  return asPair(o).map(function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        k = _ref2[0],
        v = _ref2[1];

    return typeof v === 'boolean' ? v ? k : '' : "".concat(k, "=\"").concat(v, "\"");
  }).map(function (s) {
    return "data-".concat(s);
  }).join(' ');
};

exports.asDataAttributes = asDataAttributes;

var inputName = function inputName() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
    prefix: '[',
    suffix: ']'
  };
  var prefix = options.prefix || '';
  var suffix = options.suffix || '';
  return function () {
    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
      args[_key7] = arguments[_key7];
    }

    return [head(args)].concat(tail(args).map(function (s) {
      return "".concat(prefix).concat(s).concat(suffix);
    })).join('');
  };
};

exports.inputName = inputName;

var log = function log(v) {
  console.log(v);
  return v;
};

exports.log = log;
var fill = curry2(function (len, value) {
  return new Array(len).fill(value);
});
exports.fill = fill;
var mapEach = curry2(function (maps, values) {
  return values.map(function (v, i) {
    return maps[i % maps.length](v);
  });
}); // ########   #######  ##     ##
// ##     ## ##     ## ###   ###
// ##     ## ##     ## #### ####
// ##     ## ##     ## ## ### ##
// ##     ## ##     ## ##     ##
// ##     ## ##     ## ##     ##
// ########   #######  ##     ##

exports.mapEach = mapEach;
var previewNodes = {};

function clearNodeCache() {
  Object.keys(previewNodes).forEach(function (key) {
    delete previewNodes[key];
  });
}

function getNode(html) {
  var nodeType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'div';

  if (!html) {
    return undefined;
  }

  if (previewNodes[nodeType] == null) {
    previewNodes[nodeType] = document.createElement(nodeType);
  }

  var previewNode = previewNodes[nodeType];
  previewNode.innerHTML = html;
  var node = previewNode.firstElementChild;

  if (node) {
    previewNode.removeChild(node);
  }

  previewNode.innerHTML = '';
  return node || null;
}

function getNodes(html) {
  var nodeType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'div';

  if (!html) {
    return [];
  }

  if (previewNodes[nodeType] == null) {
    previewNodes[nodeType] = document.createElement(nodeType);
  }

  var previewNode = previewNodes[nodeType];
  previewNode.innerHTML = html;
  var nodes = asArray(previewNode.childNodes);
  nodes.forEach(function (n) {
    return previewNode.removeChild(n);
  });
  previewNode.innerHTML = '';
  return nodes;
}

function cloneNode(node) {
  return node ? getNode(node.outerHTML) : undefined;
}

function nodeIndex(node) {
  return node && node.parentNode ? [].indexOf.call(node.parentNode.children, node) : -1;
}

function detachNode(node) {
  node && node.parentNode && node.parentNode.removeChild(node);
}

function animate(_ref3) {
  var from = _ref3.from,
      to = _ref3.to,
      duration = _ref3.duration,
      step = _ref3.step,
      end = _ref3.end;
  var start = getTime();
  update();

  function getTime() {
    return new Date();
  }

  function swing(progress) {
    return 0.5 - Math.cos(progress * Math.PI) / 2;
  }

  function update() {
    var passed = getTime() - start;
    var progress = Math.min(1, duration === 0 ? 1 : passed / duration);
    var delta = swing(progress);
    step(from + (to - from) * delta, delta);
    progress < 1 ? window.requestAnimationFrame(update) : end && end();
  }
} // ########     ###    ########  ######## ##    ## ########  ######
// ##     ##   ## ##   ##     ## ##       ###   ##    ##    ##    ##
// ##     ##  ##   ##  ##     ## ##       ####  ##    ##    ##
// ########  ##     ## ########  ######   ## ## ##    ##     ######
// ##        ######### ##   ##   ##       ##  ####    ##          ##
// ##        ##     ## ##    ##  ##       ##   ###    ##    ##    ##
// ##        ##     ## ##     ## ######## ##    ##    ##     ######


function eachParent(node, block) {
  var parent = node.parentNode;

  while (parent) {
    block(parent);

    if (parent.nodeName === 'HTML') {
      break;
    }

    parent = parent.parentNode;
  }
}

function parents(node) {
  var selector = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '*';
  var parentNodes = [];
  eachParent(node, function (parent) {
    if (parent.matches && parent.matches(selector)) {
      parentNodes.push(parent);
    }
  });
  return parentNodes;
}

function parent(node) {
  var selector = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '*';
  return parents(node, selector)[0];
}

function nodeAndParents(node) {
  var selector = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '*';
  return [node].concat(parents(node, selector));
} // ######## ##     ## ######## ##    ## ########  ######
// ##       ##     ## ##       ###   ##    ##    ##    ##
// ##       ##     ## ##       ####  ##    ##    ##
// ######   ##     ## ######   ## ## ##    ##     ######
// ##        ##   ##  ##       ##  ####    ##          ##
// ##         ## ##   ##       ##   ###    ##    ##    ##
// ########    ###    ######## ##    ##    ##     ######


function appendData(data, event) {
  if (data) {
    event.data = data;
  }

  return event;
}

var newEvent = function newEvent(type, data, props) {
  return appendData(data, new window.Event(type, {
    bubbles: props.bubbles != null ? props.bubbles : true,
    cancelable: props.cancelable != null ? props.cancelable : true
  }));
};

exports.newEvent = newEvent;

var createEvent = function createEvent(type, data, props) {
  var event = document.createEvent('Event');
  event.initEvent(type, props.bubbles != null ? props.bubbles : true, props.cancelable != null ? props.cancelable : true);
  return appendData(data, event);
};

exports.createEvent = createEvent;

var createEventObject = function createEventObject(type, data, props) {
  var event = document.createEventObject();
  event.type = type;
  event.cancelBubble = props.bubbles === false;
  delete props.bubbles;

  for (var k in props) {
    event[k] = props[k];
  }

  return appendData(data, event);
};

exports.createEventObject = createEventObject;
var domEventImplementation;

var domEvent = function domEvent(type, data) {
  var props = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  if (!domEventImplementation) {
    try {
      var e = new window.Event('test');
      domEventImplementation = e && newEvent;
    } catch (e) {
      domEventImplementation = document.createEvent ? createEvent : createEventObject;
    }
  }

  return domEventImplementation(type, data, props);
};

exports.domEvent = domEvent;

function addDelegatedEventListener(object, event, selector, callback) {
  if (typeof selector === 'function') {
    callback = selector;
    selector = '*';
  }

  var listener = function listener(e) {
    if (e.isPropagationStopped) {
      return;
    }

    var target = e.target;
    decorateEvent(e);
    nodeAndParents(target).forEach(function (node) {
      var matched = node.matches(selector);

      if (e.isImmediatePropagationStopped || !matched) {
        return;
      }

      e.matchedTarget = node;
      callback(e);
    });
  };

  return new _widjetDisposables.DisposableEvent(object, event, listener);

  function decorateEvent(e) {
    var overriddenStop = window.Event.prototype.stopPropagation;

    e.stopPropagation = function () {
      this.isPropagationStopped = true;
      overriddenStop.apply(this, arguments);
    };

    var overriddenStopImmediate = window.Event.prototype.stopImmediatePropagation;

    e.stopImmediatePropagation = function () {
      this.isImmediatePropagationStopped = true;
      overriddenStopImmediate.apply(this, arguments);
    };
  }
}