diff --git a/.npmignore b/.npmignore
index b40e919..fa37f81 100644
--- a/.npmignore
+++ b/.npmignore
@@ -1,4 +1,7 @@
+.eslintrc
.travis.yml
+CHANGELOG.md
+demo.png
examples
-LICENSE
+README.md
test
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 21ce291..ff5ccd5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,67 +1,15 @@
-# React Resolver Changelog
+# React Resolver Csp Changelog
-### Upcoming...
+### v0.0.3 (2015-06-07)
-- [Error Handling](https://github.com/ericclemmons/react-resolver/issues/2)
-- [React Native](https://github.com/ericclemmons/react-resolver/issues/18)
+- renamed js-csp so (hopefully) the whole lot will get published to npm
+### v0.0.2 (2015-06-07)
-### v1.0.0 - (2015-04-13)
+- Includes decorators & exports csp
-- Complete rewrite for React v0.13
-- "Higher-order Components" via `Resolver.createContainer`
-- Remove all dependencies (!)
- + [#9](https://github.com/ericclemmons/react-resolver/issues/9)
- + [#14](https://github.com/ericclemmons/react-resolver/issues/14)
- + [#15](https://github.com/ericclemmons/react-resolver/issues/15)
+### v0.0.1 (2015-06-06)
-### v0.2.0 - (2015-02-25)
+- Initial version
-- Remove [`resolver.handle`][11]
-
-
-### v0.1.2 (2015-02-25)
-
-- Fix [examples/contacts](https://github.com/ericclemmons/react-resolver/tree/e026a3b1cbf16995c10c825c18d2f20b6277f62f/examples/contacts)
-
-
-### v0.1.1 (2015-02-25)
-
-- Move `react-router` from `optionalDependencies` to `peerDependencies`
-
-
-### v0.1.0 (2015-02-24)
-
-- [#7][7] - Add `react` and `react-router` as `peerDependencies`.
-- [#8][8] - Support React v0.13
-
-
-### v0.0.4 (2015-02-24)
-
-- [#4][4] - NPM package is ES5, not ES6.
-- [#5][5] - Clarify use of `Resolver.mixin`.
-- [#6][6] - README comparison to Relay.
-
-
-### v0.0.3 (2015-02-19)
-
-- Public release
-
-
-### v0.0.2 (2015-02-18)
-
-- Working prototype with context
-
-
-### v0.0.1 (2015-01-29)
-
-- Initial commit
-
-
-[4]: https://github.com/ericclemmons/react-resolver/pull/4
-[5]: https://github.com/ericclemmons/react-resolver/issues/5
-[6]: https://github.com/ericclemmons/react-resolver/issues/6
-[7]: https://github.com/ericclemmons/react-resolver/issues/7
-[8]: https://github.com/ericclemmons/react-resolver/issues/8
-[11]: https://github.com/ericclemmons/react-resolver/issues/11
diff --git a/LICENSE b/LICENSE
index c33bc6b..e8bc73c 100644
--- a/LICENSE
+++ b/LICENSE
@@ -2,9 +2,10 @@ Internet Systems Consortium license
===================================
Copyright (c) 2015 Eric Clemmons
+Copyright (c) 2015 Giles Bradshaw
Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
+with or without fee is hereby granted, provided that the above copyright notices
and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
diff --git a/Original LICENSE b/Original LICENSE
new file mode 100644
index 0000000..c33bc6b
--- /dev/null
+++ b/Original LICENSE
@@ -0,0 +1,16 @@
+Internet Systems Consortium license
+===================================
+
+Copyright (c) 2015 Eric Clemmons
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
diff --git a/README.md b/README.md
index 24b3c96..fea36e9 100644
--- a/README.md
+++ b/README.md
@@ -1,136 +1,85 @@
-# React Resolver 
-
-> Isomorphic library to lazy-load data for React components
-
-[](https://github.com/ericclemmons/react-resolver/issues)
-[](https://travis-ci.org/ericclemmons/react-resolver)
-[](https://david-dm.org/ericclemmons/react-resolver#info=dependencies)
-[](https://david-dm.org/ericclemmons/react-resolver#info=devDependencies)
-
-
-## Features
-
-- **Promise-based** – Define & lazy-load component data dependencies and inject them as `props`.
-- **Isomorphic** – Express/Koa/Hapi-friendly server-side rendering & progressive, client-side rendering.
-- **Test friendly** – Containers promote separation between data-fetching & rendering.
-
-
-## Demo
-
-> [][demo]
-
-[View Demo][demo]
-
-
-- - -
-
-
-- [Features](#features)
-- [Demo](#demo)
-- [Requirements](#requirements)
-- [Installation](#installation)
-- [Usage](#usage)
- + [Client](#client)
- + [Server](#server)
-- [Changelog][changelog]
-- [Development](#development)
-- [Authors](#authors)
-- [License][license]
-
-- - -
-
-
-## Requirements
-
-- React `v0.13.x`
-
-_For browsers that don't nativeuly support promises, use [ES6 Promise](https://github.com/jakearchibald/es6-promise)._
-
-
-## Installation
-
-```shell
-npm install --save react-resolver
-```
-
-- - -
-
-## Usage
-
-_Example is based on [Stargazers.js](https://github.com/ericclemmons/react-resolver/blob/master/examples/stargazers/components/Stargazers.js) in the [demo][demo]._
-
-Suppose you want to display list of users, but that data is loaded
-asynchronously via an API.
-
-Rather than having your component handle data-fetching _and_ rendering,
-you can create a "container" that fetches the data and only renders when ready:
-
-```javascript
-import React from "react";
-import { Resolver } from "react-resolver";
-
-class Users extends React.Component {
- render() {
- return (
-
- {this.props.users.map(user => (
-
{user}
- ))}
-
- );
- }
-}
-
-Users.defaultProps = { limit: 5 };
-Users.propTypes = { users: React.PropTypes.array.isRequired };
-
-// Rather than `export default Users`, create a container:
-export default Resolver.createContainer(Users, {
- resolve: {
- users: function(props) {
- return fetch(`/api/users?limit=${props.limit}`);
- }
- }
+# React Resolver Csp
+
+[](https://travis-ci.org/gilesbradshaw/react-resolver-csp)
+
+[](https://coveralls.io/r/gilesbradshaw/react-resolver-csp)
+
+## Isomorphic library to lazy-load data for React components
+
+Forked and nodified to use CSP channels rather than promises
+
+I've manually included js-csp so the whole lot gets transpiled to ES5
+
+````
+describe("Resolver", function() {
+ describe(".nested", function() {
+ it("should render nested elements", function(done) {
+ @dataDependencies({
+ user: ()=>
+ go(function* (){
+ return "Ernie";
+ })
+ })
+ @displayName("TestElement1")
+ class Element1 extends Component {
+ render(){
+ return {this.props.user};
+ }
+ };
+
+ @dataDependencies({
+ user: ()=>
+ go(function* (){
+ return "Eric";
+ })
+ })
+ @displayName("TestElement")
+ class Element extends Component {
+ render(){
+ return {this.props.user};
+ }
+ };
+ go(function*(){
+ const string = yield Resolver.renderToStaticMarkup();
+ assert.equal("EricErnie",string.toString());
+ done();
+ });
+ });
+ });
});
-```
-
-
-### Client
-
-Replace `React.render` with `Resolver.render`, and you're all set!
-
-```javascript
-import React from "react";
-import Resolver from "react-resolver";
-
-Resolver.render(, document.getElementById("app"));
-```
-
-
-### Server
-
-Because data has to be fetched asynchronously, `React.renderToString`
-(and `React.renderToStaticMarkup`) won't have the data in time.
-
-Instead, replace `React` with `Resolver` and you'll receive a promise
-that resolves with the rendered output!
-
-```javascript
-import React from "react";
-import Resolver from "react-resolver";
-
-Resolver.renderToString().then((string) => {
- reply(string);
-}).catch((err) {
- // An error was thrown while rendering
- console.error(err);
+describe("Resolver", function() {
+ describe(".dom", function() {
+ it("should render a channel into dom", function(done) {
+ const ch = chan();
+ @dataDependencies({
+ user: ()=>ch
+ })
+ @displayName("TestElement")
+ class Element extends Component {
+ render(){
+ return {this.props.user};
+ }
+ };
+ const resolver = new Resolver();
+ Resolver.render(
+
+ , document.body, resolver);
+
+ go(function* (){
+ yield put(ch,"Ernie");
+ yield timeout(0);
+ assert.equal(document.querySelector('span').innerHTML, 'Ernie');
+ yield put(ch,"Wise");
+ yield timeout(0);
+ assert.equal(document.querySelector('span').innerHTML, 'Wise');
+ done();
+ });
+ });
+ });
});
-```
-
-- - -
-
+````
## Development
If you'd like to contribute to this project, all you need to do is clone
@@ -141,22 +90,6 @@ $ npm install
$ npm test
```
+## Credits
-## Authors
-
-- [Eric Clemmons](mailto:eric@smarterspam.com>) ([@ericclemmons][twitter])
-
-
-## [License][license]
-
-
-## Collaboration
-
-If you have questions or issues, please [open an issue][issue]!
-
-
-[changelog]: https://github.com/ericclemmons/react-resolver/blob/master/CHANGELOG.md
-[demo]: https://cdn.rawgit.com/ericclemmons/react-resolver/master/examples/stargazers/public/index.html
-[issue]: https://github.com/ericclemmons/react-resolver/issues/new
-[license]: https://github.com/ericclemmons/react-resolver/blob/master/LICENSE
-[twitter]: https://twitter.com/ericclemmons/
+[Based on ericclemmons/react-resolver](https://github.com/ericclemmons/react-resolver) and [iamdustan/react-resolver](https://github.com/iamdustan/react-resolver)
diff --git a/dist/Container.js b/dist/Container.js
index dfe19e6..77a73e8 100644
--- a/dist/Container.js
+++ b/dist/Container.js
@@ -1,29 +1,32 @@
"use strict";
-var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; };
-
-var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+var _react = require("react");
-var _React = require("react/addons");
+var _react2 = _interopRequireDefault(_react);
-var _React2 = _interopRequireWildcard(_React);
+var _reactLibCloneWithProps = require("react/lib/cloneWithProps");
+
+var _reactLibCloneWithProps2 = _interopRequireDefault(_reactLibCloneWithProps);
var _ResolverError = require("./ResolverError");
-var _ResolverError2 = _interopRequireWildcard(_ResolverError);
+var _ResolverError2 = _interopRequireDefault(_ResolverError);
-var Children = _React2["default"].Children;
-var cloneWithProps = _React2["default"].addons.cloneWithProps;
+var Children = _react2["default"].Children;
var Container = (function (_React$Component) {
function Container(props, context) {
@@ -42,15 +45,19 @@ var Container = (function (_React$Component) {
_createClass(Container, [{
key: "componentWillMount",
value: function componentWillMount() {
- var _this = this;
+ this.resolve();
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this.getResolver().clearContainerState(this);
+ }
+ }, {
+ key: "componentWillReceiveProps",
+ value: function componentWillReceiveProps() {
+ this.getResolver().clearContainerState(this);
- if (!this.state.fulfilled) {
- this.getResolver().resolve(this, function (state) {
- return new Promise(function (resolve) {
- _this.setState(state, resolve);
- });
- });
- }
+ this.resolve();
}
}, {
key: "getId",
@@ -75,7 +82,8 @@ var Container = (function (_React$Component) {
return {
parent: parent,
- resolver: resolver };
+ resolver: resolver
+ };
}
}, {
key: "getResolver",
@@ -91,56 +99,88 @@ var Container = (function (_React$Component) {
}, {
key: "shouldComponentUpdate",
value: function shouldComponentUpdate(props, state) {
- return state.fulfilled;
+ return state.fulfilled || state.error || false;
}
}, {
key: "render",
value: function render() {
+ if (this.state.error) {
+ if (this.props.component && this.props.component.errorRender) {
+ return this.props.component.errorRender(this.state);
+ } else {
+ return false;
+ }
+ }
if (!this.state.fulfilled) {
- return false;
+ if (this.props.component && this.props.component.waitRender) {
+ return this.props.component.waitRender(this.state);
+ } else {
+ return false;
+ }
}
if (this.props.component) {
- return _React2["default"].createElement(this.props.component, this.state.values);
+ return _react2["default"].createElement(this.props.component, this.state.values);
}
if (this.props.element) {
- return cloneWithProps(this.props.element);
+ return (0, _reactLibCloneWithProps2["default"])(this.props.element);
}
if (this.props.children) {
if (Children.count(this.props.children) === 1) {
- return cloneWithProps(Children.only(this.props.children));
+ return (0, _reactLibCloneWithProps2["default"])(Children.only(this.props.children));
}
- return _React2["default"].createElement(
+
+ return _react2["default"].createElement(
"span",
null,
- Children.map(this.props.children, cloneWithProps)
+ Children.map(this.props.children, _reactLibCloneWithProps2["default"])
);
}
throw new _ResolverError2["default"](" requires one of the following props to render: `element`, `component`, or `children`");
}
+ }, {
+ key: "resolve",
+ value: function resolve() {
+ var _this = this;
+
+ var nextState = this.getResolver().getContainerState(this);
+
+ this.setState(nextState);
+
+ if (!nextState.fulfilled) {
+ this.getResolver().resolve(this, function (finalState) {
+ return new Promise(function (resolve) {
+ _this.setState(finalState, resolve);
+ });
+ });
+ }
+ }
}]);
return Container;
-})(_React2["default"].Component);
+})(_react2["default"].Component);
Container.childContextTypes = {
- parent: _React2["default"].PropTypes.instanceOf(Container),
- resolver: _React2["default"].PropTypes.object.isRequired };
+ parent: _react2["default"].PropTypes.instanceOf(Container),
+ resolver: _react2["default"].PropTypes.object.isRequired
+};
Container.contextTypes = {
- parent: _React2["default"].PropTypes.instanceOf(Container),
- resolver: _React2["default"].PropTypes.object };
+ parent: _react2["default"].PropTypes.instanceOf(Container),
+ resolver: _react2["default"].PropTypes.object
+};
Container.displayName = "ResolverContainer";
Container.propTypes = {
- component: _React2["default"].PropTypes.any,
- element: _React2["default"].PropTypes.element,
- resolve: _React2["default"].PropTypes.object,
- resolver: _React2["default"].PropTypes.object };
+ component: _react2["default"].PropTypes.any,
+ element: _react2["default"].PropTypes.element,
+ resolve: _react2["default"].PropTypes.object,
+ resolver: _react2["default"].PropTypes.object
+};
exports["default"] = Container;
module.exports = exports["default"];
\ No newline at end of file
diff --git a/dist/Context.js b/dist/Context.js
deleted file mode 100644
index 53bfdc1..0000000
--- a/dist/Context.js
+++ /dev/null
@@ -1,53 +0,0 @@
-"use strict";
-
-var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
-
-var _createClass = (function () { function defineProperties(target, props) { for (var key in props) { var prop = props[key]; prop.configurable = true; if (prop.value) prop.writable = true; } Object.defineProperties(target, props); } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
-
-var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
-
-var React = _interopRequire(require("react"));
-
-var Resolver = _interopRequire(require("./Resolver"));
-
-var ResolverContext = (function (_React$Component) {
- function ResolverContext() {
- _classCallCheck(this, ResolverContext);
-
- if (_React$Component != null) {
- _React$Component.apply(this, arguments);
- }
- }
-
- _inherits(ResolverContext, _React$Component);
-
- _createClass(ResolverContext, {
- getChildContext: {
- value: function getChildContext() {
- var resolver = this.props.resolver || this.context.resolver;
-
- return { resolver: resolver };
- }
- },
- render: {
- value: function render() {
- return React.cloneElement(this.props.element);
- }
- }
- });
-
- return ResolverContext;
-})(React.Component);
-
-ResolverContext.childContextTypes = {
- resolver: React.PropTypes.any };
-
-ResolverContext.contextTypes = {
- resolver: React.PropTypes.any };
-
-ResolverContext.propTypes = {
- resolver: React.PropTypes.any };
-
-module.exports = ResolverContext;
\ No newline at end of file
diff --git a/dist/Resolver.js b/dist/Resolver.js
new file mode 100644
index 0000000..4762dea
--- /dev/null
+++ b/dist/Resolver.js
@@ -0,0 +1,495 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _react = require("react");
+
+var _react2 = _interopRequireDefault(_react);
+
+var _Container = require("./Container");
+
+var _Container2 = _interopRequireDefault(_Container);
+
+var _ResolverError = require("./ResolverError");
+
+var _ResolverError2 = _interopRequireDefault(_ResolverError);
+
+var _jsCspSrcCsp = require("./js-csp/src/csp");
+
+var _jsCspSrcCsp2 = _interopRequireDefault(_jsCspSrcCsp);
+
+/*eslint no-unused-vars:0 */
+
+var myRenderTo = function myRenderTo(element, renderFunc) {
+ Resolver.server = true;
+ var resolver = new Resolver(); /*eslint no-use-before-define:0*/
+ var context = _react2["default"].createElement(
+ _Container2["default"],
+ { resolver: resolver },
+ element
+ );
+ return (0, _jsCspSrcCsp.go)(regeneratorRuntime.mark(function callee$1$0() {
+ var html;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ context$2$0.next = 2;
+ return resolver.finish(function () {
+ return renderFunc(context);
+ });
+
+ case 2:
+ html = context$2$0.sent;
+
+ resolver.freeze();
+ return context$2$0.abrupt("return", {
+ data: resolver.states,
+ toString: function toString() {
+ return html;
+ }
+ });
+
+ case 5:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+};
+
+var Resolver = (function () {
+ function Resolver() {
+ var states = arguments[0] === undefined ? {} : arguments[0];
+
+ _classCallCheck(this, Resolver);
+
+ this.channels = [];
+ this.frozen = false;
+ this.awaitChan = (0, _jsCspSrcCsp.chan)();
+ this.refreshChan = (0, _jsCspSrcCsp.chan)();
+
+ this.states = states;
+ }
+
+ _createClass(Resolver, [{
+ key: "finish",
+
+ //channel that completes with result of renderer when all channels resolved
+ value: function finish(renderer) {
+ return (0, _jsCspSrcCsp.go)(regeneratorRuntime.mark(function process(total) {
+ var rendered;
+ return regeneratorRuntime.wrap(function process$(context$3$0) {
+ while (1) switch (context$3$0.prev = context$3$0.next) {
+ case 0:
+ rendered = renderer();
+
+ if (!(this.channels.length === total)) {
+ context$3$0.next = 3;
+ break;
+ }
+
+ return context$3$0.abrupt("return", rendered);
+
+ case 3:
+ context$3$0.next = 5;
+ return this.awaitChan;
+
+ case 5:
+ context$3$0.next = 7;
+ return (0, _jsCspSrcCsp.go)(process.bind(this), [this.channels.length]);
+
+ case 7:
+ return context$3$0.abrupt("return", context$3$0.sent);
+
+ case 8:
+ case "end":
+ return context$3$0.stop();
+ }
+ }, process, this);
+ }).bind(this), [this.channels.length]);
+ }
+ }, {
+ key: "freeze",
+ value: function freeze() {
+ this.frozen = true;
+ }
+ }, {
+ key: "fulfillState",
+ value: function fulfillState(state, callback) {
+ state.error = undefined;
+ state.fulfilled = true;
+ state.rejected = false;
+ return callback ? callback(state) : state;
+ }
+ }, {
+ key: "getContainerState",
+ value: function getContainerState(container) {
+ var id = container.id;
+
+ if (!id) {
+ throw new ReferenceError("" + container.constructor.displayName + " should have an ID");
+ }
+
+ var state = this.states[id] || this.rehydrate(id) || {
+ fulfilled: false,
+ rejected: false,
+ values: {}
+ };
+
+ if (!this.states[id]) {
+ this.states[id] = state;
+ }
+
+ return state;
+ }
+ }, {
+ key: "clearContainerState",
+ value: function clearContainerState(container) {
+ var _this = this;
+
+ var id = container.id;
+
+ Object.keys(this.states).filter(function (key) {
+ return key.indexOf(id) === 0;
+ }).forEach(function (key) {
+ return _this.states[key] = undefined;
+ });
+ var self = this;
+ (0, _jsCspSrcCsp.go)(regeneratorRuntime.mark(function callee$2$0() {
+ return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) {
+ while (1) switch (context$3$0.prev = context$3$0.next) {
+ case 0:
+ context$3$0.next = 2;
+ return self.refreshChan.close();
+
+ case 2:
+ case "end":
+ return context$3$0.stop();
+ }
+ }, callee$2$0, this);
+ }));
+ }
+ }, {
+ key: "rejectState",
+ value: function rejectState(error, state, callback) {
+ state.error = error;
+ state.fulfilled = false;
+ state.rejected = true;
+
+ if (callback) {
+ callback(state);
+ }
+ throw new Error("" + this.constructor.displayName + " was rejected: " + error);
+ }
+ }, {
+ key: "rehydrate",
+ value: function rehydrate(id) {
+ if (typeof __resolver__ === "undefined") {
+ return null;
+ }
+ return __resolver__[id]; /*eslint no-undef:0*/
+ }
+ }, {
+ key: "resolve",
+ value: function resolve(container, callback) {
+ var self = this;
+ var asyncProps = container.props.resolve || {};
+ var state = this.getContainerState(container);
+ var asyncKeys = Object.keys(asyncProps)
+ // Assign existing prop values
+ .filter(function (asyncProp) {
+ if (container.props.hasOwnProperty(asyncProp)) {
+ state.values[asyncProp] = container.props[asyncProp];
+
+ return false;
+ }
+
+ return true;
+ })
+ // Filter out pre-loaded values
+ .filter(function (asyncProp) {
+ return !state.values.hasOwnProperty(asyncProp);
+ });
+
+ if (!asyncKeys.length) {
+ this.fulfillState(state, callback);
+ (0, _jsCspSrcCsp.go)(regeneratorRuntime.mark(function callee$2$0() {
+ return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) {
+ while (1) switch (context$3$0.prev = context$3$0.next) {
+ case 0:
+ context$3$0.next = 2;
+ return (0, _jsCspSrcCsp.put)(self.awaitChan, []);
+
+ case 2:
+ case "end":
+ return context$3$0.stop();
+ }
+ }, callee$2$0, this);
+ }));
+ }
+
+ if (this.frozen) {
+ throw new _ResolverError2["default"](["Resolver is frozen for server rendering.", "" + container.constructor.displayName + " (#" + container.id + ") should have already resolved" //,
+ //i've only commented this out because it scuppers my sublime text colouring
+ //`"${asyncKeys.join("\", \"")}". (http://git.io/vvvkr)`,
+ ].join(" "));
+ }
+
+ var channels = asyncKeys.map(function (prop) {
+ var valueOf = container.props.resolve[prop];
+ var value = container.props.hasOwnProperty(prop) ? container.props[prop] : valueOf(container.props.props, container.props.context);
+ return { prop: prop, value: value };
+ });
+ var rejectState = this.rejectState;
+ var fulfillState = this.fulfillState;
+
+ this.channels = this.channels.concat(channels);
+ (0, _jsCspSrcCsp.go)(regeneratorRuntime.mark(function callee$2$0() {
+ var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, channel, result;
+
+ return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) {
+ while (1) switch (context$3$0.prev = context$3$0.next) {
+ case 0:
+ context$3$0.prev = 0;
+ _iteratorNormalCompletion = true;
+ _didIteratorError = false;
+ _iteratorError = undefined;
+ context$3$0.prev = 4;
+ _iterator = channels[Symbol.iterator]();
+
+ case 6:
+ if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
+ context$3$0.next = 17;
+ break;
+ }
+
+ channel = _step.value;
+ context$3$0.next = 10;
+ return channel.value;
+
+ case 10:
+ result = channel.result = context$3$0.sent;
+
+ if (!(Object.prototype.toString.call(result) === "[object Error]")) {
+ context$3$0.next = 13;
+ break;
+ }
+
+ throw result;
+
+ case 13:
+ state.values[channel.prop] = channel.result;
+
+ case 14:
+ _iteratorNormalCompletion = true;
+ context$3$0.next = 6;
+ break;
+
+ case 17:
+ context$3$0.next = 23;
+ break;
+
+ case 19:
+ context$3$0.prev = 19;
+ context$3$0.t0 = context$3$0["catch"](4);
+ _didIteratorError = true;
+ _iteratorError = context$3$0.t0;
+
+ case 23:
+ context$3$0.prev = 23;
+ context$3$0.prev = 24;
+
+ if (!_iteratorNormalCompletion && _iterator["return"]) {
+ _iterator["return"]();
+ }
+
+ case 26:
+ context$3$0.prev = 26;
+
+ if (!_didIteratorError) {
+ context$3$0.next = 29;
+ break;
+ }
+
+ throw _iteratorError;
+
+ case 29:
+ return context$3$0.finish(26);
+
+ case 30:
+ return context$3$0.finish(23);
+
+ case 31:
+ fulfillState.bind(self)(state, callback);
+
+ if (!Resolver.server) {
+ context$3$0.next = 35;
+ break;
+ }
+
+ context$3$0.next = 35;
+ return (0, _jsCspSrcCsp.put)(self.awaitChan, channels.filter(function (p) {
+ return p.result;
+ }).map(function (p) {
+ return p.result;
+ }));
+
+ case 35:
+ context$3$0.next = 40;
+ break;
+
+ case 37:
+ context$3$0.prev = 37;
+ context$3$0.t1 = context$3$0["catch"](0);
+
+ rejectState.bind(self)(context$3$0.t1, state, callback);
+
+ case 40:
+ if (!Resolver.server) {
+ //keep getting data from channels until the refreshchan gets closed
+ (0, _jsCspSrcCsp.go)(regeneratorRuntime.mark(function process(cs) {
+ var channelResult, channel;
+ return regeneratorRuntime.wrap(function process$(context$4$0) {
+ while (1) switch (context$4$0.prev = context$4$0.next) {
+ case 0:
+ context$4$0.next = 2;
+ return (0, _jsCspSrcCsp.alts)(cs);
+
+ case 2:
+ channelResult = context$4$0.sent;
+
+ if (!(channelResult.channel !== self.refreshChan)) {
+ context$4$0.next = 13;
+ break;
+ }
+
+ if (channelResult.channel.closed) {
+ context$4$0.next = 11;
+ break;
+ }
+
+ channel = channels[channels.map(function (c) {
+ return c.value;
+ }).indexOf(channelResult.channel)];
+ /*eslint no-loop-func:0*/
+ if (channel) {
+ state.values[channel.prop] = channel.result = channelResult.value;
+ fulfillState.bind(self)(state, callback);
+ }
+ context$4$0.next = 9;
+ return (0, _jsCspSrcCsp.go)(process, [cs]);
+
+ case 9:
+ context$4$0.next = 13;
+ break;
+
+ case 11:
+ context$4$0.next = 13;
+ return (0, _jsCspSrcCsp.go)(process, [cs.filter(function (c) {
+ return c !== channelResult.channel;
+ })]);
+
+ case 13:
+ case "end":
+ return context$4$0.stop();
+ }
+ }, process, this);
+ }), [channels.map(function (c) {
+ return c.value;
+ }).concat([self.refreshChan])]);
+ }
+
+ case 41:
+ case "end":
+ return context$3$0.stop();
+ }
+ }, callee$2$0, this, [[0, 37], [4, 19, 23, 31], [24,, 26, 30]]);
+ }));
+ }
+ }], [{
+ key: "createContainer",
+ value: function createContainer(Component) {
+ var props = arguments[1] === undefined ? {} : arguments[1];
+
+ if (!Component.hasOwnProperty("displayName")) {
+ throw new ReferenceError("Resolver.createContainer requires wrapped component to have `displayName`");
+ }
+
+ var ComponentContainer = (function (_React$Component) {
+ function ComponentContainer() {
+ _classCallCheck(this, ComponentContainer);
+
+ if (_React$Component != null) {
+ _React$Component.apply(this, arguments);
+ }
+ }
+
+ _inherits(ComponentContainer, _React$Component);
+
+ _createClass(ComponentContainer, [{
+ key: "render",
+ value: function render() {
+ return _react2["default"].createElement(_Container2["default"], _extends({
+ component: Component,
+ context: this.context,
+ props: this.props
+ }, props));
+ }
+ }]);
+
+ return ComponentContainer;
+ })(_react2["default"].Component);
+
+ ComponentContainer.childContextTypes = props.childContextTypes;
+ ComponentContainer.contextTypes = props.contextTypes;
+ ComponentContainer.displayName = "" + Component.displayName + "Container";
+
+ return ComponentContainer;
+ }
+ }, {
+ key: "render",
+ value: function render(element, node) {
+ var instance = arguments[2] === undefined ? new Resolver() : arguments[2];
+
+ Resolver.server = false;
+ _react2["default"].render(_react2["default"].createElement(
+ _Container2["default"],
+ { resolver: instance },
+ element
+ ), node);
+
+ return instance;
+ }
+ }, {
+ key: "renderToString",
+ value: function renderToString(element) {
+ return myRenderTo(element, _react2["default"].renderToString);
+ }
+ }, {
+ key: "renderToStaticMarkup",
+ value: function renderToStaticMarkup(element) {
+ return myRenderTo(element, _react2["default"].renderToStaticMarkup);
+ }
+ }]);
+
+ return Resolver;
+})();
+
+exports["default"] = Resolver;
+module.exports = exports["default"];
+
+//replace with alts
+
+//if channel is closed remove it from the list of channels we are monitoring
\ No newline at end of file
diff --git a/dist/ResolverError.js b/dist/ResolverError.js
index 3fdb817..2310df3 100644
--- a/dist/ResolverError.js
+++ b/dist/ResolverError.js
@@ -1,15 +1,15 @@
"use strict";
-var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
-
-var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
-
Object.defineProperty(exports, "__esModule", {
value: true
});
+var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
var ResolverError = (function (_Error) {
function ResolverError(message) {
_classCallCheck(this, ResolverError);
diff --git a/dist/decorators/dataDependencies.js b/dist/decorators/dataDependencies.js
new file mode 100644
index 0000000..e33f008
--- /dev/null
+++ b/dist/decorators/dataDependencies.js
@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _index = require("../index");
+
+exports["default"] = function (resolve) {
+ return function (target) {
+ return _index.Resolver.createContainer(target, { resolve: resolve });
+ };
+};
+
+var errorRender = function errorRender(render) {
+ return function (target) {
+ target.errorRender = render;
+ return target;
+ };
+};
+
+exports.errorRender = errorRender;
+var waitRender = function waitRender(render) {
+ return function (target) {
+ target.waitRender = render;
+ return target;
+ };
+};
+exports.waitRender = waitRender;
\ No newline at end of file
diff --git a/dist/decorators/displayName.js b/dist/decorators/displayName.js
new file mode 100644
index 0000000..3d5a0e9
--- /dev/null
+++ b/dist/decorators/displayName.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+exports["default"] = function (name) {
+ return function (target) {
+ target.displayName = name;
+ return target;
+ };
+};
+
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/dist/decorators/index.js b/dist/decorators/index.js
new file mode 100644
index 0000000..6fcd1ea
--- /dev/null
+++ b/dist/decorators/index.js
@@ -0,0 +1,14 @@
+"use strict";
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var _dataDependencies = require("./dataDependencies");
+
+var _dataDependencies2 = _interopRequireDefault(_dataDependencies);
+
+var _displayName = require("./displayName");
+
+var _displayName2 = _interopRequireDefault(_displayName);
+
+module.exports.dataDependencies = _dataDependencies2["default"];
+module.exports.displayName = _displayName2["default"];
\ No newline at end of file
diff --git a/dist/index.js b/dist/index.js
index e3579de..e3f71ba 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -1,19 +1,29 @@
"use strict";
-var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; };
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
var _Container = require("./Container");
-var _Container2 = _interopRequireWildcard(_Container);
+var _Container2 = _interopRequireDefault(_Container);
var _Resolver = require("./Resolver");
-var _Resolver2 = _interopRequireWildcard(_Resolver);
+var _Resolver2 = _interopRequireDefault(_Resolver);
var _ResolverError = require("./ResolverError");
-var _ResolverError2 = _interopRequireWildcard(_ResolverError);
+var _ResolverError2 = _interopRequireDefault(_ResolverError);
+
+var _decoratorsIndex = require("./decorators/index");
+
+var _decoratorsIndex2 = _interopRequireDefault(_decoratorsIndex);
+
+var _jsCsp = require("./js-csp");
+
+var _jsCsp2 = _interopRequireDefault(_jsCsp);
module.exports.Container = _Container2["default"];
module.exports.Error = _ResolverError2["default"];
-module.exports.Resolver = _Resolver2["default"];
\ No newline at end of file
+module.exports.Resolver = _Resolver2["default"];
+module.exports.csp = _jsCsp2["default"];
+module.exports.decorators = _decoratorsIndex2["default"];
\ No newline at end of file
diff --git a/dist/js-csp/index.js b/dist/js-csp/index.js
new file mode 100644
index 0000000..8ed1063
--- /dev/null
+++ b/dist/js-csp/index.js
@@ -0,0 +1,5 @@
+"use strict";
+
+var csp = require("./src/csp");
+
+module.exports = csp;
\ No newline at end of file
diff --git a/dist/js-csp/src/csp.core.js b/dist/js-csp/src/csp.core.js
new file mode 100644
index 0000000..d58a37a
--- /dev/null
+++ b/dist/js-csp/src/csp.core.js
@@ -0,0 +1,70 @@
+"use strict";
+
+var buffers = require("./impl/buffers");
+var channels = require("./impl/channels");
+var select = require("./impl/select");
+var process = require("./impl/process");
+var timers = require("./impl/timers");
+
+function spawn(gen, creator) {
+ var ch = channels.chan(buffers.fixed(1));
+ new process.Process(gen, function (value) {
+ if (value === channels.CLOSED) {
+ ch.close();
+ } else {
+ process.put_then_callback(ch, value, function (ok) {
+ ch.close();
+ });
+ }
+ }, creator).run();
+ return ch;
+};
+
+function go(f, args) {
+ args = args || [];
+
+ var gen = f.apply(null, args);
+ return spawn(gen, f);
+};
+
+function chan(bufferOrNumber, xform, exHandler) {
+ var buf;
+ if (bufferOrNumber === 0) {
+ bufferOrNumber = null;
+ }
+ if (typeof bufferOrNumber === "number") {
+ buf = buffers.fixed(bufferOrNumber);
+ } else {
+ buf = bufferOrNumber;
+ }
+ return channels.chan(buf, xform, exHandler);
+};
+
+function promiseChan(xform, exHandler) {
+ return chan(buffers.promise(), xform, exHandler);
+};
+
+module.exports = {
+ buffers: {
+ fixed: buffers.fixed,
+ dropping: buffers.dropping,
+ sliding: buffers.sliding,
+ promise: buffers.promise
+ },
+
+ spawn: spawn,
+ go: go,
+ chan: chan,
+ promiseChan: promiseChan,
+ DEFAULT: select.DEFAULT,
+ CLOSED: channels.CLOSED,
+
+ put: process.put,
+ take: process.take,
+ sleep: process.sleep,
+ alts: process.alts,
+ putAsync: process.put_then_callback,
+ takeAsync: process.take_then_callback,
+
+ timeout: timers.timeout
+};
\ No newline at end of file
diff --git a/dist/js-csp/src/csp.js b/dist/js-csp/src/csp.js
new file mode 100644
index 0000000..2c3b563
--- /dev/null
+++ b/dist/js-csp/src/csp.js
@@ -0,0 +1,11 @@
+"use strict";
+
+var csp = require("./csp.core");
+var operations = require("./csp.operations");
+var pipeline = require("./csp.pipeline");
+
+csp.operations = operations;
+csp.operations.pipeline = pipeline.pipeline;
+csp.operations.pipelineAsync = pipeline.pipelineAsync;
+
+module.exports = csp;
\ No newline at end of file
diff --git a/dist/js-csp/src/csp.operations.js b/dist/js-csp/src/csp.operations.js
new file mode 100644
index 0000000..ad6fa23
--- /dev/null
+++ b/dist/js-csp/src/csp.operations.js
@@ -0,0 +1,1325 @@
+"use strict";
+
+var marked0$0 = [mapcat].map(regeneratorRuntime.mark);
+var Box = require("./impl/channels").Box;
+
+var csp = require("./csp.core"),
+ go = csp.go,
+ take = csp.take,
+ put = csp.put,
+ takeAsync = csp.takeAsync,
+ putAsync = csp.putAsync,
+ alts = csp.alts,
+ chan = csp.chan,
+ CLOSED = csp.CLOSED;
+
+function mapFrom(f, ch) {
+ return {
+ is_closed: function is_closed() {
+ return ch.is_closed();
+ },
+ close: function close() {
+ ch.close();
+ },
+ _put: function _put(value, handler) {
+ return ch._put(value, handler);
+ },
+ _take: function _take(handler) {
+ var result = ch._take({
+ is_active: function is_active() {
+ return handler.is_active();
+ },
+ commit: function commit() {
+ var take_cb = handler.commit();
+ return function (value) {
+ return take_cb(value === CLOSED ? CLOSED : f(value));
+ };
+ }
+ });
+ if (result) {
+ var value = result.value;
+ return new Box(value === CLOSED ? CLOSED : f(value));
+ } else {
+ return null;
+ }
+ }
+ };
+}
+
+function mapInto(f, ch) {
+ return {
+ is_closed: function is_closed() {
+ return ch.is_closed();
+ },
+ close: function close() {
+ ch.close();
+ },
+ _put: function _put(value, handler) {
+ return ch._put(f(value), handler);
+ },
+ _take: function _take(handler) {
+ return ch._take(handler);
+ }
+ };
+}
+
+function filterFrom(p, ch, bufferOrN) {
+ var out = chan(bufferOrN);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var value;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 12;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return take(ch);
+
+ case 3:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 7;
+ break;
+ }
+
+ out.close();
+ return context$2$0.abrupt("break", 12);
+
+ case 7:
+ if (!p(value)) {
+ context$2$0.next = 10;
+ break;
+ }
+
+ context$2$0.next = 10;
+ return put(out, value);
+
+ case 10:
+ context$2$0.next = 0;
+ break;
+
+ case 12:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return out;
+}
+
+function filterInto(p, ch) {
+ return {
+ is_closed: function is_closed() {
+ return ch.is_closed();
+ },
+ close: function close() {
+ ch.close();
+ },
+ _put: function _put(value, handler) {
+ if (p(value)) {
+ return ch._put(value, handler);
+ } else {
+ return new Box(!ch.is_closed());
+ }
+ },
+ _take: function _take(handler) {
+ return ch._take(handler);
+ }
+ };
+}
+
+function removeFrom(p, ch) {
+ return filterFrom(function (value) {
+ return !p(value);
+ }, ch);
+}
+
+function removeInto(p, ch) {
+ return filterInto(function (value) {
+ return !p(value);
+ }, ch);
+}
+
+function mapcat(f, src, dst) {
+ var value, seq, length, i;
+ return regeneratorRuntime.wrap(function mapcat$(context$1$0) {
+ while (1) switch (context$1$0.prev = context$1$0.next) {
+ case 0:
+ if (!true) {
+ context$1$0.next = 22;
+ break;
+ }
+
+ context$1$0.next = 3;
+ return take(src);
+
+ case 3:
+ value = context$1$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$1$0.next = 9;
+ break;
+ }
+
+ dst.close();
+ return context$1$0.abrupt("break", 22);
+
+ case 9:
+ seq = f(value);
+ length = seq.length;
+ i = 0;
+
+ case 12:
+ if (!(i < length)) {
+ context$1$0.next = 18;
+ break;
+ }
+
+ context$1$0.next = 15;
+ return put(dst, seq[i]);
+
+ case 15:
+ i++;
+ context$1$0.next = 12;
+ break;
+
+ case 18:
+ if (!dst.is_closed()) {
+ context$1$0.next = 20;
+ break;
+ }
+
+ return context$1$0.abrupt("break", 22);
+
+ case 20:
+ context$1$0.next = 0;
+ break;
+
+ case 22:
+ case "end":
+ return context$1$0.stop();
+ }
+ }, marked0$0[0], this);
+}
+
+function mapcatFrom(f, ch, bufferOrN) {
+ var out = chan(bufferOrN);
+ go(mapcat, [f, ch, out]);
+ return out;
+}
+
+function mapcatInto(f, ch, bufferOrN) {
+ var src = chan(bufferOrN);
+ go(mapcat, [f, src, ch]);
+ return src;
+}
+
+function pipe(src, dst, keepOpen) {
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var value;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 13;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return take(src);
+
+ case 3:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 7;
+ break;
+ }
+
+ if (!keepOpen) {
+ dst.close();
+ }
+ return context$2$0.abrupt("break", 13);
+
+ case 7:
+ context$2$0.next = 9;
+ return put(dst, value);
+
+ case 9:
+ if (context$2$0.sent) {
+ context$2$0.next = 11;
+ break;
+ }
+
+ return context$2$0.abrupt("break", 13);
+
+ case 11:
+ context$2$0.next = 0;
+ break;
+
+ case 13:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return dst;
+}
+
+function split(p, ch, trueBufferOrN, falseBufferOrN) {
+ var tch = chan(trueBufferOrN);
+ var fch = chan(falseBufferOrN);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var value;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 12;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return take(ch);
+
+ case 3:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 8;
+ break;
+ }
+
+ tch.close();
+ fch.close();
+ return context$2$0.abrupt("break", 12);
+
+ case 8:
+ context$2$0.next = 10;
+ return put(p(value) ? tch : fch, value);
+
+ case 10:
+ context$2$0.next = 0;
+ break;
+
+ case 12:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return [tch, fch];
+}
+
+function reduce(f, init, ch) {
+ return go(regeneratorRuntime.mark(function callee$1$0() {
+ var result, value;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ result = init;
+
+ case 1:
+ if (!true) {
+ context$2$0.next = 12;
+ break;
+ }
+
+ context$2$0.next = 4;
+ return take(ch);
+
+ case 4:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 9;
+ break;
+ }
+
+ return context$2$0.abrupt("return", result);
+
+ case 9:
+ result = f(result, value);
+
+ case 10:
+ context$2$0.next = 1;
+ break;
+
+ case 12:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }), [], true);
+}
+
+function onto(ch, coll, keepOpen) {
+ return go(regeneratorRuntime.mark(function callee$1$0() {
+ var length, i;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ length = coll.length;
+ i = 0;
+
+ case 2:
+ if (!(i < length)) {
+ context$2$0.next = 8;
+ break;
+ }
+
+ context$2$0.next = 5;
+ return put(ch, coll[i]);
+
+ case 5:
+ i++;
+ context$2$0.next = 2;
+ break;
+
+ case 8:
+ if (!keepOpen) {
+ ch.close();
+ }
+
+ case 9:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+}
+
+// TODO: Bounded?
+function fromColl(coll) {
+ var ch = chan(coll.length);
+ onto(ch, coll);
+ return ch;
+}
+
+function map(f, chs, bufferOrN) {
+ var out = chan(bufferOrN);
+ var length = chs.length;
+ // Array holding 1 round of values
+ var values = new Array(length);
+ // TODO: Not sure why we need a size-1 buffer here
+ var dchan = chan(1);
+ // How many more items this round
+ var dcount;
+ // put callbacks for each channel
+ var dcallbacks = new Array(length);
+ for (var i = 0; i < length; i++) {
+ dcallbacks[i] = (function (i) {
+ return function (value) {
+ values[i] = value;
+ dcount--;
+ if (dcount === 0) {
+ putAsync(dchan, values.slice(0));
+ }
+ };
+ })(i);
+ }
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var i, values;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 18;
+ break;
+ }
+
+ dcount = length;
+ // We could just launch n goroutines here, but for effciency we
+ // don't
+ for (i = 0; i < length; i++) {
+ try {
+ takeAsync(chs[i], dcallbacks[i]);
+ } catch (e) {
+ // FIX: Hmm why catching here?
+ dcount--;
+ }
+ }
+ context$2$0.next = 5;
+ return take(dchan);
+
+ case 5:
+ values = context$2$0.sent;
+ i = 0;
+
+ case 7:
+ if (!(i < length)) {
+ context$2$0.next = 14;
+ break;
+ }
+
+ if (!(values[i] === CLOSED)) {
+ context$2$0.next = 11;
+ break;
+ }
+
+ out.close();
+ return context$2$0.abrupt("return");
+
+ case 11:
+ i++;
+ context$2$0.next = 7;
+ break;
+
+ case 14:
+ context$2$0.next = 16;
+ return put(out, f.apply(null, values));
+
+ case 16:
+ context$2$0.next = 0;
+ break;
+
+ case 18:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return out;
+}
+
+function merge(chs, bufferOrN) {
+ var out = chan(bufferOrN);
+ var actives = chs.slice(0);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var r, value, i;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 15;
+ break;
+ }
+
+ if (!(actives.length === 0)) {
+ context$2$0.next = 3;
+ break;
+ }
+
+ return context$2$0.abrupt("break", 15);
+
+ case 3:
+ context$2$0.next = 5;
+ return alts(actives);
+
+ case 5:
+ r = context$2$0.sent;
+ value = r.value;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 11;
+ break;
+ }
+
+ i = actives.indexOf(r.channel);
+
+ actives.splice(i, 1);
+ return context$2$0.abrupt("continue", 0);
+
+ case 11:
+ context$2$0.next = 13;
+ return put(out, value);
+
+ case 13:
+ context$2$0.next = 0;
+ break;
+
+ case 15:
+ out.close();
+
+ case 16:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return out;
+}
+
+function into(coll, ch) {
+ var result = coll.slice(0);
+ return reduce(function (result, item) {
+ result.push(item);
+ return result;
+ }, result, ch);
+}
+
+function takeN(n, ch, bufferOrN) {
+ var out = chan(bufferOrN);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var i, value;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ i = 0;
+
+ case 1:
+ if (!(i < n)) {
+ context$2$0.next = 12;
+ break;
+ }
+
+ context$2$0.next = 4;
+ return take(ch);
+
+ case 4:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 7;
+ break;
+ }
+
+ return context$2$0.abrupt("break", 12);
+
+ case 7:
+ context$2$0.next = 9;
+ return put(out, value);
+
+ case 9:
+ i++;
+ context$2$0.next = 1;
+ break;
+
+ case 12:
+ out.close();
+
+ case 13:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return out;
+}
+
+var NOTHING = {};
+
+function unique(ch, bufferOrN) {
+ var out = chan(bufferOrN);
+ var last = NOTHING;
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var value;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 13;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return take(ch);
+
+ case 3:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 6;
+ break;
+ }
+
+ return context$2$0.abrupt("break", 13);
+
+ case 6:
+ if (!(value === last)) {
+ context$2$0.next = 8;
+ break;
+ }
+
+ return context$2$0.abrupt("continue", 0);
+
+ case 8:
+ last = value;
+ context$2$0.next = 11;
+ return put(out, value);
+
+ case 11:
+ context$2$0.next = 0;
+ break;
+
+ case 13:
+ out.close();
+
+ case 14:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return out;
+}
+
+function partitionBy(f, ch, bufferOrN) {
+ var out = chan(bufferOrN);
+ var part = [];
+ var last = NOTHING;
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var value, newItem;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 23;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return take(ch);
+
+ case 3:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 12;
+ break;
+ }
+
+ if (!(part.length > 0)) {
+ context$2$0.next = 8;
+ break;
+ }
+
+ context$2$0.next = 8;
+ return put(out, part);
+
+ case 8:
+ out.close();
+ return context$2$0.abrupt("break", 23);
+
+ case 12:
+ newItem = f(value);
+
+ if (!(newItem === last || last === NOTHING)) {
+ context$2$0.next = 17;
+ break;
+ }
+
+ part.push(value);
+ context$2$0.next = 20;
+ break;
+
+ case 17:
+ context$2$0.next = 19;
+ return put(out, part);
+
+ case 19:
+ part = [value];
+
+ case 20:
+ last = newItem;
+
+ case 21:
+ context$2$0.next = 0;
+ break;
+
+ case 23:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return out;
+}
+
+function partition(n, ch, bufferOrN) {
+ var out = chan(bufferOrN);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var part, i, value;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 21;
+ break;
+ }
+
+ part = new Array(n);
+ i = 0;
+
+ case 3:
+ if (!(i < n)) {
+ context$2$0.next = 17;
+ break;
+ }
+
+ context$2$0.next = 6;
+ return take(ch);
+
+ case 6:
+ value = context$2$0.sent;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 13;
+ break;
+ }
+
+ if (!(i > 0)) {
+ context$2$0.next = 11;
+ break;
+ }
+
+ context$2$0.next = 11;
+ return put(out, part.slice(0, i));
+
+ case 11:
+ out.close();
+ return context$2$0.abrupt("return");
+
+ case 13:
+ part[i] = value;
+
+ case 14:
+ i++;
+ context$2$0.next = 3;
+ break;
+
+ case 17:
+ context$2$0.next = 19;
+ return put(out, part);
+
+ case 19:
+ context$2$0.next = 0;
+ break;
+
+ case 21:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return out;
+}
+
+// For channel identification
+var genId = (function () {
+ var i = 0;
+ return function () {
+ i++;
+ return "" + i;
+ };
+})();
+
+var ID_ATTR = "__csp_channel_id";
+
+// TODO: Do we need to check with hasOwnProperty?
+function len(obj) {
+ var count = 0;
+ for (var p in obj) {
+ count++;
+ }
+ return count;
+}
+
+function chanId(ch) {
+ var id = ch[ID_ATTR];
+ if (id === undefined) {
+ id = ch[ID_ATTR] = genId();
+ }
+ return id;
+}
+
+var Mult = function Mult(ch) {
+ this.taps = {};
+ this.ch = ch;
+};
+
+var Tap = function Tap(channel, keepOpen) {
+ this.channel = channel;
+ this.keepOpen = keepOpen;
+};
+
+Mult.prototype.muxch = function () {
+ return this.ch;
+};
+
+Mult.prototype.tap = function (ch, keepOpen) {
+ var id = chanId(ch);
+ this.taps[id] = new Tap(ch, keepOpen);
+};
+
+Mult.prototype.untap = function (ch) {
+ delete this.taps[chanId(ch)];
+};
+
+Mult.prototype.untapAll = function () {
+ this.taps = {};
+};
+
+function mult(ch) {
+ var m = new Mult(ch);
+ var dchan = chan(1);
+ var dcount;
+ function makeDoneCallback(tap) {
+ return function (stillOpen) {
+ dcount--;
+ if (dcount === 0) {
+ putAsync(dchan, true);
+ }
+ if (!stillOpen) {
+ m.untap(tap.channel);
+ }
+ };
+ }
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var value, id, t, taps, initDcount;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 17;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return take(ch);
+
+ case 3:
+ value = context$2$0.sent;
+ taps = m.taps;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 9;
+ break;
+ }
+
+ for (id in taps) {
+ t = taps[id];
+ if (!t.keepOpen) {
+ t.channel.close();
+ }
+ }
+ // TODO: Is this necessary?
+ m.untapAll();
+ return context$2$0.abrupt("break", 17);
+
+ case 9:
+ dcount = len(taps);
+ initDcount = dcount;
+
+ // Put value on tapping channels...
+ for (id in taps) {
+ t = taps[id];
+ putAsync(t.channel, value, makeDoneCallback(t));
+ }
+
+ if (!(initDcount > 0)) {
+ context$2$0.next = 15;
+ break;
+ }
+
+ context$2$0.next = 15;
+ return take(dchan);
+
+ case 15:
+ context$2$0.next = 0;
+ break;
+
+ case 17:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return m;
+}
+
+mult.tap = function tap(m, ch, keepOpen) {
+ m.tap(ch, keepOpen);
+ return ch;
+};
+
+mult.untap = function untap(m, ch) {
+ m.untap(ch);
+};
+
+mult.untapAll = function untapAll(m) {
+ m.untapAll();
+};
+
+var Mix = function Mix(ch) {
+ this.ch = ch;
+ this.stateMap = {};
+ this.change = chan();
+ this.soloMode = mix.MUTE;
+};
+
+Mix.prototype._changed = function () {
+ putAsync(this.change, true);
+};
+
+Mix.prototype._getAllState = function () {
+ var allState = {};
+ var stateMap = this.stateMap;
+ var solos = [];
+ var mutes = [];
+ var pauses = [];
+ var reads;
+ for (var id in stateMap) {
+ var chanData = stateMap[id];
+ var state = chanData.state;
+ var channel = chanData.channel;
+ if (state[mix.SOLO]) {
+ solos.push(channel);
+ }
+ // TODO
+ if (state[mix.MUTE]) {
+ mutes.push(channel);
+ }
+ if (state[mix.PAUSE]) {
+ pauses.push(channel);
+ }
+ }
+ var i, n;
+ if (this.soloMode === mix.PAUSE && solos.length > 0) {
+ n = solos.length;
+ reads = new Array(n + 1);
+ for (i = 0; i < n; i++) {
+ reads[i] = solos[i];
+ }
+ reads[n] = this.change;
+ } else {
+ reads = [];
+ for (id in stateMap) {
+ chanData = stateMap[id];
+ channel = chanData.channel;
+ if (pauses.indexOf(channel) < 0) {
+ reads.push(channel);
+ }
+ }
+ reads.push(this.change);
+ }
+
+ return {
+ solos: solos,
+ mutes: mutes,
+ reads: reads
+ };
+};
+
+Mix.prototype.admix = function (ch) {
+ this.stateMap[chanId(ch)] = {
+ channel: ch,
+ state: {}
+ };
+ this._changed();
+};
+
+Mix.prototype.unmix = function (ch) {
+ delete this.stateMap[chanId(ch)];
+ this._changed();
+};
+
+Mix.prototype.unmixAll = function () {
+ this.stateMap = {};
+ this._changed();
+};
+
+Mix.prototype.toggle = function (updateStateList) {
+ // [[ch1, {}], [ch2, {solo: true}]];
+ var length = updateStateList.length;
+ for (var i = 0; i < length; i++) {
+ var ch = updateStateList[i][0];
+ var id = chanId(ch);
+ var updateState = updateStateList[i][1];
+ var chanData = this.stateMap[id];
+ if (!chanData) {
+ chanData = this.stateMap[id] = {
+ channel: ch,
+ state: {}
+ };
+ }
+ for (var mode in updateState) {
+ chanData.state[mode] = updateState[mode];
+ }
+ }
+ this._changed();
+};
+
+Mix.prototype.setSoloMode = function (mode) {
+ if (VALID_SOLO_MODES.indexOf(mode) < 0) {
+ throw new Error("Mode must be one of: ", VALID_SOLO_MODES.join(", "));
+ }
+ this.soloMode = mode;
+ this._changed();
+};
+
+function mix(out) {
+ var m = new Mix(out);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var state, result, value, channel, solos, stillOpen;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ state = m._getAllState();
+
+ case 1:
+ if (!true) {
+ context$2$0.next = 23;
+ break;
+ }
+
+ context$2$0.next = 4;
+ return alts(state.reads);
+
+ case 4:
+ result = context$2$0.sent;
+ value = result.value;
+ channel = result.channel;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 11;
+ break;
+ }
+
+ delete m.stateMap[chanId(channel)];
+ state = m._getAllState();
+ return context$2$0.abrupt("continue", 1);
+
+ case 11:
+ if (!(channel === m.change)) {
+ context$2$0.next = 14;
+ break;
+ }
+
+ state = m._getAllState();
+ return context$2$0.abrupt("continue", 1);
+
+ case 14:
+ solos = state.solos;
+
+ if (!(solos.indexOf(channel) > -1 || solos.length === 0 && !(state.mutes.indexOf(channel) > -1))) {
+ context$2$0.next = 21;
+ break;
+ }
+
+ context$2$0.next = 18;
+ return put(out, value);
+
+ case 18:
+ stillOpen = context$2$0.sent;
+
+ if (stillOpen) {
+ context$2$0.next = 21;
+ break;
+ }
+
+ return context$2$0.abrupt("break", 23);
+
+ case 21:
+ context$2$0.next = 1;
+ break;
+
+ case 23:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return m;
+}
+
+mix.MUTE = "mute";
+mix.PAUSE = "pause";
+mix.SOLO = "solo";
+var VALID_SOLO_MODES = [mix.MUTE, mix.PAUSE];
+
+mix.add = function admix(m, ch) {
+ m.admix(ch);
+};
+
+mix.remove = function unmix(m, ch) {
+ m.unmix(ch);
+};
+
+mix.removeAll = function unmixAll(m) {
+ m.unmixAll();
+};
+
+mix.toggle = function toggle(m, updateStateList) {
+ m.toggle(updateStateList);
+};
+
+mix.setSoloMode = function setSoloMode(m, mode) {
+ m.setSoloMode(mode);
+};
+
+function constantlyNull() {
+ return null;
+}
+
+var Pub = function Pub(ch, topicFn, bufferFn) {
+ this.ch = ch;
+ this.topicFn = topicFn;
+ this.bufferFn = bufferFn;
+ this.mults = {};
+};
+
+Pub.prototype._ensureMult = function (topic) {
+ var m = this.mults[topic];
+ var bufferFn = this.bufferFn;
+ if (!m) {
+ m = this.mults[topic] = mult(chan(bufferFn(topic)));
+ }
+ return m;
+};
+
+Pub.prototype.sub = function (topic, ch, keepOpen) {
+ var m = this._ensureMult(topic);
+ return mult.tap(m, ch, keepOpen);
+};
+
+Pub.prototype.unsub = function (topic, ch) {
+ var m = this.mults[topic];
+ if (m) {
+ mult.untap(m, ch);
+ }
+};
+
+Pub.prototype.unsubAll = function (topic) {
+ if (topic === undefined) {
+ this.mults = {};
+ } else {
+ delete this.mults[topic];
+ }
+};
+
+function pub(ch, topicFn, bufferFn) {
+ bufferFn = bufferFn || constantlyNull;
+ var p = new Pub(ch, topicFn, bufferFn);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ var value, mults, topic, m, stillOpen;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 17;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return take(ch);
+
+ case 3:
+ value = context$2$0.sent;
+ mults = p.mults;
+
+ if (!(value === CLOSED)) {
+ context$2$0.next = 8;
+ break;
+ }
+
+ for (topic in mults) {
+ mults[topic].muxch().close();
+ }
+ return context$2$0.abrupt("break", 17);
+
+ case 8:
+ // TODO: Somehow ensure/document that this must return a string
+ // (otherwise use proper (hash)maps)
+ topic = topicFn(value);
+ m = mults[topic];
+
+ if (!m) {
+ context$2$0.next = 15;
+ break;
+ }
+
+ context$2$0.next = 13;
+ return put(m.muxch(), value);
+
+ case 13:
+ stillOpen = context$2$0.sent;
+
+ if (!stillOpen) {
+ delete mults[topic];
+ }
+
+ case 15:
+ context$2$0.next = 0;
+ break;
+
+ case 17:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return p;
+}
+
+pub.sub = function sub(p, topic, ch, keepOpen) {
+ return p.sub(topic, ch, keepOpen);
+};
+
+pub.unsub = function unsub(p, topic, ch) {
+ p.unsub(topic, ch);
+};
+
+pub.unsubAll = function unsubAll(p, topic) {
+ p.unsubAll(topic);
+};
+
+module.exports = {
+ mapFrom: mapFrom,
+ mapInto: mapInto,
+ filterFrom: filterFrom,
+ filterInto: filterInto,
+ removeFrom: removeFrom,
+ removeInto: removeInto,
+ mapcatFrom: mapcatFrom,
+ mapcatInto: mapcatInto,
+
+ pipe: pipe,
+ split: split,
+ reduce: reduce,
+ onto: onto,
+ fromColl: fromColl,
+
+ map: map,
+ merge: merge,
+ into: into,
+ take: takeN,
+ unique: unique,
+ partition: partition,
+ partitionBy: partitionBy,
+
+ mult: mult,
+ mix: mix,
+ pub: pub
+};
+
+// Possible "fluid" interfaces:
+
+// thread(
+// [fromColl, [1, 2, 3, 4]],
+// [mapFrom, inc],
+// [into, []]
+// )
+
+// thread(
+// [fromColl, [1, 2, 3, 4]],
+// [mapFrom, inc, _],
+// [into, [], _]
+// )
+
+// wrap()
+// .fromColl([1, 2, 3, 4])
+// .mapFrom(inc)
+// .into([])
+// .unwrap();
+
+// FIX: Should be a generic looping interface (for...in?)
+
+// Remove closed channel
+// XXX: This is because putAsync can actually call back
+// immediately. Fix that
+// ... waiting for all puts to complete
\ No newline at end of file
diff --git a/dist/js-csp/src/csp.pipeline.js b/dist/js-csp/src/csp.pipeline.js
new file mode 100644
index 0000000..8764e7f
--- /dev/null
+++ b/dist/js-csp/src/csp.pipeline.js
@@ -0,0 +1,229 @@
+'use strict';
+
+var csp = require('./csp.core');
+
+function pipelineInternal(n, to, from, close, taskFn) {
+ if (n <= 0) {
+ throw new Error('n must be positive');
+ }
+
+ var jobs = csp.chan(n);
+ var results = csp.chan(n);
+
+ for (var _ = 0; _ < n; _++) {
+ csp.go(regeneratorRuntime.mark(function callee$1$0(taskFn, jobs, results) {
+ var job;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 9;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return csp.take(jobs);
+
+ case 3:
+ job = context$2$0.sent;
+
+ if (taskFn(job)) {
+ context$2$0.next = 7;
+ break;
+ }
+
+ results.close();
+ return context$2$0.abrupt('break', 9);
+
+ case 7:
+ context$2$0.next = 0;
+ break;
+
+ case 9:
+ case 'end':
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }), [taskFn, jobs, results]);
+ }
+
+ csp.go(regeneratorRuntime.mark(function callee$1$0(jobs, from, results) {
+ var v, p;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 16;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return csp.take(from);
+
+ case 3:
+ v = context$2$0.sent;
+
+ if (!(v === csp.CLOSED)) {
+ context$2$0.next = 9;
+ break;
+ }
+
+ jobs.close();
+ return context$2$0.abrupt('break', 16);
+
+ case 9:
+ p = csp.chan(1);
+ context$2$0.next = 12;
+ return csp.put(jobs, [v, p]);
+
+ case 12:
+ context$2$0.next = 14;
+ return csp.put(results, p);
+
+ case 14:
+ context$2$0.next = 0;
+ break;
+
+ case 16:
+ case 'end':
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }), [jobs, from, results]);
+
+ csp.go(regeneratorRuntime.mark(function callee$1$0(results, close, to) {
+ var p, res, v;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ if (!true) {
+ context$2$0.next = 26;
+ break;
+ }
+
+ context$2$0.next = 3;
+ return csp.take(results);
+
+ case 3:
+ p = context$2$0.sent;
+
+ if (!(p === csp.CLOSED)) {
+ context$2$0.next = 9;
+ break;
+ }
+
+ if (close) {
+ to.close();
+ }
+ return context$2$0.abrupt('break', 26);
+
+ case 9:
+ context$2$0.next = 11;
+ return csp.take(p);
+
+ case 11:
+ res = context$2$0.sent;
+
+ case 12:
+ if (!true) {
+ context$2$0.next = 24;
+ break;
+ }
+
+ context$2$0.next = 15;
+ return csp.take(res);
+
+ case 15:
+ v = context$2$0.sent;
+
+ if (!(v !== csp.CLOSED)) {
+ context$2$0.next = 21;
+ break;
+ }
+
+ context$2$0.next = 19;
+ return csp.put(to, v);
+
+ case 19:
+ context$2$0.next = 22;
+ break;
+
+ case 21:
+ return context$2$0.abrupt('break', 24);
+
+ case 22:
+ context$2$0.next = 12;
+ break;
+
+ case 24:
+ context$2$0.next = 0;
+ break;
+
+ case 26:
+ case 'end':
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }), [results, close, to]);
+
+ return to;
+}
+
+function pipeline(to, xf, from, keepOpen, exHandler) {
+
+ function taskFn(job) {
+ if (job === csp.CLOSED) {
+ return null;
+ } else {
+ var v = job[0];
+ var p = job[1];
+ var res = csp.chan(1, xf, exHandler);
+
+ csp.go(regeneratorRuntime.mark(function callee$2$0(res, v) {
+ return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) {
+ while (1) switch (context$3$0.prev = context$3$0.next) {
+ case 0:
+ context$3$0.next = 2;
+ return csp.put(res, v);
+
+ case 2:
+ res.close();
+
+ case 3:
+ case 'end':
+ return context$3$0.stop();
+ }
+ }, callee$2$0, this);
+ }), [res, v]);
+
+ csp.putAsync(p, res);
+
+ return true;
+ }
+ }
+
+ return pipelineInternal(1, to, from, !keepOpen, taskFn);
+}
+
+function pipelineAsync(n, to, af, from, keepOpen) {
+
+ function taskFn(job) {
+ if (job === csp.CLOSED) {
+ return null;
+ } else {
+ var v = job[0];
+ var p = job[1];
+ var res = csp.chan(1);
+ af(v, res);
+ csp.putAsync(p, res);
+ return true;
+ }
+ }
+
+ return pipelineInternal(n, to, from, !keepOpen, taskFn);
+}
+
+module.exports = {
+ pipeline: pipeline,
+ pipelineAsync: pipelineAsync
+};
\ No newline at end of file
diff --git a/dist/js-csp/src/csp.test-helpers.js b/dist/js-csp/src/csp.test-helpers.js
new file mode 100644
index 0000000..abca04a
--- /dev/null
+++ b/dist/js-csp/src/csp.test-helpers.js
@@ -0,0 +1,110 @@
+"use strict";
+
+var csp = require("./csp");
+var chan = csp.chan;
+var go = csp.go;
+var put = csp.put;
+var take = csp.take;
+
+var mocha = require("mocha");
+var it = mocha.it;
+
+function identity_chan(x) {
+ var ch = chan(1);
+ go(regeneratorRuntime.mark(function callee$1$0() {
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ context$2$0.next = 2;
+ return put(ch, x);
+
+ case 2:
+ ch.close();
+
+ case 3:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this);
+ }));
+ return ch;
+}
+
+function check(f, done) {
+ return (function () {
+ try {
+ f();
+ done();
+ } catch (e) {
+ done(e);
+ }
+ })();
+}
+
+// it("", g(function*() {
+// }));
+function g(f) {
+ return function (done) {
+ go(f, [done]);
+ };
+};
+
+function gg(f) {
+ return g(regeneratorRuntime.mark(function callee$1$0(done) {
+ var ch;
+ return regeneratorRuntime.wrap(function callee$1$0$(context$2$0) {
+ while (1) switch (context$2$0.prev = context$2$0.next) {
+ case 0:
+ context$2$0.prev = 0;
+ ch = go(f, []);
+ context$2$0.next = 4;
+ return take(ch);
+
+ case 4:
+ done();
+ context$2$0.next = 10;
+ break;
+
+ case 7:
+ context$2$0.prev = 7;
+ context$2$0.t0 = context$2$0["catch"](0);
+
+ done(context$2$0.t0);
+
+ case 10:
+ case "end":
+ return context$2$0.stop();
+ }
+ }, callee$1$0, this, [[0, 7]]);
+ }));
+}
+
+module.exports = {
+ identity_chan: identity_chan,
+ check: check,
+ goAsync: g,
+ go: gg,
+
+ // f must be a generator function. For now assertions should be inside f's
+ // top-level, not functions f may call (that works but a failing test
+ // may break following tests).
+ it: function it(desc, f) {
+ return mocha.it(desc, gg(f));
+ },
+
+ beforeEach: function beforeEach(f) {
+ return mocha.beforeEach(gg(f));
+ },
+
+ afterEach: function afterEach(f) {
+ return mocha.afterEach(gg(f));
+ },
+
+ before: function before(f) {
+ return mocha.before(gg(f));
+ },
+
+ after: function after(f) {
+ return mocha.after(gg(f));
+ }
+};
\ No newline at end of file
diff --git a/dist/js-csp/src/impl/buffers.js b/dist/js-csp/src/impl/buffers.js
new file mode 100644
index 0000000..15f7c73
--- /dev/null
+++ b/dist/js-csp/src/impl/buffers.js
@@ -0,0 +1,226 @@
+"use strict";
+
+// TODO: Consider EmptyError & FullError to avoid redundant bound
+// checks, to improve performance (may need benchmarks)
+
+function acopy(src, src_start, dst, dst_start, length) {
+ var count = 0;
+ while (true) {
+ if (count >= length) {
+ break;
+ }
+ dst[dst_start + count] = src[src_start + count];
+ count++;
+ }
+}
+
+function noop() {};
+
+var EMPTY = {
+ toString: function toString() {
+ return "[object EMPTY]";
+ }
+};
+
+var RingBuffer = function RingBuffer(head, tail, length, array) {
+ this.length = length;
+ this.array = array;
+ this.head = head;
+ this.tail = tail;
+};
+
+// Internal method, callers must do bound check
+RingBuffer.prototype._unshift = function (item) {
+ var array = this.array;
+ var head = this.head;
+ array[head] = item;
+ this.head = (head + 1) % array.length;
+ this.length++;
+};
+
+RingBuffer.prototype._resize = function () {
+ var array = this.array;
+ var new_length = 2 * array.length;
+ var new_array = new Array(new_length);
+ var head = this.head;
+ var tail = this.tail;
+ var length = this.length;
+ if (tail < head) {
+ acopy(array, tail, new_array, 0, length);
+ this.tail = 0;
+ this.head = length;
+ this.array = new_array;
+ } else if (tail > head) {
+ acopy(array, tail, new_array, 0, array.length - tail);
+ acopy(array, 0, new_array, array.length - tail, head);
+ this.tail = 0;
+ this.head = length;
+ this.array = new_array;
+ } else if (tail === head) {
+ this.tail = 0;
+ this.head = 0;
+ this.array = new_array;
+ }
+};
+
+RingBuffer.prototype.unbounded_unshift = function (item) {
+ if (this.length + 1 === this.array.length) {
+ this._resize();
+ }
+ this._unshift(item);
+};
+
+RingBuffer.prototype.pop = function () {
+ if (this.length === 0) {
+ return EMPTY;
+ }
+ var array = this.array;
+ var tail = this.tail;
+ var item = array[tail];
+ array[tail] = null;
+ this.tail = (tail + 1) % array.length;
+ this.length--;
+ return item;
+};
+
+RingBuffer.prototype.cleanup = function (predicate) {
+ var length = this.length;
+ for (var i = 0; i < length; i++) {
+ var item = this.pop();
+ if (predicate(item)) {
+ this._unshift(item);
+ }
+ }
+};
+
+var FixedBuffer = function FixedBuffer(buf, n) {
+ this.buf = buf;
+ this.n = n;
+};
+
+FixedBuffer.prototype.is_full = function () {
+ return this.buf.length >= this.n;
+};
+
+FixedBuffer.prototype.remove = function () {
+ return this.buf.pop();
+};
+
+FixedBuffer.prototype.add = function (item) {
+ // Note that even though the underlying buffer may grow, "n" is
+ // fixed so after overflowing the buffer is still considered full.
+ this.buf.unbounded_unshift(item);
+};
+
+FixedBuffer.prototype.count = function () {
+ return this.buf.length;
+};
+
+FixedBuffer.prototype.close = noop;
+
+var DroppingBuffer = function DroppingBuffer(buf, n) {
+ this.buf = buf;
+ this.n = n;
+};
+
+DroppingBuffer.prototype.is_full = function () {
+ return false;
+};
+
+DroppingBuffer.prototype.remove = function () {
+ return this.buf.pop();
+};
+
+DroppingBuffer.prototype.add = function (item) {
+ if (this.buf.length < this.n) {
+ this.buf._unshift(item);
+ }
+};
+
+DroppingBuffer.prototype.count = function () {
+ return this.buf.length;
+};
+
+DroppingBuffer.prototype.close = noop;
+
+var SlidingBuffer = function SlidingBuffer(buf, n) {
+ this.buf = buf;
+ this.n = n;
+};
+
+SlidingBuffer.prototype.is_full = function () {
+ return false;
+};
+
+SlidingBuffer.prototype.remove = function () {
+ return this.buf.pop();
+};
+
+SlidingBuffer.prototype.add = function (item) {
+ if (this.buf.length === this.n) {
+ this.buf.pop();
+ }
+ this.buf._unshift(item);
+};
+
+SlidingBuffer.prototype.count = function () {
+ return this.buf.length;
+};
+
+SlidingBuffer.prototype.close = noop;
+
+var PromiseBuffer = function PromiseBuffer() {
+ this.val = EMPTY;
+};
+
+PromiseBuffer.prototype.count = function () {
+ return this.val === EMPTY ? 0 : 1;
+};
+
+PromiseBuffer.prototype.add = function (item) {
+ if (this.val === EMPTY) {
+ this.val = item;
+ }
+};
+
+PromiseBuffer.prototype.is_full = function () {
+ return false;
+};
+
+PromiseBuffer.prototype.remove = function () {
+ return this.val;
+};
+
+PromiseBuffer.prototype.close = function () {
+ this.val = EMPTY;
+};
+
+var ring = exports.ring = function ring_buffer(n) {
+ return new RingBuffer(0, 0, 0, new Array(n));
+};
+
+/**
+ * Returns a buffer that is considered "full" when it reaches size n,
+ * but still accepts additional items, effectively allow overflowing.
+ * The overflowing behavior is useful for supporting "expanding"
+ * transducers, where we want to check if a buffer is full before
+ * running the transduced step function, while still allowing a
+ * transduced step to expand into multiple "essence" steps.
+ */
+exports.fixed = function fixed_buffer(n) {
+ return new FixedBuffer(ring(n), n);
+};
+
+exports.dropping = function dropping_buffer(n) {
+ return new DroppingBuffer(ring(n), n);
+};
+
+exports.sliding = function sliding_buffer(n) {
+ return new SlidingBuffer(ring(n), n);
+};
+
+exports.promise = function promise_buffer() {
+ return new PromiseBuffer();
+};
+
+exports.EMPTY = EMPTY;
\ No newline at end of file
diff --git a/dist/js-csp/src/impl/channels.js b/dist/js-csp/src/impl/channels.js
new file mode 100644
index 0000000..67afb64
--- /dev/null
+++ b/dist/js-csp/src/impl/channels.js
@@ -0,0 +1,324 @@
+"use strict";
+
+var buffers = require("./buffers");
+var dispatch = require("./dispatch");
+
+var MAX_DIRTY = 64;
+var MAX_QUEUE_SIZE = 1024;
+
+var CLOSED = null;
+
+var Box = function Box(value) {
+ this.value = value;
+};
+
+var PutBox = function PutBox(handler, value) {
+ this.handler = handler;
+ this.value = value;
+};
+
+var Channel = function Channel(takes, puts, buf, xform) {
+ this.buf = buf;
+ this.xform = xform;
+ this.takes = takes;
+ this.puts = puts;
+
+ this.dirty_takes = 0;
+ this.dirty_puts = 0;
+ this.closed = false;
+};
+
+function isReduced(v) {
+ return v && v["@@transducer/reduced"];
+}
+
+function schedule(f, v) {
+ dispatch.run(function () {
+ f(v);
+ });
+}
+
+Channel.prototype._put = function (value, handler) {
+ if (value === CLOSED) {
+ throw new Error("Cannot put CLOSED on a channel.");
+ }
+
+ // TODO: I'm not sure how this can happen, because the operations
+ // are registered in 1 tick, and the only way for this to be inactive
+ // is for a previous operation in the same alt to have returned
+ // immediately, which would have short-circuited to prevent this to
+ // be ever register anyway. The same thing goes for the active check
+ // in "_take".
+ if (!handler.is_active()) {
+ return null;
+ }
+
+ if (this.closed) {
+ handler.commit();
+ return new Box(false);
+ }
+
+ var taker, callback;
+
+ // Soak the value through the buffer first, even if there is a
+ // pending taker. This way the step function has a chance to act on the
+ // value.
+ if (this.buf && !this.buf.is_full()) {
+ handler.commit();
+ var done = isReduced(this.xform["@@transducer/step"](this.buf, value));
+ while (true) {
+ if (this.buf.count() === 0) {
+ break;
+ }
+ taker = this.takes.pop();
+ if (taker === buffers.EMPTY) {
+ break;
+ }
+ if (taker.is_active()) {
+ value = this.buf.remove();
+ callback = taker.commit();
+ schedule(callback, value);
+ }
+ }
+ if (done) {
+ this.close();
+ }
+ return new Box(true);
+ }
+
+ // Either the buffer is full, in which case there won't be any
+ // pending takes, or we don't have a buffer, in which case this loop
+ // fulfills the first of them that is active (note that we don't
+ // have to worry about transducers here since we require a buffer
+ // for that).
+ while (true) {
+ taker = this.takes.pop();
+ if (taker === buffers.EMPTY) {
+ break;
+ }
+ if (taker.is_active()) {
+ handler.commit();
+ callback = taker.commit();
+ schedule(callback, value);
+ return new Box(true);
+ }
+ }
+
+ // No buffer, full buffer, no pending takes. Queue this put now.
+ if (this.dirty_puts > MAX_DIRTY) {
+ this.puts.cleanup(function (putter) {
+ return putter.handler.is_active();
+ });
+ this.dirty_puts = 0;
+ } else {
+ this.dirty_puts++;
+ }
+ if (this.puts.length >= MAX_QUEUE_SIZE) {
+ throw new Error("No more than " + MAX_QUEUE_SIZE + " pending puts are allowed on a single channel.");
+ }
+ this.puts.unbounded_unshift(new PutBox(handler, value));
+ return null;
+};
+
+Channel.prototype._take = function (handler) {
+ if (!handler.is_active()) {
+ return null;
+ }
+
+ var putter, put_handler, callback, value;
+
+ if (this.buf && this.buf.count() > 0) {
+ handler.commit();
+ value = this.buf.remove();
+ // We need to check pending puts here, other wise they won't
+ // be able to proceed until their number reaches MAX_DIRTY
+ while (true) {
+ if (this.buf.is_full()) {
+ break;
+ }
+ putter = this.puts.pop();
+ if (putter === buffers.EMPTY) {
+ break;
+ }
+ put_handler = putter.handler;
+ if (put_handler.is_active()) {
+ callback = put_handler.commit();
+ if (callback) {
+ schedule(callback, true);
+ }
+ if (isReduced(this.xform["@@transducer/step"](this.buf, putter.value))) {
+ this.close();
+ }
+ }
+ }
+ return new Box(value);
+ }
+
+ // Either the buffer is empty, in which case there won't be any
+ // pending puts, or we don't have a buffer, in which case this loop
+ // fulfills the first of them that is active (note that we don't
+ // have to worry about transducers here since we require a buffer
+ // for that).
+ while (true) {
+ putter = this.puts.pop();
+ value = putter.value;
+ if (putter === buffers.EMPTY) {
+ break;
+ }
+ put_handler = putter.handler;
+ if (put_handler.is_active()) {
+ handler.commit();
+ callback = put_handler.commit();
+ if (callback) {
+ schedule(callback, true);
+ }
+ return new Box(value);
+ }
+ }
+
+ if (this.closed) {
+ handler.commit();
+ return new Box(CLOSED);
+ }
+
+ // No buffer, empty buffer, no pending puts. Queue this take now.
+ if (this.dirty_takes > MAX_DIRTY) {
+ this.takes.cleanup(function (handler) {
+ return handler.is_active();
+ });
+ this.dirty_takes = 0;
+ } else {
+ this.dirty_takes++;
+ }
+ if (this.takes.length >= MAX_QUEUE_SIZE) {
+ throw new Error("No more than " + MAX_QUEUE_SIZE + " pending takes are allowed on a single channel.");
+ }
+ this.takes.unbounded_unshift(handler);
+ return null;
+};
+
+Channel.prototype.close = function () {
+ if (this.closed) {
+ return;
+ }
+ this.closed = true;
+
+ // TODO: Duplicate code. Make a "_flush" function or something
+ if (this.buf) {
+ this.buf.close();
+ this.xform["@@transducer/result"](this.buf);
+ while (true) {
+ if (this.buf.count() === 0) {
+ break;
+ }
+ taker = this.takes.pop();
+ if (taker === buffers.EMPTY) {
+ break;
+ }
+ if (taker.is_active()) {
+ callback = taker.commit();
+ var value = this.buf.remove();
+ schedule(callback, value);
+ }
+ }
+ }
+
+ while (true) {
+ var taker = this.takes.pop();
+ if (taker === buffers.EMPTY) {
+ break;
+ }
+ if (taker.is_active()) {
+ var callback = taker.commit();
+ schedule(callback, CLOSED);
+ }
+ }
+
+ while (true) {
+ var putter = this.puts.pop();
+ if (putter === buffers.EMPTY) {
+ break;
+ }
+ if (putter.handler.is_active()) {
+ var put_callback = putter.handler.commit();
+ if (put_callback) {
+ schedule(put_callback, false);
+ }
+ }
+ }
+};
+
+Channel.prototype.is_closed = function () {
+ return this.closed;
+};
+
+function defaultHandler(e) {
+ console.log("error in channel transformer", e.stack);
+ return CLOSED;
+}
+
+function handleEx(buf, exHandler, e) {
+ var def = (exHandler || defaultHandler)(e);
+ if (def !== CLOSED) {
+ buf.add(def);
+ }
+ return buf;
+}
+
+// The base transformer object to use with transducers
+function AddTransformer() {}
+
+AddTransformer.prototype["@@transducer/init"] = function () {
+ throw new Error("init not available");
+};
+
+AddTransformer.prototype["@@transducer/result"] = function (v) {
+ return v;
+};
+
+AddTransformer.prototype["@@transducer/step"] = function (buffer, input) {
+ buffer.add(input);
+ return buffer;
+};
+
+function handleException(exHandler) {
+ return function (xform) {
+ return {
+ "@@transducer/step": function transducerStep(buffer, input) {
+ try {
+ return xform["@@transducer/step"](buffer, input);
+ } catch (e) {
+ return handleEx(buffer, exHandler, e);
+ }
+ },
+ "@@transducer/result": function transducerResult(buffer) {
+ try {
+ return xform["@@transducer/result"](buffer);
+ } catch (e) {
+ return handleEx(buffer, exHandler, e);
+ }
+ }
+ };
+ };
+}
+
+// XXX: This is inconsistent. We should either call the reducing
+// function xform, or call the transducer xform, not both
+exports.chan = function (buf, xform, exHandler) {
+ if (xform) {
+ if (!buf) {
+ throw new Error("Only buffered channels can use transducers");
+ }
+
+ xform = xform(new AddTransformer());
+ } else {
+ xform = new AddTransformer();
+ }
+ xform = handleException(exHandler)(xform);
+
+ return new Channel(buffers.ring(32), buffers.ring(32), buf, xform);
+};
+
+exports.Box = Box;
+exports.Channel = Channel;
+exports.CLOSED = CLOSED;
\ No newline at end of file
diff --git a/dist/js-csp/src/impl/dispatch.js b/dist/js-csp/src/impl/dispatch.js
new file mode 100644
index 0000000..9b72386
--- /dev/null
+++ b/dist/js-csp/src/impl/dispatch.js
@@ -0,0 +1,82 @@
+"use strict";
+
+// TODO: Use process.nextTick if it's available since it's more
+// efficient
+// http://howtonode.org/understanding-process-next-tick
+// Maybe we don't even need to queue ourselves in that case?
+
+// XXX: But http://blog.nodejs.org/2013/03/11/node-v0-10-0-stable/
+// Looks like it will blow up the stack (or is that just about
+// pre-empting IO (but that's already bad enough IMO)?)
+
+// Looks like
+// http://nodejs.org/api/process.html#process_process_nexttick_callback
+// is the equivalent of our TASK_BATCH_SIZE
+
+var buffers = require("./buffers");
+
+var TASK_BATCH_SIZE = 1024;
+
+var tasks = buffers.ring(32);
+var running = false;
+var queued = false;
+
+var queue_dispatcher;
+
+function process_messages() {
+ running = true;
+ queued = false;
+ var count = 0;
+ while (true) {
+ var task = tasks.pop();
+ if (task === buffers.EMPTY) {
+ break;
+ }
+ // TODO: Don't we need a try/finally here?
+ task();
+ if (count >= TASK_BATCH_SIZE) {
+ break;
+ }
+ count++;
+ }
+ running = false;
+ if (tasks.length > 0) {
+ queue_dispatcher();
+ }
+}
+
+if (typeof MessageChannel !== "undefined") {
+ var message_channel = new MessageChannel();
+ message_channel.port1.onmessage = function (_) {
+ process_messages();
+ };
+ queue_dispatcher = function () {
+ if (!(queued && running)) {
+ queued = true;
+ message_channel.port2.postMessage(0);
+ }
+ };
+} else if (typeof setImmediate !== "undefined") {
+ queue_dispatcher = function () {
+ if (!(queued && running)) {
+ queued = true;
+ setImmediate(process_messages);
+ }
+ };
+} else {
+ queue_dispatcher = function () {
+ if (!(queued && running)) {
+ queued = true;
+ setTimeout(process_messages, 0);
+ }
+ };
+}
+
+exports.run = function (f) {
+ tasks.unbounded_unshift(f);
+ queue_dispatcher();
+};
+
+exports.queue_delay = function (f, delay) {
+ setTimeout(f, delay);
+};
\ No newline at end of file
diff --git a/dist/js-csp/src/impl/process.js b/dist/js-csp/src/impl/process.js
new file mode 100644
index 0000000..4acedb9
--- /dev/null
+++ b/dist/js-csp/src/impl/process.js
@@ -0,0 +1,157 @@
+"use strict";
+
+var dispatch = require("./dispatch");
+var select = require("./select");
+var Channel = require("./channels").Channel;
+
+var FnHandler = function FnHandler(f) {
+ this.f = f;
+};
+
+FnHandler.prototype.is_active = function () {
+ return true;
+};
+
+FnHandler.prototype.commit = function () {
+ return this.f;
+};
+
+function put_then_callback(channel, value, callback) {
+ var result = channel._put(value, new FnHandler(callback));
+ if (result && callback) {
+ callback(result.value);
+ }
+}
+
+function take_then_callback(channel, callback) {
+ var result = channel._take(new FnHandler(callback));
+ if (result) {
+ callback(result.value);
+ }
+}
+
+var Process = function Process(gen, onFinish, creator) {
+ this.gen = gen;
+ this.creatorFunc = creator;
+ this.finished = false;
+ this.onFinish = onFinish;
+};
+
+var Instruction = function Instruction(op, data) {
+ this.op = op;
+ this.data = data;
+};
+
+var TAKE = "take";
+var PUT = "put";
+var SLEEP = "sleep";
+var ALTS = "alts";
+
+// TODO FIX XXX: This is a (probably) temporary hack to avoid blowing
+// up the stack, but it means double queueing when the value is not
+// immediately available
+Process.prototype._continue = function (response) {
+ var self = this;
+ dispatch.run(function () {
+ self.run(response);
+ });
+};
+
+Process.prototype._done = function (value) {
+ if (!this.finished) {
+ this.finished = true;
+ var onFinish = this.onFinish;
+ if (typeof onFinish === "function") {
+ dispatch.run(function () {
+ onFinish(value);
+ });
+ }
+ }
+};
+
+Process.prototype.run = function (response) {
+ if (this.finished) {
+ return;
+ }
+
+ // TODO: Shouldn't we (optionally) stop error propagation here (and
+ // signal the error through a channel or something)? Otherwise the
+ // uncaught exception will crash some runtimes (e.g. Node)
+ var iter = this.gen.next(response);
+ if (iter.done) {
+ this._done(iter.value);
+ return;
+ }
+
+ var ins = iter.value;
+ var self = this;
+
+ if (ins instanceof Instruction) {
+ switch (ins.op) {
+ case PUT:
+ var data = ins.data;
+ put_then_callback(data.channel, data.value, function (ok) {
+ self._continue(ok);
+ });
+ break;
+
+ case TAKE:
+ var channel = ins.data;
+ take_then_callback(channel, function (value) {
+ self._continue(value);
+ });
+ break;
+
+ case SLEEP:
+ var msecs = ins.data;
+ dispatch.queue_delay(function () {
+ self.run(null);
+ }, msecs);
+ break;
+
+ case ALTS:
+ select.do_alts(ins.data.operations, function (result) {
+ self._continue(result);
+ }, ins.data.options);
+ break;
+ }
+ } else if (ins instanceof Channel) {
+ var channel = ins;
+ take_then_callback(channel, function (value) {
+ self._continue(value);
+ });
+ } else {
+ this._continue(ins);
+ }
+};
+
+function take(channel) {
+ return new Instruction(TAKE, channel);
+}
+
+function put(channel, value) {
+ return new Instruction(PUT, {
+ channel: channel,
+ value: value
+ });
+}
+
+function sleep(msecs) {
+ return new Instruction(SLEEP, msecs);
+}
+
+function alts(operations, options) {
+ return new Instruction(ALTS, {
+ operations: operations,
+ options: options
+ });
+}
+
+exports.put_then_callback = put_then_callback;
+exports.take_then_callback = take_then_callback;
+exports.put = put;
+exports.take = take;
+exports.sleep = sleep;
+exports.alts = alts;
+exports.Instruction = Instruction;
+exports.Process = Process;
\ No newline at end of file
diff --git a/dist/js-csp/src/impl/select.js b/dist/js-csp/src/impl/select.js
new file mode 100644
index 0000000..9c48349
--- /dev/null
+++ b/dist/js-csp/src/impl/select.js
@@ -0,0 +1,105 @@
+"use strict";
+
+var Box = require("./channels").Box;
+
+var AltHandler = function AltHandler(flag, f) {
+ this.f = f;
+ this.flag = flag;
+};
+
+AltHandler.prototype.is_active = function () {
+ return this.flag.value;
+};
+
+AltHandler.prototype.commit = function () {
+ this.flag.value = false;
+ return this.f;
+};
+
+var AltResult = function AltResult(value, channel) {
+ this.value = value;
+ this.channel = channel;
+};
+
+function rand_int(n) {
+ return Math.floor(Math.random() * (n + 1));
+}
+
+function random_array(n) {
+ var a = new Array(n);
+ var i;
+ for (i = 0; i < n; i++) {
+ a[i] = 0;
+ }
+ for (i = 1; i < n; i++) {
+ var j = rand_int(i);
+ a[i] = a[j];
+ a[j] = i;
+ }
+ return a;
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var DEFAULT = {
+ toString: function toString() {
+ return "[object DEFAULT]";
+ }
+};
+
+// TODO: Accept a priority function or something
+exports.do_alts = function (operations, callback, options) {
+ var length = operations.length;
+ // XXX Hmm
+ if (length === 0) {
+ throw new Error("Empty alt list");
+ }
+
+ var priority = options && options.priority ? true : false;
+ if (!priority) {
+ var indexes = random_array(length);
+ }
+
+ var flag = new Box(true);
+
+ for (var i = 0; i < length; i++) {
+ var operation = operations[priority ? i : indexes[i]];
+ var port, result;
+ // XXX Hmm
+ if (operation instanceof Array) {
+ var value = operation[1];
+ port = operation[0];
+ // We wrap this in a function to capture the value of "port",
+ // because js' closure captures vars by "references", not
+ // values. "let port" would have worked, but I don't want to
+ // raise the runtime requirement yet. TODO: So change this when
+ // most runtimes are modern enough.
+ result = port._put(value, (function (port) {
+ return new AltHandler(flag, function (ok) {
+ callback(new AltResult(ok, port));
+ });
+ })(port));
+ } else {
+ port = operation;
+ result = port._take((function (port) {
+ return new AltHandler(flag, function (value) {
+ callback(new AltResult(value, port));
+ });
+ })(port));
+ }
+ // XXX Hmm
+ if (result instanceof Box) {
+ callback(new AltResult(result.value, port));
+ break;
+ }
+ }
+
+ if (!(result instanceof Box) && options && hasOwnProperty.call(options, "default")) {
+ if (flag.value) {
+ flag.value = false;
+ callback(new AltResult(options["default"], DEFAULT));
+ }
+ }
+};
+
+exports.DEFAULT = DEFAULT;
\ No newline at end of file
diff --git a/dist/js-csp/src/impl/timers.js b/dist/js-csp/src/impl/timers.js
new file mode 100644
index 0000000..a447ffb
--- /dev/null
+++ b/dist/js-csp/src/impl/timers.js
@@ -0,0 +1,12 @@
+"use strict";
+
+var dispatch = require("./dispatch");
+var channels = require("./channels");
+
+exports.timeout = function timeout_channel(msecs) {
+ var chan = channels.chan();
+ dispatch.queue_delay(function () {
+ chan.close();
+ }, msecs);
+ return chan;
+};
\ No newline at end of file
diff --git a/dist/mixin.js b/dist/mixin.js
deleted file mode 100644
index a4ab18f..0000000
--- a/dist/mixin.js
+++ /dev/null
@@ -1,91 +0,0 @@
-"use strict";
-
-var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
-
-var _ = _interopRequire(require("lodash"));
-
-var assign = _interopRequire(require("react/lib/Object.assign"));
-
-var Bluebird = _interopRequire(require("bluebird"));
-
-var React = _interopRequire(require("react"));
-
-var utils = _interopRequire(require("./utils"));
-
-module.exports = {
- contextTypes: {
- resolver: React.PropTypes.shape({
- promises: React.PropTypes.object.isRequired
- })
- },
-
- componentWillMount: function componentWillMount() {
- var _this = this;
-
- var id = utils.getElementId(this);
- var promise = utils.getElementPromise(this);
- var statics = utils.getElementStatics(this);
-
- if (!statics) {
- return false;
- }
-
- if (promise) {
- if (promise.isFulfilled()) {
- assign(this.props, promise.value());
-
- return true;
- } else {
- throw new Error(id + " should not be re-rendered until Promise is fulfilled! (This is a bug in react-resolver)");
- }
- }
-
- this.renderResolved = this.render.bind(this);
-
- // Disable rendering until component has props loaded
- this.render = function () {
- return false;
- };
-
- var pending = _.mapValues(statics, function (value, key) {
- // Existing props shouldn't be replaced
- if (_.has(_this.props, key)) {
- return Bluebird.resolve(_this.props[key]);
- }
-
- if (_.isFunction(value)) {
- // Call Node-style callback when complete
- if (value.length) {
- return new Bluebird((function (resolve, reject) {
- value.call(this, function (err, result) {
- err ? reject(err) : resolve(result);
- });
- }).bind(_this));
- }
-
- // Value is a synchronous function call
- return Bluebird.resolve(value.call(_this));
- }
- });
-
- this.context.resolver.promises[id] = Bluebird.props(pending);
- },
-
- componentDidMount: function componentDidMount() {
- var promise = utils.getElementPromise(this);
-
- if (!promise) {
- return false;
- }
-
- if (promise.isPending()) {
- return promise.then(this.componentDidMount.bind(this));
- }
-
- utils.removeElementPromise(this);
-
- assign(this.props, promise.value());
-
- this.render = this.renderResolved;
- this.forceUpdate();
- } };
\ No newline at end of file
diff --git a/dist/resolver.js b/dist/resolver.js
deleted file mode 100644
index fd2f095..0000000
--- a/dist/resolver.js
+++ /dev/null
@@ -1,251 +0,0 @@
-"use strict";
-
-var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; };
-
-var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
-
-var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-
-var _React = require("react");
-
-var _React2 = _interopRequireWildcard(_React);
-
-var _Container = require("./Container");
-
-var _Container2 = _interopRequireWildcard(_Container);
-
-var _ResolverError = require("./ResolverError");
-
-var _ResolverError2 = _interopRequireWildcard(_ResolverError);
-
-var Resolver = (function () {
- function Resolver() {
- var states = arguments[0] === undefined ? {} : arguments[0];
-
- _classCallCheck(this, Resolver);
-
- this.frozen = false;
- this.promises = [];
- this.states = states;
- }
-
- _createClass(Resolver, [{
- key: "await",
- value: function await() {
- var promises = arguments[0] === undefined ? [] : arguments[0];
-
- this.promises = this.promises.concat(promises);
-
- return Promise.all(promises);
- }
- }, {
- key: "finish",
- value: function finish() {
- var _this = this;
-
- var total = this.promises.length;
-
- return Promise.all(this.promises).then(function (values) {
- if (_this.promises.length > total) {
- return _this.finish();
- }
-
- return values;
- });
- }
- }, {
- key: "freeze",
- value: function freeze() {
- this.frozen = true;
- }
- }, {
- key: "fulfillState",
- value: function fulfillState(state, callback) {
- state.error = undefined;
- state.fulfilled = true;
- state.rejected = false;
-
- return callback ? callback(state) : state;
- }
- }, {
- key: "getContainerState",
- value: function getContainerState(container) {
- var id = container.id;
-
- if (!id) {
- throw new ReferenceError("" + container.constructor.displayName + " should have an ID");
- }
-
- var state = this.states.hasOwnProperty(id) ? this.states[id] : {
- fulfilled: false,
- rejected: false,
- values: {} };
-
- if (!this.states.hasOwnProperty(id)) {
- this.states[id] = state;
- }
-
- return state;
- }
- }, {
- key: "rejectState",
- value: function rejectState(error, state, callback) {
- state.error = error;
- state.fulfilled = false;
- state.rejected = true;
-
- if (callback) {
- callback(state);
- }
-
- throw new Error("" + this.constructor.displayName + " was rejected: " + error);
- }
- }, {
- key: "resolve",
- value: function resolve(container, callback) {
- var _this2 = this;
-
- var asyncProps = container.props.resolve || {};
- var state = this.getContainerState(container);
-
- var asyncKeys = Object.keys(asyncProps)
- // Assign existing prop values
- .filter(function (asyncProp) {
- if (container.props.hasOwnProperty(asyncProp)) {
- state.values[asyncProp] = container.props[asyncProp];
-
- return false;
- }
-
- return true;
- })
- // Filter out pre-loaded values
- .filter(function (asyncProp) {
- return !state.values.hasOwnProperty(asyncProp);
- });
-
- if (!asyncKeys.length) {
- return Promise.resolve(this.fulfillState(state, callback));
- }
-
- if (this.frozen) {
- throw new _ResolverError2["default"](["Resolver is frozen for server rendering.", "" + container.constructor.displayName + " (#" + container.id + ") should have already resolved", "\"" + asyncKeys.join("\", \"") + "\". (http://git.io/vvvkr)"].join(" "));
- }
-
- var promises = asyncKeys.map(function (prop) {
- var valueOf = container.props.resolve[prop];
- var value = container.props.hasOwnProperty(prop) ? container.props[prop] : valueOf(container.props);
-
- return Promise.resolve(value).then(function (value) {
- state.values[prop] = value;
-
- return value;
- });
- });
-
- return this.await(promises).then(function () {
- return _this2.fulfillState(state, callback);
- }, function (error) {
- return _this2.rejectState(error, state, callback);
- });
- }
- }], [{
- key: "createContainer",
- value: function createContainer(Component) {
- var props = arguments[1] === undefined ? {} : arguments[1];
-
- if (!Component.hasOwnProperty("displayName")) {
- throw new ReferenceError("Resolver.createContainer requires wrapped component to have `displayName`");
- }
-
- var ComponentContainer = (function (_React$Component) {
- function ComponentContainer() {
- _classCallCheck(this, ComponentContainer);
-
- if (_React$Component != null) {
- _React$Component.apply(this, arguments);
- }
- }
-
- _inherits(ComponentContainer, _React$Component);
-
- _createClass(ComponentContainer, [{
- key: "render",
- value: function render() {
- return _React2["default"].createElement(_Container2["default"], _extends({
- component: Component
- }, props, this.props));
- }
- }]);
-
- return ComponentContainer;
- })(_React2["default"].Component);
-
- ComponentContainer.displayName = "" + Component.displayName + "Container";
-
- return ComponentContainer;
- }
- }, {
- key: "render",
- value: function render(element, node) {
- var instance = arguments[2] === undefined ? new Resolver() : arguments[2];
-
- _React2["default"].render(_React2["default"].createElement(
- _Container2["default"],
- { resolver: instance },
- element
- ), node);
-
- return instance;
- }
- }, {
- key: "renderToString",
- value: function renderToString(element) {
- var resolver = new Resolver();
- var context = _React2["default"].createElement(
- _Container2["default"],
- { resolver: resolver },
- element
- );
-
- _React2["default"].renderToString(context);
-
- return resolver.finish().then(function () {
- resolver.freeze();
-
- return _React2["default"].renderToString(context);
- });
- }
- }, {
- key: "renderToStaticMarkup",
- value: function renderToStaticMarkup(element) {
- var resolver = new Resolver();
- var context = _React2["default"].createElement(
- _Container2["default"],
- { resolver: resolver },
- element
- );
-
- _React2["default"].renderToStaticMarkup(context);
-
- return resolver.finish().then(function () {
- resolver.freeze();
-
- return _React2["default"].renderToStaticMarkup(context);
- });
- }
- }]);
-
- return Resolver;
-})();
-
-exports["default"] = Resolver;
-module.exports = exports["default"];
\ No newline at end of file
diff --git a/dist/utils.js b/dist/utils.js
deleted file mode 100644
index 348455b..0000000
--- a/dist/utils.js
+++ /dev/null
@@ -1,32 +0,0 @@
-"use strict";
-
-module.exports.getElementId = function (element) {
- return element._rootNodeID.replace(/\.\w+/, element.constructor.displayName + ".promise");
-};
-
-module.exports.getElementPromise = function (element) {
- var id = module.exports.getElementId(element);
-
- return element.context.resolver.promises[id];
-};
-
-module.exports.getElementStatics = function (element) {
- return element.constructor.resolve;
-};
-
-module.exports.removeElementPromise = function (element) {
- var id = module.exports.getElementId(element);
- var promise = module.exports.getElementPromise(element);
-
- element.context.resolver.promises[id] = null;
-
- return promise;
-};
-
-module.exports.setElementPromise = function (element, promise) {
- var id = module.exports.getElementId(element);
-
- element.context.resolver.promises[id] = promise;
-
- return promise;
-};
\ No newline at end of file
diff --git a/examples/stargazers/README.md b/examples/stargazers/README.md
index ef174ae..a6130dc 100644
--- a/examples/stargazers/README.md
+++ b/examples/stargazers/README.md
@@ -2,22 +2,10 @@
### Usage
-In the root of the `react-resolver` project, `npm link` this version:
-
-```shell
-react-resolver $ npm link .
-```
-
-From within this example directory, install dependencies and reference this version:
-
```shell
-react-resolver $ cd examples/contacts
-react-resolver/examples/contacts $ npm install
-react-resolver/examples/contacts $ npm link react-resolver
+react-resolver $ cd examples/stargazers
+react-resolver/examples/stargazers $ npm install
+react-resolver/examples/stargazers $ npm start
```
-Now you're ready to run the example:
-
-```shell
-react-resolver/examples/contacts $ npm start
-```
+Open .
diff --git a/examples/stargazers/components/Nav.js b/examples/stargazers/components/Nav.js
index 46dec75..76bbf3a 100644
--- a/examples/stargazers/components/Nav.js
+++ b/examples/stargazers/components/Nav.js
@@ -1,3 +1,4 @@
+import { Link } from "react-router";
import React from "react";
export default class Nav extends React.Component {
@@ -6,12 +7,7 @@ export default class Nav extends React.Component {
diff --git a/examples/stargazers/components/Stargazers.js b/examples/stargazers/components/Stargazers.js
index c1d659b..4b7e074 100644
--- a/examples/stargazers/components/Stargazers.js
+++ b/examples/stargazers/components/Stargazers.js
@@ -1,7 +1,7 @@
import axios from "axios";
import React from "react";
-
import { Resolver } from "react-resolver";
+import { Link } from "react-router";
class Stargazers extends React.Component {
render() {
@@ -16,7 +16,8 @@ class Stargazers extends React.Component {
+ );
+ }
+}
+
+User.displayName = "User";
+
+export default Resolver.createContainer(User, {
+ contextTypes: {
+ router: React.PropTypes.func.isRequired,
+ },
+
+ resolve: {
+ user: (props, context) => {
+ const { login } = context.router.getCurrentParams();
+ const url = `https://api.github.com/users/${login}`;
+
+ return axios.get(url).then(response => response.data);
+ },
+ },
+});
diff --git a/examples/stargazers/package.json b/examples/stargazers/package.json
index 7e465e7..ee25ffd 100644
--- a/examples/stargazers/package.json
+++ b/examples/stargazers/package.json
@@ -4,7 +4,7 @@
"scripts": {
"build": "webpack -p",
"postinstall": "npm run build",
- "preinstall": "rm -rf node_modules/react-resolver && cp -R ../../dist node_modules/react-resolver",
+ "install": "rm -rf node_modules/react-resolver && cp -R ../../dist node_modules/react-resolver",
"start": "webpack-dev-server --content-base ./public --hot --inline --no-info --devtool inline-source-map"
},
"dependencies": {
diff --git a/examples/stargazers/public/main.min.js b/examples/stargazers/public/main.min.js
index 523fc22..44fa2c9 100644
--- a/examples/stargazers/public/main.min.js
+++ b/examples/stargazers/public/main.min.js
@@ -1,7 +1,6 @@
-!function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={exports:{},id:r,loaded:!1};return e[r].call(o.exports,o,o.exports,t),o.loaded=!0,o.exports}var n={};return t.m=e,t.c=n,t.p="",t(0)}([function(e,t,n){"use strict";var r=function(e){return e&&e.__esModule?e:{"default":e}},o=n(7),i=r(o),a=n(75),s=n(49),u=r(s),c=n(73),l=r(c),p=n(135),d=r(p);l["default"].polyfill(),u["default"].run(d["default"],function(e){a.Resolver.render(i["default"].createElement(e,null),document.getElementById("app"))})},function(e,t,n){function r(){if(!s){s=!0;for(var e,t=a.length;t;){e=a,a=[];for(var n=-1;++nr;r++)n.push(arguments[r]);if(void 0===t)throw new Error("`warning(condition, format, ...args)` requires a warning message argument");if(t.length<10||/^[s\W]*$/.test(t))throw new Error("The warning format should be able to uniquely identify this warning. Please, use a more descriptive format than: "+t);if(0!==t.indexOf("Failed Composite propType: ")&&!e){var i=0,a="Warning: "+t.replace(/%s/g,function(){return n[i++]});console.warn(a);try{throw new Error(a)}catch(s){}}}),e.exports=o}).call(t,n(1))},function(e,t,n){(function(t){"use strict";function r(e,n){Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:function(){return this._store?this._store[n]:null},set:function(e){"production"!==t.env.NODE_ENV?u(!1,"Don't set the %s property of the React element. Instead, specify the correct value when initially creating the element.",n):null,this._store[n]=e}})}function o(e){try{var t={props:!0};for(var n in t)r(e,n);l=!0}catch(o){}}var i=n(57),a=n(18),s=n(3),u=n(4),c={key:!0,ref:!0},l=!1,p=function(e,n,r,o,i,a){if(this.type=e,this.key=n,this.ref=r,this._owner=o,this._context=i,"production"!==t.env.NODE_ENV){this._store={props:a,originalProps:s({},a)};try{Object.defineProperty(this._store,"validated",{configurable:!1,enumerable:!1,writable:!0})}catch(u){}if(this._store.validated=!1,l)return void Object.freeze(this)}this.props=a};p.prototype={_isReactElement:!0},"production"!==t.env.NODE_ENV&&o(p.prototype),p.createElement=function(e,t,n){var r,o={},s=null,u=null;if(null!=t){u=void 0===t.ref?null:t.ref,s=void 0===t.key?null:""+t.key;for(r in t)t.hasOwnProperty(r)&&!c.hasOwnProperty(r)&&(o[r]=t[r])}var l=arguments.length-2;if(1===l)o.children=n;else if(l>1){for(var d=Array(l),f=0;l>f;f++)d[f]=arguments[f+2];o.children=d}if(e&&e.defaultProps){var h=e.defaultProps;for(r in h)"undefined"==typeof o[r]&&(o[r]=h[r])}return new p(e,s,u,a.current,i.current,o)},p.createFactory=function(e){var t=p.createElement.bind(null,e);return t.type=e,t},p.cloneAndReplaceProps=function(e,n){var r=new p(e.type,e.key,e.ref,e._owner,e._context,n);return"production"!==t.env.NODE_ENV&&(r._store.validated=e._store.validated),r},p.cloneElement=function(e,t,n){var r,o=s({},e.props),i=e.key,u=e.ref,l=e._owner;if(null!=t){void 0!==t.ref&&(u=t.ref,l=a.current),void 0!==t.key&&(i=""+t.key);for(r in t)t.hasOwnProperty(r)&&!c.hasOwnProperty(r)&&(o[r]=t[r])}var d=arguments.length-2;if(1===d)o.children=n;else if(d>1){for(var f=Array(d),h=0;d>h;h++)f[h]=arguments[h+2];o.children=f}return new p(e.type,i,u,l,e._context,o)},p.isValidElement=function(e){var t=!(!e||!e._isReactElement);return t},e.exports=p}).call(t,n(1))},function(e,t,n){"use strict";var r=!("undefined"==typeof window||!window.document||!window.document.createElement),o={canUseDOM:r,canUseWorkers:"undefined"!=typeof Worker,canUseEventListeners:r&&!(!window.addEventListener&&!window.attachEvent),canUseViewport:r&&!!window.screen,isInWorker:!r};e.exports=o},function(e,t,n){e.exports=n(23)},function(e,t,n){"use strict";var r=n(36),o=r({bubbled:null,captured:null}),i=r({topBlur:null,topChange:null,topClick:null,topCompositionEnd:null,topCompositionStart:null,topCompositionUpdate:null,topContextMenu:null,topCopy:null,topCut:null,topDoubleClick:null,topDrag:null,topDragEnd:null,topDragEnter:null,topDragExit:null,topDragLeave:null,topDragOver:null,topDragStart:null,topDrop:null,topError:null,topFocus:null,topInput:null,topKeyDown:null,topKeyPress:null,topKeyUp:null,topLoad:null,topMouseDown:null,topMouseMove:null,topMouseOut:null,topMouseOver:null,topMouseUp:null,topPaste:null,topReset:null,topScroll:null,topSelectionChange:null,topSubmit:null,topTextInput:null,topTouchCancel:null,topTouchEnd:null,topTouchMove:null,topTouchStart:null,topWheel:null}),a={topLevelTypes:i,PropagationPhases:o};e.exports=a},function(e,t,n){(function(t){"use strict";function r(e,n,r){for(var o in n)n.hasOwnProperty(o)&&("production"!==t.env.NODE_ENV?D("function"==typeof n[o],"%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.",e.displayName||"ReactClass",E[r],o):null)}function o(e,n){var r=T.hasOwnProperty(n)?T[n]:null;I.hasOwnProperty(n)&&("production"!==t.env.NODE_ENV?N(r===x.OVERRIDE_BASE,"ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.",n):N(r===x.OVERRIDE_BASE)),e.hasOwnProperty(n)&&("production"!==t.env.NODE_ENV?N(r===x.DEFINE_MANY||r===x.DEFINE_MANY_MERGED,"ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.",n):N(r===x.DEFINE_MANY||r===x.DEFINE_MANY_MERGED))}function i(e,n){if(n){"production"!==t.env.NODE_ENV?N("function"!=typeof n,"ReactClass: You're attempting to use a component class as a mixin. Instead, just use a regular object."):N("function"!=typeof n),"production"!==t.env.NODE_ENV?N(!h.isValidElement(n),"ReactClass: You're attempting to use a component as a mixin. Instead, just use a regular object."):N(!h.isValidElement(n));var r=e.prototype;n.hasOwnProperty(O)&&P.mixins(e,n.mixins);for(var i in n)if(n.hasOwnProperty(i)&&i!==O){var a=n[i];if(o(r,i),P.hasOwnProperty(i))P[i](e,a);else{var s=T.hasOwnProperty(i),l=r.hasOwnProperty(i),p=a&&a.__reactDontBind,d="function"==typeof a,f=d&&!s&&!l&&!p;if(f)r.__reactAutoBindMap||(r.__reactAutoBindMap={}),r.__reactAutoBindMap[i]=a,r[i]=a;else if(l){var m=T[i];"production"!==t.env.NODE_ENV?N(s&&(m===x.DEFINE_MANY_MERGED||m===x.DEFINE_MANY),"ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.",m,i):N(s&&(m===x.DEFINE_MANY_MERGED||m===x.DEFINE_MANY)),m===x.DEFINE_MANY_MERGED?r[i]=u(r[i],a):m===x.DEFINE_MANY&&(r[i]=c(r[i],a))}else r[i]=a,"production"!==t.env.NODE_ENV&&"function"==typeof a&&n.displayName&&(r[i].displayName=n.displayName+"_"+i)}}}}function a(e,n){if(n)for(var r in n){var o=n[r];if(n.hasOwnProperty(r)){var i=r in P;"production"!==t.env.NODE_ENV?N(!i,'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.',r):N(!i);var a=r in e;"production"!==t.env.NODE_ENV?N(!a,"ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.",r):N(!a),e[r]=o}}}function s(e,n){"production"!==t.env.NODE_ENV?N(e&&n&&"object"==typeof e&&"object"==typeof n,"mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects."):N(e&&n&&"object"==typeof e&&"object"==typeof n);for(var r in n)n.hasOwnProperty(r)&&("production"!==t.env.NODE_ENV?N(void 0===e[r],"mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.",r):N(void 0===e[r]),e[r]=n[r]);return e}function u(e,t){return function(){var n=e.apply(this,arguments),r=t.apply(this,arguments);if(null==n)return r;if(null==r)return n;var o={};return s(o,n),s(o,r),o}}function c(e,t){return function(){e.apply(this,arguments),t.apply(this,arguments)}}function l(e,n){var r=n.bind(e);if("production"!==t.env.NODE_ENV){r.__reactBoundContext=e,r.__reactBoundMethod=n,r.__reactBoundArguments=null;var o=e.constructor.displayName,i=r.bind;r.bind=function(a){for(var s=[],u=1,c=arguments.length;c>u;u++)s.push(arguments[u]);if(a!==e&&null!==a)"production"!==t.env.NODE_ENV?D(!1,"bind(): React component methods may only be bound to the component instance. See %s",o):null;else if(!s.length)return"production"!==t.env.NODE_ENV?D(!1,"bind(): You are binding a component method to the component. React does this for you automatically in a high-performance way, so you can safely remove this call. See %s",o):null,r;var l=i.apply(r,arguments);return l.__reactBoundContext=e,l.__reactBoundMethod=n,l.__reactBoundArguments=s,l}}return r}function p(e){for(var t in e.__reactAutoBindMap)if(e.__reactAutoBindMap.hasOwnProperty(t)){var n=e.__reactAutoBindMap[t];e[t]=l(e,m.guard(n,e.constructor.displayName+"."+t))}}var d=n(92),f=n(18),h=n(5),m=n(186),v=n(26),y=n(59),g=n(60),E=n(42),b=n(61),_=n(3),N=n(2),C=n(36),w=n(13),D=n(4),O=w({mixins:null}),x=C({DEFINE_ONCE:null,DEFINE_MANY:null,OVERRIDE_BASE:null,DEFINE_MANY_MERGED:null}),R=[],T={mixins:x.DEFINE_MANY,statics:x.DEFINE_MANY,propTypes:x.DEFINE_MANY,contextTypes:x.DEFINE_MANY,childContextTypes:x.DEFINE_MANY,getDefaultProps:x.DEFINE_MANY_MERGED,getInitialState:x.DEFINE_MANY_MERGED,getChildContext:x.DEFINE_MANY_MERGED,render:x.DEFINE_ONCE,componentWillMount:x.DEFINE_MANY,componentDidMount:x.DEFINE_MANY,componentWillReceiveProps:x.DEFINE_MANY,shouldComponentUpdate:x.DEFINE_ONCE,componentWillUpdate:x.DEFINE_MANY,componentDidUpdate:x.DEFINE_MANY,componentWillUnmount:x.DEFINE_MANY,updateComponent:x.OVERRIDE_BASE},P={displayName:function(e,t){e.displayName=t},mixins:function(e,t){if(t)for(var n=0;nr;r++){var o=E[r],i=o._pendingCallbacks;if(o._pendingCallbacks=null,h.performUpdateIfNecessary(o,e.reconcileTransaction),i)for(var s=0;sr;r++)if(e.charAt(r)!==t.charAt(r))return r;return e.length===t.length?-1:n}function o(e){var t=M(e);return t&&z.getID(t)}function i(e){var n=a(e);if(n)if(U.hasOwnProperty(n)){var r=U[n];r!==e&&("production"!==t.env.NODE_ENV?S(!l(r,n),"ReactMount: Two valid but unequal nodes with the same `%s`: %s",j,n):S(!l(r,n)),U[n]=e)}else U[n]=e;return n}function a(e){return e&&e.getAttribute&&e.getAttribute(j)||""}function s(e,t){var n=a(e);n!==t&&delete U[n],e.setAttribute(j,t),U[t]=e}function u(e){return U.hasOwnProperty(e)&&l(U[e],e)||(U[e]=z.findReactNodeByID(e)),U[e]}function c(e){var t=C.get(e)._rootNodeID;return _.isNullComponentID(t)?null:(U.hasOwnProperty(t)&&l(U[t],t)||(U[t]=z.findReactNodeByID(t)),U[t])}function l(e,n){if(e){"production"!==t.env.NODE_ENV?S(a(e)===n,"ReactMount: Unexpected modification of `%s`",j):S(a(e)===n);var r=z.findReactContainerForID(n);if(r&&P(r,e))return!0}return!1}function p(e){delete U[e]}function d(e){var t=U[e];return t&&l(t,e)?void(Y=t):!1}function f(e){Y=null,N.traverseAncestors(e,d);var t=Y;return Y=null,t}function h(e,t,n,r,o){var i=O.mountComponent(e,t,r,T);e._isTopLevel=!0,z._mountImageIntoNode(i,n,o)}function m(e,t,n,r){var o=R.ReactReconcileTransaction.getPooled();o.perform(h,null,e,t,n,o,r),R.ReactReconcileTransaction.release(o)}var v=n(22),y=n(24),g=n(18),E=n(5),b=n(34),_=n(40),N=n(25),C=n(26),w=n(98),D=n(19),O=n(31),x=n(61),R=n(10),T=n(45),P=n(106),M=n(226),I=n(67),S=n(2),k=n(69),A=n(70),V=n(4),L=N.SEPARATOR,j=v.ID_ATTRIBUTE_NAME,U={},F=1,B=9,W={},H={};if("production"!==t.env.NODE_ENV)var q={};var K=[],Y=null,z={_instancesByReactRootID:W,scrollMonitor:function(e,t){t()},_updateRootComponent:function(e,n,r,i){return"production"!==t.env.NODE_ENV&&b.checkAndWarnForMutatedProps(n),z.scrollMonitor(r,function(){x.enqueueElementInternal(e,n),i&&x.enqueueCallbackInternal(e,i)}),"production"!==t.env.NODE_ENV&&(q[o(r)]=M(r)),e},_registerComponent:function(e,n){"production"!==t.env.NODE_ENV?S(n&&(n.nodeType===F||n.nodeType===B),"_registerComponent(...): Target container is not a DOM element."):S(n&&(n.nodeType===F||n.nodeType===B)),y.ensureScrollValueMonitoring();var r=z.registerContainer(n);return W[r]=e,r},_renderNewRootComponent:function(e,n,r){"production"!==t.env.NODE_ENV?V(null==g.current,"_renderNewRootComponent(): Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate."):null;var o=I(e,null),i=z._registerComponent(o,n);return R.batchedUpdates(m,o,i,n,r),"production"!==t.env.NODE_ENV&&(q[i]=M(n)),o},render:function(e,n,r){"production"!==t.env.NODE_ENV?S(E.isValidElement(e),"React.render(): Invalid component element.%s","string"==typeof e?" Instead of passing an element string, make sure to instantiate it by passing it to React.createElement.":"function"==typeof e?" Instead of passing a component class, make sure to instantiate it by passing it to React.createElement.":null!=e&&void 0!==e.props?" This may be caused by unintentionally loading two independent copies of React.":""):S(E.isValidElement(e));var i=W[o(n)];if(i){var a=i._currentElement;if(A(a,e))return z._updateRootComponent(i,e,n,r).getPublicInstance();z.unmountComponentAtNode(n)}var s=M(n),u=s&&z.isRenderedByReact(s);if("production"!==t.env.NODE_ENV&&(!u||s.nextSibling))for(var c=s;c;){if(z.isRenderedByReact(c)){"production"!==t.env.NODE_ENV?V(!1,"render(): Target node has markup rendered by React, but there are unrelated nodes as well. This is most commonly caused by white-space inserted around server-rendered markup."):null;break}c=c.nextSibling}var l=u&&!i,p=z._renderNewRootComponent(e,n,l).getPublicInstance();return r&&r.call(p),p},constructAndRenderComponent:function(e,t,n){var r=E.createElement(e,t);return z.render(r,n)},constructAndRenderComponentByID:function(e,n,r){var o=document.getElementById(r);return"production"!==t.env.NODE_ENV?S(o,'Tried to get element with id of "%s" but it is not present on the page.',r):S(o),z.constructAndRenderComponent(e,n,o)},registerContainer:function(e){var t=o(e);return t&&(t=N.getReactRootIDFromNodeID(t)),t||(t=N.createReactRootID()),H[t]=e,t},unmountComponentAtNode:function(e){"production"!==t.env.NODE_ENV?V(null==g.current,"unmountComponentAtNode(): Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate."):null,"production"!==t.env.NODE_ENV?S(e&&(e.nodeType===F||e.nodeType===B),"unmountComponentAtNode(...): Target container is not a DOM element."):S(e&&(e.nodeType===F||e.nodeType===B));var n=o(e),r=W[n];return r?(z.unmountComponentFromNode(r,e),delete W[n],delete H[n],"production"!==t.env.NODE_ENV&&delete q[n],!0):!1},unmountComponentFromNode:function(e,t){for(O.unmountComponent(e),t.nodeType===B&&(t=t.documentElement);t.lastChild;)t.removeChild(t.lastChild)},findReactContainerForID:function(e){var n=N.getReactRootIDFromNodeID(e),r=H[n];if("production"!==t.env.NODE_ENV){var o=q[n];if(o&&o.parentNode!==r){"production"!==t.env.NODE_ENV?S(a(o)===n,"ReactMount: Root element ID differed from reactRootID."):S(a(o)===n);var i=r.firstChild;i&&n===a(i)?q[n]=i:"production"!==t.env.NODE_ENV?V(!1,"ReactMount: Root element has been removed from its original container. New container:",o.parentNode):null}}return r},findReactNodeByID:function(e){var t=z.findReactContainerForID(e);return z.findComponentRoot(t,e)},isRenderedByReact:function(e){if(1!==e.nodeType)return!1;var t=z.getID(e);return t?t.charAt(0)===L:!1},getFirstReactDOM:function(e){for(var t=e;t&&t.parentNode!==t;){if(z.isRenderedByReact(t))return t;t=t.parentNode}return null},findComponentRoot:function(e,n){var r=K,o=0,i=f(n)||e;for(r[0]=i.firstChild,r.length=1;o when using tables, nesting tags like