Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

torrent-project/node_modules/react-redux/src/components/Provider.js

@@ -0,0 +1,60 @@
+import { Component, Children } from 'react'
+import PropTypes from 'prop-types'
+import { storeShape, subscriptionShape } from '../utils/PropTypes'
+import warning from '../utils/warning'
+
+let didWarnAboutReceivingStore = false
+function warnAboutReceivingStore() {
+  if (didWarnAboutReceivingStore) {
+    return
+  }
+  didWarnAboutReceivingStore = true
+
+  warning(
+    '<Provider> does not support changing `store` on the fly. ' +
+    'It is most likely that you see this error because you updated to ' +
+    'Redux 2.x and React Redux 2.x which no longer hot reload reducers ' +
+    'automatically. See https://github.com/reactjs/react-redux/releases/' +
+    'tag/v2.0.0 for the migration instructions.'
+  )
+}
+
+export function createProvider(storeKey = 'store', subKey) {
+    const subscriptionKey = subKey || `${storeKey}Subscription`
+
+    class Provider extends Component {
+        getChildContext() {
+          return { [storeKey]: this[storeKey], [subscriptionKey]: null }
+        }
+
+        constructor(props, context) {
+          super(props, context)
+          this[storeKey] = props.store;
+        }
+
+        render() {
+          return Children.only(this.props.children)
+        }
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      Provider.prototype.componentWillReceiveProps = function (nextProps) {
+        if (this[storeKey] !== nextProps.store) {
+          warnAboutReceivingStore()
+        }
+      }
+    }
+
+    Provider.propTypes = {
+        store: storeShape.isRequired,
+        children: PropTypes.element.isRequired,
+    }
+    Provider.childContextTypes = {
+        [storeKey]: storeShape.isRequired,
+        [subscriptionKey]: subscriptionShape,
+    }
+
+    return Provider
+}
+
+export default createProvider()

torrent-project/node_modules/react-redux/src/components/connectAdvanced.js

