jacobp100

const combineMiddlewares = middlewares => (store) => {
  const propagationFunctions = middlewares.map(middleware => (
    middleware(store)
  ));
  const invokeMiddlewareChain = propagationFunctions.reduceRight((nextFn, propagationFunction) => (
    propagationFunction(nextFn)
  ), null);
  return invokeMiddlewareChain;
};

jacobp100

const createStore = ({ middlewares = [] }) => {
  const store = {};

  store.dispatch = combineMiddlewares(middlewares)(store);

  return store;
};

jacobp100

const reducerMiddleware = (reducer, initialState) => store => {
  let state = initialState;

  store.getState = () => state;

  return () => (action) => { state = reducer(state, action); };
};

jacobp100

const createStore = ({
  reducer = state => state,
  middlewares = [],
  initialState = undefined,
}) => {
  const store = {};

  store.dispatch = combineMiddlewares([
    ...middlewares,
    reducerMiddleware(reducer, initialState)

jacobp100

const subscribeMiddleware = () => store => {
  let handlers = [];

  store.subscribe = (cb) => {
    handlers = handlers.concat(cb);
    const removeSubscriber = () => { handlers = handlers.filter(fn => fn !== cb) };
    return removeSubscriber;
  };

  return next => (action) => {

jacobp100

if condition {
  doSomething();
}

jacobp100

export default function () {
  return {
    manipulateOptions(opts, parserOpts) {
      parserOpts.plugins.push("jsx");
    }
  };
}

jacobp100

const { plugins } = require('babylon/lib/parser');

const pluginName = 'swift-blocks';
const plugin = createSwiftBlocksPlugin();
plugins[pluginName] = 'swift-blocks';

module.exports = () => ({
  manipulateOptions(opts, parserOpts) {
    parserOpts.plugins.push(pluginName);
  },

jacobp100

pp.parseStatement = function (declaration, topLevel) {
  let node = this.startNode();
  
  if (this.match(tokenTypes._if)) {
    return this.parseIfStatement(node);
  } else {
    ...
  }
}

jacobp100

const plugin = (instance) => {
  instance.extend('parseIfStatement', inner => function (node) {
    this.next();
    const isParenFree = this.match(tokenTypes.parenL);

    node.test = isParenFree
      ? this.parseExpression()
      : this.parseParenExpression();
    node.consequent = isParenFree
      ? this.parseBlock(false)