Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

torrent-project/node_modules/material-ui/node_modules/change-emitter/README.md

@@ -0,0 +1,53 @@
+change-emitter
+==============
+
+[![build status](https://img.shields.io/travis/acdlite/change-emitter/master.svg?style=flat-square)](https://travis-ci.org/acdlite/change-emitter)
+[![npm version](https://img.shields.io/npm/v/change-emitter.svg?style=flat-square)](https://www.npmjs.com/package/change-emitter)
+
+Listen for changes. Like an event emitter that only emits a single event type. Really tiny.
+
+I extracted this from Redux's `createStore()` because I found it to be useful in other contexts. Use it where you want the most minimal event subscription implementation possible.
+
+## Usage
+
+```js
+import { createChangeEmitter } from 'change-emitter'
+
+const emitter = createChangeEmitter()
+
+// Called `listen` instead of `subscribe` to avoid confusion with observable spec
+const unlisten = emitter.listen((...args) => {
+  console.log(args)
+})
+
+emitter.emit(1, 2, 3) // logs `[1, 2, 3]`
+unlisten()
+emitter.emit(4, 5, 6) // doesn't log
+```
+
+## Larger example
+
+Here's a (partial) implementation of Redux's `createStore`:
+
+```js
+const createStore = (reducer, initialState) => {
+  let state = initialState
+  const emitter = createChangeEmitter()
+
+  function dispatch(action) {
+    state = reducer(state, action)
+    emitter.emit()
+    return action
+  }
+
+  function getState() {
+    return state
+  }
+
+  return {
+    dispatch,
+    getState,
+    subscribe: emitter.listen
+  }
+}
+```

torrent-project/node_modules/material-ui/node_modules/change-emitter/lib/__tests__/createChangeEmitter-test.js

@@ -0,0 +1,232 @@
+'use strict';
+
+var _ava = require('ava');
+
+var _ava2 = _interopRequireDefault(_ava);
+
+var _ = require('../');
+
+var _sinon = require('sinon');
+
+var _sinon2 = _interopRequireDefault(_sinon);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _ava2.default)('calls listeners with arguments passed to emit()', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+  var calledWith = void 0;
+  emitter.listen(function () {
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    calledWith = args;
+  });
+  emitter.emit('a', 'b', 'c');
+  t.deepEqual(calledWith, ['a', 'b', 'c']);
+});
+
+(0, _ava2.default)('supports multiple listeners', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+  var listenerA = _sinon2.default.spy();
+  var listenerB = _sinon2.default.spy();
+
+  var unlistenA = emitter.listen(listenerA);
+  emitter.emit();
+  t.is(listenerA.callCount, 1);
+  t.is(listenerB.callCount, 0);
+
+  emitter.emit();
+  t.is(listenerA.callCount, 2);
+  t.is(listenerB.callCount, 0);
+
+  var unlistenB = emitter.listen(listenerB);
+  t.is(listenerA.callCount, 2);
+  t.is(listenerB.callCount, 0);
+
+  emitter.emit();
+  t.is(listenerA.callCount, 3);
+  t.is(listenerB.callCount, 1);
+
+  unlistenA();
+  t.is(listenerA.callCount, 3);
+  t.is(listenerB.callCount, 1);
+
+  emitter.emit();
+  t.is(listenerA.callCount, 3);
+  t.is(listenerB.callCount, 2);
+
+  unlistenB();
+  t.is(listenerA.callCount, 3);
+  t.is(listenerB.callCount, 2);
+
+  emitter.emit();
+  t.is(listenerA.callCount, 3);
+  t.is(listenerB.callCount, 2);
+
+  unlistenA = emitter.listen(listenerA);
+  t.is(listenerA.callCount, 3);
+  t.is(listenerB.callCount, 2);
+
+  emitter.emit();
+  t.is(listenerA.callCount, 4);
+  t.is(listenerB.callCount, 2);
+});
+
+(0, _ava2.default)('only removes listener once when unlisten is called', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+  var listenerA = _sinon2.default.spy();
+  var listenerB = _sinon2.default.spy();
+
+  var unlistenA = emitter.listen(listenerA);
+  emitter.listen(listenerB);
+
+  unlistenA();
+  unlistenA();
+
+  emitter.emit();
+  t.is(listenerA.callCount, 0);
+  t.is(listenerB.callCount, 1);
+});
+
+(0, _ava2.default)('only removes relevant listener when unlisten is called', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+  var listener = _sinon2.default.spy();
+
+  emitter.listen(listener);
+  var unlisten = emitter.listen(listener);
+
+  unlisten();
+  unlisten();
+
+  emitter.emit();
+  t.is(listener.callCount, 1);
+});
+
+(0, _ava2.default)('supports unlistening within a listener', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+  var listenerA = _sinon2.default.spy();
+  var listenerB = _sinon2.default.spy();
+  var listenerC = _sinon2.default.spy();
+
+  emitter.listen(listenerA);
+  var unlistenB = emitter.listen(function () {
+    listenerB();
+    unlistenB();
+  });
+  emitter.listen(listenerC);
+
+  emitter.emit();
+  emitter.emit();
+
+  t.is(listenerA.callCount, 2);
+  t.is(listenerB.callCount, 1);
+  t.is(listenerC.callCount, 2);
+});
+
+(0, _ava2.default)('when a listener is removed from inside another listener, it is still ' + 'called for the current change', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+
+  var unlistens = [];
+  var unlistenAll = function unlistenAll() {
+    return unlistens.forEach(function (unlisten) {
+      return unlisten();
+    });
+  };
+
+  var listener1 = _sinon2.default.spy();
+  var listener2 = _sinon2.default.spy();
+  var listener3 = _sinon2.default.spy();
+
+  unlistens.push(emitter.listen(listener1));
+  unlistens.push(emitter.listen(function () {
+    listener2();
+    unlistenAll();
+  }));
+  unlistens.push(emitter.listen(listener3));
+
+  emitter.emit();
+  t.is(listener1.callCount, 1);
+  t.is(listener2.callCount, 1);
+  t.is(listener3.callCount, 1); // Still called
+
+  // Confirm all listeners were removed
+  emitter.emit();
+  t.is(listener1.callCount, 1);
+  t.is(listener2.callCount, 1);
+  t.is(listener3.callCount, 1);
+});
+
+(0, _ava2.default)('when listener is added inside another listener, the new listener is ' + 'not called for the current change', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+
+  var listener1 = _sinon2.default.spy();
+  var listener2 = _sinon2.default.spy();
+  var listener3 = _sinon2.default.spy();
+
+  var listener3Added = false;
+  var maybeAddThirdListener = function maybeAddThirdListener() {
+    if (!listener3Added) {
+      listener3Added = true;
+      emitter.listen(listener3);
+    }
+  };
+
+  emitter.listen(listener1);
+  emitter.listen(function () {
+    listener2();
+    maybeAddThirdListener();
+  });
+
+  emitter.emit();
+  t.is(listener1.callCount, 1);
+  t.is(listener2.callCount, 1);
+  t.is(listener3.callCount, 0); // Not called
+
+  emitter.emit();
+  t.is(listener1.callCount, 2);
+  t.is(listener2.callCount, 2);
+  t.is(listener3.callCount, 1); // Called
+});
+
+(0, _ava2.default)('uses the last snapshot of listeners during nested change events', function (t) {
+  var emitter = (0, _.createChangeEmitter)();
+
+  var listener1 = _sinon2.default.spy();
+  var listener2 = _sinon2.default.spy();
+  var listener3 = _sinon2.default.spy();
+  var listener4 = _sinon2.default.spy();
+
+  var unlisten4 = void 0;
+  var unlisten1 = emitter.listen(function () {
+    listener1();
+    t.is(listener1.callCount, 1);
+    t.is(listener2.callCount, 0);
+    t.is(listener3.callCount, 0);
+    t.is(listener4.callCount, 0);
+
+    unlisten1();
+    unlisten4 = emitter.listen(listener4);
+    emitter.emit();
+
+    t.is(listener1.callCount, 1);
+    t.is(listener2.callCount, 1);
+    t.is(listener3.callCount, 1);
+    t.is(listener4.callCount, 1);
+  });
+  emitter.listen(listener2);
+  emitter.listen(listener3);
+
+  emitter.emit();
+  t.is(listener1.callCount, 1);
+  t.is(listener2.callCount, 2);
+  t.is(listener3.callCount, 2);
+  t.is(listener4.callCount, 1);
+
+  unlisten4();
+  emitter.emit();
+  t.is(listener1.callCount, 1);
+  t.is(listener2.callCount, 3);
+  t.is(listener3.callCount, 3);
+  t.is(listener4.callCount, 1);
+});