@@ -0,0 +1,296 @@
+import hoistStatics from 'hoist-non-react-statics'
+import invariant from 'invariant'
+import { Component, createElement } from 'react'
+
+import Subscription from '../utils/Subscription'
+import { storeShape, subscriptionShape } from '../utils/PropTypes'
+
+let hotReloadingVersion = 0
+const dummyState = {}
+function noop() {}
+function makeSelectorStateful(sourceSelector, store) {
+  // wrap the selector in an object that tracks its results between runs.
+  const selector = {
+    run: function runComponentSelector(props) {
+      try {
+        const nextProps = sourceSelector(store.getState(), props)
+        if (nextProps !== selector.props || selector.error) {
+          selector.shouldComponentUpdate = true
+          selector.props = nextProps
+          selector.error = null
+        }
+      } catch (error) {
+        selector.shouldComponentUpdate = true
+        selector.error = error
+      }
+    }
+  }
+
+  return selector
+}
+
+export default function connectAdvanced(
+  /*
+    selectorFactory is a func that is responsible for returning the selector function used to
+    compute new props from state, props, and dispatch. For example:
+
+      export default connectAdvanced((dispatch, options) => (state, props) => ({
+        thing: state.things[props.thingId],
+        saveThing: fields => dispatch(actionCreators.saveThing(props.thingId, fields)),
+      }))(YourComponent)
+
+    Access to dispatch is provided to the factory so selectorFactories can bind actionCreators
+    outside of their selector as an optimization. Options passed to connectAdvanced are passed to
+    the selectorFactory, along with displayName and WrappedComponent, as the second argument.
+
+    Note that selectorFactory is responsible for all caching/memoization of inbound and outbound
+    props. Do not use connectAdvanced directly without memoizing results between calls to your
+    selector, otherwise the Connect component will re-render on every state or props change.
+  */
+  selectorFactory,
+  // options object:
+  {
+    // the func used to compute this HOC's displayName from the wrapped component's displayName.
+    // probably overridden by wrapper functions such as connect()
+    getDisplayName = name => `ConnectAdvanced(${name})`,
+
+    // shown in error messages
+    // probably overridden by wrapper functions such as connect()
+    methodName = 'connectAdvanced',
+
+    // if defined, the name of the property passed to the wrapped element indicating the number of
+    // calls to render. useful for watching in react devtools for unnecessary re-renders.
+    renderCountProp = undefined,
+
+    // determines whether this HOC subscribes to store changes
+    shouldHandleStateChanges = true,
+
+    // the key of props/context to get the store
+    storeKey = 'store',
+
+    // if true, the wrapped element is exposed by this HOC via the getWrappedInstance() function.
+    withRef = false,
+
+    // additional options are passed through to the selectorFactory
+    ...connectOptions
+  } = {}
+) {
+  const subscriptionKey = storeKey + 'Subscription'
+  const version = hotReloadingVersion++
+
+  const contextTypes = {
+    [storeKey]: storeShape,
+    [subscriptionKey]: subscriptionShape,
+  }
+  const childContextTypes = {
+    [subscriptionKey]: subscriptionShape,
+  }
+
+  return function wrapWithConnect(WrappedComponent) {
+    invariant(
+      typeof WrappedComponent == 'function',
+      `You must pass a component to the function returned by ` +
+      `connect. Instead received ${JSON.stringify(WrappedComponent)}`
+    )
+
+    const wrappedComponentName = WrappedComponent.displayName
+      || WrappedComponent.name
+      || 'Component'
+
+    const displayName = getDisplayName(wrappedComponentName)
+
+    const selectorFactoryOptions = {
+      ...connectOptions,
+      getDisplayName,
+      methodName,
+      renderCountProp,
+      shouldHandleStateChanges,
+      storeKey,
+      withRef,
+      displayName,
+      wrappedComponentName,
+      WrappedComponent
+    }
+
+    class Connect extends Component {
+      constructor(props, context) {
+        super(props, context)
+
+        this.version = version
+        this.state = {}
+        this.renderCount = 0
+        this.store = props[storeKey] || context[storeKey]
+        this.propsMode = Boolean(props[storeKey])
+        this.setWrappedInstance = this.setWrappedInstance.bind(this)
+
+        invariant(this.store,
+          `Could not find "${storeKey}" in either the context or props of ` +
+          `"${displayName}". Either wrap the root component in a <Provider>, ` +
+          `or explicitly pass "${storeKey}" as a prop to "${displayName}".`
+        )
+
+        this.initSelector()
+        this.initSubscription()
+      }
+
+      getChildContext() {
+        // If this component received store from props, its subscription should be transparent
+        // to any descendants receiving store+subscription from context; it passes along
+        // subscription passed to it. Otherwise, it shadows the parent subscription, which allows
+        // Connect to control ordering of notifications to flow top-down.
+        const subscription = this.propsMode ? null : this.subscription
+        return { [subscriptionKey]: subscription || this.context[subscriptionKey] }
+      }
+
+      componentDidMount() {
+        if (!shouldHandleStateChanges) return
+
+        // componentWillMount fires during server side rendering, but componentDidMount and
+        // componentWillUnmount do not. Because of this, trySubscribe happens during ...didMount.
+        // Otherwise, unsubscription would never take place during SSR, causing a memory leak.
+        // To handle the case where a child component may have triggered a state change by
+        // dispatching an action in its componentWillMount, we have to re-run the select and maybe
+        // re-render.
+        this.subscription.trySubscribe()
+        this.selector.run(this.props)
+        if (this.selector.shouldComponentUpdate) this.forceUpdate()
+      }
+
+      componentWillReceiveProps(nextProps) {
+        this.selector.run(nextProps)
+      }
+
+      shouldComponentUpdate() {
+        return this.selector.shouldComponentUpdate
+      }
+
+      componentWillUnmount() {
+        if (this.subscription) this.subscription.tryUnsubscribe()
+        this.subscription = null
+        this.notifyNestedSubs = noop
+        this.store = null
+        this.selector.run = noop
+        this.selector.shouldComponentUpdate = false
+      }
+
+      getWrappedInstance() {
+        invariant(withRef,
+          `To access the wrapped instance, you need to specify ` +
+          `{ withRef: true } in the options argument of the ${methodName}() call.`
+        )
+        return this.wrappedInstance
+      }
+
+      setWrappedInstance(ref) {
+        this.wrappedInstance = ref
+      }
+
+      initSelector() {
+        const sourceSelector = selectorFactory(this.store.dispatch, selectorFactoryOptions)
+        this.selector = makeSelectorStateful(sourceSelector, this.store)
+        this.selector.run(this.props)
+      }
+
+      initSubscription() {
+        if (!shouldHandleStateChanges) return
+
+        // parentSub's source should match where store came from: props vs. context. A component
+        // connected to the store via props shouldn't use subscription from context, or vice versa.
+        const parentSub = (this.propsMode ? this.props : this.context)[subscriptionKey]
+        this.subscription = new Subscription(this.store, parentSub, this.onStateChange.bind(this))
+
+        // `notifyNestedSubs` is duplicated to handle the case where the component is  unmounted in
+        // the middle of the notification loop, where `this.subscription` will then be null. An
+        // extra null check every change can be avoided by copying the method onto `this` and then
+        // replacing it with a no-op on unmount. This can probably be avoided if Subscription's
+        // listeners logic is changed to not call listeners that have been unsubscribed in the
+        // middle of the notification loop.
+        this.notifyNestedSubs = this.subscription.notifyNestedSubs.bind(this.subscription)
+      }
+
+      onStateChange() {
+        this.selector.run(this.props)
+
+        if (!this.selector.shouldComponentUpdate) {
+          this.notifyNestedSubs()
+        } else {
+          this.componentDidUpdate = this.notifyNestedSubsOnComponentDidUpdate
+          this.setState(dummyState)
+        }
+      }
+
+      notifyNestedSubsOnComponentDidUpdate() {
+        // `componentDidUpdate` is conditionally implemented when `onStateChange` determines it
+        // needs to notify nested subs. Once called, it unimplements itself until further state
+        // changes occur. Doing it this way vs having a permanent `componentDidUpdate` that does
+        // a boolean check every time avoids an extra method call most of the time, resulting
+        // in some perf boost.
+        this.componentDidUpdate = undefined
+        this.notifyNestedSubs()
+      }
+
+      isSubscribed() {
+        return Boolean(this.subscription) && this.subscription.isSubscribed()
+      }
+
+      addExtraProps(props) {
+        if (!withRef && !renderCountProp && !(this.propsMode && this.subscription)) return props
+        // make a shallow copy so that fields added don't leak to the original selector.
+        // this is especially important for 'ref' since that's a reference back to the component
+        // instance. a singleton memoized selector would then be holding a reference to the
+        // instance, preventing the instance from being garbage collected, and that would be bad
+        const withExtras = { ...props }
+        if (withRef) withExtras.ref = this.setWrappedInstance
+        if (renderCountProp) withExtras[renderCountProp] = this.renderCount++
+        if (this.propsMode && this.subscription) withExtras[subscriptionKey] = this.subscription
+        return withExtras
+      }
+
+      render() {
+        const selector = this.selector
+        selector.shouldComponentUpdate = false
+
+        if (selector.error) {
+          throw selector.error
+        } else {
+          return createElement(WrappedComponent, this.addExtraProps(selector.props))
+        }
+      }
+    }
+
+    Connect.WrappedComponent = WrappedComponent
+    Connect.displayName = displayName
+    Connect.childContextTypes = childContextTypes
+    Connect.contextTypes = contextTypes
+    Connect.propTypes = contextTypes
+
+    if (process.env.NODE_ENV !== 'production') {
+      Connect.prototype.componentWillUpdate = function componentWillUpdate() {
+        // We are hot reloading!
+        if (this.version !== version) {
+          this.version = version
+          this.initSelector()
+
+          // If any connected descendants don't hot reload (and resubscribe in the process), their
+          // listeners will be lost when we unsubscribe. Unfortunately, by copying over all
+          // listeners, this does mean that the old versions of connected descendants will still be
+          // notified of state changes; however, their onStateChange function is a no-op so this
+          // isn't a huge deal.
+          let oldListeners = [];
+
+          if (this.subscription) {
+            oldListeners = this.subscription.listeners.get()
+            this.subscription.tryUnsubscribe()
+          }
+          this.initSubscription()
+          if (shouldHandleStateChanges) {
+            this.subscription.trySubscribe()
+            oldListeners.forEach(listener => this.subscription.listeners.subscribe(listener))
+          }
+        }
+      }
+    }
+
+    return hoistStatics(Connect, WrappedComponent)
+  }
+}

