jaawerth

app.use(allowCrossDomain); // Use below function as a middleware for your requests

function allowCrossDomain(req, res, next) {
    res.header('Access-Control-Allow-Origin', '*');
    res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS');
    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With');

    // intercept OPTIONS method
    if ('OPTIONS' == req.method) {
      res.send(200);

jaawerth

/* Concatenate iterators by wrapping them in a "parent" iterator.
 * When it's consumed, to the outside world it will appear as a single
 * iterator. Allows for easily-implemented lazy evaluation and immutable
 * transformations.
*/

import toIterator from './iterator';
import { isArray, isIterable, isIterator } from '../types';

function concat(...items) {

jaawerth

'use strict';

/*
 * run promises in sequence, return an array of results.
 * Returns a promise that resolves to an array of results, where funcs[i]() -> results[i]
*/
function asyncSeries(...funcs) {
  return aggregate([], funcs);
}

jaawerth

function timeout(fn, delay) {
  var args = Array.prototype.slice(arguments, 2);
  
  return new Promise(function(resolve, reject) {
    setTimeout(function() {
      try {
        resolve(fn.apply(null, args));
      } catch(e) {
        reject(e);

jaawerth

{
  "name": "promise-map",
  "version": "1.0.0",
  "main": "./promise-map.js"
}

jaawerth

JavaScript coroutines and "spawn"

In ES2017, we have async/await for unwrapping promises. However, this is just syntastic sugar for the use of coroutines, which are already available in ES6 (see the recommended modules tj/co and Bluebird's Promise.coroutine()).

Below is a sample implementation of spawn showing how it works. It takes a generator function, inside of which yield can be used to unwrap promises for synchronous-style code. spawn always returns a promise.

Try it yourself!

You can install this gist via npm to tinker with it yourself, or copy/paste the function into any environment that supports generators.

**IMPORTANT: Use this code only for tinkering and education purposes, not for use in a real project. While you're free to do so, it's a MUCH beter practice to use an existing, published module for such functionality, such as the

jaawerth

function parse(qs) {
  return qs.replace(/^\?/, '').split('&').reduce(function(col, pairStr) {
    // pairStr is of form `foo=bar`
    var pair = pairStr.split('=').map(decodeURIComponent);
    col[pair[0]] = pair[1];
    return col;
  }, {});
}

jaawerth

/* Simple implementation of "throttle".
 * Option object has boolean properties 'trailing' and 'leading', where 'leading'
 * defaults to true.
**/

function throttle(fn, period, opts) {
  opts = opts || {};
  var leading = opts.leading === false ? false : true; // defaults to true
  var trailing = !!opts.trailing; // defaults to false
  var args, cached;

jaawerth

cleanUpOriginList(){
   var i;
   for (i = this.originList.length; i--;) {
      delete this.originList[i].id;
      delete this.originList[i].createdBy;
      delete this.originList[i].modifiedBy;
      delete this.originList[i].createdDate;
      delete this.originList[i].createdDate;
      delete this.originList[i].modifiedDate;
      if (this.originList[i].targetName === '') {

jaawerth

function compose(...fnArgs) {
  const [first, ...funcs] = fnArgs.reverse();
  return function(...args) {
    return funcs.reduce((res, fn) => fn(res), first(...args));
  };
}