Completely updated React, fixed #11, (hopefully)

goTorrentWebUI/node_modules/material-ui/es/Snackbar/Snackbar.d.ts

@@ -1,28 +1,31 @@
 import * as React from 'react';
 import { StandardProps } from '..';
-import { TransitionDuration, TransitionHandlers } from '../internal/transition';
+import { SnackbarContentProps } from '.';
+import { TransitionHandlerProps, TransitionProps } from '../transitions/transition';
 
-export type Origin = {
+export type SnackBarOrigin = {
   horizontal?: 'left' | 'center' | 'right' | number;
   vertical?: 'top' | 'center' | 'bottom' | number;
 };
 
-export interface SnackbarProps extends StandardProps<
-  React.HTMLAttributes<HTMLDivElement> & Partial<TransitionHandlers>,
-  SnackbarClassKey
-> {
+export interface SnackbarProps
+  extends StandardProps<
+      React.HTMLAttributes<HTMLDivElement> & Partial<TransitionHandlerProps>,
+      SnackbarClassKey
+    > {
   action?: React.ReactElement<any> | React.ReactElement<any>[];
-  anchorOrigin?: Origin;
+  anchorOrigin?: SnackBarOrigin;
   autoHideDuration?: number;
-  resumeHideDuration?: number;
-  transitionDuration?: TransitionDuration;
+  disableWindowBlurListener?: boolean;
   message?: React.ReactElement<any>;
+  onClose?: (event: React.SyntheticEvent<any>, reason: string) => void;
   onMouseEnter?: React.MouseEventHandler<any>;
   onMouseLeave?: React.MouseEventHandler<any>;
-  onRequestClose?: (event: React.SyntheticEvent<any>, reason: string) => void;
   open: boolean;
-  SnackbarContentProps?: Object;
+  resumeHideDuration?: number;
+  SnackbarContentProps?: Partial<SnackbarContentProps>;
   transition?: React.ReactType;
+  transitionDuration?: TransitionProps['timeout'];
 }
 
 export type SnackbarClassKey =
@@ -32,8 +35,7 @@ export type SnackbarClassKey =
   | 'anchorTopRight'
   | 'anchorBottomRight'
   | 'anchorTopLeft'
-  | 'anchorBottomLeft'
-  ;
+  | 'anchorBottomLeft';
 
 declare const Snackbar: React.ComponentType<SnackbarProps>;
 

goTorrentWebUI/node_modules/material-ui/es/Snackbar/Snackbar.js

@@ -1,19 +1,16 @@
-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; };
-
-function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
-
+import _objectWithoutProperties from 'babel-runtime/helpers/objectWithoutProperties';
+import _extends from 'babel-runtime/helpers/extends';
 import React from 'react';
-
+import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import EventListener from 'react-event-listener';
 import withStyles from '../styles/withStyles';
 import { duration } from '../styles/transitions';
 import ClickAwayListener from '../utils/ClickAwayListener';
-import { capitalizeFirstLetter, createChainedFunction } from '../utils/helpers';
+import { capitalize, createChainedFunction } from '../utils/helpers';
 import Slide from '../transitions/Slide';
 import SnackbarContent from './SnackbarContent';
 
-
 export const styles = theme => {
   const gutter = theme.spacing.unit * 3;
   const top = { top: 0 };
@@ -40,46 +37,32 @@ export const styles = theme => {
       justifyContent: 'center',
       alignItems: 'center'
     },
-    anchorTopCenter: {
-      extend: [top],
-      [theme.breakpoints.up('md')]: {
-        extend: [center]
-      }
-    },
-    anchorBottomCenter: {
-      extend: [bottom],
-      [theme.breakpoints.up('md')]: {
-        extend: [center]
-      }
-    },
-    anchorTopRight: {
-      extend: [top, right],
-      [theme.breakpoints.up('md')]: {
-        left: 'auto',
-        extend: [topSpace, rightSpace]
-      }
-    },
-    anchorBottomRight: {
-      extend: [bottom, right],
-      [theme.breakpoints.up('md')]: {
-        left: 'auto',
-        extend: [bottomSpace, rightSpace]
-      }
-    },
-    anchorTopLeft: {
-      extend: [top, left],
-      [theme.breakpoints.up('md')]: {
-        right: 'auto',
-        extend: [topSpace, leftSpace]
-      }
-    },
-    anchorBottomLeft: {
-      extend: [bottom, left],
-      [theme.breakpoints.up('md')]: {
-        right: 'auto',
-        extend: [bottomSpace, leftSpace]
-      }
-    }
+    anchorTopCenter: _extends({}, top, {
+      [theme.breakpoints.up('md')]: _extends({}, center)
+    }),
+    anchorBottomCenter: _extends({}, bottom, {
+      [theme.breakpoints.up('md')]: _extends({}, center)
+    }),
+    anchorTopRight: _extends({}, top, right, {
+      [theme.breakpoints.up('md')]: _extends({
+        left: 'auto'
+      }, topSpace, rightSpace)
+    }),
+    anchorBottomRight: _extends({}, bottom, right, {
+      [theme.breakpoints.up('md')]: _extends({
+        left: 'auto'
+      }, bottomSpace, rightSpace)
+    }),
+    anchorTopLeft: _extends({}, top, left, {
+      [theme.breakpoints.up('md')]: _extends({
+        right: 'auto'
+      }, topSpace, leftSpace)
+    }),
+    anchorBottomLeft: _extends({}, bottom, left, {
+      [theme.breakpoints.up('md')]: _extends({
+        right: 'auto'
+      }, bottomSpace, leftSpace)
+    })
   };
 };
 
@@ -101,20 +84,20 @@ class Snackbar extends React.Component {
       }
       this.handleResume();
     }, this.handleClickAway = event => {
-      if (this.props.onRequestClose) {
-        this.props.onRequestClose(event, 'clickaway');
+      if (this.props.onClose) {
+        this.props.onClose(event, 'clickaway');
       }
     }, this.handlePause = () => {
       clearTimeout(this.timerAutoHide);
     }, this.handleResume = () => {
-      if (this.props.autoHideDuration !== undefined) {
+      if (this.props.autoHideDuration != null) {
         if (this.props.resumeHideDuration !== undefined) {
           this.setAutoHideTimer(this.props.resumeHideDuration);
           return;
         }
         this.setAutoHideTimer((this.props.autoHideDuration || 0) * 0.5);
       }
-    }, this.handleTransitionExited = () => {
+    }, this.handleExited = () => {
       this.setState({ exited: true });
     }, _temp;
   }
@@ -132,7 +115,7 @@ class Snackbar extends React.Component {
   }
 
   componentWillReceiveProps(nextProps) {
-    if (nextProps.open && this.state.exited) {
+    if (nextProps.open) {
       this.setState({ exited: false });
     }
   }
@@ -153,17 +136,17 @@ class Snackbar extends React.Component {
 
   // Timer that controls delay before snackbar auto hides
   setAutoHideTimer(autoHideDuration = null) {
-    if (!this.props.onRequestClose || this.props.autoHideDuration === undefined) {
+    if (!this.props.onClose || this.props.autoHideDuration == null) {
       return;
     }
 
     clearTimeout(this.timerAutoHide);
     this.timerAutoHide = setTimeout(() => {
-      if (!this.props.onRequestClose || this.props.autoHideDuration === undefined) {
+      if (!this.props.onClose || this.props.autoHideDuration == null) {
         return;
       }
 
-      this.props.onRequestClose(null, 'timeout');
+      this.props.onClose(null, 'timeout');
     }, autoHideDuration || this.props.autoHideDuration || 0);
   }
 
@@ -181,84 +164,204 @@ class Snackbar extends React.Component {
       action,
       anchorOrigin: { vertical, horizontal },
       autoHideDuration,
-      resumeHideDuration,
       children,
       classes,
       className,
-      transitionDuration,
+      disableWindowBlurListener,
       message,
+      onClose,
       onEnter,
-      onEntering,
       onEntered,
+      onEntering,
       onExit,
-      onExiting,
       onExited,
+      onExiting,
       onMouseEnter,
       onMouseLeave,
-      onRequestClose,
       open,
+      resumeHideDuration,
       SnackbarContentProps,
-      transition: TransitionProp
+      transition: TransitionProp,
+      transitionDuration
     } = _props,
-          other = _objectWithoutProperties(_props, ['action', 'anchorOrigin', 'autoHideDuration', 'resumeHideDuration', 'children', 'classes', 'className', 'transitionDuration', 'message', 'onEnter', 'onEntering', 'onEntered', 'onExit', 'onExiting', 'onExited', 'onMouseEnter', 'onMouseLeave', 'onRequestClose', 'open', 'SnackbarContentProps', 'transition']);
+          other = _objectWithoutProperties(_props, ['action', 'anchorOrigin', 'autoHideDuration', 'children', 'classes', 'className', 'disableWindowBlurListener', 'message', 'onClose', 'onEnter', 'onEntered', 'onEntering', 'onExit', 'onExited', 'onExiting', 'onMouseEnter', 'onMouseLeave', 'open', 'resumeHideDuration', 'SnackbarContentProps', 'transition', 'transitionDuration']);
 
     if (!open && this.state.exited) {
       return null;
     }
 
-    const transitionProps = {
-      in: open,
-      appear: true,
-      timeout: transitionDuration,
-      onEnter,
-      onEntering,
-      onEntered,
-      onExit,
-      onExiting,
-      onExited: createChainedFunction(this.handleTransitionExited, onExited)
-    };
-    const transitionContent = children || React.createElement(SnackbarContent, _extends({ message: message, action: action }, SnackbarContentProps));
+    const transitionProps = {};
 
-    let transition;
-    if (TransitionProp) {
-      transition = React.createElement(
-        TransitionProp,
-        transitionProps,
-        transitionContent
-      );
-    } else {
-      transition = React.createElement(
-        Slide,
-        _extends({ direction: vertical === 'top' ? 'down' : 'up' }, transitionProps),
-        transitionContent
-      );
+    // The provided transition might not support the direction property.
+    if (TransitionProp === Slide) {
+      transitionProps.direction = vertical === 'top' ? 'down' : 'up';
     }
 
     return React.createElement(
       EventListener,
-      { target: 'window', onFocus: this.handleResume, onBlur: this.handlePause },
+      {
+        target: 'window',
+        onFocus: disableWindowBlurListener ? undefined : this.handleResume,
+        onBlur: disableWindowBlurListener ? undefined : this.handlePause
+      },
       React.createElement(
         ClickAwayListener,
         { onClickAway: this.handleClickAway },
         React.createElement(
           'div',
           _extends({
-            className: classNames(classes.root, classes[`anchor${capitalizeFirstLetter(vertical)}${capitalizeFirstLetter(horizontal)}`], className),
+            className: classNames(classes.root, classes[`anchor${capitalize(vertical)}${capitalize(horizontal)}`], className),
             onMouseEnter: this.handleMouseEnter,
             onMouseLeave: this.handleMouseLeave
           }, other),
-          transition
+          React.createElement(
+            TransitionProp,
+            _extends({
+              appear: true,
+              'in': open,
+              onEnter: onEnter,
+              onEntered: onEntered,
+              onEntering: onEntering,
+              onExit: onExit,
+              onExited: createChainedFunction(this.handleExited, onExited),
+              onExiting: onExiting,
+              timeout: transitionDuration
+            }, transitionProps),
+            children || React.createElement(SnackbarContent, _extends({ message: message, action: action }, SnackbarContentProps))
+          )
         )
       )
     );
   }
 }
 
+Snackbar.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * The action to display.
+   */
+  action: PropTypes.node,
+  /**
+   * The anchor of the `Snackbar`.
+   */
+  anchorOrigin: PropTypes.shape({
+    horizontal: PropTypes.oneOfType([PropTypes.number, PropTypes.oneOf(['left', 'center', 'right'])]),
+    vertical: PropTypes.oneOfType([PropTypes.number, PropTypes.oneOf(['top', 'center', 'bottom'])])
+  }),
+  /**
+   * The number of milliseconds to wait before automatically calling the
+   * `onClose` function. `onClose` should then set the state of the `open`
+   * prop to hide the Snackbar. This behavior is disabled by default with
+   * the `null` value.
+   */
+  autoHideDuration: PropTypes.number,
+  /**
+   * If you wish the take control over the children of the component you can use this property.
+   * When used, you replace the `SnackbarContent` component with the children.
+   */
+  children: PropTypes.element,
+  /**
+   * Useful to extend the style applied to components.
+   */
+  classes: PropTypes.object.isRequired,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * If `true`, the `autoHideDuration` timer will expire even if the window is not focused.
+   */
+  disableWindowBlurListener: PropTypes.bool,
+  /**
+   * When displaying multiple consecutive Snackbars from a parent rendering a single
+   * <Snackbar/>, add the key property to ensure independent treatment of each message.
+   * e.g. <Snackbar key={message} />, otherwise, the message may update-in-place and
+   * features such as autoHideDuration may be canceled.
+   */
+  key: PropTypes.any,
+  /**
+   * The message to display.
+   */
+  message: PropTypes.node,
+  /**
+   * Callback fired when the component requests to be closed.
+   * Typically `onClose` is used to set state in the parent component,
+   * which is used to control the `Snackbar` `open` prop.
+   * The `reason` parameter can optionally be used to control the response to `onClose`,
+   * for example ignoring `clickaway`.
+   *
+   * @param {object} event The event source of the callback
+   * @param {string} reason Can be:`"timeout"` (`autoHideDuration` expired) or: `"clickaway"`
+   */
+  onClose: PropTypes.func,
+  /**
+   * Callback fired before the transition is entering.
+   */
+  onEnter: PropTypes.func,
+  /**
+   * Callback fired when the transition has entered.
+   */
+  onEntered: PropTypes.func,
+  /**
+   * Callback fired when the transition is entering.
+   */
+  onEntering: PropTypes.func,
+  /**
+   * Callback fired before the transition is exiting.
+   */
+  onExit: PropTypes.func,
+  /**
+   * Callback fired when the transition has exited.
+   */
+  onExited: PropTypes.func,
+  /**
+   * Callback fired when the transition is exiting.
+   */
+  onExiting: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onMouseEnter: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: PropTypes.func,
+  /**
+   * If true, `Snackbar` is open.
+   */
+  open: PropTypes.bool,
+  /**
+   * The number of milliseconds to wait before dismissing after user interaction.
+   * If `autoHideDuration` property isn't specified, it does nothing.
+   * If `autoHideDuration` property is specified but `resumeHideDuration` isn't,
+   * we default to `autoHideDuration / 2` ms.
+   */
+  resumeHideDuration: PropTypes.number,
+  /**
+   * Properties applied to the `SnackbarContent` element.
+   */
+  SnackbarContentProps: PropTypes.object,
+  /**
+   * Transition component.
+   */
+  transition: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   */
+  transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({ enter: PropTypes.number, exit: PropTypes.number })])
+} : {};
+
 Snackbar.defaultProps = {
-  anchorOrigin: { vertical: 'bottom', horizontal: 'center' },
+  anchorOrigin: {
+    vertical: 'bottom',
+    horizontal: 'center'
+  },
+  disableWindowBlurListener: false,
+  transition: Slide,
   transitionDuration: {
     enter: duration.enteringScreen,
     exit: duration.leavingScreen
   }
 };
+
 export default withStyles(styles, { flip: false, name: 'MuiSnackbar' })(Snackbar);

goTorrentWebUI/node_modules/material-ui/es/Snackbar/SnackbarContent.d.ts

@@ -3,19 +3,12 @@ import { StandardProps } from '..';
 import { PaperProps } from '../Paper';
 import { PaperClassKey } from '../Paper/Paper';
 
-export interface SnackbarContentProps extends StandardProps<
-  PaperProps,
-  SnackbarContentClasskey
-> {
+export interface SnackbarContentProps extends StandardProps<PaperProps, SnackbarContentClassKey> {
   action?: React.ReactElement<any>;
   message: React.ReactElement<any> | string;
 }
 
-export type SnackbarContentClasskey =
-  | PaperClassKey
-  | 'message'
-  | 'action'
-  ;
+export type SnackbarContentClassKey = PaperClassKey | 'message' | 'action';
 
 declare const SnackbarContent: React.ComponentType<SnackbarContentProps>;
 

goTorrentWebUI/node_modules/material-ui/es/Snackbar/SnackbarContent.js

@@ -1,19 +1,18 @@
-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; };
-
-function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
-
+import _extends from 'babel-runtime/helpers/extends';
+import _objectWithoutProperties from 'babel-runtime/helpers/objectWithoutProperties';
 // @inheritedComponent Paper
 
 import React from 'react';
-
+import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import withStyles from '../styles/withStyles';
 import Paper from '../Paper';
 import Typography from '../Typography';
+import { emphasize } from '../styles/colorManipulator';
 
 export const styles = theme => {
-  const type = theme.palette.type === 'light' ? 'dark' : 'light';
-  const backgroundColor = theme.palette.shades[type].background.default;
+  const emphasis = theme.palette.type === 'light' ? 0.8 : 0.98;
+  const backgroundColor = emphasize(theme.palette.background.default, emphasis);
 
   return {
     root: {
@@ -29,7 +28,7 @@ export const styles = theme => {
         maxWidth: 568,
         borderRadius: 2
       },
-      [theme.breakpoints.down('md')]: {
+      [theme.breakpoints.down('sm')]: {
         flexGrow: 1
       }
     },
@@ -75,4 +74,23 @@ function SnackbarContent(props) {
   );
 }
 
+SnackbarContent.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * The action to display.
+   */
+  action: PropTypes.node,
+  /**
+   * Useful to extend the style applied to components.
+   */
+  classes: PropTypes.object.isRequired,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * The message to display.
+   */
+  message: PropTypes.node
+} : {};
+
 export default withStyles(styles, { name: 'MuiSnackbarContent' })(SnackbarContent);