qubyte

Whilst I wait for better support for fat arrow functions, they can be emulated with what I like to call an immediately bound function expression (IBFE).

For example this:

var test = (a, b, c) => console.log(a, b, c, this.xyz);

Can be emulated with:

qubyte

// brfs is needed to use this anti-shim.
var fs = require('fs');
var functionBody = [
  'var window = {};',
  fs.readFileSync(__dirname + '/path/to/node_modules/fetch/fetch.js', 'utf8'), // Fix the path for your needs.
  'return window.fetch;'
].join('\n');

// Assigns a function fetch function to module.exports. Here I elect to use a native Promise implementation (or
// polyfilled). This is trivial to adapt into a library that can take a user defined Promise.

qubyte

function makeUuid(){
    var randomValues = window.crypto.getRandomValues(new window.Uint8ClampedArray(16));
    var randomHex = '';

    for (var i = 0; i < randomValues.length - 1; i++) {
        var hex = randomValues[i].toString(16);

        if (hex.length === 0) {
            randomHex += '00';
        } else if (hex.length === 1) {

qubyte

const promises = ['some promises in here'];

const waitForPromises = asyncRunner(function* (promises) {
    for (const promise of promises) {
      yield promise;
    }
    
    // At this point all the promises have resolved.
});

qubyte

function subRunner(gen) {
  const state = gen.next();
  const thisPromise = Promise.resolve(state.value);

  return state.done ? thisPromise : thisPromise.then(subRunner(gen));
}

function asyncWrapper(genFunc) {
  return function () {
    try {

qubyte

function* range(start, stop, step = 1) {
  for (let n = start; n < stop; n += step) {
    yield n;
  }
}

qubyte

const test1 = {
  MyConstructor: function () {}
};

new test1.MyConstructor(); // fine

const test2 = {
  MyConstructor() {}
};

qubyte

var token = '<insert token>';
var owner = '<insert owner>';
var repo = '<insert repo>';

var newLabels = [
  {color: 'e11d21', name: 'Blocked'},
  {color: '000000', name: 'Do Not Merge!'},
  {color: 'eb6420', name: 'QA Defect'},
  {color: '5319e7', name: 'Waiting for QA'},
  {color: '009800', name: 'Waiting for Review'},

qubyte

import inverter from 'promise-inverter';

// Mocha style test.
it('rejects with an error', () => {
  return someRejectedPromise
    .then(...inverter)
    .then(err => assert.ok(err instanceof Error));
});

qubyte

'use strict';

import Observable from 'an-observable-implementation';
import emitter from 'some-instance-of-vertebrate-event-emitter';

export default new Observable(observer => {
  const refs = [
    emitter.on('data', data => observer.next(data)),
    emitter.on('error', error => observer.error(error)),
    emitter.on('end', () => observer.complete())