torrent-project/node_modules/react-redux/src/connect/connect.js

@@ -0,0 +1,90 @@
+import connectAdvanced from '../components/connectAdvanced'
+import shallowEqual from '../utils/shallowEqual'
+import defaultMapDispatchToPropsFactories from './mapDispatchToProps'
+import defaultMapStateToPropsFactories from './mapStateToProps'
+import defaultMergePropsFactories from './mergeProps'
+import defaultSelectorFactory from './selectorFactory'
+
+/*
+  connect is a facade over connectAdvanced. It turns its args into a compatible
+  selectorFactory, which has the signature:
+
+    (dispatch, options) => (nextState, nextOwnProps) => nextFinalProps
+  
+  connect passes its args to connectAdvanced as options, which will in turn pass them to
+  selectorFactory each time a Connect component instance is instantiated or hot reloaded.
+
+  selectorFactory returns a final props selector from its mapStateToProps,
+  mapStateToPropsFactories, mapDispatchToProps, mapDispatchToPropsFactories, mergeProps,
+  mergePropsFactories, and pure args.
+
+  The resulting final props selector is called by the Connect component instance whenever
+  it receives new props or store state.
+ */
+
+function match(arg, factories, name) {
+  for (let i = factories.length - 1; i >= 0; i--) {
+    const result = factories[i](arg)
+    if (result) return result
+  }
+
+  return (dispatch, options) => {
+    throw new Error(`Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.`)
+  }
+}
+
+function strictEqual(a, b) { return a === b }
+
+// createConnect with default args builds the 'official' connect behavior. Calling it with
+// different options opens up some testing and extensibility scenarios
+export function createConnect({
+  connectHOC = connectAdvanced,
+  mapStateToPropsFactories = defaultMapStateToPropsFactories,
+  mapDispatchToPropsFactories = defaultMapDispatchToPropsFactories,
+  mergePropsFactories = defaultMergePropsFactories,
+  selectorFactory = defaultSelectorFactory
+} = {}) {
+  return function connect(
+    mapStateToProps,
+    mapDispatchToProps,
+    mergeProps,
+    {
+      pure = true,
+      areStatesEqual = strictEqual,
+      areOwnPropsEqual = shallowEqual,
+      areStatePropsEqual = shallowEqual,
+      areMergedPropsEqual = shallowEqual,
+      ...extraOptions
+    } = {}
+  ) {
+    const initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories, 'mapStateToProps')
+    const initMapDispatchToProps = match(mapDispatchToProps, mapDispatchToPropsFactories, 'mapDispatchToProps')
+    const initMergeProps = match(mergeProps, mergePropsFactories, 'mergeProps')
+
+    return connectHOC(selectorFactory, {
+      // used in error messages
+      methodName: 'connect',
+
+       // used to compute Connect's displayName from the wrapped component's displayName.
+      getDisplayName: name => `Connect(${name})`,
+
+      // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes
+      shouldHandleStateChanges: Boolean(mapStateToProps),
+
+      // passed through to selectorFactory
+      initMapStateToProps,
+      initMapDispatchToProps,
+      initMergeProps,
+      pure,
+      areStatesEqual,
+      areOwnPropsEqual,
+      areStatePropsEqual,
+      areMergedPropsEqual,
+
+      // any extra options args can override defaults of connect or connectAdvanced
+      ...extraOptions
+    })
+  }
+}
+
+export default createConnect()