torrent-project/node_modules/material-ui/node_modules/change-emitter/lib/index.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var createChangeEmitter = exports.createChangeEmitter = function createChangeEmitter() {
+  var currentListeners = [];
+  var nextListeners = currentListeners;
+
+  function ensureCanMutateNextListeners() {
+    if (nextListeners === currentListeners) {
+      nextListeners = currentListeners.slice();
+    }
+  }
+
+  function listen(listener) {
+    if (typeof listener !== 'function') {
+      throw new Error('Expected listener to be a function.');
+    }
+
+    var isSubscribed = true;
+
+    ensureCanMutateNextListeners();
+    nextListeners.push(listener);
+
+    return function () {
+      if (!isSubscribed) {
+        return;
+      }
+
+      isSubscribed = false;
+
+      ensureCanMutateNextListeners();
+      var index = nextListeners.indexOf(listener);
+      nextListeners.splice(index, 1);
+    };
+  }
+
+  function emit() {
+    currentListeners = nextListeners;
+    var listeners = currentListeners;
+    for (var i = 0; i < listeners.length; i++) {
+      listeners[i].apply(listeners, arguments);
+    }
+  }
+
+  return {
+    listen: listen,
+    emit: emit
+  };
+};

torrent-project/node_modules/material-ui/node_modules/change-emitter/package.json

