axefrog

import Immutable from 'immutable';
import formatDate from 'date-fns/format';
import immutableDiff from 'immutablediff';

/* eslint-disable no-underscore-dangle */

var colors = {
  0: ['white', '#7fbad8', '#0075b2'],
  1: ['white', '#91a0ce', '#24429e'],
  2: ['white', '#ab86e0', '#570ec1'],

axefrog

import {sample} from '@most/sample';
import {proxy as makeProxy} from 'most-proxy';

/**
 * FlatScan is a multi-pass accumulation operator. It takes a first-stage
 * initiator function and an initial state value, and returns a function that
 * takes a stream of values and returns a stream of cumulatively-updated values.
 *
 * For each input value received from the source stream, the initiator function
 * is called with the current accumulated state, the input value, and an

axefrog

export const dispose = disposable => disposable.dispose();

export const emptyDisposable = {
  dispose() {}
};

export class DispatchDisposable
{
  constructor(source, sink, key) {
    this.source = source;

axefrog

// Limit the rate of flow to an event every 250ms:
// const stream$ = other$.thru(limitFlow(250));

export function limitFlow(period) {
  return function limitFlow(stream) {
    const source = new RateLimitSource(stream.source, period);
    return new stream.constructor(source);
  };
}

axefrog

import chalk from 'chalk';

function str(val) {
  return val ? val.toString().replace(/\s+/g, ' ') : val;
}

let i = 0;
export function intercept(obj, title) {
  return new Proxy(obj, {
    get(target, name) {

axefrog

Conventions, Naming & Best Practices

Though you don't have to follow these conventions, you'll get off to a quicker start if you do, and your code will be more consistent and thus easier to maintain. Many of these conventions are largely an attempt to reuse common ideas and best practices that have been discovered by the Cycle community, and to provide additional abstractions to cover the specialised concerns of an isomorphic web application, and to promote the DRY principle.

Streams

Variables representing streams should be suffixed with $, for example data$. The variable name chosen, or a suffix thereof, should be a suitable name to represent the data emitted. For example, data$ should emit data. Similarly, userAuthData$ is fine for emitting any of userAuthData, authData, or just data. Example: authData$.map(data => ...) or authData$.map(authData => ...)

var frog$ = most.of({ name: 'Hopper' })

axefrog

export function upgradeSources(sources) {
  const sourceKeys = Array.from(Object.keys(sources));

  const cleanSources = sources => sourceKeys
    .reduce((acc, key) => (acc[key] = sources[key], acc), {});

  function withCustom(baseSources, customSources) {
    const cleanedSources = cleanSources(baseSources);
    const nextSources = Object.assign({}, cleanedSources, customSources);
    return augment(nextSources, cleanedSources);

axefrog

function sanitizeOptions(options) {
  if(!options) {
    options = {}
  }
  else if(typeof options === `string`) {
    options = { scope: options }
  }
  else if(Array.isArray(options)) {
    options = { include: options }
  }

axefrog

it('projectStaticsToArrayOfPairStreams() should return an array of streams of key/state objects', () => {
  const statics = internals.projectStaticsToArrayOfPairStreams(partitioned.statics);
  return deepCapture(statics)
    .then(result => {
      const expected = [
        $([{ key: 'a', state: { x: 1, y: 2 } }, { key: 'a', state: { x: 3, y: 4 } }]),
        $([{ key: 'b', state: { x: 5, y: 6 } }, { key: 'b', state: { x: 7, y: 8 } }]),
        $([{ key: 'c', state: { } }])
      ];
      assert.deepEqual(expected, result);

axefrog

export function makeContextDriver(domDriver) {
  return function(context$) {
    const ctx$ = context$.multicast();
    const vtree$ = ctx$.filter(c => c.vtree).map(c => c.vtree);
    const state$ = ctx$.filter(c => c.state).map(c => c.state);
    const metadata$ = ctx$.filter(c => c.metadata).map(c => c.metadata);

    return {
      DOM: domDriver(vtree$),
      state$,