torrent-project/node_modules/react-redux/src/connect/mapDispatchToProps.js

@@ -0,0 +1,26 @@
+import { bindActionCreators } from 'redux'
+import { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps'
+
+export function whenMapDispatchToPropsIsFunction(mapDispatchToProps) {
+  return (typeof mapDispatchToProps === 'function')
+    ? wrapMapToPropsFunc(mapDispatchToProps, 'mapDispatchToProps')
+    : undefined
+}
+
+export function whenMapDispatchToPropsIsMissing(mapDispatchToProps) {
+  return (!mapDispatchToProps)
+    ? wrapMapToPropsConstant(dispatch => ({ dispatch }))
+    : undefined
+}
+
+export function whenMapDispatchToPropsIsObject(mapDispatchToProps) {
+  return (mapDispatchToProps && typeof mapDispatchToProps === 'object')
+    ? wrapMapToPropsConstant(dispatch => bindActionCreators(mapDispatchToProps, dispatch))
+    : undefined
+}
+
+export default [
+  whenMapDispatchToPropsIsFunction,
+  whenMapDispatchToPropsIsMissing,
+  whenMapDispatchToPropsIsObject
+]

torrent-project/node_modules/react-redux/src/connect/mapStateToProps.js

@@ -0,0 +1,18 @@
+import { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps'
+
+export function whenMapStateToPropsIsFunction(mapStateToProps) {
+  return (typeof mapStateToProps === 'function')
+    ? wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps')
+    : undefined
+}
+
+export function whenMapStateToPropsIsMissing(mapStateToProps) {
+  return (!mapStateToProps)
+    ? wrapMapToPropsConstant(() => ({}))
+    : undefined
+}
+
+export default [
+  whenMapStateToPropsIsFunction,
+  whenMapStateToPropsIsMissing
+]

torrent-project/node_modules/react-redux/src/connect/mergeProps.js

@@ -0,0 +1,49 @@
+import verifyPlainObject from '../utils/verifyPlainObject'
+
+export function defaultMergeProps(stateProps, dispatchProps, ownProps) {
+  return { ...ownProps, ...stateProps, ...dispatchProps }
+}
+
+export function wrapMergePropsFunc(mergeProps) {
+  return function initMergePropsProxy(
+    dispatch, { displayName, pure, areMergedPropsEqual }
+  ) {
+    let hasRunOnce = false
+    let mergedProps
+
+    return function mergePropsProxy(stateProps, dispatchProps, ownProps) {
+      const nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps)
+
+      if (hasRunOnce) {
+        if (!pure || !areMergedPropsEqual(nextMergedProps, mergedProps))
+          mergedProps = nextMergedProps
+
+      } else {
+        hasRunOnce = true
+        mergedProps = nextMergedProps
+
+        if (process.env.NODE_ENV !== 'production')
+          verifyPlainObject(mergedProps, displayName, 'mergeProps')
+      }
+
+      return mergedProps
+    }
+  }
+}
+
+export function whenMergePropsIsFunction(mergeProps) {
+  return (typeof mergeProps === 'function')
+    ? wrapMergePropsFunc(mergeProps)
+    : undefined
+}
+
+export function whenMergePropsIsOmitted(mergeProps) {
+  return (!mergeProps)
+    ? () => defaultMergeProps
+    : undefined
+}
+
+export default [
+  whenMergePropsIsFunction,
+  whenMergePropsIsOmitted
+]

torrent-project/node_modules/react-redux/src/connect/selectorFactory.js

@@ -0,0 +1,125 @@
+import verifySubselectors from './verifySubselectors'
+  
+export function impureFinalPropsSelectorFactory(
+  mapStateToProps,
+  mapDispatchToProps,
+  mergeProps,
+  dispatch
+) {
+  return function impureFinalPropsSelector(state, ownProps) {
+    return mergeProps(
+      mapStateToProps(state, ownProps),
+      mapDispatchToProps(dispatch, ownProps),
+      ownProps
+    )
+  }
+}
+
+export function pureFinalPropsSelectorFactory(
+  mapStateToProps,
+  mapDispatchToProps,
+  mergeProps,
+  dispatch,
+  { areStatesEqual, areOwnPropsEqual, areStatePropsEqual }
+) {
+  let hasRunAtLeastOnce = false
+  let state
+  let ownProps
+  let stateProps
+  let dispatchProps
+  let mergedProps
+
+  function handleFirstCall(firstState, firstOwnProps) {
+    state = firstState
+    ownProps = firstOwnProps
+    stateProps = mapStateToProps(state, ownProps)
+    dispatchProps = mapDispatchToProps(dispatch, ownProps)
+    mergedProps = mergeProps(stateProps, dispatchProps, ownProps)
+    hasRunAtLeastOnce = true
+    return mergedProps
+  }
+
+  function handleNewPropsAndNewState() {
+    stateProps = mapStateToProps(state, ownProps)
+
+    if (mapDispatchToProps.dependsOnOwnProps)
+      dispatchProps = mapDispatchToProps(dispatch, ownProps)
+
+    mergedProps = mergeProps(stateProps, dispatchProps, ownProps)
+    return mergedProps
+  }
+
+  function handleNewProps() {
+    if (mapStateToProps.dependsOnOwnProps)
+      stateProps = mapStateToProps(state, ownProps)
+
+    if (mapDispatchToProps.dependsOnOwnProps)
+      dispatchProps = mapDispatchToProps(dispatch, ownProps)
+
+    mergedProps = mergeProps(stateProps, dispatchProps, ownProps)
+    return mergedProps
+  }
+
+  function handleNewState() {
+    const nextStateProps = mapStateToProps(state, ownProps)
+    const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps)
+    stateProps = nextStateProps
+    
+    if (statePropsChanged)
+      mergedProps = mergeProps(stateProps, dispatchProps, ownProps)
+
+    return mergedProps
+  }
+
+  function handleSubsequentCalls(nextState, nextOwnProps) {
+    const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps)
+    const stateChanged = !areStatesEqual(nextState, state)
+    state = nextState
+    ownProps = nextOwnProps
+
+    if (propsChanged && stateChanged) return handleNewPropsAndNewState()
+    if (propsChanged) return handleNewProps()
+    if (stateChanged) return handleNewState()
+    return mergedProps
+  }
+
+  return function pureFinalPropsSelector(nextState, nextOwnProps) {
+    return hasRunAtLeastOnce
+      ? handleSubsequentCalls(nextState, nextOwnProps)
+      : handleFirstCall(nextState, nextOwnProps)
+  }
+}
+
+// TODO: Add more comments
+
+// If pure is true, the selector returned by selectorFactory will memoize its results,
+// allowing connectAdvanced's shouldComponentUpdate to return false if final
+// props have not changed. If false, the selector will always return a new
+// object and shouldComponentUpdate will always return true.
+
+export default function finalPropsSelectorFactory(dispatch, {
+  initMapStateToProps,
+  initMapDispatchToProps,
+  initMergeProps,
+  ...options
+}) {
+  const mapStateToProps = initMapStateToProps(dispatch, options)
+  const mapDispatchToProps = initMapDispatchToProps(dispatch, options)
+  const mergeProps = initMergeProps(dispatch, options)
+
+  if (process.env.NODE_ENV !== 'production') {
+    verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, options.displayName)
+  }
+
+  const selectorFactory = options.pure
+    ? pureFinalPropsSelectorFactory
+    : impureFinalPropsSelectorFactory
+
+  return selectorFactory(
+    mapStateToProps,
+    mapDispatchToProps,
+    mergeProps,
+    dispatch,
+    options
+  )
+}