@@ -0,0 +1,84 @@
+{
+  "_args": [
+    [
+      "change-emitter@0.1.6",
+      "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project"
+    ]
+  ],
+  "_from": "change-emitter@0.1.6",
+  "_id": "change-emitter@0.1.6",
+  "_inBundle": false,
+  "_integrity": "sha1-6LL+PX8at9aaMhma/5HqaTFAlRU=",
+  "_location": "/material-ui/change-emitter",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "change-emitter@0.1.6",
+    "name": "change-emitter",
+    "escapedName": "change-emitter",
+    "rawSpec": "0.1.6",
+    "saveSpec": null,
+    "fetchSpec": "0.1.6"
+  },
+  "_requiredBy": [
+    "/material-ui/recompose"
+  ],
+  "_resolved": "https://registry.npmjs.org/change-emitter/-/change-emitter-0.1.6.tgz",
+  "_spec": "0.1.6",
+  "_where": "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project",
+  "author": {
+    "name": "Andrew Clark",
+    "email": "acdlite@me.com"
+  },
+  "ava": {
+    "babel": "inherit",
+    "files": [
+      "**/*-test.js"
+    ],
+    "source": [
+      "**/*.js"
+    ],
+    "require": [
+      "babel-register"
+    ]
+  },
+  "bugs": {
+    "url": "https://github.com/acdlite/change-emitter/issues"
+  },
+  "description": "Listen for changes. Like an event emitter that only emits a single event type. Really tiny.",
+  "devDependencies": {
+    "ava": "^0.14.0",
+    "babel-cli": "^6.8.0",
+    "babel-core": "^6.8.0",
+    "babel-preset-es2015": "^6.6.0",
+    "eslint": "^2.10.1",
+    "eslint-config-airbnb-base": "^3.0.1",
+    "eslint-plugin-import": "^1.8.0",
+    "sinon": "^1.17.4"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/acdlite/change-emitter#readme",
+  "keywords": [
+    "change",
+    "event",
+    "emitter"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "change-emitter",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acdlite/change-emitter.git"
+  },
+  "scripts": {
+    "build": "babel src --out-dir lib",
+    "check": "eslint src",
+    "prepublish": "yarn run check && yarn run test && yarn run build",
+    "test": "ava",
+    "test:watch": "yarn run test -- --watch"
+  },
+  "version": "0.1.6"
+}