benjamingr

// load Peer5 with a script timeout

var initiated;
function initClappr() {
  if (initiated) return;
  initiated = true;
  // var player = new Clappr.Player();
  // rest of clappr initialization
}

benjamingr

const obj1 = {"1,1" : "hello"},
obj2 = {"1,1" : "hi"},
obj3 = [obj1, obj2].reduce((a, c) => {
  return {...a, [k] : (a[k] || []).concat(c[k]);
}, {});

benjamingr

function cleanUp (arr, max) {
  const cnts = {}  // keep track of what we find
  return arr.reduce((a, i) => { // loop over the array index by index
    cnts[i] = (cnts[i] || 0) + 1;  // mark that I seen the number
    if (cnts[i] <= max) {  // check to see if we are under the max
      return a.concat(i)  //if we are, add it to an arry
    }
    return a  // return the array for reduce
  }, [])
}

benjamingr

A Promise handles a single event when an async operation completes or fails.

So, a promise doesn't handle anything - a promise is just a value over time. The charactaristics of promises are that:

• Because a promise is just a value - promises are multicast which means multiple .thens are 'transparent'.
• Native promises are what async functions return and what they await.
• Promises have three states (fulfilled, pending and rejected) and transition between them just once.

Promises aren't really eager - but if you have a promise an operation has already started - so terms lik running promises don't make sense. They have a built in (stage 4 and part of JavaScript) multi-value counterpart (async iterators) which do multiple values and

benjamingr

// generators are lazy so maxItems isn't needed anymore - you just take as many items as you need
// it's also lazy, so if you need less items you will pay less for it. Naming a Set `set` is like naming a Number `number`
const uniqueMergeWithoutMax = function *(arrays, withoutValue) {
  const seen = new Set();
  for(const array of arrays) {
    for(const item of array) {
      if (item === withoutValue || seen.has(item)) continue;
      seen.add(item);
      yield item;

benjamingr

class AggregateAbortController extends AbortController {
  constructor(...controllers = []) {
    super();
    this.controllers = controllers;
  }
  abort() {
    for(const controllers of this.controllers) {
      controllers.abort();
    }
  }

benjamingr

const React = require('react');
const { expect } = require('chai');
const { shallow, configure } = require('enzyme');
const { createSandbox } = require('sinon');
require('react-dom'); // required by the enzyme adapter internally
const Adapter = require('enzyme-adapter-react-16');

configure({ adapter: new Adapter() });

var called = 0;

benjamingr

const React = require('react');
const { expect } = require('chai');
const { shallow, configure } = require('enzyme');
const { createSandbox } = require('sinon');
require('react-dom'); // required by the enzyme adapter internally
const Adapter = require('enzyme-adapter-react-16');

configure({ adapter: new Adapter() });

var called = 0;

benjamingr

function querySelectorAllDeep(root, selector) {
  const [start, ...rest] = Array.isArray(selector) ? selector : selector.split(" /deep/ ");
  if (rest.length === 0) return [...root.querySelectorAll(start)];
  return [...root.querySelectorAll(start + " *")].map(x => x.shadowRoot).filter(Boolean).map(x => querySelectorAllDeep(x, rest)).flat();
}

function unshadowDOM(dom, tagnNameOverride) {
  const root = document.createElement(tagnNameOverride || dom.tagName || "fragment");
  for(const {name, value} of (dom.attributes || [])) {
    try {

benjamingr

function interceptNetworkRequests(ee) {
    const open = XMLHttpRequest.prototype.open;
    const send = XMLHttpRequest.prototype.send;

    const isRegularXHR = open.toString().indexOf('native code') !== -1;


    // don't hijack if already hijacked - this will mess up with frameworks like Angular with zones
    // we work if we load first there which we can.
    if (isRegularXHR) {