torrent-project/node_modules/react-redux/src/connect/verifySubselectors.js

@@ -0,0 +1,20 @@
+import warning from '../utils/warning'
+
+function verify(selector, methodName, displayName) {
+  if (!selector) {
+    throw new Error(`Unexpected value for ${methodName} in ${displayName}.`)
+
+  } else if (methodName === 'mapStateToProps' || methodName === 'mapDispatchToProps') {
+    if (!selector.hasOwnProperty('dependsOnOwnProps')) {
+      warning(
+        `The selector for ${methodName} of ${displayName} did not specify a value for dependsOnOwnProps.`
+      )
+    }
+  }
+}
+
+export default function verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, displayName) {
+  verify(mapStateToProps, 'mapStateToProps', displayName)
+  verify(mapDispatchToProps, 'mapDispatchToProps', displayName)
+  verify(mergeProps, 'mergeProps', displayName)
+}

torrent-project/node_modules/react-redux/src/connect/wrapMapToProps.js

@@ -0,0 +1,68 @@
+import verifyPlainObject from '../utils/verifyPlainObject'
+
+export function wrapMapToPropsConstant(getConstant) {
+  return function initConstantSelector(dispatch, options) {
+    const constant = getConstant(dispatch, options)
+
+    function constantSelector() { return constant }
+    constantSelector.dependsOnOwnProps = false 
+    return constantSelector
+  }
+}
+
+// dependsOnOwnProps is used by createMapToPropsProxy to determine whether to pass props as args
+// to the mapToProps function being wrapped. It is also used by makePurePropsSelector to determine
+// whether mapToProps needs to be invoked when props have changed.
+// 
+// A length of one signals that mapToProps does not depend on props from the parent component.
+// A length of zero is assumed to mean mapToProps is getting args via arguments or ...args and
+// therefore not reporting its length accurately..
+export function getDependsOnOwnProps(mapToProps) {
+  return (mapToProps.dependsOnOwnProps !== null && mapToProps.dependsOnOwnProps !== undefined)
+    ? Boolean(mapToProps.dependsOnOwnProps)
+    : mapToProps.length !== 1
+}
+
+// Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,
+// this function wraps mapToProps in a proxy function which does several things:
+// 
+//  * Detects whether the mapToProps function being called depends on props, which
+//    is used by selectorFactory to decide if it should reinvoke on props changes.
+//    
+//  * On first call, handles mapToProps if returns another function, and treats that
+//    new function as the true mapToProps for subsequent calls.
+//    
+//  * On first call, verifies the first result is a plain object, in order to warn
+//    the developer that their mapToProps function is not returning a valid result.
+//    
+export function wrapMapToPropsFunc(mapToProps, methodName) {
+  return function initProxySelector(dispatch, { displayName }) {
+    const proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {
+      return proxy.dependsOnOwnProps
+        ? proxy.mapToProps(stateOrDispatch, ownProps)
+        : proxy.mapToProps(stateOrDispatch)
+    }
+
+    // allow detectFactoryAndVerify to get ownProps
+    proxy.dependsOnOwnProps = true
+
+    proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {
+      proxy.mapToProps = mapToProps
+      proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps)
+      let props = proxy(stateOrDispatch, ownProps)
+
+      if (typeof props === 'function') {
+        proxy.mapToProps = props
+        proxy.dependsOnOwnProps = getDependsOnOwnProps(props)
+        props = proxy(stateOrDispatch, ownProps)
+      }
+
+      if (process.env.NODE_ENV !== 'production') 
+        verifyPlainObject(props, displayName, methodName)
+
+      return props
+    }
+
+    return proxy
+  }
+}

torrent-project/node_modules/react-redux/src/index.js

@@ -0,0 +1,5 @@
+import Provider, { createProvider } from './components/Provider'
+import connectAdvanced from './components/connectAdvanced'
+import connect from './connect/connect'
+
+export { Provider, createProvider, connectAdvanced, connect }

torrent-project/node_modules/react-redux/src/utils/PropTypes.js

@@ -0,0 +1,14 @@
+import PropTypes from 'prop-types'
+
+export const subscriptionShape = PropTypes.shape({
+  trySubscribe: PropTypes.func.isRequired,
+  tryUnsubscribe: PropTypes.func.isRequired,
+  notifyNestedSubs: PropTypes.func.isRequired,
+  isSubscribed: PropTypes.func.isRequired,
+})
+
+export const storeShape = PropTypes.shape({
+  subscribe: PropTypes.func.isRequired,
+  dispatch: PropTypes.func.isRequired,
+  getState: PropTypes.func.isRequired
+})

torrent-project/node_modules/react-redux/src/utils/Subscription.js

@@ -0,0 +1,87 @@
+// encapsulates the subscription logic for connecting a component to the redux store, as
+// well as nesting subscriptions of descendant components, so that we can ensure the
+// ancestor components re-render before descendants
+
+const CLEARED = null
+const nullListeners = { notify() {} }
+
+function createListenerCollection() {
+  // the current/next pattern is copied from redux's createStore code.
+  // TODO: refactor+expose that code to be reusable here?
+  let current = []
+  let next = []
+
+  return {
+    clear() {
+      next = CLEARED
+      current = CLEARED
+    },
+
+    notify() {
+      const listeners = current = next
+      for (let i = 0; i < listeners.length; i++) {
+        listeners[i]()
+      }
+    },
+
+    get() {
+      return next
+    },
+
+    subscribe(listener) {
+      let isSubscribed = true
+      if (next === current) next = current.slice()
+      next.push(listener)
+
+      return function unsubscribe() {
+        if (!isSubscribed || current === CLEARED) return
+        isSubscribed = false
+
+        if (next === current) next = current.slice()
+        next.splice(next.indexOf(listener), 1)
+      }
+    }
+  }
+}
+
+export default class Subscription {
+  constructor(store, parentSub, onStateChange) {
+    this.store = store
+    this.parentSub = parentSub
+    this.onStateChange = onStateChange
+    this.unsubscribe = null
+    this.listeners = nullListeners
+  }
+
+  addNestedSub(listener) {
+    this.trySubscribe()
+    return this.listeners.subscribe(listener)
+  }
+
+  notifyNestedSubs() {
+    this.listeners.notify()
+  }
+
+  isSubscribed() {
+    return Boolean(this.unsubscribe)
+  }
+
+  trySubscribe() {
+    if (!this.unsubscribe) {
+      this.unsubscribe = this.parentSub
+        ? this.parentSub.addNestedSub(this.onStateChange)
+        : this.store.subscribe(this.onStateChange)
+ 
+      this.listeners = createListenerCollection()
+    }
+  }
+
+  tryUnsubscribe() {
+    if (this.unsubscribe) {
+      this.unsubscribe()
+      this.unsubscribe = null
+      this.listeners.clear()
+      this.listeners = nullListeners
+    }
+  }
+}

