made with requirebin
Last active
November 9, 2016 15:49
-
-
Save vorg/bd641eadffff6ba6b8a6dca1835f3c2f to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Streams implementation for mouse events. | |
| // Started based thinking in https://github.com/pex-gl/pex-gui/issues/8 | |
| // IMPORT DEPENDENCIES | |
| // Flyd is "The less is more, modular, functional reactive programming library" | |
| const flyd = require('flyd') | |
| // emit events from one stream until another stream fires | |
| const takeUntil = require('flyd/module/takeuntil') | |
| // merge multiple streams into one | |
| const mergeAll = require('flyd/module/mergeall') | |
| // filter stream events based on predicate | |
| const filterStream = require('flyd/module/filter') | |
| // map events from a stream using a function | |
| const mapStream = flyd.map | |
| // check if point is inside a rectangle | |
| const containsPoint = require('pex-geom/Rect').containsPoint | |
| // UI | |
| // Draw a red canvas with yellow "button" on the left | |
| const btnRect = [[10, 10], [100, 100]] | |
| const canvas = document.createElement('canvas') | |
| canvas.style.background = 'red' | |
| document.body.appendChild(canvas) | |
| const ctx = canvas.getContext('2d') | |
| ctx.fillStyle = '#FFFF00' | |
| ctx.fillRect(btnRect[0][0], btnRect[0][1], btnRect[1][0] - btnRect[0][0], btnRect[1][1] - btnRect[0][1]) | |
| // crate streams for all mouse events | |
| const mousedown = flyd.stream() | |
| const mouseup = flyd.stream() | |
| const mousemove = flyd.stream() | |
| const windowmouseup = flyd.stream() | |
| canvas.addEventListener('mousedown', mousedown) | |
| canvas.addEventListener('mouseup', mouseup) | |
| canvas.addEventListener('mousemove', mousemove) | |
| window.addEventListener('mouseup', windowmouseup) | |
| //flyd.on((e) => console.log('windowmouseup', e), windowmouseup) | |
| // DRAG event stream implementation | |
| // This shows how to combine streams (down, move, up) into a new stream | |
| function createMouseDragStream (mousedown, mousemove, mouseup) { | |
| const mousedrag = flyd.stream() | |
| // on each mousedown event | |
| flyd.on((e) => { | |
| // create new stream that take events from mousemove | |
| // until mouse up on canvas or window | |
| const drag = takeUntil(mousemove, mergeAll([mouseup, windowmouseup])) | |
| // then forward all events from drag to mousedrag | |
| flyd.on(mousedrag, drag) | |
| }, mousedown) | |
| return mousedrag | |
| } | |
| const mousedrag = createMouseDragStream(mousedown, mousemove, mouseup) | |
| // print mousedrag when dragging mouse over canvas | |
| //flyd.on((e) => console.log('mousedrag', e), mousedrag) | |
| // filter functon checking if mouse event is inside rectangle | |
| function inRect (rect) { | |
| return function (e) { | |
| // TODO: curry this! | |
| return containsPoint(rect, [e.clientX, e.clientY]) | |
| } | |
| } | |
| // we use preventDefault to mark handled streams | |
| function markAsHandled (e) { | |
| e.preventDefault() | |
| return e | |
| } | |
| function notHandledYet (e) { | |
| return !e.defaultPrevented | |
| } | |
| // we add background event listener first as we go from broad to more specific | |
| const bgmousedown = filterStream(notHandledYet, mousedown) | |
| flyd.on((e) => console.log('bg mousedown', e), bgmousedown) | |
| /* | |
| const bgmousedrag = mapStream(markAsHandled, createMouseDragStream( | |
| bgmousedown, | |
| mousemove, | |
| mouseup | |
| ) | |
| ) | |
| flyd.on((e) => console.log('bg mousedrag', e), bgmousedrag) | |
| */ | |
| // mouse clicks inside yellow rect | |
| //const buttonmousedown = mapStream(markAsHandled, filterStream(inRect(btnRect), mousedown)) | |
| // mouse clicks outside yellow rect | |
| //flyd.on((e) => console.log('button mousedown', e), buttonmousedown) | |
| // crate drag event stream that happens only if we click inside button | |
| const buttonmousedrag = createMouseDragStream( | |
| mapStream(markAsHandled, filterStream(inRect(btnRect), mousedown)), | |
| mousemove, | |
| mouseup | |
| ) | |
| //flyd.on((e) => console.log('button drag', e), buttonmousedrag) | |
| /* | |
| const a = flyd.stream() | |
| const g = flyd.stream() | |
| window.addEventListener('mousedown', a) | |
| window.addEventListener('mousedown', g) | |
| flyd.on((e) => console.log('a', e), a) | |
| flyd.on((e) => console.log('g background', e), g) | |
| flyd.on((e) => console.log('g slider', e), g) | |
| */ | |
| //const pointer = require('pointer-events-stream')(gl.canvas) | |
| canvas.addEventListener('mousedown', (e) => { | |
| e.preventDefault() | |
| console.log('canvas down') | |
| }) | |
| canvas.addEventListener('mouseup', (e) => { | |
| console.log('canvas up', e.defaultPrevented) | |
| }) | |
| window.addEventListener('mouseup', (e) => { | |
| console.log('window up', e.defaultPrevented) | |
| }) | |
| window.addEventListener('mouseout', (e) => { | |
| console.log('window out', e.defaultPrevented) | |
| }) | |
| /* Ideal scenario | |
| var mouseclicks = stream() | |
| var leftoferclicks = gui.addMouse(mouseclicks) | |
| // inside gui | |
| var click = mouseclicks.peak() | |
| if (insideSlier(click)) { | |
| mouseclicks.take() | |
| } | |
| */ | |
| // PROBLEM | |
| // - calling e.preventDefault in canvas.mousedown prevents window.mouseup released outside of browser bounds | |
| // - gui and arcball / scene are using same canvas events. That wouldn't happen with canvas + dom dat.gui | |
| // SCENARIOS | |
| // gui vs arcball conflicks, picking bounding boxes vs arcball | |
| // SOLUTIONS | |
| // - keep using pex-sys/MouseEvent | |
| // - flyd: add a handled flag to the Event object | |
| // - create sepate window for gui |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| setTimeout(function(){ | |
| ;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| var _arity = require('./internal/_arity'); | |
| var _curry1 = require('./internal/_curry1'); | |
| var _curry2 = require('./internal/_curry2'); | |
| var _curryN = require('./internal/_curryN'); | |
| /** | |
| * Returns a curried equivalent of the provided function, with the specified | |
| * arity. The curried function has two unusual capabilities. First, its | |
| * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1)(2)(3)` | |
| * - `g(1)(2, 3)` | |
| * - `g(1, 2)(3)` | |
| * - `g(1, 2, 3)` | |
| * | |
| * Secondly, the special placeholder value `R.__` may be used to specify | |
| * "gaps", allowing partial application of any combination of arguments, | |
| * regardless of their positions. If `g` is as above and `_` is `R.__`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1, 2, 3)` | |
| * - `g(_, 2, 3)(1)` | |
| * - `g(_, _, 3)(1)(2)` | |
| * - `g(_, _, 3)(1, 2)` | |
| * - `g(_, 2)(1)(3)` | |
| * - `g(_, 2)(1, 3)` | |
| * - `g(_, 2)(_, 3)(1)` | |
| * | |
| * @func | |
| * @memberOf R | |
| * @since v0.5.0 | |
| * @category Function | |
| * @sig Number -> (* -> a) -> (* -> a) | |
| * @param {Number} length The arity for the returned function. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} A new, curried function. | |
| * @see R.curry | |
| * @example | |
| * | |
| * var sumArgs = (...args) => R.sum(args); | |
| * | |
| * var curriedAddFourNumbers = R.curryN(4, sumArgs); | |
| * var f = curriedAddFourNumbers(1, 2); | |
| * var g = f(3); | |
| * g(4); //=> 10 | |
| */ | |
| module.exports = _curry2(function curryN(length, fn) { | |
| if (length === 1) { | |
| return _curry1(fn); | |
| } | |
| return _arity(length, _curryN(length, [], fn)); | |
| }); | |
| },{"./internal/_arity":2,"./internal/_curry1":3,"./internal/_curry2":4,"./internal/_curryN":5}],2:[function(require,module,exports){ | |
| module.exports = function _arity(n, fn) { | |
| /* eslint-disable no-unused-vars */ | |
| switch (n) { | |
| case 0: return function() { return fn.apply(this, arguments); }; | |
| case 1: return function(a0) { return fn.apply(this, arguments); }; | |
| case 2: return function(a0, a1) { return fn.apply(this, arguments); }; | |
| case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); }; | |
| case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); }; | |
| case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); }; | |
| case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); }; | |
| case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); }; | |
| case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); }; | |
| case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); }; | |
| case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); }; | |
| default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); | |
| } | |
| }; | |
| },{}],3:[function(require,module,exports){ | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal one-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry1(fn) { | |
| return function f1(a) { | |
| if (arguments.length === 0 || _isPlaceholder(a)) { | |
| return f1; | |
| } else { | |
| return fn.apply(this, arguments); | |
| } | |
| }; | |
| }; | |
| },{"./_isPlaceholder":6}],4:[function(require,module,exports){ | |
| var _curry1 = require('./_curry1'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal two-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry2(fn) { | |
| return function f2(a, b) { | |
| switch (arguments.length) { | |
| case 0: | |
| return f2; | |
| case 1: | |
| return _isPlaceholder(a) ? f2 | |
| : _curry1(function(_b) { return fn(a, _b); }); | |
| default: | |
| return _isPlaceholder(a) && _isPlaceholder(b) ? f2 | |
| : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); }) | |
| : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); }) | |
| : fn(a, b); | |
| } | |
| }; | |
| }; | |
| },{"./_curry1":3,"./_isPlaceholder":6}],5:[function(require,module,exports){ | |
| var _arity = require('./_arity'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Internal curryN function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Number} length The arity of the curried function. | |
| * @param {Array} received An array of arguments received thus far. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curryN(length, received, fn) { | |
| return function() { | |
| var combined = []; | |
| var argsIdx = 0; | |
| var left = length; | |
| var combinedIdx = 0; | |
| while (combinedIdx < received.length || argsIdx < arguments.length) { | |
| var result; | |
| if (combinedIdx < received.length && | |
| (!_isPlaceholder(received[combinedIdx]) || | |
| argsIdx >= arguments.length)) { | |
| result = received[combinedIdx]; | |
| } else { | |
| result = arguments[argsIdx]; | |
| argsIdx += 1; | |
| } | |
| combined[combinedIdx] = result; | |
| if (!_isPlaceholder(result)) { | |
| left -= 1; | |
| } | |
| combinedIdx += 1; | |
| } | |
| return left <= 0 ? fn.apply(this, combined) | |
| : _arity(left, _curryN(length, combined, fn)); | |
| }; | |
| }; | |
| },{"./_arity":2,"./_isPlaceholder":6}],6:[function(require,module,exports){ | |
| module.exports = function _isPlaceholder(a) { | |
| return a != null && | |
| typeof a === 'object' && | |
| a['@@functional/placeholder'] === true; | |
| }; | |
| },{}],"flyd":[function(require,module,exports){ | |
| 'use strict'; | |
| var curryN = require('ramda/src/curryN'); | |
| // Utility | |
| function isFunction(obj) { | |
| return !!(obj && obj.constructor && obj.call && obj.apply); | |
| } | |
| function trueFn() { return true; } | |
| // Globals | |
| var toUpdate = []; | |
| var inStream; | |
| var order = []; | |
| var orderNextIdx = -1; | |
| var flushing = false; | |
| /** @namespace */ | |
| var flyd = {} | |
| // /////////////////////////// API ///////////////////////////////// // | |
| /** | |
| * Creates a new stream | |
| * | |
| * __Signature__: `a -> Stream a` | |
| * | |
| * @name flyd.stream | |
| * @param {*} initialValue - (Optional) the initial value of the stream | |
| * @return {stream} the stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); // Stream with initial value `1` | |
| * var s = flyd.stream(); // Stream with no initial value | |
| */ | |
| flyd.stream = function(initialValue) { | |
| var endStream = createDependentStream([], trueFn); | |
| var s = createStream(); | |
| s.end = endStream; | |
| s.fnArgs = []; | |
| endStream.listeners.push(s); | |
| if (arguments.length > 0) s(initialValue); | |
| return s; | |
| } | |
| /** | |
| * Create a new dependent stream | |
| * | |
| * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b` | |
| * | |
| * @name flyd.combine | |
| * @param {Function} fn - the function used to combine the streams | |
| * @param {Array<stream>} dependencies - the streams that this one depends on | |
| * @return {stream} the dependent stream | |
| * | |
| * @example | |
| * var n1 = flyd.stream(0); | |
| * var n2 = flyd.stream(0); | |
| * var max = flyd.combine(function(n1, n2, self, changed) { | |
| * return n1() > n2() ? n1() : n2(); | |
| * }, [n1, n2]); | |
| */ | |
| flyd.combine = curryN(2, combine); | |
| function combine(fn, streams) { | |
| var i, s, deps, depEndStreams; | |
| var endStream = createDependentStream([], trueFn); | |
| deps = []; depEndStreams = []; | |
| for (i = 0; i < streams.length; ++i) { | |
| if (streams[i] !== undefined) { | |
| deps.push(streams[i]); | |
| if (streams[i].end !== undefined) depEndStreams.push(streams[i].end); | |
| } | |
| } | |
| s = createDependentStream(deps, fn); | |
| s.depsChanged = []; | |
| s.fnArgs = s.deps.concat([s, s.depsChanged]); | |
| s.end = endStream; | |
| endStream.listeners.push(s); | |
| addListeners(depEndStreams, endStream); | |
| endStream.deps = depEndStreams; | |
| updateStream(s); | |
| return s; | |
| } | |
| /** | |
| * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise. | |
| * | |
| * __Signature__: `* -> Boolean` | |
| * | |
| * @name flyd.isStream | |
| * @param {*} value - the value to test | |
| * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise | |
| * | |
| * @example | |
| * var s = flyd.stream(1); | |
| * var n = 1; | |
| * flyd.isStream(s); //=> true | |
| * flyd.isStream(n); //=> false | |
| */ | |
| flyd.isStream = function(stream) { | |
| return isFunction(stream) && 'hasVal' in stream; | |
| } | |
| /** | |
| * Invokes the body (the function to calculate the value) of a dependent stream | |
| * | |
| * By default the body of a dependent stream is only called when all the streams | |
| * upon which it depends has a value. `immediate` can circumvent this behaviour. | |
| * It immediately invokes the body of a dependent stream. | |
| * | |
| * __Signature__: `Stream a -> Stream a` | |
| * | |
| * @name flyd.immediate | |
| * @param {stream} stream - the dependent stream | |
| * @return {stream} the same stream | |
| * | |
| * @example | |
| * var s = flyd.stream(); | |
| * var hasItems = flyd.immediate(flyd.combine(function(s) { | |
| * return s() !== undefined && s().length > 0; | |
| * }, [s]); | |
| * console.log(hasItems()); // logs `false`. Had `immediate` not been | |
| * // used `hasItems()` would've returned `undefined` | |
| * s([1]); | |
| * console.log(hasItems()); // logs `true`. | |
| * s([]); | |
| * console.log(hasItems()); // logs `false`. | |
| */ | |
| flyd.immediate = function(s) { | |
| if (s.depsMet === false) { | |
| s.depsMet = true; | |
| updateStream(s); | |
| } | |
| return s; | |
| } | |
| /** | |
| * Changes which `endsStream` should trigger the ending of `s`. | |
| * | |
| * __Signature__: `Stream a -> Stream b -> Stream b` | |
| * | |
| * @name flyd.endsOn | |
| * @param {stream} endStream - the stream to trigger the ending | |
| * @param {stream} stream - the stream to be ended by the endStream | |
| * @param {stream} the stream modified to be ended by endStream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var killer = flyd.stream(); | |
| * // `double` ends when `n` ends or when `killer` emits any value | |
| * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) { | |
| * return 2 * n(); | |
| * }, [n]); | |
| */ | |
| flyd.endsOn = function(endS, s) { | |
| detachDeps(s.end); | |
| endS.listeners.push(s.end); | |
| s.end.deps.push(endS); | |
| return s; | |
| } | |
| /** | |
| * Map a stream | |
| * | |
| * Returns a new stream consisting of every value from `s` passed through | |
| * `fn`. I.e. `map` creates a new stream that listens to `s` and | |
| * applies `fn` to every new value. | |
| * __Signature__: `(a -> result) -> Stream a -> Stream result` | |
| * | |
| * @name flyd.map | |
| * @param {Function} fn - the function that produces the elements of the new stream | |
| * @param {stream} stream - the stream to map | |
| * @return {stream} a new stream with the mapped values | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers); | |
| */ | |
| // Library functions use self callback to accept (null, undefined) update triggers. | |
| flyd.map = curryN(2, function(f, s) { | |
| return combine(function(s, self) { self(f(s.val)); }, [s]); | |
| }) | |
| /** | |
| * Listen to stream events | |
| * | |
| * Similar to `map` except that the returned stream is empty. Use `on` for doing | |
| * side effects in reaction to stream changes. Use the returned stream only if you | |
| * need to manually end it. | |
| * | |
| * __Signature__: `(a -> result) -> Stream a -> Stream undefined` | |
| * | |
| * @name flyd.on | |
| * @param {Function} cb - the callback | |
| * @param {stream} stream - the stream | |
| * @return {stream} an empty stream (can be ended) | |
| */ | |
| flyd.on = curryN(2, function(f, s) { | |
| return combine(function(s) { f(s.val); }, [s]); | |
| }) | |
| /** | |
| * Creates a new stream with the results of calling the function on every incoming | |
| * stream with and accumulator and the incoming value. | |
| * | |
| * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a` | |
| * | |
| * @name flyd.scan | |
| * @param {Function} fn - the function to call | |
| * @param {*} val - the initial value of the accumulator | |
| * @param {stream} stream - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var numbers = flyd.stream(); | |
| * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers); | |
| * numbers(2)(3)(5); | |
| * sum(); // 10 | |
| */ | |
| flyd.scan = curryN(3, function(f, acc, s) { | |
| var ns = combine(function(s, self) { | |
| self(acc = f(acc, s.val)); | |
| }, [s]); | |
| if (!ns.hasVal) ns(acc); | |
| return ns; | |
| }); | |
| /** | |
| * Creates a new stream down which all values from both `stream1` and `stream2` | |
| * will be sent. | |
| * | |
| * __Signature__: `Stream a -> Stream a -> Stream a` | |
| * | |
| * @name flyd.merge | |
| * @param {stream} source1 - one stream to be merged | |
| * @param {stream} source2 - the other stream to be merged | |
| * @return {stream} a stream with the values from both sources | |
| * | |
| * @example | |
| * var btn1Clicks = flyd.stream(); | |
| * button1Elm.addEventListener(btn1Clicks); | |
| * var btn2Clicks = flyd.stream(); | |
| * button2Elm.addEventListener(btn2Clicks); | |
| * var allClicks = flyd.merge(btn1Clicks, btn2Clicks); | |
| */ | |
| flyd.merge = curryN(2, function(s1, s2) { | |
| var s = flyd.immediate(combine(function(s1, s2, self, changed) { | |
| if (changed[0]) { | |
| self(changed[0]()); | |
| } else if (s1.hasVal) { | |
| self(s1.val); | |
| } else if (s2.hasVal) { | |
| self(s2.val); | |
| } | |
| }, [s1, s2])); | |
| flyd.endsOn(combine(function() { | |
| return true; | |
| }, [s1.end, s2.end]), s); | |
| return s; | |
| }); | |
| /** | |
| * Creates a new stream resulting from applying `transducer` to `stream`. | |
| * | |
| * __Signature__: `Transducer -> Stream a -> Stream b` | |
| * | |
| * @name flyd.transduce | |
| * @param {Transducer} xform - the transducer transformation | |
| * @param {stream} source - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var t = require('transducers.js'); | |
| * | |
| * var results = []; | |
| * var s1 = flyd.stream(); | |
| * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe()); | |
| * var s2 = flyd.transduce(tx, s1); | |
| * flyd.combine(function(s2) { results.push(s2()); }, [s2]); | |
| * s1(1)(1)(2)(3)(3)(3)(4); | |
| * results; // => [2, 4, 6, 8] | |
| */ | |
| flyd.transduce = curryN(2, function(xform, source) { | |
| xform = xform(new StreamTransformer()); | |
| return combine(function(source, self) { | |
| var res = xform['@@transducer/step'](undefined, source.val); | |
| if (res && res['@@transducer/reduced'] === true) { | |
| self.end(true); | |
| return res['@@transducer/value']; | |
| } else { | |
| return res; | |
| } | |
| }, [source]); | |
| }); | |
| /** | |
| * Returns `fn` curried to `n`. Use this function to curry functions exposed by | |
| * modules for Flyd. | |
| * | |
| * @name flyd.curryN | |
| * @function | |
| * @param {Integer} arity - the function arity | |
| * @param {Function} fn - the function to curry | |
| * @return {Function} the curried function | |
| * | |
| * @example | |
| * function add(x, y) { return x + y; }; | |
| * var a = flyd.curryN(2, add); | |
| * a(2)(4) // => 6 | |
| */ | |
| flyd.curryN = curryN | |
| /** | |
| * Returns a new stream identical to the original except every | |
| * value will be passed through `f`. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b` | |
| * | |
| * @name stream.map | |
| * @param {Function} function - the function to apply | |
| * @return {stream} a new stream with the values mapped | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = numbers.map(function(n) { return n*n; }); | |
| */ | |
| function boundMap(f) { return flyd.map(f, this); } | |
| /** | |
| * Returns a new stream which is the result of applying the | |
| * functions from `this` stream to the values in `stream` parameter. | |
| * | |
| * `this` stream must be a stream of functions. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b` | |
| * | |
| * @name stream.ap | |
| * @param {stream} stream - the values stream | |
| * @return {stream} a new stram with the functions applied to values | |
| * | |
| * @example | |
| * var add = flyd.curryN(2, function(x, y) { return x + y; }); | |
| * var numbers1 = flyd.stream(); | |
| * var numbers2 = flyd.stream(); | |
| * var addToNumbers1 = flyd.map(add, numbers1); | |
| * var added = addToNumbers1.ap(numbers2); | |
| */ | |
| function ap(s2) { | |
| var s1 = this; | |
| return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]); | |
| } | |
| /** | |
| * Get a human readable view of a stream | |
| * @name stream.toString | |
| * @return {String} the stream string representation | |
| */ | |
| function streamToString() { | |
| return 'stream(' + this.val + ')'; | |
| } | |
| /** | |
| * @name stream.end | |
| * @memberof stream | |
| * A stream that emits `true` when the stream ends. If `true` is pushed down the | |
| * stream the parent stream ends. | |
| */ | |
| /** | |
| * @name stream.of | |
| * @function | |
| * @memberof stream | |
| * Returns a new stream with `value` as its initial value. It is identical to | |
| * calling `flyd.stream` with one argument. | |
| * | |
| * __Signature__: Called bound to `Stream (a)`: `b -> Stream b` | |
| * | |
| * @param {*} value - the initial value | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var m = n.of(1); | |
| */ | |
| // /////////////////////////// PRIVATE ///////////////////////////////// // | |
| /** | |
| * @private | |
| * Create a stream with no dependencies and no value | |
| * @return {Function} a flyd stream | |
| */ | |
| function createStream() { | |
| function s(n) { | |
| if (arguments.length === 0) return s.val | |
| updateStreamValue(s, n) | |
| return s | |
| } | |
| s.hasVal = false; | |
| s.val = undefined; | |
| s.vals = []; | |
| s.listeners = []; | |
| s.queued = false; | |
| s.end = undefined; | |
| s.map = boundMap; | |
| s.ap = ap; | |
| s.of = flyd.stream; | |
| s.toString = streamToString; | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Create a dependent stream | |
| * @param {Array<stream>} dependencies - an array of the streams | |
| * @param {Function} fn - the function used to calculate the new stream value | |
| * from the dependencies | |
| * @return {stream} the created stream | |
| */ | |
| function createDependentStream(deps, fn) { | |
| var s = createStream(); | |
| s.fn = fn; | |
| s.deps = deps; | |
| s.depsMet = false; | |
| s.depsChanged = deps.length > 0 ? [] : undefined; | |
| s.shouldUpdate = false; | |
| addListeners(deps, s); | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Check if all the dependencies have values | |
| * @param {stream} stream - the stream to check depencencies from | |
| * @return {Boolean} `true` if all dependencies have vales, `false` otherwise | |
| */ | |
| function initialDepsNotMet(stream) { | |
| stream.depsMet = stream.deps.every(function(s) { | |
| return s.hasVal; | |
| }); | |
| return !stream.depsMet; | |
| } | |
| /** | |
| * @private | |
| * Update a dependent stream using its dependencies in an atomic way | |
| * @param {stream} stream - the stream to update | |
| */ | |
| function updateStream(s) { | |
| if ((s.depsMet !== true && initialDepsNotMet(s)) || | |
| (s.end !== undefined && s.end.val === true)) return; | |
| if (inStream !== undefined) { | |
| toUpdate.push(s); | |
| return; | |
| } | |
| inStream = s; | |
| if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged; | |
| var returnVal = s.fn.apply(s.fn, s.fnArgs); | |
| if (returnVal !== undefined) { | |
| s(returnVal); | |
| } | |
| inStream = undefined; | |
| if (s.depsChanged !== undefined) s.depsChanged = []; | |
| s.shouldUpdate = false; | |
| if (flushing === false) flushUpdate(); | |
| } | |
| /** | |
| * @private | |
| * Update the dependencies of a stream | |
| * @param {stream} stream | |
| */ | |
| function updateDeps(s) { | |
| var i, o, list | |
| var listeners = s.listeners; | |
| for (i = 0; i < listeners.length; ++i) { | |
| list = listeners[i]; | |
| if (list.end === s) { | |
| endStream(list); | |
| } else { | |
| if (list.depsChanged !== undefined) list.depsChanged.push(s); | |
| list.shouldUpdate = true; | |
| findDeps(list); | |
| } | |
| } | |
| for (; orderNextIdx >= 0; --orderNextIdx) { | |
| o = order[orderNextIdx]; | |
| if (o.shouldUpdate === true) updateStream(o); | |
| o.queued = false; | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add stream dependencies to the global `order` queue. | |
| * @param {stream} stream | |
| * @see updateDeps | |
| */ | |
| function findDeps(s) { | |
| var i | |
| var listeners = s.listeners; | |
| if (s.queued === false) { | |
| s.queued = true; | |
| for (i = 0; i < listeners.length; ++i) { | |
| findDeps(listeners[i]); | |
| } | |
| order[++orderNextIdx] = s; | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function flushUpdate() { | |
| flushing = true; | |
| while (toUpdate.length > 0) { | |
| var s = toUpdate.shift(); | |
| if (s.vals.length > 0) s.val = s.vals.shift(); | |
| updateDeps(s); | |
| } | |
| flushing = false; | |
| } | |
| /** | |
| * @private | |
| * Push down a value into a stream | |
| * @param {stream} stream | |
| * @param {*} value | |
| */ | |
| function updateStreamValue(s, n) { | |
| if (n !== undefined && n !== null && isFunction(n.then)) { | |
| n.then(s); | |
| return; | |
| } | |
| s.val = n; | |
| s.hasVal = true; | |
| if (inStream === undefined) { | |
| flushing = true; | |
| updateDeps(s); | |
| if (toUpdate.length > 0) flushUpdate(); else flushing = false; | |
| } else if (inStream === s) { | |
| markListeners(s, s.listeners); | |
| } else { | |
| s.vals.push(n); | |
| toUpdate.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function markListeners(s, lists) { | |
| var i, list; | |
| for (i = 0; i < lists.length; ++i) { | |
| list = lists[i]; | |
| if (list.end !== s) { | |
| if (list.depsChanged !== undefined) { | |
| list.depsChanged.push(s); | |
| } | |
| list.shouldUpdate = true; | |
| } else { | |
| endStream(list); | |
| } | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add dependencies to a stream | |
| * @param {Array<stream>} dependencies | |
| * @param {stream} stream | |
| */ | |
| function addListeners(deps, s) { | |
| for (var i = 0; i < deps.length; ++i) { | |
| deps[i].listeners.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| * Removes an stream from a dependency array | |
| * @param {stream} stream | |
| * @param {Array<stream>} dependencies | |
| */ | |
| function removeListener(s, listeners) { | |
| var idx = listeners.indexOf(s); | |
| listeners[idx] = listeners[listeners.length - 1]; | |
| listeners.length--; | |
| } | |
| /** | |
| * @private | |
| * Detach a stream from its dependencies | |
| * @param {stream} stream | |
| */ | |
| function detachDeps(s) { | |
| for (var i = 0; i < s.deps.length; ++i) { | |
| removeListener(s, s.deps[i].listeners); | |
| } | |
| s.deps.length = 0; | |
| } | |
| /** | |
| * @private | |
| * Ends a stream | |
| */ | |
| function endStream(s) { | |
| if (s.deps !== undefined) detachDeps(s); | |
| if (s.end !== undefined) detachDeps(s.end); | |
| } | |
| /** | |
| * @private | |
| * transducer stream transformer | |
| */ | |
| function StreamTransformer() { } | |
| StreamTransformer.prototype['@@transducer/init'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/result'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; }; | |
| module.exports = flyd; | |
| },{"ramda/src/curryN":1}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_isPlaceholder.js","lib/index.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`, the\n * following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var sumArgs = (...args) => R.sum(args);\n *\n *      var curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","module.exports = function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n      case 1:\n        return _isPlaceholder(a) ? f2\n             : _curry1(function(_b) { return fn(a, _b); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })\n             : fn(a, b);\n    }\n  };\n};\n","var _arity = require('./_arity');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (!_isPlaceholder(received[combinedIdx]) ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined)\n                     : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","module.exports = function _isPlaceholder(a) {\n  return a != null &&\n         typeof a === 'object' &&\n         a['@@functional/placeholder'] === true;\n};\n","'use strict';\n\nvar curryN = require('ramda/src/curryN');\n\n// Utility\nfunction isFunction(obj) {\n  return !!(obj && obj.constructor && obj.call && obj.apply);\n}\nfunction trueFn() { return true; }\n\n// Globals\nvar toUpdate = [];\nvar inStream;\nvar order = [];\nvar orderNextIdx = -1;\nvar flushing = false;\n\n/** @namespace */\nvar flyd = {}\n\n// /////////////////////////// API ///////////////////////////////// //\n\n/**\n * Creates a new stream\n *\n * __Signature__: `a -> Stream a`\n *\n * @name flyd.stream\n * @param {*} initialValue - (Optional) the initial value of the stream\n * @return {stream} the stream\n *\n * @example\n * var n = flyd.stream(1); // Stream with initial value `1`\n * var s = flyd.stream(); // Stream with no initial value\n */\nflyd.stream = function(initialValue) {\n  var endStream = createDependentStream([], trueFn);\n  var s = createStream();\n  s.end = endStream;\n  s.fnArgs = [];\n  endStream.listeners.push(s);\n  if (arguments.length > 0) s(initialValue);\n  return s;\n}\n\n/**\n * Create a new dependent stream\n *\n * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b`\n *\n * @name flyd.combine\n * @param {Function} fn - the function used to combine the streams\n * @param {Array<stream>} dependencies - the streams that this one depends on\n * @return {stream} the dependent stream\n *\n * @example\n * var n1 = flyd.stream(0);\n * var n2 = flyd.stream(0);\n * var max = flyd.combine(function(n1, n2, self, changed) {\n *   return n1() > n2() ? n1() : n2();\n * }, [n1, n2]);\n */\nflyd.combine = curryN(2, combine);\nfunction combine(fn, streams) {\n  var i, s, deps, depEndStreams;\n  var endStream = createDependentStream([], trueFn);\n  deps = []; depEndStreams = [];\n  for (i = 0; i < streams.length; ++i) {\n    if (streams[i] !== undefined) {\n      deps.push(streams[i]);\n      if (streams[i].end !== undefined) depEndStreams.push(streams[i].end);\n    }\n  }\n  s = createDependentStream(deps, fn);\n  s.depsChanged = [];\n  s.fnArgs = s.deps.concat([s, s.depsChanged]);\n  s.end = endStream;\n  endStream.listeners.push(s);\n  addListeners(depEndStreams, endStream);\n  endStream.deps = depEndStreams;\n  updateStream(s);\n  return s;\n}\n\n/**\n * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise.\n *\n * __Signature__: `* -> Boolean`\n *\n * @name flyd.isStream\n * @param {*} value - the value to test\n * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise\n *\n * @example\n * var s = flyd.stream(1);\n * var n = 1;\n * flyd.isStream(s); //=> true\n * flyd.isStream(n); //=> false\n */\nflyd.isStream = function(stream) {\n  return isFunction(stream) && 'hasVal' in stream;\n}\n\n/**\n * Invokes the body (the function to calculate the value) of a dependent stream\n *\n * By default the body of a dependent stream is only called when all the streams\n * upon which it depends has a value. `immediate` can circumvent this behaviour.\n * It immediately invokes the body of a dependent stream.\n *\n * __Signature__: `Stream a -> Stream a`\n *\n * @name flyd.immediate\n * @param {stream} stream - the dependent stream\n * @return {stream} the same stream\n *\n * @example\n * var s = flyd.stream();\n * var hasItems = flyd.immediate(flyd.combine(function(s) {\n *   return s() !== undefined && s().length > 0;\n * }, [s]);\n * console.log(hasItems()); // logs `false`. Had `immediate` not been\n *                          // used `hasItems()` would've returned `undefined`\n * s([1]);\n * console.log(hasItems()); // logs `true`.\n * s([]);\n * console.log(hasItems()); // logs `false`.\n */\nflyd.immediate = function(s) {\n  if (s.depsMet === false) {\n    s.depsMet = true;\n    updateStream(s);\n  }\n  return s;\n}\n\n/**\n * Changes which `endsStream` should trigger the ending of `s`.\n *\n * __Signature__: `Stream a -> Stream b -> Stream b`\n *\n * @name flyd.endsOn\n * @param {stream} endStream - the stream to trigger the ending\n * @param {stream} stream - the stream to be ended by the endStream\n * @param {stream} the stream modified to be ended by endStream\n *\n * @example\n * var n = flyd.stream(1);\n * var killer = flyd.stream();\n * // `double` ends when `n` ends or when `killer` emits any value\n * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) {\n *   return 2 * n();\n * }, [n]);\n*/\nflyd.endsOn = function(endS, s) {\n  detachDeps(s.end);\n  endS.listeners.push(s.end);\n  s.end.deps.push(endS);\n  return s;\n}\n\n/**\n * Map a stream\n *\n * Returns a new stream consisting of every value from `s` passed through\n * `fn`. I.e. `map` creates a new stream that listens to `s` and\n * applies `fn` to every new value.\n * __Signature__: `(a -> result) -> Stream a -> Stream result`\n *\n * @name flyd.map\n * @param {Function} fn - the function that produces the elements of the new stream\n * @param {stream} stream - the stream to map\n * @return {stream} a new stream with the mapped values\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers);\n */\n// Library functions use self callback to accept (null, undefined) update triggers.\nflyd.map = curryN(2, function(f, s) {\n  return combine(function(s, self) { self(f(s.val)); }, [s]);\n})\n\n/**\n * Listen to stream events\n *\n * Similar to `map` except that the returned stream is empty. Use `on` for doing\n * side effects in reaction to stream changes. Use the returned stream only if you\n * need to manually end it.\n *\n * __Signature__: `(a -> result) -> Stream a -> Stream undefined`\n *\n * @name flyd.on\n * @param {Function} cb - the callback\n * @param {stream} stream - the stream\n * @return {stream} an empty stream (can be ended)\n */\nflyd.on = curryN(2, function(f, s) {\n  return combine(function(s) { f(s.val); }, [s]);\n})\n\n/**\n * Creates a new stream with the results of calling the function on every incoming\n * stream with and accumulator and the incoming value.\n *\n * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a`\n *\n * @name flyd.scan\n * @param {Function} fn - the function to call\n * @param {*} val - the initial value of the accumulator\n * @param {stream} stream - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var numbers = flyd.stream();\n * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers);\n * numbers(2)(3)(5);\n * sum(); // 10\n */\nflyd.scan = curryN(3, function(f, acc, s) {\n  var ns = combine(function(s, self) {\n    self(acc = f(acc, s.val));\n  }, [s]);\n  if (!ns.hasVal) ns(acc);\n  return ns;\n});\n\n/**\n * Creates a new stream down which all values from both `stream1` and `stream2`\n * will be sent.\n *\n * __Signature__: `Stream a -> Stream a -> Stream a`\n *\n * @name flyd.merge\n * @param {stream} source1 - one stream to be merged\n * @param {stream} source2 - the other stream to be merged\n * @return {stream} a stream with the values from both sources\n *\n * @example\n * var btn1Clicks = flyd.stream();\n * button1Elm.addEventListener(btn1Clicks);\n * var btn2Clicks = flyd.stream();\n * button2Elm.addEventListener(btn2Clicks);\n * var allClicks = flyd.merge(btn1Clicks, btn2Clicks);\n */\nflyd.merge = curryN(2, function(s1, s2) {\n  var s = flyd.immediate(combine(function(s1, s2, self, changed) {\n    if (changed[0]) {\n      self(changed[0]());\n    } else if (s1.hasVal) {\n      self(s1.val);\n    } else if (s2.hasVal) {\n      self(s2.val);\n    }\n  }, [s1, s2]));\n  flyd.endsOn(combine(function() {\n    return true;\n  }, [s1.end, s2.end]), s);\n  return s;\n});\n\n/**\n * Creates a new stream resulting from applying `transducer` to `stream`.\n *\n * __Signature__: `Transducer -> Stream a -> Stream b`\n *\n * @name flyd.transduce\n * @param {Transducer} xform - the transducer transformation\n * @param {stream} source - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var t = require('transducers.js');\n *\n * var results = [];\n * var s1 = flyd.stream();\n * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe());\n * var s2 = flyd.transduce(tx, s1);\n * flyd.combine(function(s2) { results.push(s2()); }, [s2]);\n * s1(1)(1)(2)(3)(3)(3)(4);\n * results; // => [2, 4, 6, 8]\n */\nflyd.transduce = curryN(2, function(xform, source) {\n  xform = xform(new StreamTransformer());\n  return combine(function(source, self) {\n    var res = xform['@@transducer/step'](undefined, source.val);\n    if (res && res['@@transducer/reduced'] === true) {\n      self.end(true);\n      return res['@@transducer/value'];\n    } else {\n      return res;\n    }\n  }, [source]);\n});\n\n/**\n * Returns `fn` curried to `n`. Use this function to curry functions exposed by\n * modules for Flyd.\n *\n * @name flyd.curryN\n * @function\n * @param {Integer} arity - the function arity\n * @param {Function} fn - the function to curry\n * @return {Function} the curried function\n *\n * @example\n * function add(x, y) { return x + y; };\n * var a = flyd.curryN(2, add);\n * a(2)(4) // => 6\n */\nflyd.curryN = curryN\n\n/**\n * Returns a new stream identical to the original except every\n * value will be passed through `f`.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b`\n *\n * @name stream.map\n * @param {Function} function - the function to apply\n * @return {stream} a new stream with the values mapped\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = numbers.map(function(n) { return n*n; });\n */\nfunction boundMap(f) { return flyd.map(f, this); }\n\n/**\n * Returns a new stream which is the result of applying the\n * functions from `this` stream to the values in `stream` parameter.\n *\n * `this` stream must be a stream of functions.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b`\n *\n * @name stream.ap\n * @param {stream} stream - the values stream\n * @return {stream} a new stram with the functions applied to values\n *\n * @example\n * var add = flyd.curryN(2, function(x, y) { return x + y; });\n * var numbers1 = flyd.stream();\n * var numbers2 = flyd.stream();\n * var addToNumbers1 = flyd.map(add, numbers1);\n * var added = addToNumbers1.ap(numbers2);\n */\nfunction ap(s2) {\n  var s1 = this;\n  return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]);\n}\n\n/**\n * Get a human readable view of a stream\n * @name stream.toString\n * @return {String} the stream string representation\n */\nfunction streamToString() {\n  return 'stream(' + this.val + ')';\n}\n\n/**\n * @name stream.end\n * @memberof stream\n * A stream that emits `true` when the stream ends. If `true` is pushed down the\n * stream the parent stream ends.\n */\n\n/**\n * @name stream.of\n * @function\n * @memberof stream\n * Returns a new stream with `value` as its initial value. It is identical to\n * calling `flyd.stream` with one argument.\n *\n * __Signature__: Called bound to `Stream (a)`: `b -> Stream b`\n *\n * @param {*} value - the initial value\n * @return {stream} the new stream\n *\n * @example\n * var n = flyd.stream(1);\n * var m = n.of(1);\n */\n\n// /////////////////////////// PRIVATE ///////////////////////////////// //\n/**\n * @private\n * Create a stream with no dependencies and no value\n * @return {Function} a flyd stream\n */\nfunction createStream() {\n  function s(n) {\n    if (arguments.length === 0) return s.val\n    updateStreamValue(s, n)\n    return s\n  }\n  s.hasVal = false;\n  s.val = undefined;\n  s.vals = [];\n  s.listeners = [];\n  s.queued = false;\n  s.end = undefined;\n  s.map = boundMap;\n  s.ap = ap;\n  s.of = flyd.stream;\n  s.toString = streamToString;\n  return s;\n}\n\n/**\n * @private\n * Create a dependent stream\n * @param {Array<stream>} dependencies - an array of the streams\n * @param {Function} fn - the function used to calculate the new stream value\n * from the dependencies\n * @return {stream} the created stream\n */\nfunction createDependentStream(deps, fn) {\n  var s = createStream();\n  s.fn = fn;\n  s.deps = deps;\n  s.depsMet = false;\n  s.depsChanged = deps.length > 0 ? [] : undefined;\n  s.shouldUpdate = false;\n  addListeners(deps, s);\n  return s;\n}\n\n/**\n * @private\n * Check if all the dependencies have values\n * @param {stream} stream - the stream to check depencencies from\n * @return {Boolean} `true` if all dependencies have vales, `false` otherwise\n */\nfunction initialDepsNotMet(stream) {\n  stream.depsMet = stream.deps.every(function(s) {\n    return s.hasVal;\n  });\n  return !stream.depsMet;\n}\n\n/**\n * @private\n * Update a dependent stream using its dependencies in an atomic way\n * @param {stream} stream - the stream to update\n */\nfunction updateStream(s) {\n  if ((s.depsMet !== true && initialDepsNotMet(s)) ||\n      (s.end !== undefined && s.end.val === true)) return;\n  if (inStream !== undefined) {\n    toUpdate.push(s);\n    return;\n  }\n  inStream = s;\n  if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged;\n  var returnVal = s.fn.apply(s.fn, s.fnArgs);\n  if (returnVal !== undefined) {\n    s(returnVal);\n  }\n  inStream = undefined;\n  if (s.depsChanged !== undefined) s.depsChanged = [];\n  s.shouldUpdate = false;\n  if (flushing === false) flushUpdate();\n}\n\n/**\n * @private\n * Update the dependencies of a stream\n * @param {stream} stream\n */\nfunction updateDeps(s) {\n  var i, o, list\n  var listeners = s.listeners;\n  for (i = 0; i < listeners.length; ++i) {\n    list = listeners[i];\n    if (list.end === s) {\n      endStream(list);\n    } else {\n      if (list.depsChanged !== undefined) list.depsChanged.push(s);\n      list.shouldUpdate = true;\n      findDeps(list);\n    }\n  }\n  for (; orderNextIdx >= 0; --orderNextIdx) {\n    o = order[orderNextIdx];\n    if (o.shouldUpdate === true) updateStream(o);\n    o.queued = false;\n  }\n}\n\n/**\n * @private\n * Add stream dependencies to the global `order` queue.\n * @param {stream} stream\n * @see updateDeps\n */\nfunction findDeps(s) {\n  var i\n  var listeners = s.listeners;\n  if (s.queued === false) {\n    s.queued = true;\n    for (i = 0; i < listeners.length; ++i) {\n      findDeps(listeners[i]);\n    }\n    order[++orderNextIdx] = s;\n  }\n}\n\n/**\n * @private\n */\nfunction flushUpdate() {\n  flushing = true;\n  while (toUpdate.length > 0) {\n    var s = toUpdate.shift();\n    if (s.vals.length > 0) s.val = s.vals.shift();\n    updateDeps(s);\n  }\n  flushing = false;\n}\n\n/**\n * @private\n * Push down a value into a stream\n * @param {stream} stream\n * @param {*} value\n */\nfunction updateStreamValue(s, n) {\n  if (n !== undefined && n !== null && isFunction(n.then)) {\n    n.then(s);\n    return;\n  }\n  s.val = n;\n  s.hasVal = true;\n  if (inStream === undefined) {\n    flushing = true;\n    updateDeps(s);\n    if (toUpdate.length > 0) flushUpdate(); else flushing = false;\n  } else if (inStream === s) {\n    markListeners(s, s.listeners);\n  } else {\n    s.vals.push(n);\n    toUpdate.push(s);\n  }\n}\n\n/**\n * @private\n */\nfunction markListeners(s, lists) {\n  var i, list;\n  for (i = 0; i < lists.length; ++i) {\n    list = lists[i];\n    if (list.end !== s) {\n      if (list.depsChanged !== undefined) {\n        list.depsChanged.push(s);\n      }\n      list.shouldUpdate = true;\n    } else {\n      endStream(list);\n    }\n  }\n}\n\n/**\n * @private\n * Add dependencies to a stream\n * @param {Array<stream>} dependencies\n * @param {stream} stream\n */\nfunction addListeners(deps, s) {\n  for (var i = 0; i < deps.length; ++i) {\n    deps[i].listeners.push(s);\n  }\n}\n\n/**\n * @private\n * Removes an stream from a dependency array\n * @param {stream} stream\n * @param {Array<stream>} dependencies\n */\nfunction removeListener(s, listeners) {\n  var idx = listeners.indexOf(s);\n  listeners[idx] = listeners[listeners.length - 1];\n  listeners.length--;\n}\n\n/**\n * @private\n * Detach a stream from its dependencies\n * @param {stream} stream\n */\nfunction detachDeps(s) {\n  for (var i = 0; i < s.deps.length; ++i) {\n    removeListener(s, s.deps[i].listeners);\n  }\n  s.deps.length = 0;\n}\n\n/**\n * @private\n * Ends a stream\n */\nfunction endStream(s) {\n  if (s.deps !== undefined) detachDeps(s);\n  if (s.end !== undefined) detachDeps(s.end);\n}\n\n/**\n * @private\n * transducer stream transformer\n */\nfunction StreamTransformer() { }\nStreamTransformer.prototype['@@transducer/init'] = function() { };\nStreamTransformer.prototype['@@transducer/result'] = function() { };\nStreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; };\n\nmodule.exports = flyd;\n"]} | |
| require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| 'use strict'; | |
| var curryN = require('ramda/src/curryN'); | |
| // Utility | |
| function isFunction(obj) { | |
| return !!(obj && obj.constructor && obj.call && obj.apply); | |
| } | |
| function trueFn() { return true; } | |
| // Globals | |
| var toUpdate = []; | |
| var inStream; | |
| var order = []; | |
| var orderNextIdx = -1; | |
| var flushing = false; | |
| /** @namespace */ | |
| var flyd = {} | |
| // /////////////////////////// API ///////////////////////////////// // | |
| /** | |
| * Creates a new stream | |
| * | |
| * __Signature__: `a -> Stream a` | |
| * | |
| * @name flyd.stream | |
| * @param {*} initialValue - (Optional) the initial value of the stream | |
| * @return {stream} the stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); // Stream with initial value `1` | |
| * var s = flyd.stream(); // Stream with no initial value | |
| */ | |
| flyd.stream = function(initialValue) { | |
| var endStream = createDependentStream([], trueFn); | |
| var s = createStream(); | |
| s.end = endStream; | |
| s.fnArgs = []; | |
| endStream.listeners.push(s); | |
| if (arguments.length > 0) s(initialValue); | |
| return s; | |
| } | |
| /** | |
| * Create a new dependent stream | |
| * | |
| * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b` | |
| * | |
| * @name flyd.combine | |
| * @param {Function} fn - the function used to combine the streams | |
| * @param {Array<stream>} dependencies - the streams that this one depends on | |
| * @return {stream} the dependent stream | |
| * | |
| * @example | |
| * var n1 = flyd.stream(0); | |
| * var n2 = flyd.stream(0); | |
| * var max = flyd.combine(function(n1, n2, self, changed) { | |
| * return n1() > n2() ? n1() : n2(); | |
| * }, [n1, n2]); | |
| */ | |
| flyd.combine = curryN(2, combine); | |
| function combine(fn, streams) { | |
| var i, s, deps, depEndStreams; | |
| var endStream = createDependentStream([], trueFn); | |
| deps = []; depEndStreams = []; | |
| for (i = 0; i < streams.length; ++i) { | |
| if (streams[i] !== undefined) { | |
| deps.push(streams[i]); | |
| if (streams[i].end !== undefined) depEndStreams.push(streams[i].end); | |
| } | |
| } | |
| s = createDependentStream(deps, fn); | |
| s.depsChanged = []; | |
| s.fnArgs = s.deps.concat([s, s.depsChanged]); | |
| s.end = endStream; | |
| endStream.listeners.push(s); | |
| addListeners(depEndStreams, endStream); | |
| endStream.deps = depEndStreams; | |
| updateStream(s); | |
| return s; | |
| } | |
| /** | |
| * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise. | |
| * | |
| * __Signature__: `* -> Boolean` | |
| * | |
| * @name flyd.isStream | |
| * @param {*} value - the value to test | |
| * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise | |
| * | |
| * @example | |
| * var s = flyd.stream(1); | |
| * var n = 1; | |
| * flyd.isStream(s); //=> true | |
| * flyd.isStream(n); //=> false | |
| */ | |
| flyd.isStream = function(stream) { | |
| return isFunction(stream) && 'hasVal' in stream; | |
| } | |
| /** | |
| * Invokes the body (the function to calculate the value) of a dependent stream | |
| * | |
| * By default the body of a dependent stream is only called when all the streams | |
| * upon which it depends has a value. `immediate` can circumvent this behaviour. | |
| * It immediately invokes the body of a dependent stream. | |
| * | |
| * __Signature__: `Stream a -> Stream a` | |
| * | |
| * @name flyd.immediate | |
| * @param {stream} stream - the dependent stream | |
| * @return {stream} the same stream | |
| * | |
| * @example | |
| * var s = flyd.stream(); | |
| * var hasItems = flyd.immediate(flyd.combine(function(s) { | |
| * return s() !== undefined && s().length > 0; | |
| * }, [s]); | |
| * console.log(hasItems()); // logs `false`. Had `immediate` not been | |
| * // used `hasItems()` would've returned `undefined` | |
| * s([1]); | |
| * console.log(hasItems()); // logs `true`. | |
| * s([]); | |
| * console.log(hasItems()); // logs `false`. | |
| */ | |
| flyd.immediate = function(s) { | |
| if (s.depsMet === false) { | |
| s.depsMet = true; | |
| updateStream(s); | |
| } | |
| return s; | |
| } | |
| /** | |
| * Changes which `endsStream` should trigger the ending of `s`. | |
| * | |
| * __Signature__: `Stream a -> Stream b -> Stream b` | |
| * | |
| * @name flyd.endsOn | |
| * @param {stream} endStream - the stream to trigger the ending | |
| * @param {stream} stream - the stream to be ended by the endStream | |
| * @param {stream} the stream modified to be ended by endStream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var killer = flyd.stream(); | |
| * // `double` ends when `n` ends or when `killer` emits any value | |
| * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) { | |
| * return 2 * n(); | |
| * }, [n]); | |
| */ | |
| flyd.endsOn = function(endS, s) { | |
| detachDeps(s.end); | |
| endS.listeners.push(s.end); | |
| s.end.deps.push(endS); | |
| return s; | |
| } | |
| /** | |
| * Map a stream | |
| * | |
| * Returns a new stream consisting of every value from `s` passed through | |
| * `fn`. I.e. `map` creates a new stream that listens to `s` and | |
| * applies `fn` to every new value. | |
| * __Signature__: `(a -> result) -> Stream a -> Stream result` | |
| * | |
| * @name flyd.map | |
| * @param {Function} fn - the function that produces the elements of the new stream | |
| * @param {stream} stream - the stream to map | |
| * @return {stream} a new stream with the mapped values | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers); | |
| */ | |
| // Library functions use self callback to accept (null, undefined) update triggers. | |
| flyd.map = curryN(2, function(f, s) { | |
| return combine(function(s, self) { self(f(s.val)); }, [s]); | |
| }) | |
| /** | |
| * Listen to stream events | |
| * | |
| * Similar to `map` except that the returned stream is empty. Use `on` for doing | |
| * side effects in reaction to stream changes. Use the returned stream only if you | |
| * need to manually end it. | |
| * | |
| * __Signature__: `(a -> result) -> Stream a -> Stream undefined` | |
| * | |
| * @name flyd.on | |
| * @param {Function} cb - the callback | |
| * @param {stream} stream - the stream | |
| * @return {stream} an empty stream (can be ended) | |
| */ | |
| flyd.on = curryN(2, function(f, s) { | |
| return combine(function(s) { f(s.val); }, [s]); | |
| }) | |
| /** | |
| * Creates a new stream with the results of calling the function on every incoming | |
| * stream with and accumulator and the incoming value. | |
| * | |
| * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a` | |
| * | |
| * @name flyd.scan | |
| * @param {Function} fn - the function to call | |
| * @param {*} val - the initial value of the accumulator | |
| * @param {stream} stream - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var numbers = flyd.stream(); | |
| * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers); | |
| * numbers(2)(3)(5); | |
| * sum(); // 10 | |
| */ | |
| flyd.scan = curryN(3, function(f, acc, s) { | |
| var ns = combine(function(s, self) { | |
| self(acc = f(acc, s.val)); | |
| }, [s]); | |
| if (!ns.hasVal) ns(acc); | |
| return ns; | |
| }); | |
| /** | |
| * Creates a new stream down which all values from both `stream1` and `stream2` | |
| * will be sent. | |
| * | |
| * __Signature__: `Stream a -> Stream a -> Stream a` | |
| * | |
| * @name flyd.merge | |
| * @param {stream} source1 - one stream to be merged | |
| * @param {stream} source2 - the other stream to be merged | |
| * @return {stream} a stream with the values from both sources | |
| * | |
| * @example | |
| * var btn1Clicks = flyd.stream(); | |
| * button1Elm.addEventListener(btn1Clicks); | |
| * var btn2Clicks = flyd.stream(); | |
| * button2Elm.addEventListener(btn2Clicks); | |
| * var allClicks = flyd.merge(btn1Clicks, btn2Clicks); | |
| */ | |
| flyd.merge = curryN(2, function(s1, s2) { | |
| var s = flyd.immediate(combine(function(s1, s2, self, changed) { | |
| if (changed[0]) { | |
| self(changed[0]()); | |
| } else if (s1.hasVal) { | |
| self(s1.val); | |
| } else if (s2.hasVal) { | |
| self(s2.val); | |
| } | |
| }, [s1, s2])); | |
| flyd.endsOn(combine(function() { | |
| return true; | |
| }, [s1.end, s2.end]), s); | |
| return s; | |
| }); | |
| /** | |
| * Creates a new stream resulting from applying `transducer` to `stream`. | |
| * | |
| * __Signature__: `Transducer -> Stream a -> Stream b` | |
| * | |
| * @name flyd.transduce | |
| * @param {Transducer} xform - the transducer transformation | |
| * @param {stream} source - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var t = require('transducers.js'); | |
| * | |
| * var results = []; | |
| * var s1 = flyd.stream(); | |
| * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe()); | |
| * var s2 = flyd.transduce(tx, s1); | |
| * flyd.combine(function(s2) { results.push(s2()); }, [s2]); | |
| * s1(1)(1)(2)(3)(3)(3)(4); | |
| * results; // => [2, 4, 6, 8] | |
| */ | |
| flyd.transduce = curryN(2, function(xform, source) { | |
| xform = xform(new StreamTransformer()); | |
| return combine(function(source, self) { | |
| var res = xform['@@transducer/step'](undefined, source.val); | |
| if (res && res['@@transducer/reduced'] === true) { | |
| self.end(true); | |
| return res['@@transducer/value']; | |
| } else { | |
| return res; | |
| } | |
| }, [source]); | |
| }); | |
| /** | |
| * Returns `fn` curried to `n`. Use this function to curry functions exposed by | |
| * modules for Flyd. | |
| * | |
| * @name flyd.curryN | |
| * @function | |
| * @param {Integer} arity - the function arity | |
| * @param {Function} fn - the function to curry | |
| * @return {Function} the curried function | |
| * | |
| * @example | |
| * function add(x, y) { return x + y; }; | |
| * var a = flyd.curryN(2, add); | |
| * a(2)(4) // => 6 | |
| */ | |
| flyd.curryN = curryN | |
| /** | |
| * Returns a new stream identical to the original except every | |
| * value will be passed through `f`. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b` | |
| * | |
| * @name stream.map | |
| * @param {Function} function - the function to apply | |
| * @return {stream} a new stream with the values mapped | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = numbers.map(function(n) { return n*n; }); | |
| */ | |
| function boundMap(f) { return flyd.map(f, this); } | |
| /** | |
| * Returns a new stream which is the result of applying the | |
| * functions from `this` stream to the values in `stream` parameter. | |
| * | |
| * `this` stream must be a stream of functions. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b` | |
| * | |
| * @name stream.ap | |
| * @param {stream} stream - the values stream | |
| * @return {stream} a new stram with the functions applied to values | |
| * | |
| * @example | |
| * var add = flyd.curryN(2, function(x, y) { return x + y; }); | |
| * var numbers1 = flyd.stream(); | |
| * var numbers2 = flyd.stream(); | |
| * var addToNumbers1 = flyd.map(add, numbers1); | |
| * var added = addToNumbers1.ap(numbers2); | |
| */ | |
| function ap(s2) { | |
| var s1 = this; | |
| return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]); | |
| } | |
| /** | |
| * Get a human readable view of a stream | |
| * @name stream.toString | |
| * @return {String} the stream string representation | |
| */ | |
| function streamToString() { | |
| return 'stream(' + this.val + ')'; | |
| } | |
| /** | |
| * @name stream.end | |
| * @memberof stream | |
| * A stream that emits `true` when the stream ends. If `true` is pushed down the | |
| * stream the parent stream ends. | |
| */ | |
| /** | |
| * @name stream.of | |
| * @function | |
| * @memberof stream | |
| * Returns a new stream with `value` as its initial value. It is identical to | |
| * calling `flyd.stream` with one argument. | |
| * | |
| * __Signature__: Called bound to `Stream (a)`: `b -> Stream b` | |
| * | |
| * @param {*} value - the initial value | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var m = n.of(1); | |
| */ | |
| // /////////////////////////// PRIVATE ///////////////////////////////// // | |
| /** | |
| * @private | |
| * Create a stream with no dependencies and no value | |
| * @return {Function} a flyd stream | |
| */ | |
| function createStream() { | |
| function s(n) { | |
| if (arguments.length === 0) return s.val | |
| updateStreamValue(s, n) | |
| return s | |
| } | |
| s.hasVal = false; | |
| s.val = undefined; | |
| s.vals = []; | |
| s.listeners = []; | |
| s.queued = false; | |
| s.end = undefined; | |
| s.map = boundMap; | |
| s.ap = ap; | |
| s.of = flyd.stream; | |
| s.toString = streamToString; | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Create a dependent stream | |
| * @param {Array<stream>} dependencies - an array of the streams | |
| * @param {Function} fn - the function used to calculate the new stream value | |
| * from the dependencies | |
| * @return {stream} the created stream | |
| */ | |
| function createDependentStream(deps, fn) { | |
| var s = createStream(); | |
| s.fn = fn; | |
| s.deps = deps; | |
| s.depsMet = false; | |
| s.depsChanged = deps.length > 0 ? [] : undefined; | |
| s.shouldUpdate = false; | |
| addListeners(deps, s); | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Check if all the dependencies have values | |
| * @param {stream} stream - the stream to check depencencies from | |
| * @return {Boolean} `true` if all dependencies have vales, `false` otherwise | |
| */ | |
| function initialDepsNotMet(stream) { | |
| stream.depsMet = stream.deps.every(function(s) { | |
| return s.hasVal; | |
| }); | |
| return !stream.depsMet; | |
| } | |
| /** | |
| * @private | |
| * Update a dependent stream using its dependencies in an atomic way | |
| * @param {stream} stream - the stream to update | |
| */ | |
| function updateStream(s) { | |
| if ((s.depsMet !== true && initialDepsNotMet(s)) || | |
| (s.end !== undefined && s.end.val === true)) return; | |
| if (inStream !== undefined) { | |
| toUpdate.push(s); | |
| return; | |
| } | |
| inStream = s; | |
| if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged; | |
| var returnVal = s.fn.apply(s.fn, s.fnArgs); | |
| if (returnVal !== undefined) { | |
| s(returnVal); | |
| } | |
| inStream = undefined; | |
| if (s.depsChanged !== undefined) s.depsChanged = []; | |
| s.shouldUpdate = false; | |
| if (flushing === false) flushUpdate(); | |
| } | |
| /** | |
| * @private | |
| * Update the dependencies of a stream | |
| * @param {stream} stream | |
| */ | |
| function updateDeps(s) { | |
| var i, o, list | |
| var listeners = s.listeners; | |
| for (i = 0; i < listeners.length; ++i) { | |
| list = listeners[i]; | |
| if (list.end === s) { | |
| endStream(list); | |
| } else { | |
| if (list.depsChanged !== undefined) list.depsChanged.push(s); | |
| list.shouldUpdate = true; | |
| findDeps(list); | |
| } | |
| } | |
| for (; orderNextIdx >= 0; --orderNextIdx) { | |
| o = order[orderNextIdx]; | |
| if (o.shouldUpdate === true) updateStream(o); | |
| o.queued = false; | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add stream dependencies to the global `order` queue. | |
| * @param {stream} stream | |
| * @see updateDeps | |
| */ | |
| function findDeps(s) { | |
| var i | |
| var listeners = s.listeners; | |
| if (s.queued === false) { | |
| s.queued = true; | |
| for (i = 0; i < listeners.length; ++i) { | |
| findDeps(listeners[i]); | |
| } | |
| order[++orderNextIdx] = s; | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function flushUpdate() { | |
| flushing = true; | |
| while (toUpdate.length > 0) { | |
| var s = toUpdate.shift(); | |
| if (s.vals.length > 0) s.val = s.vals.shift(); | |
| updateDeps(s); | |
| } | |
| flushing = false; | |
| } | |
| /** | |
| * @private | |
| * Push down a value into a stream | |
| * @param {stream} stream | |
| * @param {*} value | |
| */ | |
| function updateStreamValue(s, n) { | |
| if (n !== undefined && n !== null && isFunction(n.then)) { | |
| n.then(s); | |
| return; | |
| } | |
| s.val = n; | |
| s.hasVal = true; | |
| if (inStream === undefined) { | |
| flushing = true; | |
| updateDeps(s); | |
| if (toUpdate.length > 0) flushUpdate(); else flushing = false; | |
| } else if (inStream === s) { | |
| markListeners(s, s.listeners); | |
| } else { | |
| s.vals.push(n); | |
| toUpdate.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function markListeners(s, lists) { | |
| var i, list; | |
| for (i = 0; i < lists.length; ++i) { | |
| list = lists[i]; | |
| if (list.end !== s) { | |
| if (list.depsChanged !== undefined) { | |
| list.depsChanged.push(s); | |
| } | |
| list.shouldUpdate = true; | |
| } else { | |
| endStream(list); | |
| } | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add dependencies to a stream | |
| * @param {Array<stream>} dependencies | |
| * @param {stream} stream | |
| */ | |
| function addListeners(deps, s) { | |
| for (var i = 0; i < deps.length; ++i) { | |
| deps[i].listeners.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| * Removes an stream from a dependency array | |
| * @param {stream} stream | |
| * @param {Array<stream>} dependencies | |
| */ | |
| function removeListener(s, listeners) { | |
| var idx = listeners.indexOf(s); | |
| listeners[idx] = listeners[listeners.length - 1]; | |
| listeners.length--; | |
| } | |
| /** | |
| * @private | |
| * Detach a stream from its dependencies | |
| * @param {stream} stream | |
| */ | |
| function detachDeps(s) { | |
| for (var i = 0; i < s.deps.length; ++i) { | |
| removeListener(s, s.deps[i].listeners); | |
| } | |
| s.deps.length = 0; | |
| } | |
| /** | |
| * @private | |
| * Ends a stream | |
| */ | |
| function endStream(s) { | |
| if (s.deps !== undefined) detachDeps(s); | |
| if (s.end !== undefined) detachDeps(s.end); | |
| } | |
| /** | |
| * @private | |
| * transducer stream transformer | |
| */ | |
| function StreamTransformer() { } | |
| StreamTransformer.prototype['@@transducer/init'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/result'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; }; | |
| module.exports = flyd; | |
| },{"ramda/src/curryN":2}],2:[function(require,module,exports){ | |
| var _arity = require('./internal/_arity'); | |
| var _curry1 = require('./internal/_curry1'); | |
| var _curry2 = require('./internal/_curry2'); | |
| var _curryN = require('./internal/_curryN'); | |
| /** | |
| * Returns a curried equivalent of the provided function, with the specified | |
| * arity. The curried function has two unusual capabilities. First, its | |
| * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1)(2)(3)` | |
| * - `g(1)(2, 3)` | |
| * - `g(1, 2)(3)` | |
| * - `g(1, 2, 3)` | |
| * | |
| * Secondly, the special placeholder value `R.__` may be used to specify | |
| * "gaps", allowing partial application of any combination of arguments, | |
| * regardless of their positions. If `g` is as above and `_` is `R.__`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1, 2, 3)` | |
| * - `g(_, 2, 3)(1)` | |
| * - `g(_, _, 3)(1)(2)` | |
| * - `g(_, _, 3)(1, 2)` | |
| * - `g(_, 2)(1)(3)` | |
| * - `g(_, 2)(1, 3)` | |
| * - `g(_, 2)(_, 3)(1)` | |
| * | |
| * @func | |
| * @memberOf R | |
| * @since v0.5.0 | |
| * @category Function | |
| * @sig Number -> (* -> a) -> (* -> a) | |
| * @param {Number} length The arity for the returned function. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} A new, curried function. | |
| * @see R.curry | |
| * @example | |
| * | |
| * var sumArgs = (...args) => R.sum(args); | |
| * | |
| * var curriedAddFourNumbers = R.curryN(4, sumArgs); | |
| * var f = curriedAddFourNumbers(1, 2); | |
| * var g = f(3); | |
| * g(4); //=> 10 | |
| */ | |
| module.exports = _curry2(function curryN(length, fn) { | |
| if (length === 1) { | |
| return _curry1(fn); | |
| } | |
| return _arity(length, _curryN(length, [], fn)); | |
| }); | |
| },{"./internal/_arity":3,"./internal/_curry1":4,"./internal/_curry2":5,"./internal/_curryN":6}],3:[function(require,module,exports){ | |
| module.exports = function _arity(n, fn) { | |
| /* eslint-disable no-unused-vars */ | |
| switch (n) { | |
| case 0: return function() { return fn.apply(this, arguments); }; | |
| case 1: return function(a0) { return fn.apply(this, arguments); }; | |
| case 2: return function(a0, a1) { return fn.apply(this, arguments); }; | |
| case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); }; | |
| case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); }; | |
| case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); }; | |
| case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); }; | |
| case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); }; | |
| case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); }; | |
| case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); }; | |
| case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); }; | |
| default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); | |
| } | |
| }; | |
| },{}],4:[function(require,module,exports){ | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal one-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry1(fn) { | |
| return function f1(a) { | |
| if (arguments.length === 0 || _isPlaceholder(a)) { | |
| return f1; | |
| } else { | |
| return fn.apply(this, arguments); | |
| } | |
| }; | |
| }; | |
| },{"./_isPlaceholder":7}],5:[function(require,module,exports){ | |
| var _curry1 = require('./_curry1'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal two-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry2(fn) { | |
| return function f2(a, b) { | |
| switch (arguments.length) { | |
| case 0: | |
| return f2; | |
| case 1: | |
| return _isPlaceholder(a) ? f2 | |
| : _curry1(function(_b) { return fn(a, _b); }); | |
| default: | |
| return _isPlaceholder(a) && _isPlaceholder(b) ? f2 | |
| : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); }) | |
| : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); }) | |
| : fn(a, b); | |
| } | |
| }; | |
| }; | |
| },{"./_curry1":4,"./_isPlaceholder":7}],6:[function(require,module,exports){ | |
| var _arity = require('./_arity'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Internal curryN function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Number} length The arity of the curried function. | |
| * @param {Array} received An array of arguments received thus far. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curryN(length, received, fn) { | |
| return function() { | |
| var combined = []; | |
| var argsIdx = 0; | |
| var left = length; | |
| var combinedIdx = 0; | |
| while (combinedIdx < received.length || argsIdx < arguments.length) { | |
| var result; | |
| if (combinedIdx < received.length && | |
| (!_isPlaceholder(received[combinedIdx]) || | |
| argsIdx >= arguments.length)) { | |
| result = received[combinedIdx]; | |
| } else { | |
| result = arguments[argsIdx]; | |
| argsIdx += 1; | |
| } | |
| combined[combinedIdx] = result; | |
| if (!_isPlaceholder(result)) { | |
| left -= 1; | |
| } | |
| combinedIdx += 1; | |
| } | |
| return left <= 0 ? fn.apply(this, combined) | |
| : _arity(left, _curryN(length, combined, fn)); | |
| }; | |
| }; | |
| },{"./_arity":3,"./_isPlaceholder":7}],7:[function(require,module,exports){ | |
| module.exports = function _isPlaceholder(a) { | |
| return a != null && | |
| typeof a === 'object' && | |
| a['@@functional/placeholder'] === true; | |
| }; | |
| },{}],"flyd/module/mergeall":[function(require,module,exports){ | |
| var flyd = require('../../lib'); | |
| module.exports = function mergeAll(streams) { | |
| var s = flyd.immediate(flyd.combine(function() { | |
| var self = arguments[arguments.length - 2]; | |
| if (arguments[arguments.length - 1][0]) { | |
| self(arguments[arguments.length - 1][0]()); | |
| return; | |
| } | |
| [].slice.call(arguments, 0, arguments.length - 2) | |
| .some(function(s1) { | |
| if (s1.hasVal) { | |
| self(s1.val); | |
| return true; | |
| } | |
| }); | |
| }, streams)); | |
| flyd.endsOn(flyd.combine(function() { | |
| return true; | |
| }, streams.map(function(sm) { return sm.end; })), s); | |
| return s; | |
| }; | |
| },{"../../lib":1}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","lib/index.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_isPlaceholder.js","module/mergeall/index.js"],"names":[],"mappings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lnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nvar curryN = require('ramda/src/curryN');\n\n// Utility\nfunction isFunction(obj) {\n  return !!(obj && obj.constructor && obj.call && obj.apply);\n}\nfunction trueFn() { return true; }\n\n// Globals\nvar toUpdate = [];\nvar inStream;\nvar order = [];\nvar orderNextIdx = -1;\nvar flushing = false;\n\n/** @namespace */\nvar flyd = {}\n\n// /////////////////////////// API ///////////////////////////////// //\n\n/**\n * Creates a new stream\n *\n * __Signature__: `a -> Stream a`\n *\n * @name flyd.stream\n * @param {*} initialValue - (Optional) the initial value of the stream\n * @return {stream} the stream\n *\n * @example\n * var n = flyd.stream(1); // Stream with initial value `1`\n * var s = flyd.stream(); // Stream with no initial value\n */\nflyd.stream = function(initialValue) {\n  var endStream = createDependentStream([], trueFn);\n  var s = createStream();\n  s.end = endStream;\n  s.fnArgs = [];\n  endStream.listeners.push(s);\n  if (arguments.length > 0) s(initialValue);\n  return s;\n}\n\n/**\n * Create a new dependent stream\n *\n * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b`\n *\n * @name flyd.combine\n * @param {Function} fn - the function used to combine the streams\n * @param {Array<stream>} dependencies - the streams that this one depends on\n * @return {stream} the dependent stream\n *\n * @example\n * var n1 = flyd.stream(0);\n * var n2 = flyd.stream(0);\n * var max = flyd.combine(function(n1, n2, self, changed) {\n *   return n1() > n2() ? n1() : n2();\n * }, [n1, n2]);\n */\nflyd.combine = curryN(2, combine);\nfunction combine(fn, streams) {\n  var i, s, deps, depEndStreams;\n  var endStream = createDependentStream([], trueFn);\n  deps = []; depEndStreams = [];\n  for (i = 0; i < streams.length; ++i) {\n    if (streams[i] !== undefined) {\n      deps.push(streams[i]);\n      if (streams[i].end !== undefined) depEndStreams.push(streams[i].end);\n    }\n  }\n  s = createDependentStream(deps, fn);\n  s.depsChanged = [];\n  s.fnArgs = s.deps.concat([s, s.depsChanged]);\n  s.end = endStream;\n  endStream.listeners.push(s);\n  addListeners(depEndStreams, endStream);\n  endStream.deps = depEndStreams;\n  updateStream(s);\n  return s;\n}\n\n/**\n * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise.\n *\n * __Signature__: `* -> Boolean`\n *\n * @name flyd.isStream\n * @param {*} value - the value to test\n * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise\n *\n * @example\n * var s = flyd.stream(1);\n * var n = 1;\n * flyd.isStream(s); //=> true\n * flyd.isStream(n); //=> false\n */\nflyd.isStream = function(stream) {\n  return isFunction(stream) && 'hasVal' in stream;\n}\n\n/**\n * Invokes the body (the function to calculate the value) of a dependent stream\n *\n * By default the body of a dependent stream is only called when all the streams\n * upon which it depends has a value. `immediate` can circumvent this behaviour.\n * It immediately invokes the body of a dependent stream.\n *\n * __Signature__: `Stream a -> Stream a`\n *\n * @name flyd.immediate\n * @param {stream} stream - the dependent stream\n * @return {stream} the same stream\n *\n * @example\n * var s = flyd.stream();\n * var hasItems = flyd.immediate(flyd.combine(function(s) {\n *   return s() !== undefined && s().length > 0;\n * }, [s]);\n * console.log(hasItems()); // logs `false`. Had `immediate` not been\n *                          // used `hasItems()` would've returned `undefined`\n * s([1]);\n * console.log(hasItems()); // logs `true`.\n * s([]);\n * console.log(hasItems()); // logs `false`.\n */\nflyd.immediate = function(s) {\n  if (s.depsMet === false) {\n    s.depsMet = true;\n    updateStream(s);\n  }\n  return s;\n}\n\n/**\n * Changes which `endsStream` should trigger the ending of `s`.\n *\n * __Signature__: `Stream a -> Stream b -> Stream b`\n *\n * @name flyd.endsOn\n * @param {stream} endStream - the stream to trigger the ending\n * @param {stream} stream - the stream to be ended by the endStream\n * @param {stream} the stream modified to be ended by endStream\n *\n * @example\n * var n = flyd.stream(1);\n * var killer = flyd.stream();\n * // `double` ends when `n` ends or when `killer` emits any value\n * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) {\n *   return 2 * n();\n * }, [n]);\n*/\nflyd.endsOn = function(endS, s) {\n  detachDeps(s.end);\n  endS.listeners.push(s.end);\n  s.end.deps.push(endS);\n  return s;\n}\n\n/**\n * Map a stream\n *\n * Returns a new stream consisting of every value from `s` passed through\n * `fn`. I.e. `map` creates a new stream that listens to `s` and\n * applies `fn` to every new value.\n * __Signature__: `(a -> result) -> Stream a -> Stream result`\n *\n * @name flyd.map\n * @param {Function} fn - the function that produces the elements of the new stream\n * @param {stream} stream - the stream to map\n * @return {stream} a new stream with the mapped values\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers);\n */\n// Library functions use self callback to accept (null, undefined) update triggers.\nflyd.map = curryN(2, function(f, s) {\n  return combine(function(s, self) { self(f(s.val)); }, [s]);\n})\n\n/**\n * Listen to stream events\n *\n * Similar to `map` except that the returned stream is empty. Use `on` for doing\n * side effects in reaction to stream changes. Use the returned stream only if you\n * need to manually end it.\n *\n * __Signature__: `(a -> result) -> Stream a -> Stream undefined`\n *\n * @name flyd.on\n * @param {Function} cb - the callback\n * @param {stream} stream - the stream\n * @return {stream} an empty stream (can be ended)\n */\nflyd.on = curryN(2, function(f, s) {\n  return combine(function(s) { f(s.val); }, [s]);\n})\n\n/**\n * Creates a new stream with the results of calling the function on every incoming\n * stream with and accumulator and the incoming value.\n *\n * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a`\n *\n * @name flyd.scan\n * @param {Function} fn - the function to call\n * @param {*} val - the initial value of the accumulator\n * @param {stream} stream - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var numbers = flyd.stream();\n * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers);\n * numbers(2)(3)(5);\n * sum(); // 10\n */\nflyd.scan = curryN(3, function(f, acc, s) {\n  var ns = combine(function(s, self) {\n    self(acc = f(acc, s.val));\n  }, [s]);\n  if (!ns.hasVal) ns(acc);\n  return ns;\n});\n\n/**\n * Creates a new stream down which all values from both `stream1` and `stream2`\n * will be sent.\n *\n * __Signature__: `Stream a -> Stream a -> Stream a`\n *\n * @name flyd.merge\n * @param {stream} source1 - one stream to be merged\n * @param {stream} source2 - the other stream to be merged\n * @return {stream} a stream with the values from both sources\n *\n * @example\n * var btn1Clicks = flyd.stream();\n * button1Elm.addEventListener(btn1Clicks);\n * var btn2Clicks = flyd.stream();\n * button2Elm.addEventListener(btn2Clicks);\n * var allClicks = flyd.merge(btn1Clicks, btn2Clicks);\n */\nflyd.merge = curryN(2, function(s1, s2) {\n  var s = flyd.immediate(combine(function(s1, s2, self, changed) {\n    if (changed[0]) {\n      self(changed[0]());\n    } else if (s1.hasVal) {\n      self(s1.val);\n    } else if (s2.hasVal) {\n      self(s2.val);\n    }\n  }, [s1, s2]));\n  flyd.endsOn(combine(function() {\n    return true;\n  }, [s1.end, s2.end]), s);\n  return s;\n});\n\n/**\n * Creates a new stream resulting from applying `transducer` to `stream`.\n *\n * __Signature__: `Transducer -> Stream a -> Stream b`\n *\n * @name flyd.transduce\n * @param {Transducer} xform - the transducer transformation\n * @param {stream} source - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var t = require('transducers.js');\n *\n * var results = [];\n * var s1 = flyd.stream();\n * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe());\n * var s2 = flyd.transduce(tx, s1);\n * flyd.combine(function(s2) { results.push(s2()); }, [s2]);\n * s1(1)(1)(2)(3)(3)(3)(4);\n * results; // => [2, 4, 6, 8]\n */\nflyd.transduce = curryN(2, function(xform, source) {\n  xform = xform(new StreamTransformer());\n  return combine(function(source, self) {\n    var res = xform['@@transducer/step'](undefined, source.val);\n    if (res && res['@@transducer/reduced'] === true) {\n      self.end(true);\n      return res['@@transducer/value'];\n    } else {\n      return res;\n    }\n  }, [source]);\n});\n\n/**\n * Returns `fn` curried to `n`. Use this function to curry functions exposed by\n * modules for Flyd.\n *\n * @name flyd.curryN\n * @function\n * @param {Integer} arity - the function arity\n * @param {Function} fn - the function to curry\n * @return {Function} the curried function\n *\n * @example\n * function add(x, y) { return x + y; };\n * var a = flyd.curryN(2, add);\n * a(2)(4) // => 6\n */\nflyd.curryN = curryN\n\n/**\n * Returns a new stream identical to the original except every\n * value will be passed through `f`.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b`\n *\n * @name stream.map\n * @param {Function} function - the function to apply\n * @return {stream} a new stream with the values mapped\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = numbers.map(function(n) { return n*n; });\n */\nfunction boundMap(f) { return flyd.map(f, this); }\n\n/**\n * Returns a new stream which is the result of applying the\n * functions from `this` stream to the values in `stream` parameter.\n *\n * `this` stream must be a stream of functions.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b`\n *\n * @name stream.ap\n * @param {stream} stream - the values stream\n * @return {stream} a new stram with the functions applied to values\n *\n * @example\n * var add = flyd.curryN(2, function(x, y) { return x + y; });\n * var numbers1 = flyd.stream();\n * var numbers2 = flyd.stream();\n * var addToNumbers1 = flyd.map(add, numbers1);\n * var added = addToNumbers1.ap(numbers2);\n */\nfunction ap(s2) {\n  var s1 = this;\n  return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]);\n}\n\n/**\n * Get a human readable view of a stream\n * @name stream.toString\n * @return {String} the stream string representation\n */\nfunction streamToString() {\n  return 'stream(' + this.val + ')';\n}\n\n/**\n * @name stream.end\n * @memberof stream\n * A stream that emits `true` when the stream ends. If `true` is pushed down the\n * stream the parent stream ends.\n */\n\n/**\n * @name stream.of\n * @function\n * @memberof stream\n * Returns a new stream with `value` as its initial value. It is identical to\n * calling `flyd.stream` with one argument.\n *\n * __Signature__: Called bound to `Stream (a)`: `b -> Stream b`\n *\n * @param {*} value - the initial value\n * @return {stream} the new stream\n *\n * @example\n * var n = flyd.stream(1);\n * var m = n.of(1);\n */\n\n// /////////////////////////// PRIVATE ///////////////////////////////// //\n/**\n * @private\n * Create a stream with no dependencies and no value\n * @return {Function} a flyd stream\n */\nfunction createStream() {\n  function s(n) {\n    if (arguments.length === 0) return s.val\n    updateStreamValue(s, n)\n    return s\n  }\n  s.hasVal = false;\n  s.val = undefined;\n  s.vals = [];\n  s.listeners = [];\n  s.queued = false;\n  s.end = undefined;\n  s.map = boundMap;\n  s.ap = ap;\n  s.of = flyd.stream;\n  s.toString = streamToString;\n  return s;\n}\n\n/**\n * @private\n * Create a dependent stream\n * @param {Array<stream>} dependencies - an array of the streams\n * @param {Function} fn - the function used to calculate the new stream value\n * from the dependencies\n * @return {stream} the created stream\n */\nfunction createDependentStream(deps, fn) {\n  var s = createStream();\n  s.fn = fn;\n  s.deps = deps;\n  s.depsMet = false;\n  s.depsChanged = deps.length > 0 ? [] : undefined;\n  s.shouldUpdate = false;\n  addListeners(deps, s);\n  return s;\n}\n\n/**\n * @private\n * Check if all the dependencies have values\n * @param {stream} stream - the stream to check depencencies from\n * @return {Boolean} `true` if all dependencies have vales, `false` otherwise\n */\nfunction initialDepsNotMet(stream) {\n  stream.depsMet = stream.deps.every(function(s) {\n    return s.hasVal;\n  });\n  return !stream.depsMet;\n}\n\n/**\n * @private\n * Update a dependent stream using its dependencies in an atomic way\n * @param {stream} stream - the stream to update\n */\nfunction updateStream(s) {\n  if ((s.depsMet !== true && initialDepsNotMet(s)) ||\n      (s.end !== undefined && s.end.val === true)) return;\n  if (inStream !== undefined) {\n    toUpdate.push(s);\n    return;\n  }\n  inStream = s;\n  if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged;\n  var returnVal = s.fn.apply(s.fn, s.fnArgs);\n  if (returnVal !== undefined) {\n    s(returnVal);\n  }\n  inStream = undefined;\n  if (s.depsChanged !== undefined) s.depsChanged = [];\n  s.shouldUpdate = false;\n  if (flushing === false) flushUpdate();\n}\n\n/**\n * @private\n * Update the dependencies of a stream\n * @param {stream} stream\n */\nfunction updateDeps(s) {\n  var i, o, list\n  var listeners = s.listeners;\n  for (i = 0; i < listeners.length; ++i) {\n    list = listeners[i];\n    if (list.end === s) {\n      endStream(list);\n    } else {\n      if (list.depsChanged !== undefined) list.depsChanged.push(s);\n      list.shouldUpdate = true;\n      findDeps(list);\n    }\n  }\n  for (; orderNextIdx >= 0; --orderNextIdx) {\n    o = order[orderNextIdx];\n    if (o.shouldUpdate === true) updateStream(o);\n    o.queued = false;\n  }\n}\n\n/**\n * @private\n * Add stream dependencies to the global `order` queue.\n * @param {stream} stream\n * @see updateDeps\n */\nfunction findDeps(s) {\n  var i\n  var listeners = s.listeners;\n  if (s.queued === false) {\n    s.queued = true;\n    for (i = 0; i < listeners.length; ++i) {\n      findDeps(listeners[i]);\n    }\n    order[++orderNextIdx] = s;\n  }\n}\n\n/**\n * @private\n */\nfunction flushUpdate() {\n  flushing = true;\n  while (toUpdate.length > 0) {\n    var s = toUpdate.shift();\n    if (s.vals.length > 0) s.val = s.vals.shift();\n    updateDeps(s);\n  }\n  flushing = false;\n}\n\n/**\n * @private\n * Push down a value into a stream\n * @param {stream} stream\n * @param {*} value\n */\nfunction updateStreamValue(s, n) {\n  if (n !== undefined && n !== null && isFunction(n.then)) {\n    n.then(s);\n    return;\n  }\n  s.val = n;\n  s.hasVal = true;\n  if (inStream === undefined) {\n    flushing = true;\n    updateDeps(s);\n    if (toUpdate.length > 0) flushUpdate(); else flushing = false;\n  } else if (inStream === s) {\n    markListeners(s, s.listeners);\n  } else {\n    s.vals.push(n);\n    toUpdate.push(s);\n  }\n}\n\n/**\n * @private\n */\nfunction markListeners(s, lists) {\n  var i, list;\n  for (i = 0; i < lists.length; ++i) {\n    list = lists[i];\n    if (list.end !== s) {\n      if (list.depsChanged !== undefined) {\n        list.depsChanged.push(s);\n      }\n      list.shouldUpdate = true;\n    } else {\n      endStream(list);\n    }\n  }\n}\n\n/**\n * @private\n * Add dependencies to a stream\n * @param {Array<stream>} dependencies\n * @param {stream} stream\n */\nfunction addListeners(deps, s) {\n  for (var i = 0; i < deps.length; ++i) {\n    deps[i].listeners.push(s);\n  }\n}\n\n/**\n * @private\n * Removes an stream from a dependency array\n * @param {stream} stream\n * @param {Array<stream>} dependencies\n */\nfunction removeListener(s, listeners) {\n  var idx = listeners.indexOf(s);\n  listeners[idx] = listeners[listeners.length - 1];\n  listeners.length--;\n}\n\n/**\n * @private\n * Detach a stream from its dependencies\n * @param {stream} stream\n */\nfunction detachDeps(s) {\n  for (var i = 0; i < s.deps.length; ++i) {\n    removeListener(s, s.deps[i].listeners);\n  }\n  s.deps.length = 0;\n}\n\n/**\n * @private\n * Ends a stream\n */\nfunction endStream(s) {\n  if (s.deps !== undefined) detachDeps(s);\n  if (s.end !== undefined) detachDeps(s.end);\n}\n\n/**\n * @private\n * transducer stream transformer\n */\nfunction StreamTransformer() { }\nStreamTransformer.prototype['@@transducer/init'] = function() { };\nStreamTransformer.prototype['@@transducer/result'] = function() { };\nStreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; };\n\nmodule.exports = flyd;\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`, the\n * following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var sumArgs = (...args) => R.sum(args);\n *\n *      var curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","module.exports = function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n      case 1:\n        return _isPlaceholder(a) ? f2\n             : _curry1(function(_b) { return fn(a, _b); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })\n             : fn(a, b);\n    }\n  };\n};\n","var _arity = require('./_arity');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (!_isPlaceholder(received[combinedIdx]) ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined)\n                     : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","module.exports = function _isPlaceholder(a) {\n  return a != null &&\n         typeof a === 'object' &&\n         a['@@functional/placeholder'] === true;\n};\n","var flyd = require('../../lib');\n\nmodule.exports = function mergeAll(streams) {\n  var s = flyd.immediate(flyd.combine(function() {\n    var self = arguments[arguments.length - 2];\n    if (arguments[arguments.length - 1][0]) {\n      self(arguments[arguments.length - 1][0]());\n      return;\n    }\n    [].slice.call(arguments, 0, arguments.length - 2)\n    .some(function(s1) {\n      if (s1.hasVal) {\n        self(s1.val);\n        return true;\n      }\n    });\n  }, streams));\n  flyd.endsOn(flyd.combine(function() {\n    return true;\n  }, streams.map(function(sm) { return sm.end; })), s);\n  return s;\n};\n\n"]} | |
| require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| 'use strict'; | |
| var curryN = require('ramda/src/curryN'); | |
| // Utility | |
| function isFunction(obj) { | |
| return !!(obj && obj.constructor && obj.call && obj.apply); | |
| } | |
| function trueFn() { return true; } | |
| // Globals | |
| var toUpdate = []; | |
| var inStream; | |
| var order = []; | |
| var orderNextIdx = -1; | |
| var flushing = false; | |
| /** @namespace */ | |
| var flyd = {} | |
| // /////////////////////////// API ///////////////////////////////// // | |
| /** | |
| * Creates a new stream | |
| * | |
| * __Signature__: `a -> Stream a` | |
| * | |
| * @name flyd.stream | |
| * @param {*} initialValue - (Optional) the initial value of the stream | |
| * @return {stream} the stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); // Stream with initial value `1` | |
| * var s = flyd.stream(); // Stream with no initial value | |
| */ | |
| flyd.stream = function(initialValue) { | |
| var endStream = createDependentStream([], trueFn); | |
| var s = createStream(); | |
| s.end = endStream; | |
| s.fnArgs = []; | |
| endStream.listeners.push(s); | |
| if (arguments.length > 0) s(initialValue); | |
| return s; | |
| } | |
| /** | |
| * Create a new dependent stream | |
| * | |
| * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b` | |
| * | |
| * @name flyd.combine | |
| * @param {Function} fn - the function used to combine the streams | |
| * @param {Array<stream>} dependencies - the streams that this one depends on | |
| * @return {stream} the dependent stream | |
| * | |
| * @example | |
| * var n1 = flyd.stream(0); | |
| * var n2 = flyd.stream(0); | |
| * var max = flyd.combine(function(n1, n2, self, changed) { | |
| * return n1() > n2() ? n1() : n2(); | |
| * }, [n1, n2]); | |
| */ | |
| flyd.combine = curryN(2, combine); | |
| function combine(fn, streams) { | |
| var i, s, deps, depEndStreams; | |
| var endStream = createDependentStream([], trueFn); | |
| deps = []; depEndStreams = []; | |
| for (i = 0; i < streams.length; ++i) { | |
| if (streams[i] !== undefined) { | |
| deps.push(streams[i]); | |
| if (streams[i].end !== undefined) depEndStreams.push(streams[i].end); | |
| } | |
| } | |
| s = createDependentStream(deps, fn); | |
| s.depsChanged = []; | |
| s.fnArgs = s.deps.concat([s, s.depsChanged]); | |
| s.end = endStream; | |
| endStream.listeners.push(s); | |
| addListeners(depEndStreams, endStream); | |
| endStream.deps = depEndStreams; | |
| updateStream(s); | |
| return s; | |
| } | |
| /** | |
| * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise. | |
| * | |
| * __Signature__: `* -> Boolean` | |
| * | |
| * @name flyd.isStream | |
| * @param {*} value - the value to test | |
| * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise | |
| * | |
| * @example | |
| * var s = flyd.stream(1); | |
| * var n = 1; | |
| * flyd.isStream(s); //=> true | |
| * flyd.isStream(n); //=> false | |
| */ | |
| flyd.isStream = function(stream) { | |
| return isFunction(stream) && 'hasVal' in stream; | |
| } | |
| /** | |
| * Invokes the body (the function to calculate the value) of a dependent stream | |
| * | |
| * By default the body of a dependent stream is only called when all the streams | |
| * upon which it depends has a value. `immediate` can circumvent this behaviour. | |
| * It immediately invokes the body of a dependent stream. | |
| * | |
| * __Signature__: `Stream a -> Stream a` | |
| * | |
| * @name flyd.immediate | |
| * @param {stream} stream - the dependent stream | |
| * @return {stream} the same stream | |
| * | |
| * @example | |
| * var s = flyd.stream(); | |
| * var hasItems = flyd.immediate(flyd.combine(function(s) { | |
| * return s() !== undefined && s().length > 0; | |
| * }, [s]); | |
| * console.log(hasItems()); // logs `false`. Had `immediate` not been | |
| * // used `hasItems()` would've returned `undefined` | |
| * s([1]); | |
| * console.log(hasItems()); // logs `true`. | |
| * s([]); | |
| * console.log(hasItems()); // logs `false`. | |
| */ | |
| flyd.immediate = function(s) { | |
| if (s.depsMet === false) { | |
| s.depsMet = true; | |
| updateStream(s); | |
| } | |
| return s; | |
| } | |
| /** | |
| * Changes which `endsStream` should trigger the ending of `s`. | |
| * | |
| * __Signature__: `Stream a -> Stream b -> Stream b` | |
| * | |
| * @name flyd.endsOn | |
| * @param {stream} endStream - the stream to trigger the ending | |
| * @param {stream} stream - the stream to be ended by the endStream | |
| * @param {stream} the stream modified to be ended by endStream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var killer = flyd.stream(); | |
| * // `double` ends when `n` ends or when `killer` emits any value | |
| * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) { | |
| * return 2 * n(); | |
| * }, [n]); | |
| */ | |
| flyd.endsOn = function(endS, s) { | |
| detachDeps(s.end); | |
| endS.listeners.push(s.end); | |
| s.end.deps.push(endS); | |
| return s; | |
| } | |
| /** | |
| * Map a stream | |
| * | |
| * Returns a new stream consisting of every value from `s` passed through | |
| * `fn`. I.e. `map` creates a new stream that listens to `s` and | |
| * applies `fn` to every new value. | |
| * __Signature__: `(a -> result) -> Stream a -> Stream result` | |
| * | |
| * @name flyd.map | |
| * @param {Function} fn - the function that produces the elements of the new stream | |
| * @param {stream} stream - the stream to map | |
| * @return {stream} a new stream with the mapped values | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers); | |
| */ | |
| // Library functions use self callback to accept (null, undefined) update triggers. | |
| flyd.map = curryN(2, function(f, s) { | |
| return combine(function(s, self) { self(f(s.val)); }, [s]); | |
| }) | |
| /** | |
| * Listen to stream events | |
| * | |
| * Similar to `map` except that the returned stream is empty. Use `on` for doing | |
| * side effects in reaction to stream changes. Use the returned stream only if you | |
| * need to manually end it. | |
| * | |
| * __Signature__: `(a -> result) -> Stream a -> Stream undefined` | |
| * | |
| * @name flyd.on | |
| * @param {Function} cb - the callback | |
| * @param {stream} stream - the stream | |
| * @return {stream} an empty stream (can be ended) | |
| */ | |
| flyd.on = curryN(2, function(f, s) { | |
| return combine(function(s) { f(s.val); }, [s]); | |
| }) | |
| /** | |
| * Creates a new stream with the results of calling the function on every incoming | |
| * stream with and accumulator and the incoming value. | |
| * | |
| * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a` | |
| * | |
| * @name flyd.scan | |
| * @param {Function} fn - the function to call | |
| * @param {*} val - the initial value of the accumulator | |
| * @param {stream} stream - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var numbers = flyd.stream(); | |
| * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers); | |
| * numbers(2)(3)(5); | |
| * sum(); // 10 | |
| */ | |
| flyd.scan = curryN(3, function(f, acc, s) { | |
| var ns = combine(function(s, self) { | |
| self(acc = f(acc, s.val)); | |
| }, [s]); | |
| if (!ns.hasVal) ns(acc); | |
| return ns; | |
| }); | |
| /** | |
| * Creates a new stream down which all values from both `stream1` and `stream2` | |
| * will be sent. | |
| * | |
| * __Signature__: `Stream a -> Stream a -> Stream a` | |
| * | |
| * @name flyd.merge | |
| * @param {stream} source1 - one stream to be merged | |
| * @param {stream} source2 - the other stream to be merged | |
| * @return {stream} a stream with the values from both sources | |
| * | |
| * @example | |
| * var btn1Clicks = flyd.stream(); | |
| * button1Elm.addEventListener(btn1Clicks); | |
| * var btn2Clicks = flyd.stream(); | |
| * button2Elm.addEventListener(btn2Clicks); | |
| * var allClicks = flyd.merge(btn1Clicks, btn2Clicks); | |
| */ | |
| flyd.merge = curryN(2, function(s1, s2) { | |
| var s = flyd.immediate(combine(function(s1, s2, self, changed) { | |
| if (changed[0]) { | |
| self(changed[0]()); | |
| } else if (s1.hasVal) { | |
| self(s1.val); | |
| } else if (s2.hasVal) { | |
| self(s2.val); | |
| } | |
| }, [s1, s2])); | |
| flyd.endsOn(combine(function() { | |
| return true; | |
| }, [s1.end, s2.end]), s); | |
| return s; | |
| }); | |
| /** | |
| * Creates a new stream resulting from applying `transducer` to `stream`. | |
| * | |
| * __Signature__: `Transducer -> Stream a -> Stream b` | |
| * | |
| * @name flyd.transduce | |
| * @param {Transducer} xform - the transducer transformation | |
| * @param {stream} source - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var t = require('transducers.js'); | |
| * | |
| * var results = []; | |
| * var s1 = flyd.stream(); | |
| * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe()); | |
| * var s2 = flyd.transduce(tx, s1); | |
| * flyd.combine(function(s2) { results.push(s2()); }, [s2]); | |
| * s1(1)(1)(2)(3)(3)(3)(4); | |
| * results; // => [2, 4, 6, 8] | |
| */ | |
| flyd.transduce = curryN(2, function(xform, source) { | |
| xform = xform(new StreamTransformer()); | |
| return combine(function(source, self) { | |
| var res = xform['@@transducer/step'](undefined, source.val); | |
| if (res && res['@@transducer/reduced'] === true) { | |
| self.end(true); | |
| return res['@@transducer/value']; | |
| } else { | |
| return res; | |
| } | |
| }, [source]); | |
| }); | |
| /** | |
| * Returns `fn` curried to `n`. Use this function to curry functions exposed by | |
| * modules for Flyd. | |
| * | |
| * @name flyd.curryN | |
| * @function | |
| * @param {Integer} arity - the function arity | |
| * @param {Function} fn - the function to curry | |
| * @return {Function} the curried function | |
| * | |
| * @example | |
| * function add(x, y) { return x + y; }; | |
| * var a = flyd.curryN(2, add); | |
| * a(2)(4) // => 6 | |
| */ | |
| flyd.curryN = curryN | |
| /** | |
| * Returns a new stream identical to the original except every | |
| * value will be passed through `f`. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b` | |
| * | |
| * @name stream.map | |
| * @param {Function} function - the function to apply | |
| * @return {stream} a new stream with the values mapped | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = numbers.map(function(n) { return n*n; }); | |
| */ | |
| function boundMap(f) { return flyd.map(f, this); } | |
| /** | |
| * Returns a new stream which is the result of applying the | |
| * functions from `this` stream to the values in `stream` parameter. | |
| * | |
| * `this` stream must be a stream of functions. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b` | |
| * | |
| * @name stream.ap | |
| * @param {stream} stream - the values stream | |
| * @return {stream} a new stram with the functions applied to values | |
| * | |
| * @example | |
| * var add = flyd.curryN(2, function(x, y) { return x + y; }); | |
| * var numbers1 = flyd.stream(); | |
| * var numbers2 = flyd.stream(); | |
| * var addToNumbers1 = flyd.map(add, numbers1); | |
| * var added = addToNumbers1.ap(numbers2); | |
| */ | |
| function ap(s2) { | |
| var s1 = this; | |
| return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]); | |
| } | |
| /** | |
| * Get a human readable view of a stream | |
| * @name stream.toString | |
| * @return {String} the stream string representation | |
| */ | |
| function streamToString() { | |
| return 'stream(' + this.val + ')'; | |
| } | |
| /** | |
| * @name stream.end | |
| * @memberof stream | |
| * A stream that emits `true` when the stream ends. If `true` is pushed down the | |
| * stream the parent stream ends. | |
| */ | |
| /** | |
| * @name stream.of | |
| * @function | |
| * @memberof stream | |
| * Returns a new stream with `value` as its initial value. It is identical to | |
| * calling `flyd.stream` with one argument. | |
| * | |
| * __Signature__: Called bound to `Stream (a)`: `b -> Stream b` | |
| * | |
| * @param {*} value - the initial value | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var m = n.of(1); | |
| */ | |
| // /////////////////////////// PRIVATE ///////////////////////////////// // | |
| /** | |
| * @private | |
| * Create a stream with no dependencies and no value | |
| * @return {Function} a flyd stream | |
| */ | |
| function createStream() { | |
| function s(n) { | |
| if (arguments.length === 0) return s.val | |
| updateStreamValue(s, n) | |
| return s | |
| } | |
| s.hasVal = false; | |
| s.val = undefined; | |
| s.vals = []; | |
| s.listeners = []; | |
| s.queued = false; | |
| s.end = undefined; | |
| s.map = boundMap; | |
| s.ap = ap; | |
| s.of = flyd.stream; | |
| s.toString = streamToString; | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Create a dependent stream | |
| * @param {Array<stream>} dependencies - an array of the streams | |
| * @param {Function} fn - the function used to calculate the new stream value | |
| * from the dependencies | |
| * @return {stream} the created stream | |
| */ | |
| function createDependentStream(deps, fn) { | |
| var s = createStream(); | |
| s.fn = fn; | |
| s.deps = deps; | |
| s.depsMet = false; | |
| s.depsChanged = deps.length > 0 ? [] : undefined; | |
| s.shouldUpdate = false; | |
| addListeners(deps, s); | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Check if all the dependencies have values | |
| * @param {stream} stream - the stream to check depencencies from | |
| * @return {Boolean} `true` if all dependencies have vales, `false` otherwise | |
| */ | |
| function initialDepsNotMet(stream) { | |
| stream.depsMet = stream.deps.every(function(s) { | |
| return s.hasVal; | |
| }); | |
| return !stream.depsMet; | |
| } | |
| /** | |
| * @private | |
| * Update a dependent stream using its dependencies in an atomic way | |
| * @param {stream} stream - the stream to update | |
| */ | |
| function updateStream(s) { | |
| if ((s.depsMet !== true && initialDepsNotMet(s)) || | |
| (s.end !== undefined && s.end.val === true)) return; | |
| if (inStream !== undefined) { | |
| toUpdate.push(s); | |
| return; | |
| } | |
| inStream = s; | |
| if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged; | |
| var returnVal = s.fn.apply(s.fn, s.fnArgs); | |
| if (returnVal !== undefined) { | |
| s(returnVal); | |
| } | |
| inStream = undefined; | |
| if (s.depsChanged !== undefined) s.depsChanged = []; | |
| s.shouldUpdate = false; | |
| if (flushing === false) flushUpdate(); | |
| } | |
| /** | |
| * @private | |
| * Update the dependencies of a stream | |
| * @param {stream} stream | |
| */ | |
| function updateDeps(s) { | |
| var i, o, list | |
| var listeners = s.listeners; | |
| for (i = 0; i < listeners.length; ++i) { | |
| list = listeners[i]; | |
| if (list.end === s) { | |
| endStream(list); | |
| } else { | |
| if (list.depsChanged !== undefined) list.depsChanged.push(s); | |
| list.shouldUpdate = true; | |
| findDeps(list); | |
| } | |
| } | |
| for (; orderNextIdx >= 0; --orderNextIdx) { | |
| o = order[orderNextIdx]; | |
| if (o.shouldUpdate === true) updateStream(o); | |
| o.queued = false; | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add stream dependencies to the global `order` queue. | |
| * @param {stream} stream | |
| * @see updateDeps | |
| */ | |
| function findDeps(s) { | |
| var i | |
| var listeners = s.listeners; | |
| if (s.queued === false) { | |
| s.queued = true; | |
| for (i = 0; i < listeners.length; ++i) { | |
| findDeps(listeners[i]); | |
| } | |
| order[++orderNextIdx] = s; | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function flushUpdate() { | |
| flushing = true; | |
| while (toUpdate.length > 0) { | |
| var s = toUpdate.shift(); | |
| if (s.vals.length > 0) s.val = s.vals.shift(); | |
| updateDeps(s); | |
| } | |
| flushing = false; | |
| } | |
| /** | |
| * @private | |
| * Push down a value into a stream | |
| * @param {stream} stream | |
| * @param {*} value | |
| */ | |
| function updateStreamValue(s, n) { | |
| if (n !== undefined && n !== null && isFunction(n.then)) { | |
| n.then(s); | |
| return; | |
| } | |
| s.val = n; | |
| s.hasVal = true; | |
| if (inStream === undefined) { | |
| flushing = true; | |
| updateDeps(s); | |
| if (toUpdate.length > 0) flushUpdate(); else flushing = false; | |
| } else if (inStream === s) { | |
| markListeners(s, s.listeners); | |
| } else { | |
| s.vals.push(n); | |
| toUpdate.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function markListeners(s, lists) { | |
| var i, list; | |
| for (i = 0; i < lists.length; ++i) { | |
| list = lists[i]; | |
| if (list.end !== s) { | |
| if (list.depsChanged !== undefined) { | |
| list.depsChanged.push(s); | |
| } | |
| list.shouldUpdate = true; | |
| } else { | |
| endStream(list); | |
| } | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add dependencies to a stream | |
| * @param {Array<stream>} dependencies | |
| * @param {stream} stream | |
| */ | |
| function addListeners(deps, s) { | |
| for (var i = 0; i < deps.length; ++i) { | |
| deps[i].listeners.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| * Removes an stream from a dependency array | |
| * @param {stream} stream | |
| * @param {Array<stream>} dependencies | |
| */ | |
| function removeListener(s, listeners) { | |
| var idx = listeners.indexOf(s); | |
| listeners[idx] = listeners[listeners.length - 1]; | |
| listeners.length--; | |
| } | |
| /** | |
| * @private | |
| * Detach a stream from its dependencies | |
| * @param {stream} stream | |
| */ | |
| function detachDeps(s) { | |
| for (var i = 0; i < s.deps.length; ++i) { | |
| removeListener(s, s.deps[i].listeners); | |
| } | |
| s.deps.length = 0; | |
| } | |
| /** | |
| * @private | |
| * Ends a stream | |
| */ | |
| function endStream(s) { | |
| if (s.deps !== undefined) detachDeps(s); | |
| if (s.end !== undefined) detachDeps(s.end); | |
| } | |
| /** | |
| * @private | |
| * transducer stream transformer | |
| */ | |
| function StreamTransformer() { } | |
| StreamTransformer.prototype['@@transducer/init'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/result'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; }; | |
| module.exports = flyd; | |
| },{"ramda/src/curryN":2}],2:[function(require,module,exports){ | |
| var _arity = require('./internal/_arity'); | |
| var _curry1 = require('./internal/_curry1'); | |
| var _curry2 = require('./internal/_curry2'); | |
| var _curryN = require('./internal/_curryN'); | |
| /** | |
| * Returns a curried equivalent of the provided function, with the specified | |
| * arity. The curried function has two unusual capabilities. First, its | |
| * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1)(2)(3)` | |
| * - `g(1)(2, 3)` | |
| * - `g(1, 2)(3)` | |
| * - `g(1, 2, 3)` | |
| * | |
| * Secondly, the special placeholder value `R.__` may be used to specify | |
| * "gaps", allowing partial application of any combination of arguments, | |
| * regardless of their positions. If `g` is as above and `_` is `R.__`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1, 2, 3)` | |
| * - `g(_, 2, 3)(1)` | |
| * - `g(_, _, 3)(1)(2)` | |
| * - `g(_, _, 3)(1, 2)` | |
| * - `g(_, 2)(1)(3)` | |
| * - `g(_, 2)(1, 3)` | |
| * - `g(_, 2)(_, 3)(1)` | |
| * | |
| * @func | |
| * @memberOf R | |
| * @since v0.5.0 | |
| * @category Function | |
| * @sig Number -> (* -> a) -> (* -> a) | |
| * @param {Number} length The arity for the returned function. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} A new, curried function. | |
| * @see R.curry | |
| * @example | |
| * | |
| * var sumArgs = (...args) => R.sum(args); | |
| * | |
| * var curriedAddFourNumbers = R.curryN(4, sumArgs); | |
| * var f = curriedAddFourNumbers(1, 2); | |
| * var g = f(3); | |
| * g(4); //=> 10 | |
| */ | |
| module.exports = _curry2(function curryN(length, fn) { | |
| if (length === 1) { | |
| return _curry1(fn); | |
| } | |
| return _arity(length, _curryN(length, [], fn)); | |
| }); | |
| },{"./internal/_arity":3,"./internal/_curry1":4,"./internal/_curry2":5,"./internal/_curryN":6}],3:[function(require,module,exports){ | |
| module.exports = function _arity(n, fn) { | |
| /* eslint-disable no-unused-vars */ | |
| switch (n) { | |
| case 0: return function() { return fn.apply(this, arguments); }; | |
| case 1: return function(a0) { return fn.apply(this, arguments); }; | |
| case 2: return function(a0, a1) { return fn.apply(this, arguments); }; | |
| case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); }; | |
| case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); }; | |
| case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); }; | |
| case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); }; | |
| case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); }; | |
| case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); }; | |
| case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); }; | |
| case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); }; | |
| default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); | |
| } | |
| }; | |
| },{}],4:[function(require,module,exports){ | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal one-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry1(fn) { | |
| return function f1(a) { | |
| if (arguments.length === 0 || _isPlaceholder(a)) { | |
| return f1; | |
| } else { | |
| return fn.apply(this, arguments); | |
| } | |
| }; | |
| }; | |
| },{"./_isPlaceholder":7}],5:[function(require,module,exports){ | |
| var _curry1 = require('./_curry1'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal two-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry2(fn) { | |
| return function f2(a, b) { | |
| switch (arguments.length) { | |
| case 0: | |
| return f2; | |
| case 1: | |
| return _isPlaceholder(a) ? f2 | |
| : _curry1(function(_b) { return fn(a, _b); }); | |
| default: | |
| return _isPlaceholder(a) && _isPlaceholder(b) ? f2 | |
| : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); }) | |
| : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); }) | |
| : fn(a, b); | |
| } | |
| }; | |
| }; | |
| },{"./_curry1":4,"./_isPlaceholder":7}],6:[function(require,module,exports){ | |
| var _arity = require('./_arity'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Internal curryN function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Number} length The arity of the curried function. | |
| * @param {Array} received An array of arguments received thus far. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curryN(length, received, fn) { | |
| return function() { | |
| var combined = []; | |
| var argsIdx = 0; | |
| var left = length; | |
| var combinedIdx = 0; | |
| while (combinedIdx < received.length || argsIdx < arguments.length) { | |
| var result; | |
| if (combinedIdx < received.length && | |
| (!_isPlaceholder(received[combinedIdx]) || | |
| argsIdx >= arguments.length)) { | |
| result = received[combinedIdx]; | |
| } else { | |
| result = arguments[argsIdx]; | |
| argsIdx += 1; | |
| } | |
| combined[combinedIdx] = result; | |
| if (!_isPlaceholder(result)) { | |
| left -= 1; | |
| } | |
| combinedIdx += 1; | |
| } | |
| return left <= 0 ? fn.apply(this, combined) | |
| : _arity(left, _curryN(length, combined, fn)); | |
| }; | |
| }; | |
| },{"./_arity":3,"./_isPlaceholder":7}],7:[function(require,module,exports){ | |
| module.exports = function _isPlaceholder(a) { | |
| return a != null && | |
| typeof a === 'object' && | |
| a['@@functional/placeholder'] === true; | |
| }; | |
| },{}],"flyd/module/takeuntil":[function(require,module,exports){ | |
| var flyd = require('../../lib'); | |
| module.exports = function(src, term) { | |
| return flyd.endsOn(flyd.merge(term, src.end), flyd.combine(function(src, self) { | |
| self(src()); | |
| }, [src])); | |
| }; | |
| },{"../../lib":1}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","lib/index.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_isPlaceholder.js","module/takeuntil/index.js"],"names":[],"mappings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lnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nvar curryN = require('ramda/src/curryN');\n\n// Utility\nfunction isFunction(obj) {\n  return !!(obj && obj.constructor && obj.call && obj.apply);\n}\nfunction trueFn() { return true; }\n\n// Globals\nvar toUpdate = [];\nvar inStream;\nvar order = [];\nvar orderNextIdx = -1;\nvar flushing = false;\n\n/** @namespace */\nvar flyd = {}\n\n// /////////////////////////// API ///////////////////////////////// //\n\n/**\n * Creates a new stream\n *\n * __Signature__: `a -> Stream a`\n *\n * @name flyd.stream\n * @param {*} initialValue - (Optional) the initial value of the stream\n * @return {stream} the stream\n *\n * @example\n * var n = flyd.stream(1); // Stream with initial value `1`\n * var s = flyd.stream(); // Stream with no initial value\n */\nflyd.stream = function(initialValue) {\n  var endStream = createDependentStream([], trueFn);\n  var s = createStream();\n  s.end = endStream;\n  s.fnArgs = [];\n  endStream.listeners.push(s);\n  if (arguments.length > 0) s(initialValue);\n  return s;\n}\n\n/**\n * Create a new dependent stream\n *\n * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b`\n *\n * @name flyd.combine\n * @param {Function} fn - the function used to combine the streams\n * @param {Array<stream>} dependencies - the streams that this one depends on\n * @return {stream} the dependent stream\n *\n * @example\n * var n1 = flyd.stream(0);\n * var n2 = flyd.stream(0);\n * var max = flyd.combine(function(n1, n2, self, changed) {\n *   return n1() > n2() ? n1() : n2();\n * }, [n1, n2]);\n */\nflyd.combine = curryN(2, combine);\nfunction combine(fn, streams) {\n  var i, s, deps, depEndStreams;\n  var endStream = createDependentStream([], trueFn);\n  deps = []; depEndStreams = [];\n  for (i = 0; i < streams.length; ++i) {\n    if (streams[i] !== undefined) {\n      deps.push(streams[i]);\n      if (streams[i].end !== undefined) depEndStreams.push(streams[i].end);\n    }\n  }\n  s = createDependentStream(deps, fn);\n  s.depsChanged = [];\n  s.fnArgs = s.deps.concat([s, s.depsChanged]);\n  s.end = endStream;\n  endStream.listeners.push(s);\n  addListeners(depEndStreams, endStream);\n  endStream.deps = depEndStreams;\n  updateStream(s);\n  return s;\n}\n\n/**\n * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise.\n *\n * __Signature__: `* -> Boolean`\n *\n * @name flyd.isStream\n * @param {*} value - the value to test\n * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise\n *\n * @example\n * var s = flyd.stream(1);\n * var n = 1;\n * flyd.isStream(s); //=> true\n * flyd.isStream(n); //=> false\n */\nflyd.isStream = function(stream) {\n  return isFunction(stream) && 'hasVal' in stream;\n}\n\n/**\n * Invokes the body (the function to calculate the value) of a dependent stream\n *\n * By default the body of a dependent stream is only called when all the streams\n * upon which it depends has a value. `immediate` can circumvent this behaviour.\n * It immediately invokes the body of a dependent stream.\n *\n * __Signature__: `Stream a -> Stream a`\n *\n * @name flyd.immediate\n * @param {stream} stream - the dependent stream\n * @return {stream} the same stream\n *\n * @example\n * var s = flyd.stream();\n * var hasItems = flyd.immediate(flyd.combine(function(s) {\n *   return s() !== undefined && s().length > 0;\n * }, [s]);\n * console.log(hasItems()); // logs `false`. Had `immediate` not been\n *                          // used `hasItems()` would've returned `undefined`\n * s([1]);\n * console.log(hasItems()); // logs `true`.\n * s([]);\n * console.log(hasItems()); // logs `false`.\n */\nflyd.immediate = function(s) {\n  if (s.depsMet === false) {\n    s.depsMet = true;\n    updateStream(s);\n  }\n  return s;\n}\n\n/**\n * Changes which `endsStream` should trigger the ending of `s`.\n *\n * __Signature__: `Stream a -> Stream b -> Stream b`\n *\n * @name flyd.endsOn\n * @param {stream} endStream - the stream to trigger the ending\n * @param {stream} stream - the stream to be ended by the endStream\n * @param {stream} the stream modified to be ended by endStream\n *\n * @example\n * var n = flyd.stream(1);\n * var killer = flyd.stream();\n * // `double` ends when `n` ends or when `killer` emits any value\n * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) {\n *   return 2 * n();\n * }, [n]);\n*/\nflyd.endsOn = function(endS, s) {\n  detachDeps(s.end);\n  endS.listeners.push(s.end);\n  s.end.deps.push(endS);\n  return s;\n}\n\n/**\n * Map a stream\n *\n * Returns a new stream consisting of every value from `s` passed through\n * `fn`. I.e. `map` creates a new stream that listens to `s` and\n * applies `fn` to every new value.\n * __Signature__: `(a -> result) -> Stream a -> Stream result`\n *\n * @name flyd.map\n * @param {Function} fn - the function that produces the elements of the new stream\n * @param {stream} stream - the stream to map\n * @return {stream} a new stream with the mapped values\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers);\n */\n// Library functions use self callback to accept (null, undefined) update triggers.\nflyd.map = curryN(2, function(f, s) {\n  return combine(function(s, self) { self(f(s.val)); }, [s]);\n})\n\n/**\n * Listen to stream events\n *\n * Similar to `map` except that the returned stream is empty. Use `on` for doing\n * side effects in reaction to stream changes. Use the returned stream only if you\n * need to manually end it.\n *\n * __Signature__: `(a -> result) -> Stream a -> Stream undefined`\n *\n * @name flyd.on\n * @param {Function} cb - the callback\n * @param {stream} stream - the stream\n * @return {stream} an empty stream (can be ended)\n */\nflyd.on = curryN(2, function(f, s) {\n  return combine(function(s) { f(s.val); }, [s]);\n})\n\n/**\n * Creates a new stream with the results of calling the function on every incoming\n * stream with and accumulator and the incoming value.\n *\n * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a`\n *\n * @name flyd.scan\n * @param {Function} fn - the function to call\n * @param {*} val - the initial value of the accumulator\n * @param {stream} stream - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var numbers = flyd.stream();\n * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers);\n * numbers(2)(3)(5);\n * sum(); // 10\n */\nflyd.scan = curryN(3, function(f, acc, s) {\n  var ns = combine(function(s, self) {\n    self(acc = f(acc, s.val));\n  }, [s]);\n  if (!ns.hasVal) ns(acc);\n  return ns;\n});\n\n/**\n * Creates a new stream down which all values from both `stream1` and `stream2`\n * will be sent.\n *\n * __Signature__: `Stream a -> Stream a -> Stream a`\n *\n * @name flyd.merge\n * @param {stream} source1 - one stream to be merged\n * @param {stream} source2 - the other stream to be merged\n * @return {stream} a stream with the values from both sources\n *\n * @example\n * var btn1Clicks = flyd.stream();\n * button1Elm.addEventListener(btn1Clicks);\n * var btn2Clicks = flyd.stream();\n * button2Elm.addEventListener(btn2Clicks);\n * var allClicks = flyd.merge(btn1Clicks, btn2Clicks);\n */\nflyd.merge = curryN(2, function(s1, s2) {\n  var s = flyd.immediate(combine(function(s1, s2, self, changed) {\n    if (changed[0]) {\n      self(changed[0]());\n    } else if (s1.hasVal) {\n      self(s1.val);\n    } else if (s2.hasVal) {\n      self(s2.val);\n    }\n  }, [s1, s2]));\n  flyd.endsOn(combine(function() {\n    return true;\n  }, [s1.end, s2.end]), s);\n  return s;\n});\n\n/**\n * Creates a new stream resulting from applying `transducer` to `stream`.\n *\n * __Signature__: `Transducer -> Stream a -> Stream b`\n *\n * @name flyd.transduce\n * @param {Transducer} xform - the transducer transformation\n * @param {stream} source - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var t = require('transducers.js');\n *\n * var results = [];\n * var s1 = flyd.stream();\n * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe());\n * var s2 = flyd.transduce(tx, s1);\n * flyd.combine(function(s2) { results.push(s2()); }, [s2]);\n * s1(1)(1)(2)(3)(3)(3)(4);\n * results; // => [2, 4, 6, 8]\n */\nflyd.transduce = curryN(2, function(xform, source) {\n  xform = xform(new StreamTransformer());\n  return combine(function(source, self) {\n    var res = xform['@@transducer/step'](undefined, source.val);\n    if (res && res['@@transducer/reduced'] === true) {\n      self.end(true);\n      return res['@@transducer/value'];\n    } else {\n      return res;\n    }\n  }, [source]);\n});\n\n/**\n * Returns `fn` curried to `n`. Use this function to curry functions exposed by\n * modules for Flyd.\n *\n * @name flyd.curryN\n * @function\n * @param {Integer} arity - the function arity\n * @param {Function} fn - the function to curry\n * @return {Function} the curried function\n *\n * @example\n * function add(x, y) { return x + y; };\n * var a = flyd.curryN(2, add);\n * a(2)(4) // => 6\n */\nflyd.curryN = curryN\n\n/**\n * Returns a new stream identical to the original except every\n * value will be passed through `f`.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b`\n *\n * @name stream.map\n * @param {Function} function - the function to apply\n * @return {stream} a new stream with the values mapped\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = numbers.map(function(n) { return n*n; });\n */\nfunction boundMap(f) { return flyd.map(f, this); }\n\n/**\n * Returns a new stream which is the result of applying the\n * functions from `this` stream to the values in `stream` parameter.\n *\n * `this` stream must be a stream of functions.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b`\n *\n * @name stream.ap\n * @param {stream} stream - the values stream\n * @return {stream} a new stram with the functions applied to values\n *\n * @example\n * var add = flyd.curryN(2, function(x, y) { return x + y; });\n * var numbers1 = flyd.stream();\n * var numbers2 = flyd.stream();\n * var addToNumbers1 = flyd.map(add, numbers1);\n * var added = addToNumbers1.ap(numbers2);\n */\nfunction ap(s2) {\n  var s1 = this;\n  return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]);\n}\n\n/**\n * Get a human readable view of a stream\n * @name stream.toString\n * @return {String} the stream string representation\n */\nfunction streamToString() {\n  return 'stream(' + this.val + ')';\n}\n\n/**\n * @name stream.end\n * @memberof stream\n * A stream that emits `true` when the stream ends. If `true` is pushed down the\n * stream the parent stream ends.\n */\n\n/**\n * @name stream.of\n * @function\n * @memberof stream\n * Returns a new stream with `value` as its initial value. It is identical to\n * calling `flyd.stream` with one argument.\n *\n * __Signature__: Called bound to `Stream (a)`: `b -> Stream b`\n *\n * @param {*} value - the initial value\n * @return {stream} the new stream\n *\n * @example\n * var n = flyd.stream(1);\n * var m = n.of(1);\n */\n\n// /////////////////////////// PRIVATE ///////////////////////////////// //\n/**\n * @private\n * Create a stream with no dependencies and no value\n * @return {Function} a flyd stream\n */\nfunction createStream() {\n  function s(n) {\n    if (arguments.length === 0) return s.val\n    updateStreamValue(s, n)\n    return s\n  }\n  s.hasVal = false;\n  s.val = undefined;\n  s.vals = [];\n  s.listeners = [];\n  s.queued = false;\n  s.end = undefined;\n  s.map = boundMap;\n  s.ap = ap;\n  s.of = flyd.stream;\n  s.toString = streamToString;\n  return s;\n}\n\n/**\n * @private\n * Create a dependent stream\n * @param {Array<stream>} dependencies - an array of the streams\n * @param {Function} fn - the function used to calculate the new stream value\n * from the dependencies\n * @return {stream} the created stream\n */\nfunction createDependentStream(deps, fn) {\n  var s = createStream();\n  s.fn = fn;\n  s.deps = deps;\n  s.depsMet = false;\n  s.depsChanged = deps.length > 0 ? [] : undefined;\n  s.shouldUpdate = false;\n  addListeners(deps, s);\n  return s;\n}\n\n/**\n * @private\n * Check if all the dependencies have values\n * @param {stream} stream - the stream to check depencencies from\n * @return {Boolean} `true` if all dependencies have vales, `false` otherwise\n */\nfunction initialDepsNotMet(stream) {\n  stream.depsMet = stream.deps.every(function(s) {\n    return s.hasVal;\n  });\n  return !stream.depsMet;\n}\n\n/**\n * @private\n * Update a dependent stream using its dependencies in an atomic way\n * @param {stream} stream - the stream to update\n */\nfunction updateStream(s) {\n  if ((s.depsMet !== true && initialDepsNotMet(s)) ||\n      (s.end !== undefined && s.end.val === true)) return;\n  if (inStream !== undefined) {\n    toUpdate.push(s);\n    return;\n  }\n  inStream = s;\n  if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged;\n  var returnVal = s.fn.apply(s.fn, s.fnArgs);\n  if (returnVal !== undefined) {\n    s(returnVal);\n  }\n  inStream = undefined;\n  if (s.depsChanged !== undefined) s.depsChanged = [];\n  s.shouldUpdate = false;\n  if (flushing === false) flushUpdate();\n}\n\n/**\n * @private\n * Update the dependencies of a stream\n * @param {stream} stream\n */\nfunction updateDeps(s) {\n  var i, o, list\n  var listeners = s.listeners;\n  for (i = 0; i < listeners.length; ++i) {\n    list = listeners[i];\n    if (list.end === s) {\n      endStream(list);\n    } else {\n      if (list.depsChanged !== undefined) list.depsChanged.push(s);\n      list.shouldUpdate = true;\n      findDeps(list);\n    }\n  }\n  for (; orderNextIdx >= 0; --orderNextIdx) {\n    o = order[orderNextIdx];\n    if (o.shouldUpdate === true) updateStream(o);\n    o.queued = false;\n  }\n}\n\n/**\n * @private\n * Add stream dependencies to the global `order` queue.\n * @param {stream} stream\n * @see updateDeps\n */\nfunction findDeps(s) {\n  var i\n  var listeners = s.listeners;\n  if (s.queued === false) {\n    s.queued = true;\n    for (i = 0; i < listeners.length; ++i) {\n      findDeps(listeners[i]);\n    }\n    order[++orderNextIdx] = s;\n  }\n}\n\n/**\n * @private\n */\nfunction flushUpdate() {\n  flushing = true;\n  while (toUpdate.length > 0) {\n    var s = toUpdate.shift();\n    if (s.vals.length > 0) s.val = s.vals.shift();\n    updateDeps(s);\n  }\n  flushing = false;\n}\n\n/**\n * @private\n * Push down a value into a stream\n * @param {stream} stream\n * @param {*} value\n */\nfunction updateStreamValue(s, n) {\n  if (n !== undefined && n !== null && isFunction(n.then)) {\n    n.then(s);\n    return;\n  }\n  s.val = n;\n  s.hasVal = true;\n  if (inStream === undefined) {\n    flushing = true;\n    updateDeps(s);\n    if (toUpdate.length > 0) flushUpdate(); else flushing = false;\n  } else if (inStream === s) {\n    markListeners(s, s.listeners);\n  } else {\n    s.vals.push(n);\n    toUpdate.push(s);\n  }\n}\n\n/**\n * @private\n */\nfunction markListeners(s, lists) {\n  var i, list;\n  for (i = 0; i < lists.length; ++i) {\n    list = lists[i];\n    if (list.end !== s) {\n      if (list.depsChanged !== undefined) {\n        list.depsChanged.push(s);\n      }\n      list.shouldUpdate = true;\n    } else {\n      endStream(list);\n    }\n  }\n}\n\n/**\n * @private\n * Add dependencies to a stream\n * @param {Array<stream>} dependencies\n * @param {stream} stream\n */\nfunction addListeners(deps, s) {\n  for (var i = 0; i < deps.length; ++i) {\n    deps[i].listeners.push(s);\n  }\n}\n\n/**\n * @private\n * Removes an stream from a dependency array\n * @param {stream} stream\n * @param {Array<stream>} dependencies\n */\nfunction removeListener(s, listeners) {\n  var idx = listeners.indexOf(s);\n  listeners[idx] = listeners[listeners.length - 1];\n  listeners.length--;\n}\n\n/**\n * @private\n * Detach a stream from its dependencies\n * @param {stream} stream\n */\nfunction detachDeps(s) {\n  for (var i = 0; i < s.deps.length; ++i) {\n    removeListener(s, s.deps[i].listeners);\n  }\n  s.deps.length = 0;\n}\n\n/**\n * @private\n * Ends a stream\n */\nfunction endStream(s) {\n  if (s.deps !== undefined) detachDeps(s);\n  if (s.end !== undefined) detachDeps(s.end);\n}\n\n/**\n * @private\n * transducer stream transformer\n */\nfunction StreamTransformer() { }\nStreamTransformer.prototype['@@transducer/init'] = function() { };\nStreamTransformer.prototype['@@transducer/result'] = function() { };\nStreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; };\n\nmodule.exports = flyd;\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`, the\n * following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var sumArgs = (...args) => R.sum(args);\n *\n *      var curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","module.exports = function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n      case 1:\n        return _isPlaceholder(a) ? f2\n             : _curry1(function(_b) { return fn(a, _b); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })\n             : fn(a, b);\n    }\n  };\n};\n","var _arity = require('./_arity');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (!_isPlaceholder(received[combinedIdx]) ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined)\n                     : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","module.exports = function _isPlaceholder(a) {\n  return a != null &&\n         typeof a === 'object' &&\n         a['@@functional/placeholder'] === true;\n};\n","var flyd = require('../../lib');\n\nmodule.exports = function(src, term) {\n  return flyd.endsOn(flyd.merge(term, src.end), flyd.combine(function(src, self) {\n    self(src());\n  }, [src]));\n};\n"]} | |
| require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| 'use strict'; | |
| var curryN = require('ramda/src/curryN'); | |
| // Utility | |
| function isFunction(obj) { | |
| return !!(obj && obj.constructor && obj.call && obj.apply); | |
| } | |
| function trueFn() { return true; } | |
| // Globals | |
| var toUpdate = []; | |
| var inStream; | |
| var order = []; | |
| var orderNextIdx = -1; | |
| var flushing = false; | |
| /** @namespace */ | |
| var flyd = {} | |
| // /////////////////////////// API ///////////////////////////////// // | |
| /** | |
| * Creates a new stream | |
| * | |
| * __Signature__: `a -> Stream a` | |
| * | |
| * @name flyd.stream | |
| * @param {*} initialValue - (Optional) the initial value of the stream | |
| * @return {stream} the stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); // Stream with initial value `1` | |
| * var s = flyd.stream(); // Stream with no initial value | |
| */ | |
| flyd.stream = function(initialValue) { | |
| var endStream = createDependentStream([], trueFn); | |
| var s = createStream(); | |
| s.end = endStream; | |
| s.fnArgs = []; | |
| endStream.listeners.push(s); | |
| if (arguments.length > 0) s(initialValue); | |
| return s; | |
| } | |
| /** | |
| * Create a new dependent stream | |
| * | |
| * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b` | |
| * | |
| * @name flyd.combine | |
| * @param {Function} fn - the function used to combine the streams | |
| * @param {Array<stream>} dependencies - the streams that this one depends on | |
| * @return {stream} the dependent stream | |
| * | |
| * @example | |
| * var n1 = flyd.stream(0); | |
| * var n2 = flyd.stream(0); | |
| * var max = flyd.combine(function(n1, n2, self, changed) { | |
| * return n1() > n2() ? n1() : n2(); | |
| * }, [n1, n2]); | |
| */ | |
| flyd.combine = curryN(2, combine); | |
| function combine(fn, streams) { | |
| var i, s, deps, depEndStreams; | |
| var endStream = createDependentStream([], trueFn); | |
| deps = []; depEndStreams = []; | |
| for (i = 0; i < streams.length; ++i) { | |
| if (streams[i] !== undefined) { | |
| deps.push(streams[i]); | |
| if (streams[i].end !== undefined) depEndStreams.push(streams[i].end); | |
| } | |
| } | |
| s = createDependentStream(deps, fn); | |
| s.depsChanged = []; | |
| s.fnArgs = s.deps.concat([s, s.depsChanged]); | |
| s.end = endStream; | |
| endStream.listeners.push(s); | |
| addListeners(depEndStreams, endStream); | |
| endStream.deps = depEndStreams; | |
| updateStream(s); | |
| return s; | |
| } | |
| /** | |
| * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise. | |
| * | |
| * __Signature__: `* -> Boolean` | |
| * | |
| * @name flyd.isStream | |
| * @param {*} value - the value to test | |
| * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise | |
| * | |
| * @example | |
| * var s = flyd.stream(1); | |
| * var n = 1; | |
| * flyd.isStream(s); //=> true | |
| * flyd.isStream(n); //=> false | |
| */ | |
| flyd.isStream = function(stream) { | |
| return isFunction(stream) && 'hasVal' in stream; | |
| } | |
| /** | |
| * Invokes the body (the function to calculate the value) of a dependent stream | |
| * | |
| * By default the body of a dependent stream is only called when all the streams | |
| * upon which it depends has a value. `immediate` can circumvent this behaviour. | |
| * It immediately invokes the body of a dependent stream. | |
| * | |
| * __Signature__: `Stream a -> Stream a` | |
| * | |
| * @name flyd.immediate | |
| * @param {stream} stream - the dependent stream | |
| * @return {stream} the same stream | |
| * | |
| * @example | |
| * var s = flyd.stream(); | |
| * var hasItems = flyd.immediate(flyd.combine(function(s) { | |
| * return s() !== undefined && s().length > 0; | |
| * }, [s]); | |
| * console.log(hasItems()); // logs `false`. Had `immediate` not been | |
| * // used `hasItems()` would've returned `undefined` | |
| * s([1]); | |
| * console.log(hasItems()); // logs `true`. | |
| * s([]); | |
| * console.log(hasItems()); // logs `false`. | |
| */ | |
| flyd.immediate = function(s) { | |
| if (s.depsMet === false) { | |
| s.depsMet = true; | |
| updateStream(s); | |
| } | |
| return s; | |
| } | |
| /** | |
| * Changes which `endsStream` should trigger the ending of `s`. | |
| * | |
| * __Signature__: `Stream a -> Stream b -> Stream b` | |
| * | |
| * @name flyd.endsOn | |
| * @param {stream} endStream - the stream to trigger the ending | |
| * @param {stream} stream - the stream to be ended by the endStream | |
| * @param {stream} the stream modified to be ended by endStream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var killer = flyd.stream(); | |
| * // `double` ends when `n` ends or when `killer` emits any value | |
| * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) { | |
| * return 2 * n(); | |
| * }, [n]); | |
| */ | |
| flyd.endsOn = function(endS, s) { | |
| detachDeps(s.end); | |
| endS.listeners.push(s.end); | |
| s.end.deps.push(endS); | |
| return s; | |
| } | |
| /** | |
| * Map a stream | |
| * | |
| * Returns a new stream consisting of every value from `s` passed through | |
| * `fn`. I.e. `map` creates a new stream that listens to `s` and | |
| * applies `fn` to every new value. | |
| * __Signature__: `(a -> result) -> Stream a -> Stream result` | |
| * | |
| * @name flyd.map | |
| * @param {Function} fn - the function that produces the elements of the new stream | |
| * @param {stream} stream - the stream to map | |
| * @return {stream} a new stream with the mapped values | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers); | |
| */ | |
| // Library functions use self callback to accept (null, undefined) update triggers. | |
| flyd.map = curryN(2, function(f, s) { | |
| return combine(function(s, self) { self(f(s.val)); }, [s]); | |
| }) | |
| /** | |
| * Listen to stream events | |
| * | |
| * Similar to `map` except that the returned stream is empty. Use `on` for doing | |
| * side effects in reaction to stream changes. Use the returned stream only if you | |
| * need to manually end it. | |
| * | |
| * __Signature__: `(a -> result) -> Stream a -> Stream undefined` | |
| * | |
| * @name flyd.on | |
| * @param {Function} cb - the callback | |
| * @param {stream} stream - the stream | |
| * @return {stream} an empty stream (can be ended) | |
| */ | |
| flyd.on = curryN(2, function(f, s) { | |
| return combine(function(s) { f(s.val); }, [s]); | |
| }) | |
| /** | |
| * Creates a new stream with the results of calling the function on every incoming | |
| * stream with and accumulator and the incoming value. | |
| * | |
| * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a` | |
| * | |
| * @name flyd.scan | |
| * @param {Function} fn - the function to call | |
| * @param {*} val - the initial value of the accumulator | |
| * @param {stream} stream - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var numbers = flyd.stream(); | |
| * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers); | |
| * numbers(2)(3)(5); | |
| * sum(); // 10 | |
| */ | |
| flyd.scan = curryN(3, function(f, acc, s) { | |
| var ns = combine(function(s, self) { | |
| self(acc = f(acc, s.val)); | |
| }, [s]); | |
| if (!ns.hasVal) ns(acc); | |
| return ns; | |
| }); | |
| /** | |
| * Creates a new stream down which all values from both `stream1` and `stream2` | |
| * will be sent. | |
| * | |
| * __Signature__: `Stream a -> Stream a -> Stream a` | |
| * | |
| * @name flyd.merge | |
| * @param {stream} source1 - one stream to be merged | |
| * @param {stream} source2 - the other stream to be merged | |
| * @return {stream} a stream with the values from both sources | |
| * | |
| * @example | |
| * var btn1Clicks = flyd.stream(); | |
| * button1Elm.addEventListener(btn1Clicks); | |
| * var btn2Clicks = flyd.stream(); | |
| * button2Elm.addEventListener(btn2Clicks); | |
| * var allClicks = flyd.merge(btn1Clicks, btn2Clicks); | |
| */ | |
| flyd.merge = curryN(2, function(s1, s2) { | |
| var s = flyd.immediate(combine(function(s1, s2, self, changed) { | |
| if (changed[0]) { | |
| self(changed[0]()); | |
| } else if (s1.hasVal) { | |
| self(s1.val); | |
| } else if (s2.hasVal) { | |
| self(s2.val); | |
| } | |
| }, [s1, s2])); | |
| flyd.endsOn(combine(function() { | |
| return true; | |
| }, [s1.end, s2.end]), s); | |
| return s; | |
| }); | |
| /** | |
| * Creates a new stream resulting from applying `transducer` to `stream`. | |
| * | |
| * __Signature__: `Transducer -> Stream a -> Stream b` | |
| * | |
| * @name flyd.transduce | |
| * @param {Transducer} xform - the transducer transformation | |
| * @param {stream} source - the stream source | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var t = require('transducers.js'); | |
| * | |
| * var results = []; | |
| * var s1 = flyd.stream(); | |
| * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe()); | |
| * var s2 = flyd.transduce(tx, s1); | |
| * flyd.combine(function(s2) { results.push(s2()); }, [s2]); | |
| * s1(1)(1)(2)(3)(3)(3)(4); | |
| * results; // => [2, 4, 6, 8] | |
| */ | |
| flyd.transduce = curryN(2, function(xform, source) { | |
| xform = xform(new StreamTransformer()); | |
| return combine(function(source, self) { | |
| var res = xform['@@transducer/step'](undefined, source.val); | |
| if (res && res['@@transducer/reduced'] === true) { | |
| self.end(true); | |
| return res['@@transducer/value']; | |
| } else { | |
| return res; | |
| } | |
| }, [source]); | |
| }); | |
| /** | |
| * Returns `fn` curried to `n`. Use this function to curry functions exposed by | |
| * modules for Flyd. | |
| * | |
| * @name flyd.curryN | |
| * @function | |
| * @param {Integer} arity - the function arity | |
| * @param {Function} fn - the function to curry | |
| * @return {Function} the curried function | |
| * | |
| * @example | |
| * function add(x, y) { return x + y; }; | |
| * var a = flyd.curryN(2, add); | |
| * a(2)(4) // => 6 | |
| */ | |
| flyd.curryN = curryN | |
| /** | |
| * Returns a new stream identical to the original except every | |
| * value will be passed through `f`. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b` | |
| * | |
| * @name stream.map | |
| * @param {Function} function - the function to apply | |
| * @return {stream} a new stream with the values mapped | |
| * | |
| * @example | |
| * var numbers = flyd.stream(0); | |
| * var squaredNumbers = numbers.map(function(n) { return n*n; }); | |
| */ | |
| function boundMap(f) { return flyd.map(f, this); } | |
| /** | |
| * Returns a new stream which is the result of applying the | |
| * functions from `this` stream to the values in `stream` parameter. | |
| * | |
| * `this` stream must be a stream of functions. | |
| * | |
| * _Note:_ This function is included in order to support the fantasy land | |
| * specification. | |
| * | |
| * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b` | |
| * | |
| * @name stream.ap | |
| * @param {stream} stream - the values stream | |
| * @return {stream} a new stram with the functions applied to values | |
| * | |
| * @example | |
| * var add = flyd.curryN(2, function(x, y) { return x + y; }); | |
| * var numbers1 = flyd.stream(); | |
| * var numbers2 = flyd.stream(); | |
| * var addToNumbers1 = flyd.map(add, numbers1); | |
| * var added = addToNumbers1.ap(numbers2); | |
| */ | |
| function ap(s2) { | |
| var s1 = this; | |
| return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]); | |
| } | |
| /** | |
| * Get a human readable view of a stream | |
| * @name stream.toString | |
| * @return {String} the stream string representation | |
| */ | |
| function streamToString() { | |
| return 'stream(' + this.val + ')'; | |
| } | |
| /** | |
| * @name stream.end | |
| * @memberof stream | |
| * A stream that emits `true` when the stream ends. If `true` is pushed down the | |
| * stream the parent stream ends. | |
| */ | |
| /** | |
| * @name stream.of | |
| * @function | |
| * @memberof stream | |
| * Returns a new stream with `value` as its initial value. It is identical to | |
| * calling `flyd.stream` with one argument. | |
| * | |
| * __Signature__: Called bound to `Stream (a)`: `b -> Stream b` | |
| * | |
| * @param {*} value - the initial value | |
| * @return {stream} the new stream | |
| * | |
| * @example | |
| * var n = flyd.stream(1); | |
| * var m = n.of(1); | |
| */ | |
| // /////////////////////////// PRIVATE ///////////////////////////////// // | |
| /** | |
| * @private | |
| * Create a stream with no dependencies and no value | |
| * @return {Function} a flyd stream | |
| */ | |
| function createStream() { | |
| function s(n) { | |
| if (arguments.length === 0) return s.val | |
| updateStreamValue(s, n) | |
| return s | |
| } | |
| s.hasVal = false; | |
| s.val = undefined; | |
| s.vals = []; | |
| s.listeners = []; | |
| s.queued = false; | |
| s.end = undefined; | |
| s.map = boundMap; | |
| s.ap = ap; | |
| s.of = flyd.stream; | |
| s.toString = streamToString; | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Create a dependent stream | |
| * @param {Array<stream>} dependencies - an array of the streams | |
| * @param {Function} fn - the function used to calculate the new stream value | |
| * from the dependencies | |
| * @return {stream} the created stream | |
| */ | |
| function createDependentStream(deps, fn) { | |
| var s = createStream(); | |
| s.fn = fn; | |
| s.deps = deps; | |
| s.depsMet = false; | |
| s.depsChanged = deps.length > 0 ? [] : undefined; | |
| s.shouldUpdate = false; | |
| addListeners(deps, s); | |
| return s; | |
| } | |
| /** | |
| * @private | |
| * Check if all the dependencies have values | |
| * @param {stream} stream - the stream to check depencencies from | |
| * @return {Boolean} `true` if all dependencies have vales, `false` otherwise | |
| */ | |
| function initialDepsNotMet(stream) { | |
| stream.depsMet = stream.deps.every(function(s) { | |
| return s.hasVal; | |
| }); | |
| return !stream.depsMet; | |
| } | |
| /** | |
| * @private | |
| * Update a dependent stream using its dependencies in an atomic way | |
| * @param {stream} stream - the stream to update | |
| */ | |
| function updateStream(s) { | |
| if ((s.depsMet !== true && initialDepsNotMet(s)) || | |
| (s.end !== undefined && s.end.val === true)) return; | |
| if (inStream !== undefined) { | |
| toUpdate.push(s); | |
| return; | |
| } | |
| inStream = s; | |
| if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged; | |
| var returnVal = s.fn.apply(s.fn, s.fnArgs); | |
| if (returnVal !== undefined) { | |
| s(returnVal); | |
| } | |
| inStream = undefined; | |
| if (s.depsChanged !== undefined) s.depsChanged = []; | |
| s.shouldUpdate = false; | |
| if (flushing === false) flushUpdate(); | |
| } | |
| /** | |
| * @private | |
| * Update the dependencies of a stream | |
| * @param {stream} stream | |
| */ | |
| function updateDeps(s) { | |
| var i, o, list | |
| var listeners = s.listeners; | |
| for (i = 0; i < listeners.length; ++i) { | |
| list = listeners[i]; | |
| if (list.end === s) { | |
| endStream(list); | |
| } else { | |
| if (list.depsChanged !== undefined) list.depsChanged.push(s); | |
| list.shouldUpdate = true; | |
| findDeps(list); | |
| } | |
| } | |
| for (; orderNextIdx >= 0; --orderNextIdx) { | |
| o = order[orderNextIdx]; | |
| if (o.shouldUpdate === true) updateStream(o); | |
| o.queued = false; | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add stream dependencies to the global `order` queue. | |
| * @param {stream} stream | |
| * @see updateDeps | |
| */ | |
| function findDeps(s) { | |
| var i | |
| var listeners = s.listeners; | |
| if (s.queued === false) { | |
| s.queued = true; | |
| for (i = 0; i < listeners.length; ++i) { | |
| findDeps(listeners[i]); | |
| } | |
| order[++orderNextIdx] = s; | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function flushUpdate() { | |
| flushing = true; | |
| while (toUpdate.length > 0) { | |
| var s = toUpdate.shift(); | |
| if (s.vals.length > 0) s.val = s.vals.shift(); | |
| updateDeps(s); | |
| } | |
| flushing = false; | |
| } | |
| /** | |
| * @private | |
| * Push down a value into a stream | |
| * @param {stream} stream | |
| * @param {*} value | |
| */ | |
| function updateStreamValue(s, n) { | |
| if (n !== undefined && n !== null && isFunction(n.then)) { | |
| n.then(s); | |
| return; | |
| } | |
| s.val = n; | |
| s.hasVal = true; | |
| if (inStream === undefined) { | |
| flushing = true; | |
| updateDeps(s); | |
| if (toUpdate.length > 0) flushUpdate(); else flushing = false; | |
| } else if (inStream === s) { | |
| markListeners(s, s.listeners); | |
| } else { | |
| s.vals.push(n); | |
| toUpdate.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| */ | |
| function markListeners(s, lists) { | |
| var i, list; | |
| for (i = 0; i < lists.length; ++i) { | |
| list = lists[i]; | |
| if (list.end !== s) { | |
| if (list.depsChanged !== undefined) { | |
| list.depsChanged.push(s); | |
| } | |
| list.shouldUpdate = true; | |
| } else { | |
| endStream(list); | |
| } | |
| } | |
| } | |
| /** | |
| * @private | |
| * Add dependencies to a stream | |
| * @param {Array<stream>} dependencies | |
| * @param {stream} stream | |
| */ | |
| function addListeners(deps, s) { | |
| for (var i = 0; i < deps.length; ++i) { | |
| deps[i].listeners.push(s); | |
| } | |
| } | |
| /** | |
| * @private | |
| * Removes an stream from a dependency array | |
| * @param {stream} stream | |
| * @param {Array<stream>} dependencies | |
| */ | |
| function removeListener(s, listeners) { | |
| var idx = listeners.indexOf(s); | |
| listeners[idx] = listeners[listeners.length - 1]; | |
| listeners.length--; | |
| } | |
| /** | |
| * @private | |
| * Detach a stream from its dependencies | |
| * @param {stream} stream | |
| */ | |
| function detachDeps(s) { | |
| for (var i = 0; i < s.deps.length; ++i) { | |
| removeListener(s, s.deps[i].listeners); | |
| } | |
| s.deps.length = 0; | |
| } | |
| /** | |
| * @private | |
| * Ends a stream | |
| */ | |
| function endStream(s) { | |
| if (s.deps !== undefined) detachDeps(s); | |
| if (s.end !== undefined) detachDeps(s.end); | |
| } | |
| /** | |
| * @private | |
| * transducer stream transformer | |
| */ | |
| function StreamTransformer() { } | |
| StreamTransformer.prototype['@@transducer/init'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/result'] = function() { }; | |
| StreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; }; | |
| module.exports = flyd; | |
| },{"ramda/src/curryN":2}],2:[function(require,module,exports){ | |
| var _arity = require('./internal/_arity'); | |
| var _curry1 = require('./internal/_curry1'); | |
| var _curry2 = require('./internal/_curry2'); | |
| var _curryN = require('./internal/_curryN'); | |
| /** | |
| * Returns a curried equivalent of the provided function, with the specified | |
| * arity. The curried function has two unusual capabilities. First, its | |
| * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1)(2)(3)` | |
| * - `g(1)(2, 3)` | |
| * - `g(1, 2)(3)` | |
| * - `g(1, 2, 3)` | |
| * | |
| * Secondly, the special placeholder value `R.__` may be used to specify | |
| * "gaps", allowing partial application of any combination of arguments, | |
| * regardless of their positions. If `g` is as above and `_` is `R.__`, the | |
| * following are equivalent: | |
| * | |
| * - `g(1, 2, 3)` | |
| * - `g(_, 2, 3)(1)` | |
| * - `g(_, _, 3)(1)(2)` | |
| * - `g(_, _, 3)(1, 2)` | |
| * - `g(_, 2)(1)(3)` | |
| * - `g(_, 2)(1, 3)` | |
| * - `g(_, 2)(_, 3)(1)` | |
| * | |
| * @func | |
| * @memberOf R | |
| * @since v0.5.0 | |
| * @category Function | |
| * @sig Number -> (* -> a) -> (* -> a) | |
| * @param {Number} length The arity for the returned function. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} A new, curried function. | |
| * @see R.curry | |
| * @example | |
| * | |
| * var sumArgs = (...args) => R.sum(args); | |
| * | |
| * var curriedAddFourNumbers = R.curryN(4, sumArgs); | |
| * var f = curriedAddFourNumbers(1, 2); | |
| * var g = f(3); | |
| * g(4); //=> 10 | |
| */ | |
| module.exports = _curry2(function curryN(length, fn) { | |
| if (length === 1) { | |
| return _curry1(fn); | |
| } | |
| return _arity(length, _curryN(length, [], fn)); | |
| }); | |
| },{"./internal/_arity":3,"./internal/_curry1":4,"./internal/_curry2":5,"./internal/_curryN":6}],3:[function(require,module,exports){ | |
| module.exports = function _arity(n, fn) { | |
| /* eslint-disable no-unused-vars */ | |
| switch (n) { | |
| case 0: return function() { return fn.apply(this, arguments); }; | |
| case 1: return function(a0) { return fn.apply(this, arguments); }; | |
| case 2: return function(a0, a1) { return fn.apply(this, arguments); }; | |
| case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); }; | |
| case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); }; | |
| case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); }; | |
| case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); }; | |
| case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); }; | |
| case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); }; | |
| case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); }; | |
| case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); }; | |
| default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); | |
| } | |
| }; | |
| },{}],4:[function(require,module,exports){ | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal one-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry1(fn) { | |
| return function f1(a) { | |
| if (arguments.length === 0 || _isPlaceholder(a)) { | |
| return f1; | |
| } else { | |
| return fn.apply(this, arguments); | |
| } | |
| }; | |
| }; | |
| },{"./_isPlaceholder":7}],5:[function(require,module,exports){ | |
| var _curry1 = require('./_curry1'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Optimized internal two-arity curry function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curry2(fn) { | |
| return function f2(a, b) { | |
| switch (arguments.length) { | |
| case 0: | |
| return f2; | |
| case 1: | |
| return _isPlaceholder(a) ? f2 | |
| : _curry1(function(_b) { return fn(a, _b); }); | |
| default: | |
| return _isPlaceholder(a) && _isPlaceholder(b) ? f2 | |
| : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); }) | |
| : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); }) | |
| : fn(a, b); | |
| } | |
| }; | |
| }; | |
| },{"./_curry1":4,"./_isPlaceholder":7}],6:[function(require,module,exports){ | |
| var _arity = require('./_arity'); | |
| var _isPlaceholder = require('./_isPlaceholder'); | |
| /** | |
| * Internal curryN function. | |
| * | |
| * @private | |
| * @category Function | |
| * @param {Number} length The arity of the curried function. | |
| * @param {Array} received An array of arguments received thus far. | |
| * @param {Function} fn The function to curry. | |
| * @return {Function} The curried function. | |
| */ | |
| module.exports = function _curryN(length, received, fn) { | |
| return function() { | |
| var combined = []; | |
| var argsIdx = 0; | |
| var left = length; | |
| var combinedIdx = 0; | |
| while (combinedIdx < received.length || argsIdx < arguments.length) { | |
| var result; | |
| if (combinedIdx < received.length && | |
| (!_isPlaceholder(received[combinedIdx]) || | |
| argsIdx >= arguments.length)) { | |
| result = received[combinedIdx]; | |
| } else { | |
| result = arguments[argsIdx]; | |
| argsIdx += 1; | |
| } | |
| combined[combinedIdx] = result; | |
| if (!_isPlaceholder(result)) { | |
| left -= 1; | |
| } | |
| combinedIdx += 1; | |
| } | |
| return left <= 0 ? fn.apply(this, combined) | |
| : _arity(left, _curryN(length, combined, fn)); | |
| }; | |
| }; | |
| },{"./_arity":3,"./_isPlaceholder":7}],7:[function(require,module,exports){ | |
| module.exports = function _isPlaceholder(a) { | |
| return a != null && | |
| typeof a === 'object' && | |
| a['@@functional/placeholder'] === true; | |
| }; | |
| },{}],"flyd/module/filter":[function(require,module,exports){ | |
| var flyd = require('../../lib'); | |
| module.exports = flyd.curryN(2, function(fn, s) { | |
| return flyd.combine(function(s, self) { | |
| if (fn(s())) self(s.val); | |
| }, [s]); | |
| }); | |
| },{"../../lib":1}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","lib/index.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_isPlaceholder.js","module/filter/index.js"],"names":[],"mappings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lnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nvar curryN = require('ramda/src/curryN');\n\n// Utility\nfunction isFunction(obj) {\n  return !!(obj && obj.constructor && obj.call && obj.apply);\n}\nfunction trueFn() { return true; }\n\n// Globals\nvar toUpdate = [];\nvar inStream;\nvar order = [];\nvar orderNextIdx = -1;\nvar flushing = false;\n\n/** @namespace */\nvar flyd = {}\n\n// /////////////////////////// API ///////////////////////////////// //\n\n/**\n * Creates a new stream\n *\n * __Signature__: `a -> Stream a`\n *\n * @name flyd.stream\n * @param {*} initialValue - (Optional) the initial value of the stream\n * @return {stream} the stream\n *\n * @example\n * var n = flyd.stream(1); // Stream with initial value `1`\n * var s = flyd.stream(); // Stream with no initial value\n */\nflyd.stream = function(initialValue) {\n  var endStream = createDependentStream([], trueFn);\n  var s = createStream();\n  s.end = endStream;\n  s.fnArgs = [];\n  endStream.listeners.push(s);\n  if (arguments.length > 0) s(initialValue);\n  return s;\n}\n\n/**\n * Create a new dependent stream\n *\n * __Signature__: `(...Stream * -> Stream b -> b) -> [Stream *] -> Stream b`\n *\n * @name flyd.combine\n * @param {Function} fn - the function used to combine the streams\n * @param {Array<stream>} dependencies - the streams that this one depends on\n * @return {stream} the dependent stream\n *\n * @example\n * var n1 = flyd.stream(0);\n * var n2 = flyd.stream(0);\n * var max = flyd.combine(function(n1, n2, self, changed) {\n *   return n1() > n2() ? n1() : n2();\n * }, [n1, n2]);\n */\nflyd.combine = curryN(2, combine);\nfunction combine(fn, streams) {\n  var i, s, deps, depEndStreams;\n  var endStream = createDependentStream([], trueFn);\n  deps = []; depEndStreams = [];\n  for (i = 0; i < streams.length; ++i) {\n    if (streams[i] !== undefined) {\n      deps.push(streams[i]);\n      if (streams[i].end !== undefined) depEndStreams.push(streams[i].end);\n    }\n  }\n  s = createDependentStream(deps, fn);\n  s.depsChanged = [];\n  s.fnArgs = s.deps.concat([s, s.depsChanged]);\n  s.end = endStream;\n  endStream.listeners.push(s);\n  addListeners(depEndStreams, endStream);\n  endStream.deps = depEndStreams;\n  updateStream(s);\n  return s;\n}\n\n/**\n * Returns `true` if the supplied argument is a Flyd stream and `false` otherwise.\n *\n * __Signature__: `* -> Boolean`\n *\n * @name flyd.isStream\n * @param {*} value - the value to test\n * @return {Boolean} `true` if is a Flyd streamn, `false` otherwise\n *\n * @example\n * var s = flyd.stream(1);\n * var n = 1;\n * flyd.isStream(s); //=> true\n * flyd.isStream(n); //=> false\n */\nflyd.isStream = function(stream) {\n  return isFunction(stream) && 'hasVal' in stream;\n}\n\n/**\n * Invokes the body (the function to calculate the value) of a dependent stream\n *\n * By default the body of a dependent stream is only called when all the streams\n * upon which it depends has a value. `immediate` can circumvent this behaviour.\n * It immediately invokes the body of a dependent stream.\n *\n * __Signature__: `Stream a -> Stream a`\n *\n * @name flyd.immediate\n * @param {stream} stream - the dependent stream\n * @return {stream} the same stream\n *\n * @example\n * var s = flyd.stream();\n * var hasItems = flyd.immediate(flyd.combine(function(s) {\n *   return s() !== undefined && s().length > 0;\n * }, [s]);\n * console.log(hasItems()); // logs `false`. Had `immediate` not been\n *                          // used `hasItems()` would've returned `undefined`\n * s([1]);\n * console.log(hasItems()); // logs `true`.\n * s([]);\n * console.log(hasItems()); // logs `false`.\n */\nflyd.immediate = function(s) {\n  if (s.depsMet === false) {\n    s.depsMet = true;\n    updateStream(s);\n  }\n  return s;\n}\n\n/**\n * Changes which `endsStream` should trigger the ending of `s`.\n *\n * __Signature__: `Stream a -> Stream b -> Stream b`\n *\n * @name flyd.endsOn\n * @param {stream} endStream - the stream to trigger the ending\n * @param {stream} stream - the stream to be ended by the endStream\n * @param {stream} the stream modified to be ended by endStream\n *\n * @example\n * var n = flyd.stream(1);\n * var killer = flyd.stream();\n * // `double` ends when `n` ends or when `killer` emits any value\n * var double = flyd.endsOn(flyd.merge(n.end, killer), flyd.combine(function(n) {\n *   return 2 * n();\n * }, [n]);\n*/\nflyd.endsOn = function(endS, s) {\n  detachDeps(s.end);\n  endS.listeners.push(s.end);\n  s.end.deps.push(endS);\n  return s;\n}\n\n/**\n * Map a stream\n *\n * Returns a new stream consisting of every value from `s` passed through\n * `fn`. I.e. `map` creates a new stream that listens to `s` and\n * applies `fn` to every new value.\n * __Signature__: `(a -> result) -> Stream a -> Stream result`\n *\n * @name flyd.map\n * @param {Function} fn - the function that produces the elements of the new stream\n * @param {stream} stream - the stream to map\n * @return {stream} a new stream with the mapped values\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = flyd.map(function(n) { return n*n; }, numbers);\n */\n// Library functions use self callback to accept (null, undefined) update triggers.\nflyd.map = curryN(2, function(f, s) {\n  return combine(function(s, self) { self(f(s.val)); }, [s]);\n})\n\n/**\n * Listen to stream events\n *\n * Similar to `map` except that the returned stream is empty. Use `on` for doing\n * side effects in reaction to stream changes. Use the returned stream only if you\n * need to manually end it.\n *\n * __Signature__: `(a -> result) -> Stream a -> Stream undefined`\n *\n * @name flyd.on\n * @param {Function} cb - the callback\n * @param {stream} stream - the stream\n * @return {stream} an empty stream (can be ended)\n */\nflyd.on = curryN(2, function(f, s) {\n  return combine(function(s) { f(s.val); }, [s]);\n})\n\n/**\n * Creates a new stream with the results of calling the function on every incoming\n * stream with and accumulator and the incoming value.\n *\n * __Signature__: `(a -> b -> a) -> a -> Stream b -> Stream a`\n *\n * @name flyd.scan\n * @param {Function} fn - the function to call\n * @param {*} val - the initial value of the accumulator\n * @param {stream} stream - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var numbers = flyd.stream();\n * var sum = flyd.scan(function(sum, n) { return sum+n; }, 0, numbers);\n * numbers(2)(3)(5);\n * sum(); // 10\n */\nflyd.scan = curryN(3, function(f, acc, s) {\n  var ns = combine(function(s, self) {\n    self(acc = f(acc, s.val));\n  }, [s]);\n  if (!ns.hasVal) ns(acc);\n  return ns;\n});\n\n/**\n * Creates a new stream down which all values from both `stream1` and `stream2`\n * will be sent.\n *\n * __Signature__: `Stream a -> Stream a -> Stream a`\n *\n * @name flyd.merge\n * @param {stream} source1 - one stream to be merged\n * @param {stream} source2 - the other stream to be merged\n * @return {stream} a stream with the values from both sources\n *\n * @example\n * var btn1Clicks = flyd.stream();\n * button1Elm.addEventListener(btn1Clicks);\n * var btn2Clicks = flyd.stream();\n * button2Elm.addEventListener(btn2Clicks);\n * var allClicks = flyd.merge(btn1Clicks, btn2Clicks);\n */\nflyd.merge = curryN(2, function(s1, s2) {\n  var s = flyd.immediate(combine(function(s1, s2, self, changed) {\n    if (changed[0]) {\n      self(changed[0]());\n    } else if (s1.hasVal) {\n      self(s1.val);\n    } else if (s2.hasVal) {\n      self(s2.val);\n    }\n  }, [s1, s2]));\n  flyd.endsOn(combine(function() {\n    return true;\n  }, [s1.end, s2.end]), s);\n  return s;\n});\n\n/**\n * Creates a new stream resulting from applying `transducer` to `stream`.\n *\n * __Signature__: `Transducer -> Stream a -> Stream b`\n *\n * @name flyd.transduce\n * @param {Transducer} xform - the transducer transformation\n * @param {stream} source - the stream source\n * @return {stream} the new stream\n *\n * @example\n * var t = require('transducers.js');\n *\n * var results = [];\n * var s1 = flyd.stream();\n * var tx = t.compose(t.map(function(x) { return x * 2; }), t.dedupe());\n * var s2 = flyd.transduce(tx, s1);\n * flyd.combine(function(s2) { results.push(s2()); }, [s2]);\n * s1(1)(1)(2)(3)(3)(3)(4);\n * results; // => [2, 4, 6, 8]\n */\nflyd.transduce = curryN(2, function(xform, source) {\n  xform = xform(new StreamTransformer());\n  return combine(function(source, self) {\n    var res = xform['@@transducer/step'](undefined, source.val);\n    if (res && res['@@transducer/reduced'] === true) {\n      self.end(true);\n      return res['@@transducer/value'];\n    } else {\n      return res;\n    }\n  }, [source]);\n});\n\n/**\n * Returns `fn` curried to `n`. Use this function to curry functions exposed by\n * modules for Flyd.\n *\n * @name flyd.curryN\n * @function\n * @param {Integer} arity - the function arity\n * @param {Function} fn - the function to curry\n * @return {Function} the curried function\n *\n * @example\n * function add(x, y) { return x + y; };\n * var a = flyd.curryN(2, add);\n * a(2)(4) // => 6\n */\nflyd.curryN = curryN\n\n/**\n * Returns a new stream identical to the original except every\n * value will be passed through `f`.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream a`: `(a -> b) -> Stream b`\n *\n * @name stream.map\n * @param {Function} function - the function to apply\n * @return {stream} a new stream with the values mapped\n *\n * @example\n * var numbers = flyd.stream(0);\n * var squaredNumbers = numbers.map(function(n) { return n*n; });\n */\nfunction boundMap(f) { return flyd.map(f, this); }\n\n/**\n * Returns a new stream which is the result of applying the\n * functions from `this` stream to the values in `stream` parameter.\n *\n * `this` stream must be a stream of functions.\n *\n * _Note:_ This function is included in order to support the fantasy land\n * specification.\n *\n * __Signature__: Called bound to `Stream (a -> b)`: `a -> Stream b`\n *\n * @name stream.ap\n * @param {stream} stream - the values stream\n * @return {stream} a new stram with the functions applied to values\n *\n * @example\n * var add = flyd.curryN(2, function(x, y) { return x + y; });\n * var numbers1 = flyd.stream();\n * var numbers2 = flyd.stream();\n * var addToNumbers1 = flyd.map(add, numbers1);\n * var added = addToNumbers1.ap(numbers2);\n */\nfunction ap(s2) {\n  var s1 = this;\n  return combine(function(s1, s2, self) { self(s1.val(s2.val)); }, [s1, s2]);\n}\n\n/**\n * Get a human readable view of a stream\n * @name stream.toString\n * @return {String} the stream string representation\n */\nfunction streamToString() {\n  return 'stream(' + this.val + ')';\n}\n\n/**\n * @name stream.end\n * @memberof stream\n * A stream that emits `true` when the stream ends. If `true` is pushed down the\n * stream the parent stream ends.\n */\n\n/**\n * @name stream.of\n * @function\n * @memberof stream\n * Returns a new stream with `value` as its initial value. It is identical to\n * calling `flyd.stream` with one argument.\n *\n * __Signature__: Called bound to `Stream (a)`: `b -> Stream b`\n *\n * @param {*} value - the initial value\n * @return {stream} the new stream\n *\n * @example\n * var n = flyd.stream(1);\n * var m = n.of(1);\n */\n\n// /////////////////////////// PRIVATE ///////////////////////////////// //\n/**\n * @private\n * Create a stream with no dependencies and no value\n * @return {Function} a flyd stream\n */\nfunction createStream() {\n  function s(n) {\n    if (arguments.length === 0) return s.val\n    updateStreamValue(s, n)\n    return s\n  }\n  s.hasVal = false;\n  s.val = undefined;\n  s.vals = [];\n  s.listeners = [];\n  s.queued = false;\n  s.end = undefined;\n  s.map = boundMap;\n  s.ap = ap;\n  s.of = flyd.stream;\n  s.toString = streamToString;\n  return s;\n}\n\n/**\n * @private\n * Create a dependent stream\n * @param {Array<stream>} dependencies - an array of the streams\n * @param {Function} fn - the function used to calculate the new stream value\n * from the dependencies\n * @return {stream} the created stream\n */\nfunction createDependentStream(deps, fn) {\n  var s = createStream();\n  s.fn = fn;\n  s.deps = deps;\n  s.depsMet = false;\n  s.depsChanged = deps.length > 0 ? [] : undefined;\n  s.shouldUpdate = false;\n  addListeners(deps, s);\n  return s;\n}\n\n/**\n * @private\n * Check if all the dependencies have values\n * @param {stream} stream - the stream to check depencencies from\n * @return {Boolean} `true` if all dependencies have vales, `false` otherwise\n */\nfunction initialDepsNotMet(stream) {\n  stream.depsMet = stream.deps.every(function(s) {\n    return s.hasVal;\n  });\n  return !stream.depsMet;\n}\n\n/**\n * @private\n * Update a dependent stream using its dependencies in an atomic way\n * @param {stream} stream - the stream to update\n */\nfunction updateStream(s) {\n  if ((s.depsMet !== true && initialDepsNotMet(s)) ||\n      (s.end !== undefined && s.end.val === true)) return;\n  if (inStream !== undefined) {\n    toUpdate.push(s);\n    return;\n  }\n  inStream = s;\n  if (s.depsChanged) s.fnArgs[s.fnArgs.length - 1] = s.depsChanged;\n  var returnVal = s.fn.apply(s.fn, s.fnArgs);\n  if (returnVal !== undefined) {\n    s(returnVal);\n  }\n  inStream = undefined;\n  if (s.depsChanged !== undefined) s.depsChanged = [];\n  s.shouldUpdate = false;\n  if (flushing === false) flushUpdate();\n}\n\n/**\n * @private\n * Update the dependencies of a stream\n * @param {stream} stream\n */\nfunction updateDeps(s) {\n  var i, o, list\n  var listeners = s.listeners;\n  for (i = 0; i < listeners.length; ++i) {\n    list = listeners[i];\n    if (list.end === s) {\n      endStream(list);\n    } else {\n      if (list.depsChanged !== undefined) list.depsChanged.push(s);\n      list.shouldUpdate = true;\n      findDeps(list);\n    }\n  }\n  for (; orderNextIdx >= 0; --orderNextIdx) {\n    o = order[orderNextIdx];\n    if (o.shouldUpdate === true) updateStream(o);\n    o.queued = false;\n  }\n}\n\n/**\n * @private\n * Add stream dependencies to the global `order` queue.\n * @param {stream} stream\n * @see updateDeps\n */\nfunction findDeps(s) {\n  var i\n  var listeners = s.listeners;\n  if (s.queued === false) {\n    s.queued = true;\n    for (i = 0; i < listeners.length; ++i) {\n      findDeps(listeners[i]);\n    }\n    order[++orderNextIdx] = s;\n  }\n}\n\n/**\n * @private\n */\nfunction flushUpdate() {\n  flushing = true;\n  while (toUpdate.length > 0) {\n    var s = toUpdate.shift();\n    if (s.vals.length > 0) s.val = s.vals.shift();\n    updateDeps(s);\n  }\n  flushing = false;\n}\n\n/**\n * @private\n * Push down a value into a stream\n * @param {stream} stream\n * @param {*} value\n */\nfunction updateStreamValue(s, n) {\n  if (n !== undefined && n !== null && isFunction(n.then)) {\n    n.then(s);\n    return;\n  }\n  s.val = n;\n  s.hasVal = true;\n  if (inStream === undefined) {\n    flushing = true;\n    updateDeps(s);\n    if (toUpdate.length > 0) flushUpdate(); else flushing = false;\n  } else if (inStream === s) {\n    markListeners(s, s.listeners);\n  } else {\n    s.vals.push(n);\n    toUpdate.push(s);\n  }\n}\n\n/**\n * @private\n */\nfunction markListeners(s, lists) {\n  var i, list;\n  for (i = 0; i < lists.length; ++i) {\n    list = lists[i];\n    if (list.end !== s) {\n      if (list.depsChanged !== undefined) {\n        list.depsChanged.push(s);\n      }\n      list.shouldUpdate = true;\n    } else {\n      endStream(list);\n    }\n  }\n}\n\n/**\n * @private\n * Add dependencies to a stream\n * @param {Array<stream>} dependencies\n * @param {stream} stream\n */\nfunction addListeners(deps, s) {\n  for (var i = 0; i < deps.length; ++i) {\n    deps[i].listeners.push(s);\n  }\n}\n\n/**\n * @private\n * Removes an stream from a dependency array\n * @param {stream} stream\n * @param {Array<stream>} dependencies\n */\nfunction removeListener(s, listeners) {\n  var idx = listeners.indexOf(s);\n  listeners[idx] = listeners[listeners.length - 1];\n  listeners.length--;\n}\n\n/**\n * @private\n * Detach a stream from its dependencies\n * @param {stream} stream\n */\nfunction detachDeps(s) {\n  for (var i = 0; i < s.deps.length; ++i) {\n    removeListener(s, s.deps[i].listeners);\n  }\n  s.deps.length = 0;\n}\n\n/**\n * @private\n * Ends a stream\n */\nfunction endStream(s) {\n  if (s.deps !== undefined) detachDeps(s);\n  if (s.end !== undefined) detachDeps(s.end);\n}\n\n/**\n * @private\n * transducer stream transformer\n */\nfunction StreamTransformer() { }\nStreamTransformer.prototype['@@transducer/init'] = function() { };\nStreamTransformer.prototype['@@transducer/result'] = function() { };\nStreamTransformer.prototype['@@transducer/step'] = function(s, v) { return v; };\n\nmodule.exports = flyd;\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`, the\n * following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var sumArgs = (...args) => R.sum(args);\n *\n *      var curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","module.exports = function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n      case 1:\n        return _isPlaceholder(a) ? f2\n             : _curry1(function(_b) { return fn(a, _b); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })\n             : fn(a, b);\n    }\n  };\n};\n","var _arity = require('./_arity');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (!_isPlaceholder(received[combinedIdx]) ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined)\n                     : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","module.exports = function _isPlaceholder(a) {\n  return a != null &&\n         typeof a === 'object' &&\n         a['@@functional/placeholder'] === true;\n};\n","var flyd = require('../../lib');\n\nmodule.exports = flyd.curryN(2, function(fn, s) {\n  return flyd.combine(function(s, self) {\n    if (fn(s())) self(s.val);\n  }, [s]);\n});\n"]} | |
| require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"pex-geom/Rect":[function(require,module,exports){ | |
| function create(){ | |
| return [[Infinity,Infinity],[-Infinity,-Infinity]]; | |
| } | |
| function zero(){ | |
| return [[0,0],[0,0]]; | |
| } | |
| function copy(a){ | |
| return [a[0].slice(0),a[1].slice()]; | |
| } | |
| function set(a,b){ | |
| a[0][0] = b[0][0]; | |
| a[0][1] = b[0][1]; | |
| a[1][0] = b[1][0]; | |
| a[1][1] = b[1][1]; | |
| return a; | |
| } | |
| function set4(a,x,y,w,h){ | |
| a[0][0] = x; | |
| a[0][1] = y; | |
| a[1][0] = x + w; | |
| a[1][1] = y + h; | |
| return a; | |
| } | |
| function scale(a,n){ | |
| a[0][0] *= n; | |
| a[0][1] *= n; | |
| a[1][0] *= n; | |
| a[1][1] *= n; | |
| return a; | |
| } | |
| function setMinMax(a,min,max){ | |
| a[0][0] = min[0]; | |
| a[0][1] = min[1]; | |
| a[1][0] = max[0]; | |
| a[1][1] = max[1]; | |
| return a; | |
| } | |
| function setMinMax4(a,minx,miny,maxx,maxy){ | |
| a[0][0] = minx; | |
| a[0][1] = miny; | |
| a[1][0] = maxx; | |
| a[1][1] = maxy; | |
| return a; | |
| } | |
| function getMin(a,out){ | |
| if(out === undefined){ | |
| return [a[0][0],a[0][1]]; | |
| } | |
| out[0] = a[0][0]; | |
| out[1] = a[0][1]; | |
| return out; | |
| } | |
| function getMax(a,out){ | |
| if(out === undefined){ | |
| return [a[1][0],a[1][1]]; | |
| } | |
| out[0] = a[1][0]; | |
| out[1] = a[1][1]; | |
| return out; | |
| } | |
| function setSize2(a,width,height){ | |
| a[1][0] = a[0][0] + width; | |
| a[1][1] = a[0][1] + height; | |
| return a; | |
| } | |
| function setSize(a,size){ | |
| a[1][0] = a[0][0] + size[0]; | |
| a[1][1] = a[0][1] + size[1]; | |
| return a; | |
| } | |
| function getSize(a,out){ | |
| var width = getWidth(a); | |
| var height = getHeight(a); | |
| if(out === undefined){ | |
| return [width,height]; | |
| } | |
| out[0] = width; | |
| out[1] = height; | |
| return out; | |
| } | |
| function setWidth(a,width){ | |
| a[1][0] = a[0][0] + width; | |
| return a; | |
| } | |
| function setHeight(a,height){ | |
| a[1][1] = a[0][1] + height; | |
| return a; | |
| } | |
| function getWidth(a){ | |
| return a[1][0] - a[0][0]; | |
| } | |
| function getHeight(a){ | |
| return a[1][1] - a[0][1]; | |
| } | |
| function getAspectRatio(a){ | |
| return getWidth(a) / getHeight(a); | |
| } | |
| function setPosition(a,position){ | |
| return setPosition2(a,position[0],position[1]); | |
| } | |
| function setPosition2(a,x,y){ | |
| a[0][0] = x; | |
| a[0][1] = y; | |
| a[1][0] = x + getWidth(a); | |
| a[1][1] = y + getHeight(a); | |
| return a; | |
| } | |
| function getTR(a,out){ | |
| if(out === undefined){ | |
| return [a[1][0],a[1]]; | |
| } | |
| out[0] = a[1][0]; | |
| out[1] = a[0][1]; | |
| return out; | |
| } | |
| function getBL(a,out){ | |
| if(out === undefined){ | |
| return [a[0][0],a[1][1]]; | |
| } | |
| out[0] = a[0][0]; | |
| out[1] = a[1][1]; | |
| return out; | |
| } | |
| function getCenter(a,out){ | |
| var x = getWidth(a) * 0.5; | |
| var y = getHeight(a) * 0.5; | |
| if(out === undefined){ | |
| return [x,y]; | |
| } | |
| out[0] = x; | |
| out[1] = y; | |
| return out; | |
| } | |
| function containsPoint(a,point){ | |
| return containsPoint2(a,point[0],point[1]); | |
| } | |
| function containsPoint2(a,x,y){ | |
| return x >= a[0][0] && x <= a[1][0] && y >= a[0][1] && y <= a[1][1]; | |
| } | |
| function containsRect(a,b){ | |
| return containsPoint2(a,b[0][0],b[0][1]) && containsPoint2(a,b[1][0],b[1][1]); | |
| } | |
| function includePoint(a,point){ | |
| return includePoint2(a,point[0],point[1]); | |
| } | |
| function includePoint2(a,x,y){ | |
| var minx = a[0][0]; | |
| var miny = a[0][1]; | |
| var maxx = a[1][0]; | |
| var maxy = a[1][1]; | |
| a[0][0] = minx > x ? x : minx; | |
| a[0][1] = miny > y ? y : miny; | |
| a[1][0] = maxx < x ? x : maxx; | |
| a[1][1] = maxy < y ? y : maxy; | |
| return a; | |
| } | |
| function includePoints(a,points){ | |
| var minx = a[0][0]; | |
| var miny = a[0][1]; | |
| var maxx = a[1][0]; | |
| var maxy = a[1][1]; | |
| for(var i = 0, l = points.length, x, y; i < l; ++i){ | |
| x = points[i][0]; | |
| y = points[i][1]; | |
| minx = minx > x ? x : minx; | |
| miny = miny > y ? y : miny; | |
| maxx = maxx < x ? x : maxx; | |
| maxy = maxy < y ? y : maxy; | |
| } | |
| a[0][0] = minx; | |
| a[0][1] = miny; | |
| a[1][0] = maxx; | |
| a[1][1] = maxy; | |
| return a; | |
| } | |
| function includePointsFlat(a,points){ | |
| var minx = a[0][0]; | |
| var miny = a[0][1]; | |
| var maxx = a[1][0]; | |
| var maxy = a[1][1]; | |
| for(var i = 0, l = points.length, x, y; i < l; i+=2){ | |
| x = points[i ]; | |
| y = points[i+1]; | |
| minx = minx > x ? x : minx; | |
| miny = miny > y ? y : miny; | |
| maxx = maxx < x ? x : maxx; | |
| maxy = maxy < y ? y : maxy; | |
| } | |
| a[0][0] = minx; | |
| a[0][1] = miny; | |
| a[1][0] = maxx; | |
| a[1][1] = maxy; | |
| return a; | |
| } | |
| function includeRect(a,rect){ | |
| includePoint(a,rect[0]); | |
| includePoint(a,rect[1]); | |
| return a; | |
| } | |
| function includeRects(a,rects){ | |
| for(var i = 0, l = rects.length; i < l; ++i){ | |
| includeRect(a,rects[i]); | |
| } | |
| return a; | |
| } | |
| function mapPoint(a,point){ | |
| var minx = a[0][0]; | |
| var miny = a[0][1]; | |
| var maxx = a[1][0]; | |
| var maxy = a[1][1]; | |
| var x = point[0]; | |
| var y = point[1]; | |
| point[0] = Math.max(minx,Math.min(x,maxx)) - minx; | |
| point[1] = Math.max(miny,Math.min(y,maxy)) - miny; | |
| return point; | |
| } | |
| function clampPoint(a,point){ | |
| var minx = a[0][0]; | |
| var miny = a[0][1]; | |
| var maxx = a[1][0]; | |
| var maxy = a[1][1]; | |
| point[0] = Math.max(minx,Math.min(point[0],maxx)); | |
| point[1] = Math.max(miny,Math.min(point[1],maxy)); | |
| return point; | |
| } | |
| function toMax(a){ | |
| a[0][0] = a[1][0] = -Number.MAX_VALUE; | |
| a[0][1] = a[1][1] = Number.MAX_VALUE; | |
| } | |
| function setEmpty(a){ | |
| a[0][0] = a[0][1] = Infinity; | |
| a[1][0] = a[1][1] = -Infinity; | |
| return a; | |
| } | |
| function isEmpty(a){ | |
| return (a[0][0] > a[1][0]) || (a[0][1] > a[1][1]); | |
| } | |
| function isZero(a){ | |
| return a[0][0] == 0 && a[0][1] == 0 && a[1][0] == 0 && a[1][1] == 0; | |
| } | |
| function setZero(a){ | |
| a[0][0] = a[0][1] = a[1][0] = a[1][1] = 0; | |
| return a; | |
| } | |
| function createFromPoints(points){ | |
| return includePoints(create(),points); | |
| } | |
| function createFromPointsFlat(points){ | |
| return includePointsFlat(create(),points); | |
| } | |
| function createFromRects(rects){ | |
| return includeRects(create(),rects); | |
| } | |
| /** | |
| * [Rect description] | |
| * @type {Object} | |
| */ | |
| var Rect = { | |
| /** | |
| * [create description] | |
| * @type {[type]} | |
| */ | |
| create : create, | |
| /** | |
| * [zero description] | |
| * @type {[type]} | |
| */ | |
| zero : zero, | |
| /** | |
| * [copy description] | |
| * @type {[type]} | |
| */ | |
| copy : copy, | |
| /** | |
| * [set description] | |
| * @type {[type]} | |
| */ | |
| set : set, | |
| /** | |
| * [set4 description] | |
| * @type {[type]} | |
| */ | |
| set4 : set4, | |
| /** | |
| * [scale description] | |
| * @type {[type]} | |
| */ | |
| scale : scale, | |
| /** | |
| * [setMinMax description] | |
| * @type {[type]} | |
| */ | |
| setMinMax : setMinMax, | |
| /** | |
| * [setMinMax4 description] | |
| * @type {[type]} | |
| */ | |
| setMinMax4 : setMinMax4, | |
| /** | |
| * [getMin description] | |
| * @type {[type]} | |
| */ | |
| getMin : getMin, | |
| /** | |
| * [getMax description] | |
| * @type {[type]} | |
| */ | |
| getMax : getMax, | |
| /** | |
| * [setSize2 description] | |
| * @type {[type]} | |
| */ | |
| setSize2 : setSize2, | |
| /** | |
| * [setSize description] | |
| * @type {[type]} | |
| */ | |
| setSize : setSize, | |
| /** | |
| * [getSize description] | |
| * @type {[type]} | |
| */ | |
| getSize : getSize, | |
| /** | |
| * [setWidth description] | |
| * @type {[type]} | |
| */ | |
| setWidth : setWidth, | |
| /** | |
| * [getWidth description] | |
| * @type {[type]} | |
| */ | |
| getWidth : getWidth, | |
| /** | |
| * [setHeight description] | |
| * @type {[type]} | |
| */ | |
| setHeight : setHeight, | |
| /** | |
| * [getHeight description] | |
| * @type {[type]} | |
| */ | |
| getHeight : getHeight, | |
| /** | |
| * [getAspectRatio description] | |
| * @type {[type]} | |
| */ | |
| getAspectRatio : getAspectRatio, | |
| /** | |
| * [setPosition description] | |
| * @type {[type]} | |
| */ | |
| setPosition : setPosition, | |
| /** | |
| * [setPosition2 description] | |
| * @type {[type]} | |
| */ | |
| setPosition2 : setPosition2, | |
| /** | |
| * [getPosition description] | |
| * @type {[type]} | |
| */ | |
| getPosition : getMin, | |
| /** | |
| * [getTL description] | |
| * @type {[type]} | |
| */ | |
| getTL : getMin, | |
| /** | |
| * [getTR description] | |
| * @type {[type]} | |
| */ | |
| getTR : getTR, | |
| /** | |
| * [getBL description] | |
| * @type {[type]} | |
| */ | |
| getBL : getBL, | |
| /** | |
| * [getBR description] | |
| * @type {[type]} | |
| */ | |
| getBR : getMax, | |
| /** | |
| * [getCenter description] | |
| * @type {[type]} | |
| */ | |
| getCenter : getCenter, | |
| /** | |
| * [containsPoint description] | |
| * @type {[type]} | |
| */ | |
| containsPoint : containsPoint, | |
| /** | |
| * [containsPoint2 description] | |
| * @type {[type]} | |
| */ | |
| containsPoint2 : containsPoint2, | |
| /** | |
| * [containsRect description] | |
| * @type {[type]} | |
| */ | |
| containsRect : containsRect, | |
| /** | |
| * [includePoint description] | |
| * @type {[type]} | |
| */ | |
| includePoint : includePoint, | |
| /** | |
| * [includePoint2 description] | |
| * @type {[type]} | |
| */ | |
| includePoint2 : includePoint2, | |
| /** | |
| * [includePoints description] | |
| * @type {[type]} | |
| */ | |
| includePoints : includePoints, | |
| /** | |
| * [includePointsFlat description] | |
| * @type {[type]} | |
| */ | |
| includePointsFlat : includePointsFlat, | |
| /** | |
| * [includeRect description] | |
| * @type {[type]} | |
| */ | |
| includeRect : includeRect, | |
| /** | |
| * [includeRects description] | |
| * @type {[type]} | |
| */ | |
| includeRects : includeRects, | |
| /** | |
| * [mapPoint description] | |
| * @type {[type]} | |
| */ | |
| mapPoint : mapPoint, | |
| /** | |
| * [clampPoint description] | |
| * @type {[type]} | |
| */ | |
| clampPoint : clampPoint, | |
| /** | |
| * [isZero description] | |
| * @type {Boolean} | |
| */ | |
| isZero : isZero, | |
| /** | |
| * [isEmpty description] | |
| * @type {Boolean} | |
| */ | |
| isEmpty : isEmpty, | |
| /** | |
| * [setEmpty description] | |
| * @type {[type]} | |
| */ | |
| setEmpty : setEmpty, | |
| /** | |
| * [toMax description] | |
| * @type {[type]} | |
| */ | |
| toMax : toMax, | |
| /** | |
| * [setZero description] | |
| * @type {[type]} | |
| */ | |
| setZero : setZero, | |
| /** | |
| * [createFromPoints description] | |
| * @type {[type]} | |
| */ | |
| createFromPoints : createFromPoints, | |
| /** | |
| * [createFromPointsFlat description] | |
| * @type {[type]} | |
| */ | |
| createFromPointsFlat : createFromPointsFlat, | |
| /** | |
| * [createFromRects description] | |
| * @type {[type]} | |
| */ | |
| createFromRects : createFromRects | |
| }; | |
| module.exports = Rect; | |
| },{}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","Rect.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","function create(){\n    return [[Infinity,Infinity],[-Infinity,-Infinity]];\n}\n\nfunction zero(){\n    return [[0,0],[0,0]];\n}\n\nfunction copy(a){\n    return [a[0].slice(0),a[1].slice()];\n}\n\nfunction set(a,b){\n    a[0][0] = b[0][0];\n    a[0][1] = b[0][1];\n    a[1][0] = b[1][0];\n    a[1][1] = b[1][1];\n    return a;\n}\n\nfunction set4(a,x,y,w,h){\n    a[0][0] = x;\n    a[0][1] = y;\n    a[1][0] = x + w;\n    a[1][1] = y + h;\n    return a;\n}\n\nfunction scale(a,n){\n    a[0][0] *= n;\n    a[0][1] *= n;\n    a[1][0] *= n;\n    a[1][1] *= n;\n    return a;\n}\n\nfunction setMinMax(a,min,max){\n    a[0][0] = min[0];\n    a[0][1] = min[1];\n    a[1][0] = max[0];\n    a[1][1] = max[1];\n    return a;\n}\n\nfunction setMinMax4(a,minx,miny,maxx,maxy){\n    a[0][0] = minx;\n    a[0][1] = miny;\n    a[1][0] = maxx;\n    a[1][1] = maxy;\n    return a;\n}\n\nfunction getMin(a,out){\n    if(out === undefined){\n        return [a[0][0],a[0][1]];\n    }\n    out[0] = a[0][0];\n    out[1] = a[0][1];\n    return out;\n}\n\nfunction getMax(a,out){\n    if(out === undefined){\n        return [a[1][0],a[1][1]];\n    }\n    out[0] = a[1][0];\n    out[1] = a[1][1];\n    return out;\n}\n\nfunction setSize2(a,width,height){\n    a[1][0] = a[0][0] + width;\n    a[1][1] = a[0][1] + height;\n    return a;\n}\n\nfunction setSize(a,size){\n    a[1][0] = a[0][0] + size[0];\n    a[1][1] = a[0][1] + size[1];\n    return a;\n}\n\nfunction getSize(a,out){\n    var width  = getWidth(a);\n    var height = getHeight(a);\n    if(out === undefined){\n        return [width,height];\n    }\n    out[0] = width;\n    out[1] = height;\n    return out;\n}\n\nfunction setWidth(a,width){\n    a[1][0] = a[0][0] + width;\n    return a;\n}\n\nfunction setHeight(a,height){\n    a[1][1] = a[0][1] + height;\n    return a;\n}\n\nfunction getWidth(a){\n    return a[1][0] - a[0][0];\n}\n\nfunction getHeight(a){\n    return a[1][1] - a[0][1];\n}\n\nfunction getAspectRatio(a){\n    return getWidth(a) / getHeight(a);\n}\n\nfunction setPosition(a,position){\n    return setPosition2(a,position[0],position[1]);\n}\n\nfunction setPosition2(a,x,y){\n    a[0][0] = x;\n    a[0][1] = y;\n    a[1][0] = x + getWidth(a);\n    a[1][1] = y + getHeight(a);\n    return a;\n}\n\nfunction getTR(a,out){\n    if(out === undefined){\n        return [a[1][0],a[1]];\n    }\n    out[0] = a[1][0];\n    out[1] = a[0][1];\n    return out;\n}\n\nfunction getBL(a,out){\n    if(out === undefined){\n        return [a[0][0],a[1][1]];\n    }\n    out[0] = a[0][0];\n    out[1] = a[1][1];\n    return out;\n}\n\nfunction getCenter(a,out){\n    var x = getWidth(a) * 0.5;\n    var y = getHeight(a) * 0.5;\n    if(out === undefined){\n        return [x,y];\n    }\n    out[0] = x;\n    out[1] = y;\n    return out;\n}\n\nfunction containsPoint(a,point){\n    return containsPoint2(a,point[0],point[1]);\n}\n\nfunction containsPoint2(a,x,y){\n    return x >= a[0][0] && x <= a[1][0] && y >= a[0][1] && y <= a[1][1];\n}\n\nfunction containsRect(a,b){\n    return containsPoint2(a,b[0][0],b[0][1]) && containsPoint2(a,b[1][0],b[1][1]);\n}\n\nfunction includePoint(a,point){\n    return includePoint2(a,point[0],point[1]);\n}\n\nfunction includePoint2(a,x,y){\n    var minx = a[0][0];\n    var miny = a[0][1];\n    var maxx = a[1][0];\n    var maxy = a[1][1];\n\n    a[0][0] = minx > x ? x : minx;\n    a[0][1] = miny > y ? y : miny;\n    a[1][0] = maxx < x ? x : maxx;\n    a[1][1] = maxy < y ? y : maxy;\n\n    return a;\n}\n\nfunction includePoints(a,points){\n    var minx = a[0][0];\n    var miny = a[0][1];\n    var maxx = a[1][0];\n    var maxy = a[1][1];\n\n    for(var i = 0, l = points.length, x, y; i < l; ++i){\n        x = points[i][0];\n        y = points[i][1];\n\n        minx = minx > x ? x : minx;\n        miny = miny > y ? y : miny;\n        maxx = maxx < x ? x : maxx;\n        maxy = maxy < y ? y : maxy;\n    }\n\n    a[0][0] = minx;\n    a[0][1] = miny;\n    a[1][0] = maxx;\n    a[1][1] = maxy;\n\n    return a;\n}\n\nfunction includePointsFlat(a,points){\n    var minx = a[0][0];\n    var miny = a[0][1];\n    var maxx = a[1][0];\n    var maxy = a[1][1];\n\n    for(var i = 0, l = points.length, x, y; i < l; i+=2){\n        x = points[i  ];\n        y = points[i+1];\n\n        minx = minx > x ? x : minx;\n        miny = miny > y ? y : miny;\n        maxx = maxx < x ? x : maxx;\n        maxy = maxy < y ? y : maxy;\n    }\n\n    a[0][0] = minx;\n    a[0][1] = miny;\n    a[1][0] = maxx;\n    a[1][1] = maxy;\n\n    return a;\n}\n\nfunction includeRect(a,rect){\n    includePoint(a,rect[0]);\n    includePoint(a,rect[1]);\n    return a;\n}\n\nfunction includeRects(a,rects){\n    for(var i = 0, l = rects.length; i < l; ++i){\n        includeRect(a,rects[i]);\n    }\n    return a;\n}\n\nfunction mapPoint(a,point){\n    var minx = a[0][0];\n    var miny = a[0][1];\n    var maxx = a[1][0];\n    var maxy = a[1][1];\n    var x = point[0];\n    var y = point[1];\n\n    point[0] = Math.max(minx,Math.min(x,maxx)) - minx;\n    point[1] = Math.max(miny,Math.min(y,maxy)) - miny;\n    return point;\n}\n\nfunction clampPoint(a,point){\n\n    var minx = a[0][0];\n    var miny = a[0][1];\n    var maxx = a[1][0];\n    var maxy = a[1][1];\n\n    point[0] = Math.max(minx,Math.min(point[0],maxx));\n    point[1] = Math.max(miny,Math.min(point[1],maxy));\n    return point;\n}\n\nfunction toMax(a){\n    a[0][0] = a[1][0] = -Number.MAX_VALUE;\n    a[0][1] = a[1][1] =  Number.MAX_VALUE;\n}\n\nfunction setEmpty(a){\n    a[0][0] = a[0][1] =  Infinity;\n    a[1][0] = a[1][1] = -Infinity;\n    return a;\n}\n\nfunction isEmpty(a){\n    return (a[0][0] > a[1][0]) || (a[0][1] > a[1][1]);\n}\n\nfunction isZero(a){\n    return a[0][0] == 0 && a[0][1] == 0 && a[1][0] == 0 && a[1][1] == 0;\n}\n\nfunction setZero(a){\n    a[0][0] = a[0][1] = a[1][0] = a[1][1] = 0;\n    return a;\n}\n\nfunction createFromPoints(points){\n    return includePoints(create(),points);\n}\n\nfunction createFromPointsFlat(points){\n    return includePointsFlat(create(),points);\n}\n\nfunction createFromRects(rects){\n    return includeRects(create(),rects);\n}\n\n/**\n * [Rect description]\n * @type {Object}\n */\nvar Rect = {\n    /**\n     * [create description]\n     * @type {[type]}\n     */\n    create : create,\n    /**\n     * [zero description]\n     * @type {[type]}\n     */\n    zero   : zero,\n    /**\n     * [copy description]\n     * @type {[type]}\n     */\n    copy   : copy,\n    /**\n     * [set description]\n     * @type {[type]}\n     */\n    set  : set,\n    /**\n     * [set4 description]\n     * @type {[type]}\n     */\n    set4 : set4,\n    /**\n     * [scale description]\n     * @type {[type]}\n     */\n    scale : scale,\n    /**\n     * [setMinMax description]\n     * @type {[type]}\n     */\n    setMinMax : setMinMax,\n    /**\n     * [setMinMax4 description]\n     * @type {[type]}\n     */\n    setMinMax4 : setMinMax4,\n    /**\n     * [getMin description]\n     * @type {[type]}\n     */\n    getMin : getMin,\n    /**\n     * [getMax description]\n     * @type {[type]}\n     */\n    getMax : getMax,\n    /**\n     * [setSize2 description]\n     * @type {[type]}\n     */\n    setSize2  : setSize2,\n    /**\n     * [setSize description]\n     * @type {[type]}\n     */\n    setSize   : setSize,\n    /**\n     * [getSize description]\n     * @type {[type]}\n     */\n    getSize   : getSize,\n    /**\n     * [setWidth description]\n     * @type {[type]}\n     */\n    setWidth  : setWidth,\n    /**\n     * [getWidth description]\n     * @type {[type]}\n     */\n    getWidth  : getWidth,\n    /**\n     * [setHeight description]\n     * @type {[type]}\n     */\n    setHeight : setHeight,\n    /**\n     * [getHeight description]\n     * @type {[type]}\n     */\n    getHeight : getHeight,\n    /**\n     * [getAspectRatio description]\n     * @type {[type]}\n     */\n    getAspectRatio : getAspectRatio,\n    /**\n     * [setPosition description]\n     * @type {[type]}\n     */\n    setPosition  : setPosition,\n    /**\n     * [setPosition2 description]\n     * @type {[type]}\n     */\n    setPosition2 : setPosition2,\n    /**\n     * [getPosition description]\n     * @type {[type]}\n     */\n    getPosition  : getMin,\n    /**\n     * [getTL description]\n     * @type {[type]}\n     */\n    getTL : getMin,\n    /**\n     * [getTR description]\n     * @type {[type]}\n     */\n    getTR : getTR,\n    /**\n     * [getBL description]\n     * @type {[type]}\n     */\n    getBL : getBL,\n    /**\n     * [getBR description]\n     * @type {[type]}\n     */\n    getBR : getMax,\n    /**\n     * [getCenter description]\n     * @type {[type]}\n     */\n    getCenter : getCenter,\n    /**\n     * [containsPoint description]\n     * @type {[type]}\n     */\n    containsPoint : containsPoint,\n    /**\n     * [containsPoint2 description]\n     * @type {[type]}\n     */\n    containsPoint2 : containsPoint2,\n    /**\n     * [containsRect description]\n     * @type {[type]}\n     */\n    containsRect   : containsRect,\n    /**\n     * [includePoint description]\n     * @type {[type]}\n     */\n    includePoint      : includePoint,\n    /**\n     * [includePoint2 description]\n     * @type {[type]}\n     */\n    includePoint2     : includePoint2,\n    /**\n     * [includePoints description]\n     * @type {[type]}\n     */\n    includePoints     : includePoints,\n    /**\n     * [includePointsFlat description]\n     * @type {[type]}\n     */\n    includePointsFlat : includePointsFlat,\n    /**\n     * [includeRect description]\n     * @type {[type]}\n     */\n    includeRect   : includeRect,\n    /**\n     * [includeRects description]\n     * @type {[type]}\n     */\n    includeRects  : includeRects,\n    /**\n     * [mapPoint description]\n     * @type {[type]}\n     */\n    mapPoint   : mapPoint,\n    /**\n     * [clampPoint description]\n     * @type {[type]}\n     */\n    clampPoint : clampPoint,\n    /**\n     * [isZero description]\n     * @type {Boolean}\n     */\n    isZero   : isZero,\n    /**\n     * [isEmpty description]\n     * @type {Boolean}\n     */\n    isEmpty  : isEmpty,\n    /**\n     * [setEmpty description]\n     * @type {[type]}\n     */\n    setEmpty : setEmpty,\n    /**\n     * [toMax description]\n     * @type {[type]}\n     */\n    toMax  : toMax,\n    /**\n     * [setZero description]\n     * @type {[type]}\n     */\n    setZero : setZero,\n    /**\n     * [createFromPoints description]\n     * @type {[type]}\n     */\n    createFromPoints     : createFromPoints,\n    /**\n     * [createFromPointsFlat description]\n     * @type {[type]}\n     */\n    createFromPointsFlat : createFromPointsFlat,\n    /**\n     * [createFromRects description]\n     * @type {[type]}\n     */\n    createFromRects      : createFromRects\n};\n\nmodule.exports = Rect;\n"]} | |
| // Streams implementation for mouse events. | |
| // Started based thinking in https://github.com/pex-gl/pex-gui/issues/8 | |
| // IMPORT DEPENDENCIES | |
| // Flyd is "The less is more, modular, functional reactive programming library" | |
| const flyd = require('flyd') | |
| // emit events from one stream until another stream fires | |
| const takeUntil = require('flyd/module/takeuntil') | |
| // merge multiple streams into one | |
| const mergeAll = require('flyd/module/mergeall') | |
| // filter stream events based on predicate | |
| const filterStream = require('flyd/module/filter') | |
| // map events from a stream using a function | |
| const mapStream = flyd.map | |
| // check if point is inside a rectangle | |
| const containsPoint = require('pex-geom/Rect').containsPoint | |
| // UI | |
| // Draw a red canvas with yellow "button" on the left | |
| const btnRect = [[10, 10], [100, 100]] | |
| const canvas = document.createElement('canvas') | |
| canvas.style.background = 'red' | |
| document.body.appendChild(canvas) | |
| const ctx = canvas.getContext('2d') | |
| ctx.fillStyle = '#FFFF00' | |
| ctx.fillRect(btnRect[0][0], btnRect[0][1], btnRect[1][0] - btnRect[0][0], btnRect[1][1] - btnRect[0][1]) | |
| // crate streams for all mouse events | |
| const mousedown = flyd.stream() | |
| const mouseup = flyd.stream() | |
| const mousemove = flyd.stream() | |
| const windowmouseup = flyd.stream() | |
| canvas.addEventListener('mousedown', mousedown) | |
| canvas.addEventListener('mouseup', mouseup) | |
| canvas.addEventListener('mousemove', mousemove) | |
| window.addEventListener('mouseup', windowmouseup) | |
| //flyd.on((e) => console.log('windowmouseup', e), windowmouseup) | |
| // DRAG event stream implementation | |
| // This shows how to combine streams (down, move, up) into a new stream | |
| function createMouseDragStream (mousedown, mousemove, mouseup) { | |
| const mousedrag = flyd.stream() | |
| // on each mousedown event | |
| flyd.on((e) => { | |
| // create new stream that take events from mousemove | |
| // until mouse up on canvas or window | |
| const drag = takeUntil(mousemove, mergeAll([mouseup, windowmouseup])) | |
| // then forward all events from drag to mousedrag | |
| flyd.on(mousedrag, drag) | |
| }, mousedown) | |
| return mousedrag | |
| } | |
| const mousedrag = createMouseDragStream(mousedown, mousemove, mouseup) | |
| // print mousedrag when dragging mouse over canvas | |
| //flyd.on((e) => console.log('mousedrag', e), mousedrag) | |
| // filter functon checking if mouse event is inside rectangle | |
| function inRect (rect) { | |
| return function (e) { | |
| // TODO: curry this! | |
| return containsPoint(rect, [e.clientX, e.clientY]) | |
| } | |
| } | |
| // we use preventDefault to mark handled streams | |
| function markAsHandled (e) { | |
| e.preventDefault() | |
| return e | |
| } | |
| function notHandledYet (e) { | |
| return !e.defaultPrevented | |
| } | |
| // we add background event listener first as we go from broad to more specific | |
| const bgmousedown = filterStream(notHandledYet, mousedown) | |
| flyd.on((e) => console.log('bg mousedown', e), bgmousedown) | |
| /* | |
| const bgmousedrag = mapStream(markAsHandled, createMouseDragStream( | |
| bgmousedown, | |
| mousemove, | |
| mouseup | |
| ) | |
| ) | |
| flyd.on((e) => console.log('bg mousedrag', e), bgmousedrag) | |
| */ | |
| // mouse clicks inside yellow rect | |
| //const buttonmousedown = mapStream(markAsHandled, filterStream(inRect(btnRect), mousedown)) | |
| // mouse clicks outside yellow rect | |
| //flyd.on((e) => console.log('button mousedown', e), buttonmousedown) | |
| // crate drag event stream that happens only if we click inside button | |
| const buttonmousedrag = createMouseDragStream( | |
| mapStream(markAsHandled, filterStream(inRect(btnRect), mousedown)), | |
| mousemove, | |
| mouseup | |
| ) | |
| //flyd.on((e) => console.log('button drag', e), buttonmousedrag) | |
| /* | |
| const a = flyd.stream() | |
| const g = flyd.stream() | |
| window.addEventListener('mousedown', a) | |
| window.addEventListener('mousedown', g) | |
| flyd.on((e) => console.log('a', e), a) | |
| flyd.on((e) => console.log('g background', e), g) | |
| flyd.on((e) => console.log('g slider', e), g) | |
| */ | |
| //const pointer = require('pointer-events-stream')(gl.canvas) | |
| canvas.addEventListener('mousedown', (e) => { | |
| e.preventDefault() | |
| console.log('canvas down') | |
| }) | |
| canvas.addEventListener('mouseup', (e) => { | |
| console.log('canvas up', e.defaultPrevented) | |
| }) | |
| window.addEventListener('mouseup', (e) => { | |
| console.log('window up', e.defaultPrevented) | |
| }) | |
| window.addEventListener('mouseout', (e) => { | |
| console.log('window out', e.defaultPrevented) | |
| }) | |
| /* Ideal scenario | |
| var mouseclicks = stream() | |
| var leftoferclicks = gui.addMouse(mouseclicks) | |
| // inside gui | |
| var click = mouseclicks.peak() | |
| if (insideSlier(click)) { | |
| mouseclicks.take() | |
| } | |
| */ | |
| // PROBLEM | |
| // - calling e.preventDefault in canvas.mousedown prevents window.mouseup released outside of browser bounds | |
| // - gui and arcball / scene are using same canvas events. That wouldn't happen with canvas + dom dat.gui | |
| // SCENARIOS | |
| // gui vs arcball conflicks, picking bounding boxes vs arcball | |
| // SOLUTIONS | |
| // - keep using pex-sys/MouseEvent | |
| // - flyd: add a handled flag to the Event object | |
| // - create sepate window for gui | |
| ;}, 0) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "name": "requirebin-sketch", | |
| "version": "1.0.0", | |
| "dependencies": { | |
| "flyd": "0.2.2", | |
| "pex-geom": "1.0.0-beta.2" | |
| } | |
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <body> --> |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <head> --> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment