@deephaven/console 0.5.2-matplotlib.2 → 0.6.1-demo.8

package/dist/csv/CsvInputBar.js

@@ -1,56 +1,17 @@
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
-import { connect } from 'react-redux';
 import classNames from 'classnames';
 import JSZip from 'jszip';
-import { Checkbox } from '@deephaven/components';
+import { Button, Checkbox } from '@deephaven/components';
 import Log from '@deephaven/log';
-import { getTimeZone } from '@deephaven/redux';
 import { DbNameValidator } from '@deephaven/utils';
-import CsvOverlay from './CsvOverlay';
-import CsvParser from './CsvParser';
-import CsvFormats from './CsvFormats';
+import CsvOverlay from "./CsvOverlay.js";
+import CsvParser from "./CsvParser.js";
+import CsvFormats from "./CsvFormats.js";
 import "./CsvInputBar.css";
 var log = Log.module('CsvInputBar');
-var TYPE_OPTIONS = Object.entries(CsvFormats.TYPES).map(function (_ref) {
-  var _ref2 = _slicedToArray(_ref, 2),
-      key = _ref2[0],
-      value = _ref2[1];
-
+var TYPE_OPTIONS = Object.entries(CsvFormats.TYPES).map((_ref) => {
+  var [key, value] = _ref;
   return /*#__PURE__*/React.createElement("option", {
     key: key,
     value: key
@@ -60,27 +21,19 @@ var TYPE_OPTIONS = Object.entries(CsvFormats.TYPES).map(function (_ref) {
  * Input controls for CSV upload.
  */
 
-var CsvInputBar = /*#__PURE__*/function (_Component) {
-  _inherits(CsvInputBar, _Component);
-
-  var _super = _createSuper(CsvInputBar);
-
-  function CsvInputBar(props) {
-    var _this;
-
-    _classCallCheck(this, CsvInputBar);
-
-    _this = _super.call(this, props);
-    _this.handleUpload = _this.handleUpload.bind(_assertThisInitialized(_this));
-    _this.handleCancel = _this.handleCancel.bind(_assertThisInitialized(_this));
-    _this.handleError = _this.handleError.bind(_assertThisInitialized(_this));
-    _this.handleTableName = _this.handleTableName.bind(_assertThisInitialized(_this));
-    _this.toggleFirstRowHeaders = _this.toggleFirstRowHeaders.bind(_assertThisInitialized(_this));
-    _this.handleProgress = _this.handleProgress.bind(_assertThisInitialized(_this));
-    _this.handleCancelInProgress = _this.handleCancelInProgress.bind(_assertThisInitialized(_this));
-    _this.handleQueryTypeChange = _this.handleQueryTypeChange.bind(_assertThisInitialized(_this));
-    _this.inputRef = /*#__PURE__*/React.createRef();
-    _this.state = {
+class CsvInputBar extends Component {
+  constructor(props) {
+    super(props);
+    this.handleUpload = this.handleUpload.bind(this);
+    this.handleCancel = this.handleCancel.bind(this);
+    this.handleError = this.handleError.bind(this);
+    this.handleTableName = this.handleTableName.bind(this);
+    this.toggleFirstRowHeaders = this.toggleFirstRowHeaders.bind(this);
+    this.handleProgress = this.handleProgress.bind(this);
+    this.handleCancelInProgress = this.handleCancelInProgress.bind(this);
+    this.handleQueryTypeChange = this.handleQueryTypeChange.bind(this);
+    this.inputRef = /*#__PURE__*/React.createRef();
+    this.state = {
       tableName: '',
       tableNameSet: false,
       isFirstRowHeaders: true,
@@ -89,332 +42,312 @@ var CsvInputBar = /*#__PURE__*/function (_Component) {
       type: CsvFormats.DEFAULT_TYPE,
       parser: null
     };
-    return _this;
   } // React documentation says it is fine to update state inside an if statment
 
   /* eslint-disable react/no-did-update-set-state */
 
 
-  _createClass(CsvInputBar, [{
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps) {
-      var _this$props = this.props,
-          file = _this$props.file,
-          paste = _this$props.paste;
-      var _this$state = this.state,
-          tableName = _this$state.tableName,
-          tableNameSet = _this$state.tableNameSet; // Set the table name from a file
-
-      if (!tableNameSet && file && !tableName) {
-        var dotIndex = file.name.lastIndexOf('.');
-        var fileTableName = DbNameValidator.legalizeTableName(file.name.substring(0, dotIndex));
-        this.setState({
-          tableName: fileTableName,
-          tableNameSet: true
-        });
-        this.inputRef.current.focus();
-      } else if (!file && prevProps.file || !paste && prevProps.paste) {
-        // The file or paste was unstaged
-        this.setState({
-          tableName: '',
-          tableNameSet: false
-        });
-      } // Focus the name input field on paste
-
-
-      if (paste && !tableName && this.inputRef.current) {
-        this.inputRef.current.focus();
-      } // Determine parser type by file extension
-
-
-      if (file && file !== prevProps.file) {
-        this.setState({
-          type: CsvFormats.fromExtension(file.name)
-        });
-      } else if (paste && !prevProps.paste) {
-        this.setState({
-          type: CsvFormats.AUTO
-        });
-      }
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      var parser = this.state.parser;
+  componentDidUpdate(prevProps) {
+    var {
+      file,
+      paste
+    } = this.props;
+    var {
+      tableName,
+      tableNameSet
+    } = this.state; // Set the table name from a file
 
-      if (parser) {
-        parser.cancel();
-      }
-    }
-  }, {
-    key: "handleCancel",
-    value: function handleCancel() {
-      var onClose = this.props.onClose;
-      onClose();
-    }
-  }, {
-    key: "handleError",
-    value: function handleError(e) {
-      var _this$props2 = this.props,
-          onClose = _this$props2.onClose,
-          onError = _this$props2.onError;
-      log.error(e);
-      onError(e);
-      onClose();
-    }
-  }, {
-    key: "handleTableName",
-    value: function handleTableName(event) {
+    if (!tableNameSet && file && !tableName) {
+      var dotIndex = file.name.lastIndexOf('.');
+      var fileTableName = DbNameValidator.legalizeTableName(file.name.substring(0, dotIndex));
       this.setState({
-        tableName: event.target.value,
+        tableName: fileTableName,
         tableNameSet: true
       });
-    }
-  }, {
-    key: "toggleFirstRowHeaders",
-    value: function toggleFirstRowHeaders() {
-      var isFirstRowHeaders = this.state.isFirstRowHeaders;
+      this.inputRef.current.focus();
+    } else if (!file && prevProps.file || !paste && prevProps.paste) {
+      // The file or paste was unstaged
       this.setState({
-        isFirstRowHeaders: !isFirstRowHeaders
+        tableName: '',
+        tableNameSet: false
       });
-    }
-  }, {
-    key: "handleUpload",
-    value: function handleUpload(event) {
-      var _this2 = this;
+    } // Focus the name input field on paste
 
-      event.stopPropagation();
-      event.preventDefault();
-      var _this$props3 = this.props,
-          file = _this$props3.file,
-          paste = _this$props3.paste,
-          onUpdate = _this$props3.onUpdate;
 
-      if (file) {
-        if (file.name.endsWith('.zip')) {
-          JSZip.loadAsync(file).then(function (zip) {
-            var files = zip.files;
-            var csvFound = false; // Using a for loop instead of forEach in order to break
+    if (paste && !tableName && this.inputRef.current) {
+      this.inputRef.current.focus();
+    } // Determine parser type by file extension
 
-            var values = Object.values(files);
 
-            for (var i = 0; i < values.length; i += 1) {
-              var f = values[i];
-
-              if (CsvOverlay.isValidExtension(f.name)) {
-                onUpdate("Loading ".concat(f.name, " as csv from ").concat(file.name));
-                csvFound = true;
-
-                _this2.handleFile(f, true);
+    if (file && file !== prevProps.file) {
+      this.setState({
+        type: CsvFormats.fromExtension(file.name)
+      });
+    } else if (paste && !prevProps.paste) {
+      this.setState({
+        type: CsvFormats.AUTO
+      });
+    }
+  }
 
-                break;
-              }
-            }
+  componentWillUnmount() {
+    var {
+      parser
+    } = this.state;
 
-            if (!csvFound) {
-              throw new Error("No csv file found in ".concat(file.name));
+    if (parser) {
+      parser.cancel();
+    }
+  }
+
+  handleCancel() {
+    var {
+      onClose
+    } = this.props;
+    onClose();
+  }
+
+  handleError(e) {
+    var {
+      onClose,
+      onError
+    } = this.props;
+    log.error(e);
+    onError(e);
+    onClose();
+  }
+
+  handleTableName(event) {
+    this.setState({
+      tableName: event.target.value,
+      tableNameSet: true
+    });
+  }
+
+  toggleFirstRowHeaders() {
+    var {
+      isFirstRowHeaders
+    } = this.state;
+    this.setState({
+      isFirstRowHeaders: !isFirstRowHeaders
+    });
+  }
+
+  handleUpload(event) {
+    event.stopPropagation();
+    event.preventDefault();
+    var {
+      file,
+      paste,
+      onUpdate
+    } = this.props;
+
+    if (file) {
+      if (file.name.endsWith('.zip')) {
+        JSZip.loadAsync(file).then(zip => {
+          var {
+            files
+          } = zip;
+          var csvFound = false; // Using a for loop instead of forEach in order to break
+
+          var values = Object.values(files);
+
+          for (var i = 0; i < values.length; i += 1) {
+            var f = values[i];
+
+            if (CsvOverlay.isValidExtension(f.name)) {
+              onUpdate("Loading ".concat(f.name, " as csv from ").concat(file.name));
+              csvFound = true;
+              this.handleFile(f, true);
+              break;
             }
-          })["catch"](function (e) {
-            return _this2.handleError(e);
-          });
-        } else {
-          this.handleFile(file);
-        }
-      } else if (paste) {
-        this.handleFile(new Blob([paste], {
-          type: 'text/plain'
-        }));
+          }
+
+          if (!csvFound) {
+            throw new Error("No csv file found in ".concat(file.name));
+          }
+        }).catch(e => this.handleError(e));
+      } else {
+        this.handleFile(file);
       }
+    } else if (paste) {
+      this.handleFile(new Blob([paste], {
+        type: 'text/plain'
+      }));
     }
-  }, {
-    key: "handleFile",
-    value: function handleFile(file) {
-      var _this3 = this;
-
-      var isZip = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      log.info("Starting CSV parser for ".concat(file.name, " ").concat(isZip ? '' : "".concat(file.size, " bytes")));
-      var _this$props4 = this.props,
-          session = _this$props4.session,
-          timeZone = _this$props4.timeZone,
-          onInProgress = _this$props4.onInProgress;
-      var _this$state2 = this.state,
-          tableName = _this$state2.tableName,
-          isFirstRowHeaders = _this$state2.isFirstRowHeaders,
-          type = _this$state2.type;
-
-      var handleParseDone = function handleParseDone(tables) {
-        // Do not bother merging just one table
-        if (tables.length === 1) {
-          session.bindTableToVariable(tables[0], tableName).then(function () {
-            return _this3.openTable();
-          })["catch"](function (e) {
-            return _this3.handleError(e);
-          });
-        } else {
-          session.mergeTables(tables).then(function (table) {
-            session.bindTableToVariable(table, tableName).then(function () {
-              return _this3.openTable();
-            })["catch"](function (e) {
-              return _this3.handleError(e);
-            });
-            tables.forEach(function (t) {
-              return t.close();
-            });
-          })["catch"](function (e) {
-            return _this3.handleError(e);
-          });
-        }
-      };
-
-      var parser = new CsvParser({
-        onFileCompleted: handleParseDone,
-        session: session,
-        file: file,
-        type: CsvFormats.TYPES[type],
-        readHeaders: isFirstRowHeaders,
-        onProgress: this.handleProgress,
-        onError: this.handleError,
-        timeZone: timeZone,
-        isZip: isZip
-      });
-      parser.parse();
-      this.setState({
-        showProgress: true,
-        parser: parser
-      }); // Note that calling onClose will set in progress to false
-
-      onInProgress(true);
-    }
-  }, {
-    key: "handleProgress",
-    value: function handleProgress(progressValue) {
-      var showProgress = this.state.showProgress;
+  }
+
+  handleFile(file) {
+    var isZip = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    log.info("Starting CSV parser for ".concat(file.name, " ").concat(isZip ? '' : "".concat(file.size, " bytes")));
+    var {
+      session,
+      timeZone,
+      onInProgress
+    } = this.props;
+    var {
+      tableName,
+      isFirstRowHeaders,
+      type
+    } = this.state;
+
+    var handleParseDone = tables => {
+      // Do not bother merging just one table
+      if (tables.length === 1) {
+        session.bindTableToVariable(tables[0], tableName).then(() => this.openTable()).catch(e => this.handleError(e));
+      } else {
+        session.mergeTables(tables).then(table => {
+          session.bindTableToVariable(table, tableName).then(() => this.openTable()).catch(e => this.handleError(e));
+          tables.forEach(t => t.close());
+        }).catch(e => this.handleError(e));
+      }
+    };
 
-      if (showProgress) {
-        this.setState({
-          progressValue: progressValue
-        });
-      } // Indicates to the caller that the upload has been cancelled
+    var parser = new CsvParser({
+      onFileCompleted: handleParseDone,
+      session,
+      file,
+      type: CsvFormats.TYPES[type],
+      readHeaders: isFirstRowHeaders,
+      onProgress: this.handleProgress,
+      onError: this.handleError,
+      timeZone,
+      isZip
+    });
+    parser.parse();
+    this.setState({
+      showProgress: true,
+      parser
+    }); // Note that calling onClose will set in progress to false
+
+    onInProgress(true);
+  }
+
+  handleProgress(progressValue) {
+    var {
+      showProgress
+    } = this.state;
+
+    if (showProgress) {
+      this.setState({
+        progressValue
+      });
+    } // Indicates to the caller that the upload has been cancelled
 
 
-      return !showProgress;
-    } // Cancels an in progress upload
+    return !showProgress;
+  } // Cancels an in progress upload
 
-  }, {
-    key: "handleCancelInProgress",
-    value: function handleCancelInProgress() {
-      var onInProgress = this.props.onInProgress;
-      var parser = this.state.parser;
 
-      if (parser) {
-        parser.cancel();
-      }
+  handleCancelInProgress() {
+    var {
+      onInProgress
+    } = this.props;
+    var {
+      parser
+    } = this.state;
 
-      this.setState({
-        showProgress: false,
-        progressValue: 0
-      });
-      onInProgress(false);
-    }
-  }, {
-    key: "openTable",
-    value: function openTable() {
-      var _this$props5 = this.props,
-          onOpenTable = _this$props5.onOpenTable,
-          onClose = _this$props5.onClose;
-      var tableName = this.state.tableName;
-      onOpenTable(tableName);
-      onClose();
-    }
-  }, {
-    key: "handleQueryTypeChange",
-    value: function handleQueryTypeChange(event) {
-      this.setState({
-        type: event.target.value
-      });
+    if (parser) {
+      parser.cancel();
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props6 = this.props,
-          file = _this$props6.file,
-          paste = _this$props6.paste;
-      var _this$state3 = this.state,
-          tableName = _this$state3.tableName,
-          isFirstRowHeaders = _this$state3.isFirstRowHeaders,
-          showProgress = _this$state3.showProgress,
-          progressValue = _this$state3.progressValue,
-          type = _this$state3.type; // A blank table name is invalid for pasted values
-
-      var isNameInvalid = paste && !tableName;
-      return /*#__PURE__*/React.createElement("div", null, !showProgress && /*#__PURE__*/React.createElement("form", {
-        onSubmit: this.handleUpload,
-        className: "csv-input-bar-container"
-      }, /*#__PURE__*/React.createElement("div", {
-        className: "csv-input-form form-inline"
-      }, /*#__PURE__*/React.createElement("div", {
-        className: "form-group"
-      }, /*#__PURE__*/React.createElement("label", {
-        className: "mr-sm-2 mb-1",
-        htmlFor: "tableNameInput"
-      }, "Table name"), /*#__PURE__*/React.createElement("input", {
-        ref: this.inputRef,
-        id: "tableNameInput",
-        type: "text",
-        className: classNames('form-control mb-2 mr-sm-2', {
-          'is-invalid': isNameInvalid
-        }),
-        value: tableName,
-        onChange: this.handleTableName
-      })), /*#__PURE__*/React.createElement("div", {
-        className: "form-group"
-      }, /*#__PURE__*/React.createElement("label", {
-        className: "mr-sm-2 mb-1",
-        htmlFor: "formatSelect"
-      }, "File format"), /*#__PURE__*/React.createElement("select", {
-        id: "formatSelect",
-        className: "custom-select mb-2 mr-sm-2",
-        value: type,
-        onChange: this.handleQueryTypeChange
-      }, TYPE_OPTIONS)), /*#__PURE__*/React.createElement(Checkbox, {
-        className: "firstRowHeaders",
-        checked: isFirstRowHeaders,
-        onChange: this.toggleFirstRowHeaders
-      }, "First row is column headers"), /*#__PURE__*/React.createElement("div", {
-        className: "csv-input-buttons form-group"
-      }, /*#__PURE__*/React.createElement("button", {
-        type: "submit",
-        className: "btn btn-primary",
-        disabled: !(file || paste) || !tableName
-      }, "Upload"), /*#__PURE__*/React.createElement("button", {
-        type: "button",
-        className: "btn btn-outline-primary",
-        onClick: this.handleCancel
-      }, "Cancel")))), showProgress && /*#__PURE__*/React.createElement("div", {
-        className: "csv-progress-container"
-      }, /*#__PURE__*/React.createElement("label", null, "Uploading Table"), /*#__PURE__*/React.createElement("div", {
-        className: "progress",
-        style: {
-          marginBottom: '1rem'
-        }
-      }, /*#__PURE__*/React.createElement("div", {
-        className: "progress-bar bg-primary",
-        style: {
-          width: "".concat(progressValue, "%")
-        },
-        "aria-valuenow": progressValue,
-        "aria-valuemin": "0",
-        "aria-valuemax": "100"
-      })), /*#__PURE__*/React.createElement("label", null, progressValue, "%"), /*#__PURE__*/React.createElement("button", {
-        type: "button",
-        className: "btn btn-primary",
-        onClick: this.handleCancelInProgress
-      }, "Cancel")));
-    }
-  }]);
 
-  return CsvInputBar;
-}(Component);
+    this.setState({
+      showProgress: false,
+      progressValue: 0
+    });
+    onInProgress(false);
+  }
+
+  openTable() {
+    var {
+      onOpenTable,
+      onClose
+    } = this.props;
+    var {
+      tableName
+    } = this.state;
+    onOpenTable(tableName);
+    onClose();
+  }
+
+  handleQueryTypeChange(event) {
+    this.setState({
+      type: event.target.value
+    });
+  }
+
+  render() {
+    var {
+      file,
+      paste
+    } = this.props;
+    var {
+      tableName,
+      isFirstRowHeaders,
+      showProgress,
+      progressValue,
+      type
+    } = this.state; // A blank table name is invalid for pasted values
+
+    var isNameInvalid = paste && !tableName;
+    return /*#__PURE__*/React.createElement("div", null, !showProgress && /*#__PURE__*/React.createElement("form", {
+      onSubmit: this.handleUpload,
+      className: "csv-input-bar-container form-inline"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "form-group"
+    }, /*#__PURE__*/React.createElement("label", {
+      htmlFor: "tableNameInput"
+    }, "Table name"), /*#__PURE__*/React.createElement("input", {
+      ref: this.inputRef,
+      id: "tableNameInput",
+      type: "text",
+      className: classNames('form-control', {
+        'is-invalid': isNameInvalid
+      }),
+      value: tableName,
+      onChange: this.handleTableName
+    })), /*#__PURE__*/React.createElement("div", {
+      className: "form-group"
+    }, /*#__PURE__*/React.createElement("label", {
+      htmlFor: "formatSelect"
+    }, "File format"), /*#__PURE__*/React.createElement("select", {
+      id: "formatSelect",
+      className: "custom-select",
+      value: type,
+      onChange: this.handleQueryTypeChange
+    }, TYPE_OPTIONS)), /*#__PURE__*/React.createElement(Checkbox, {
+      className: "firstRowHeaders",
+      checked: isFirstRowHeaders,
+      onChange: this.toggleFirstRowHeaders
+    }, "First row is column headers"), /*#__PURE__*/React.createElement("div", {
+      className: "csv-input-buttons form-group"
+    }, /*#__PURE__*/React.createElement(Button, {
+      kind: "secondary",
+      onClick: this.handleCancel
+    }, "Cancel"), /*#__PURE__*/React.createElement(Button, {
+      kind: "primary",
+      type: "submit",
+      disabled: !(file || paste) || !tableName
+    }, "Upload"))), showProgress && /*#__PURE__*/React.createElement("div", {
+      className: "csv-progress-container"
+    }, /*#__PURE__*/React.createElement("label", null, "Uploading Table"), /*#__PURE__*/React.createElement("div", {
+      className: "progress"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "progress-bar bg-primary",
+      style: {
+        width: "".concat(progressValue, "%")
+      },
+      "aria-valuenow": progressValue,
+      "aria-valuemin": "0",
+      "aria-valuemax": "100"
+    })), /*#__PURE__*/React.createElement("label", null, progressValue, "%"), /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      className: "btn btn-primary",
+      onClick: this.handleCancelInProgress
+    }, "Cancel")));
+  }
+
+}
 
 CsvInputBar.propTypes = {
   session: PropTypes.shape({
@@ -434,12 +367,5 @@ CsvInputBar.defaultProps = {
   file: null,
   paste: null
 };
-
-var mapStateToProps = function mapStateToProps(state) {
-  return {
-    timeZone: getTimeZone(state)
-  };
-};
-
-export default connect(mapStateToProps)(CsvInputBar);
+export default CsvInputBar;
 //# sourceMappingURL=CsvInputBar.js.map