torrent-project/node_modules/react-redux/src/utils/shallowEqual.js

@@ -0,0 +1,32 @@
+const hasOwn = Object.prototype.hasOwnProperty
+
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || y !== 0 || 1 / x === 1 / y
+  } else {
+    return x !== x && y !== y
+  }
+}
+
+export default function shallowEqual(objA, objB) {
+  if (is(objA, objB)) return true
+
+  if (typeof objA !== 'object' || objA === null ||
+      typeof objB !== 'object' || objB === null) {
+    return false
+  }
+
+  const keysA = Object.keys(objA)
+  const keysB = Object.keys(objB)
+
+  if (keysA.length !== keysB.length) return false
+
+  for (let i = 0; i < keysA.length; i++) {
+    if (!hasOwn.call(objB, keysA[i]) ||
+        !is(objA[keysA[i]], objB[keysA[i]])) {
+      return false
+    }
+  }
+
+  return true
+}

torrent-project/node_modules/react-redux/src/utils/verifyPlainObject.js

@@ -0,0 +1,10 @@
+import isPlainObject from 'lodash/isPlainObject'
+import warning from './warning'
+
+export default function verifyPlainObject(value, displayName, methodName) {
+  if (!isPlainObject(value)) {
+    warning(
+      `${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`
+    )
+  }
+}

torrent-project/node_modules/react-redux/src/utils/warning.js

@@ -0,0 +1,21 @@
+/**
+ * Prints a warning in the console if it exists.
+ *
+ * @param {String} message The warning message.
+ * @returns {void}
+ */
+export default function warning(message) {
+  /* eslint-disable no-console */
+  if (typeof console !== 'undefined' && typeof console.error === 'function') {
+    console.error(message)
+  }
+  /* eslint-enable no-console */
+  try {
+    // This error was thrown as a convenience so that if you enable
+    // "break on all exceptions" in your console,
+    // it would pause the execution at this line.
+    throw new Error(message)
+    /* eslint-disable no-empty */
+  } catch (e) {}
+  /* eslint-enable no-empty */
+}

torrent-project/node_modules/react-redux/src/utils/wrapActionCreators.js

@@ -0,0 +1,5 @@
+import { bindActionCreators } from 'redux'
+
+export default function wrapActionCreators(actionCreators) {
+  return dispatch => bindActionCreators(actionCreators, dispatch)
+}