@pie-lib/editable-html-tip-tap 1.0.0

package/lib/plugins/media/media-dialog.js

@@ -0,0 +1,709 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.MediaDialog = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _renderUi = require("@pie-lib/render-ui");
+
+var _styles = require("@material-ui/core/styles");
+
+var _Button = _interopRequireDefault(require("@material-ui/core/Button"));
+
+var _Dialog = _interopRequireDefault(require("@material-ui/core/Dialog"));
+
+var _Tabs = _interopRequireDefault(require("@material-ui/core/Tabs"));
+
+var _Tab = _interopRequireDefault(require("@material-ui/core/Tab"));
+
+var _DialogTitle = _interopRequireDefault(require("@material-ui/core/DialogTitle"));
+
+var _DialogContent = _interopRequireDefault(require("@material-ui/core/DialogContent"));
+
+var _DialogContentText = _interopRequireDefault(require("@material-ui/core/DialogContentText"));
+
+var _DialogActions = _interopRequireDefault(require("@material-ui/core/DialogActions"));
+
+var _TextField = _interopRequireDefault(require("@material-ui/core/TextField"));
+
+var _Typography = _interopRequireDefault(require("@material-ui/core/Typography"));
+
+var _IconButton = _interopRequireDefault(require("@material-ui/core/IconButton"));
+
+var _Delete = _interopRequireDefault(require("@material-ui/icons/Delete"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+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; } }
+
+var log = (0, _debug["default"])('@pie-lib:editable-html:plugins:media:dialog');
+
+var matchYoutubeUrl = function matchYoutubeUrl(url) {
+  if (!url) {
+    return false;
+  }
+
+  var p = /^(?:https?:\/\/)?(?:m\.|www\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=))((\w|-){11})(?:\S+)?$/;
+
+  if (url.match(p)) {
+    return url.match(p)[1];
+  }
+
+  return false;
+};
+
+var matchVimeoUrl = function matchVimeoUrl(url) {
+  return url && /(http|https)?:\/\/(www\.)?(player\.)?vimeo.com\/(?:channels\/(?:\w+\/)?|groups\/([^/]*)\/videos\/|)(video\/)?(\d+)(?:|\/\?)/.test(url);
+};
+
+var matchDriveUrl = function matchDriveUrl(url) {
+  return url && /^https:\/\/drive\.google\.com\/(?:file\/d\/|drive\/(?:u\/\d+\/)?folders\/|uc\?id=)([a-zA-Z0-9_-]+)/.test(url);
+};
+
+var matchSoundCloudUrl = function matchSoundCloudUrl(url) {
+  if (!url) {
+    return false;
+  }
+
+  var regexp = /^https?:\/\/(soundcloud\.com|snd\.sc)\/(.*)$/;
+  return url.match(regexp) && url.match(regexp)[2];
+};
+
+var makeApiRequest = function makeApiRequest(url) {
+  return new Promise(function (resolve) {
+    try {
+      fetch("https://soundcloud.com/oembed?format=json&url=".concat(url)).then(function (response) {
+        return response.json();
+      }).then(function (json) {
+        var d = document.createElement('div');
+        d.innerHTML = json.html;
+        var iframe = d.querySelector('iframe');
+        resolve(iframe.src);
+      })["catch"](function (err) {
+        resolve('');
+        log(err);
+      });
+    } catch (err) {
+      resolve('');
+    }
+  });
+};
+
+var typeMap = {
+  video: 'Video',
+  audio: 'Audio'
+};
+var tabsTypeMap = {
+  uploadFile: 'upload-file',
+  insertUrl: 'insert-url'
+};
+
+var MediaDialog = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(MediaDialog, _React$Component);
+
+  var _super = _createSuper(MediaDialog);
+
+  function MediaDialog(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, MediaDialog);
+    _this = _super.call(this, props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "formatUrl", function () {
+      var _this$state = _this.state,
+          url = _this$state.url,
+          urlToUse = _this$state.urlToUse,
+          starts = _this$state.starts,
+          ends = _this$state.ends;
+      var isYoutube = matchYoutubeUrl(url);
+      var isVimeo = matchVimeoUrl(url);
+      var formattedUrl = urlToUse;
+
+      if ((isYoutube || isVimeo) && urlToUse) {
+        var params = [];
+        var paramName;
+        var paramStart;
+
+        switch (true) {
+          case isVimeo:
+            paramName = 't';
+            paramStart = '#';
+            break;
+
+          case isYoutube:
+            paramName = 'start';
+            paramStart = '?';
+            break;
+
+          default:
+            paramName = 'start';
+            paramStart = '?';
+        }
+
+        if (starts) {
+          params.push("".concat(paramName, "=").concat(starts));
+        }
+
+        if (ends) {
+          params.push("end=".concat(ends));
+        }
+
+        formattedUrl = "".concat(urlToUse).concat(params.length ? paramStart : '').concat(params.join('&'));
+      }
+
+      var callback = function callback() {
+        return _this.setState({
+          formattedUrl: formattedUrl,
+          updating: false
+        });
+      };
+
+      _this.setState({
+        formattedUrl: null,
+        updating: true
+      }, callback);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleStateChange", function (newState) {
+      return _this.setState(newState, _this.formatUrl);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "checkAudio", function (value) {
+      if (matchSoundCloudUrl(value)) {
+        makeApiRequest(value).then(function (urlToUse) {
+          _this.handleStateChange({
+            urlToUse: urlToUse,
+            invalid: !urlToUse,
+            url: value
+          });
+        })["catch"](log);
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "checkVideo", function (value) {
+      if (matchYoutubeUrl(value)) {
+        var regExp = /^.*(youtu\.be\/|v\/|u\/\w\/|embed\/|watch\?v=|&v=)([^#&?]*).*/;
+        var match = value.match(regExp);
+        var id = match[2];
+        var urlToUse = "https://youtube.com/embed/".concat(id);
+        log('is youtube');
+
+        _this.handleStateChange({
+          urlToUse: urlToUse,
+          url: value,
+          invalid: false
+        });
+      }
+
+      if (matchVimeoUrl(value)) {
+        var _id = value.replace(/.*vimeo.com\/(.*)/g, '$1');
+
+        var _urlToUse2 = "https://player.vimeo.com/video/".concat(_id);
+
+        log('is vimeo');
+
+        _this.handleStateChange({
+          urlToUse: _urlToUse2,
+          url: value,
+          ends: null,
+          invalid: false
+        });
+      }
+
+      if (matchDriveUrl(value)) {
+        // https://drive.google.com/file/d/11QkK_gUO068amNvZBm9cxZpKX74WYb8q/view
+        var _id2 = value.replace(/^https:\/\/drive\.google\.com\/(?:file\/d\/|drive\/(?:u\/\d+\/)?folders\/|uc\?id=)([a-zA-Z0-9_-]+)\/.*/, '$1');
+
+        var _urlToUse3 = "https://drive.google.com/file/d/".concat(_id2, "/preview");
+
+        log('is google drive');
+
+        _this.handleStateChange({
+          urlToUse: _urlToUse3,
+          url: value,
+          ends: null,
+          invalid: false
+        });
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "urlChange", function (e) {
+      var _ref = e.target || {},
+          value = _ref.value;
+
+      var type = _this.props.type;
+
+      if (type && type === 'audio') {
+        _this.checkAudio();
+
+        return;
+      } else if (type && type === 'video') {
+        _this.checkVideo(value);
+
+        return;
+      }
+
+      _this.handleStateChange({
+        urlToUse: null,
+        url: null,
+        invalid: true
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "changeHandler", function (type) {
+      return function (e) {
+        return _this.handleStateChange((0, _defineProperty2["default"])({}, type, e.target.value));
+      };
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleDone", function (val) {
+      var handleClose = _this.props.handleClose;
+      var _this$state2 = _this.state,
+          tabValue = _this$state2.tabValue,
+          fileUpload = _this$state2.fileUpload;
+      var isInsertURL = tabValue === tabsTypeMap.insertUrl;
+
+      if (!val) {
+        if (fileUpload.url) {
+          _this.handleRemoveFile();
+        }
+
+        handleClose(val);
+        return;
+      }
+
+      if (isInsertURL) {
+        var _this$state3 = _this.state,
+            ends = _this$state3.ends,
+            height = _this$state3.height,
+            url = _this$state3.url,
+            urlToUse = _this$state3.urlToUse,
+            formattedUrl = _this$state3.formattedUrl,
+            starts = _this$state3.starts,
+            width = _this$state3.width;
+        handleClose(val, {
+          tag: 'iframe',
+          ends: ends,
+          height: height,
+          starts: starts,
+          width: width,
+          url: url,
+          urlToUse: urlToUse,
+          src: formattedUrl
+        });
+        return;
+      }
+
+      if (!fileUpload.loading) {
+        handleClose(val, {
+          tag: 'audio',
+          src: fileUpload.url
+        });
+        return;
+      }
+
+      _this.setState({
+        fileUpload: _objectSpread(_objectSpread({}, fileUpload), {}, {
+          scheduled: true
+        })
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleUploadFile", /*#__PURE__*/function () {
+      var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(e) {
+        var fileChosen, reader;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                e.preventDefault();
+
+                _this.setState({
+                  fileUpload: _objectSpread(_objectSpread({}, _this.state.fileUpload), {}, {
+                    error: null,
+                    loading: true
+                  })
+                });
+
+                fileChosen = e.target.files[0];
+                reader = new FileReader();
+
+                reader.onload = function () {
+                  var dataURL = reader.result;
+
+                  _this.setState({
+                    fileUpload: _objectSpread(_objectSpread({}, _this.state.fileUpload), {}, {
+                      url: dataURL,
+                      mimeType: fileChosen.type
+                    })
+                  });
+                };
+
+                reader.readAsDataURL(fileChosen);
+
+                _this.props.uploadSoundSupport.add({
+                  fileChosen: fileChosen,
+                  done: function done(err, src) {
+                    log('done: err:', err);
+
+                    if (err) {
+                      //eslint-disable-next-line
+                      console.log(err);
+
+                      _this.setState({
+                        fileUpload: _objectSpread(_objectSpread({}, _this.state.fileUpload), {}, {
+                          scheduled: false,
+                          loading: false,
+                          error: err
+                        })
+                      });
+
+                      return;
+                    }
+
+                    var fileUpload = _this.state.fileUpload;
+                    var callback = fileUpload && fileUpload.scheduled ? _this.handleDone.bind((0, _assertThisInitialized2["default"])(_this), true) : undefined;
+
+                    _this.setState({
+                      fileUpload: _objectSpread(_objectSpread({}, fileUpload), {}, {
+                        scheduled: false,
+                        loading: false,
+                        url: src
+                      })
+                    }, callback);
+                  }
+                });
+
+              case 7:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleRemoveFile", /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      return _regenerator["default"].wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _this.props.uploadSoundSupport["delete"](_this.state.fileUpload.url, function (err) {
+                if (err) {
+                  //eslint-disable-next-line
+                  console.log(err);
+
+                  _this.setState({
+                    fileUpload: _objectSpread(_objectSpread({}, _this.state.fileUpload), {}, {
+                      error: err
+                    })
+                  });
+                }
+              }); // we should put it inside uploadSoundSupport.delete but we can leave it here for testing purposes
+
+
+              _this.setState({
+                fileUpload: _objectSpread(_objectSpread({}, _this.state.fileUpload), {}, {
+                  loading: false,
+                  url: '',
+                  mimeType: ''
+                })
+              });
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    })));
+    var _ends = props.ends,
+        _height = props.height,
+        _src = props.src,
+        _starts = props.starts,
+        _type = props.type,
+        uploadSoundSupport = props.uploadSoundSupport,
+        _url = props.url,
+        _urlToUse = props.urlToUse,
+        _width = props.width;
+    var showUploadFile = (uploadSoundSupport === null || uploadSoundSupport === void 0 ? void 0 : uploadSoundSupport.add) && (uploadSoundSupport === null || uploadSoundSupport === void 0 ? void 0 : uploadSoundSupport["delete"]) && _type !== 'video';
+    _this.state = {
+      ends: _ends || 0,
+      url: _url,
+      urlToUse: _urlToUse,
+      formattedUrl: _src,
+      height: _height || 315,
+      invalid: false,
+      starts: _starts || 0,
+      width: _width || 560,
+      // default selected tab should be upload file if available
+      tabValue: showUploadFile ? tabsTypeMap.uploadFile : tabsTypeMap.insertUrl,
+      fileUpload: {
+        error: null,
+        loading: false,
+        scheduled: false,
+        url: '',
+        mimeType: ''
+      }
+    };
+    return _this;
+  }
+
+  (0, _createClass2["default"])(MediaDialog, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.url) {
+        this.urlChange({
+          target: {
+            value: this.props.url
+          }
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props = this.props,
+          classes = _this$props.classes,
+          open = _this$props.open,
+          disablePortal = _this$props.disablePortal,
+          type = _this$props.type,
+          edit = _this$props.edit,
+          uploadSoundSupport = _this$props.uploadSoundSupport;
+      var _this$state4 = this.state,
+          ends = _this$state4.ends,
+          height = _this$state4.height,
+          invalid = _this$state4.invalid,
+          starts = _this$state4.starts,
+          width = _this$state4.width,
+          url = _this$state4.url,
+          mimeType = _this$state4.mimeType,
+          formattedUrl = _this$state4.formattedUrl,
+          updating = _this$state4.updating,
+          tabValue = _this$state4.tabValue,
+          fileUpload = _this$state4.fileUpload;
+      var isYoutube = matchYoutubeUrl(url);
+      var isInsertURL = tabValue === tabsTypeMap.insertUrl;
+      var isUploadMedia = tabValue === tabsTypeMap.uploadFile;
+      var submitIsDisabled = isInsertURL ? invalid || url === null || url === undefined : !fileUpload.url || fileUpload.scheduled;
+      var showUploadFile = (uploadSoundSupport === null || uploadSoundSupport === void 0 ? void 0 : uploadSoundSupport.add) && (uploadSoundSupport === null || uploadSoundSupport === void 0 ? void 0 : uploadSoundSupport["delete"]) && type !== 'video';
+      return /*#__PURE__*/_react["default"].createElement(_Dialog["default"], {
+        classes: {
+          paper: classes.paper
+        },
+        disablePortal: disablePortal,
+        open: open,
+        onClose: function onClose() {
+          return _this2.handleDone(false);
+        },
+        "aria-labelledby": "form-dialog-title"
+      }, /*#__PURE__*/_react["default"].createElement(_DialogTitle["default"], {
+        id: "form-dialog-title"
+      }, "Insert ", typeMap[type]), /*#__PURE__*/_react["default"].createElement(_DialogContent["default"], null, /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement("div", {
+        className: classes.row
+      }, /*#__PURE__*/_react["default"].createElement(_Tabs["default"], {
+        indicatorColor: "primary",
+        value: tabValue,
+        onChange: function onChange(event, value) {
+          _this2.setState({
+            tabValue: value
+          });
+        }
+      }, showUploadFile ? /*#__PURE__*/_react["default"].createElement(_Tab["default"], {
+        value: tabsTypeMap.uploadFile,
+        label: "Upload file"
+      }) : null, /*#__PURE__*/_react["default"].createElement(_Tab["default"], {
+        value: tabsTypeMap.insertUrl,
+        label: type === 'video' ? 'Insert YouTube, Vimeo, or Google Drive URL' : 'Insert SoundCloud URL'
+      }))), isInsertURL && /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
+        autoFocus: true,
+        error: invalid,
+        helperText: invalid ? 'Invalid URL' : '',
+        margin: "dense",
+        id: "name",
+        label: "URL",
+        placeholder: "Paste URL of ".concat(type, "..."),
+        type: "text",
+        onChange: this.urlChange,
+        value: url,
+        fullWidth: true
+      }), type === 'video' && /*#__PURE__*/_react["default"].createElement(_DialogContent["default"], {
+        classes: {
+          root: classes.properties
+        }
+      }, /*#__PURE__*/_react["default"].createElement(_DialogContentText["default"], null, "Video Properties"), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
+        autoFocus: true,
+        margin: "dense",
+        id: "width",
+        label: "Width",
+        type: "number",
+        placeholder: "Width",
+        value: width,
+        onChange: this.changeHandler('width')
+      }), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
+        autoFocus: true,
+        margin: "dense",
+        id: "height",
+        label: "Height",
+        type: "number",
+        placeholder: "Height",
+        value: height,
+        onChange: this.changeHandler('height')
+      })), formattedUrl && /*#__PURE__*/_react["default"].createElement("iframe", {
+        width: width,
+        height: height,
+        src: formattedUrl,
+        frameBorder: "0",
+        allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture",
+        allowFullScreen: true
+      }), type === 'video' && (formattedUrl || updating) && !invalid && /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(_DialogContent["default"], {
+        classes: {
+          root: classes.properties
+        }
+      }, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
+        autoFocus: true,
+        margin: "dense",
+        id: "starts",
+        label: "Starts",
+        type: "number",
+        placeholder: "Starts",
+        value: starts,
+        onChange: this.changeHandler('starts')
+      }), isYoutube && /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
+        autoFocus: true,
+        margin: "dense",
+        id: "ends",
+        label: "Ends",
+        type: "number",
+        placeholder: "Ends",
+        value: ends,
+        onChange: this.changeHandler('ends')
+      })))), isUploadMedia && /*#__PURE__*/_react["default"].createElement("div", {
+        className: classes.uploadInput
+      }, /*#__PURE__*/_react["default"].createElement("div", null, fileUpload.url ? /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement("div", {
+        className: classes.row
+      }, /*#__PURE__*/_react["default"].createElement("audio", {
+        controls: "controls",
+        controlsList: "nodownload"
+      }, /*#__PURE__*/_react["default"].createElement("source", {
+        type: mimeType,
+        src: fileUpload.url
+      })), /*#__PURE__*/_react["default"].createElement(_IconButton["default"], {
+        "aria-label": "delete",
+        className: classes.deleteIcon,
+        onClick: this.handleRemoveFile
+      }, /*#__PURE__*/_react["default"].createElement(_Delete["default"], null))), !fileUpload.scheduled && fileUpload.loading ? /*#__PURE__*/_react["default"].createElement(_Typography["default"], {
+        variant: "subheading"
+      }, "Loading...") : null, fileUpload.scheduled ? /*#__PURE__*/_react["default"].createElement(_Typography["default"], {
+        variant: "subheading"
+      }, "Waiting for Upload to finish, then inserting item...") : null) : !fileUpload.loading ? /*#__PURE__*/_react["default"].createElement("input", {
+        accept: "audio/*",
+        className: classes.input,
+        onChange: this.handleUploadFile,
+        type: "file"
+      }) : null, !!fileUpload.error && /*#__PURE__*/_react["default"].createElement(_Typography["default"], {
+        className: classes.error,
+        variant: "caption"
+      }, fileUpload.error))))), /*#__PURE__*/_react["default"].createElement(_DialogActions["default"], null, /*#__PURE__*/_react["default"].createElement(_Button["default"], {
+        onClick: function onClick() {
+          return _this2.handleDone(false);
+        },
+        color: "primary"
+      }, "Cancel"), /*#__PURE__*/_react["default"].createElement(_Button["default"], {
+        disabled: submitIsDisabled,
+        onClick: function onClick() {
+          return _this2.handleDone(true);
+        },
+        color: "primary"
+      }, edit ? 'Update' : 'Insert')));
+    }
+  }]);
+  return MediaDialog;
+}(_react["default"].Component);
+
+exports.MediaDialog = MediaDialog;
+(0, _defineProperty2["default"])(MediaDialog, "propTypes", {
+  classes: _propTypes["default"].object.isRequired,
+  open: _propTypes["default"].bool,
+  edit: _propTypes["default"].bool,
+  disablePortal: _propTypes["default"].bool,
+  handleClose: _propTypes["default"].func,
+  uploadSoundSupport: _propTypes["default"].shape({
+    add: _propTypes["default"].func,
+    "delete": _propTypes["default"].func
+  }),
+  type: _propTypes["default"].string,
+  src: _propTypes["default"].string,
+  url: _propTypes["default"].string,
+  urlToUse: _propTypes["default"].string,
+  starts: _propTypes["default"].number,
+  ends: _propTypes["default"].number,
+  height: _propTypes["default"].number,
+  width: _propTypes["default"].number
+});
+
+var styles = function styles(theme) {
+  return {
+    paper: {
+      minWidth: '500px'
+    },
+    properties: {
+      padding: 0
+    },
+    row: {
+      display: 'flex',
+      flexDirection: 'space-between'
+    },
+    rowItem: {
+      marginRight: theme.spacing.unit * 1.5,
+      cursor: 'pointer'
+    },
+    active: {
+      color: _renderUi.color.primary(),
+      borderBottom: "2px solid ".concat(_renderUi.color.primary())
+    },
+    uploadInput: {
+      marginTop: theme.spacing.unit * 1.5
+    },
+    error: {
+      marginTop: theme.spacing.unit * 1.5,
+      color: theme.palette.error.main
+    },
+    deleteIcon: {
+      marginLeft: theme.spacing.unit * 1.5
+    }
+  };
+};
+
+var _default = (0, _styles.withStyles)(styles)(MediaDialog);
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/plugins/media/media-dialog.js"],"names":["log","matchYoutubeUrl","url","p","match","matchVimeoUrl","test","matchDriveUrl","matchSoundCloudUrl","regexp","makeApiRequest","Promise","resolve","fetch","then","response","json","d","document","createElement","innerHTML","html","iframe","querySelector","src","err","typeMap","video","audio","tabsTypeMap","uploadFile","insertUrl","MediaDialog","props","state","urlToUse","starts","ends","isYoutube","isVimeo","formattedUrl","params","paramName","paramStart","push","length","join","callback","setState","updating","newState","formatUrl","value","handleStateChange","invalid","regExp","id","replace","e","target","type","checkAudio","checkVideo","val","handleClose","tabValue","fileUpload","isInsertURL","handleRemoveFile","height","width","tag","loading","scheduled","preventDefault","error","fileChosen","files","reader","FileReader","onload","dataURL","result","mimeType","readAsDataURL","uploadSoundSupport","add","done","console","handleDone","bind","undefined","showUploadFile","urlChange","classes","open","disablePortal","edit","isUploadMedia","submitIsDisabled","paper","row","event","root","properties","changeHandler","uploadInput","deleteIcon","input","handleUploadFile","React","Component","PropTypes","object","isRequired","bool","func","shape","string","number","styles","theme","minWidth","padding","display","flexDirection","rowItem","marginRight","spacing","unit","cursor","active","color","primary","borderBottom","marginTop","palette","main","marginLeft"],"mappings":"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","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport debug from 'debug';\nimport { color } from '@pie-lib/render-ui';\nimport { withStyles } from '@material-ui/core/styles';\nimport Button from '@material-ui/core/Button';\nimport Dialog from '@material-ui/core/Dialog';\nimport MuiTabs from '@material-ui/core/Tabs';\nimport MuiTab from '@material-ui/core/Tab';\nimport DialogTitle from '@material-ui/core/DialogTitle';\nimport DialogContent from '@material-ui/core/DialogContent';\nimport DialogContentText from '@material-ui/core/DialogContentText';\nimport DialogActions from '@material-ui/core/DialogActions';\nimport TextField from '@material-ui/core/TextField';\nimport Typography from '@material-ui/core/Typography';\nimport IconButton from '@material-ui/core/IconButton';\nimport ActionDelete from '@material-ui/icons/Delete';\n\nconst log = debug('@pie-lib:editable-html:plugins:media:dialog');\n\nconst matchYoutubeUrl = (url) => {\n  if (!url) {\n    return false;\n  }\n\n  const p = /^(?:https?:\\/\\/)?(?:m\\.|www\\.)?(?:youtu\\.be\\/|youtube\\.com\\/(?:embed\\/|v\\/|watch\\?v=|watch\\?.+&v=))((\\w|-){11})(?:\\S+)?$/;\n  if (url.match(p)) {\n    return url.match(p)[1];\n  }\n  return false;\n};\n\nconst matchVimeoUrl = (url) =>\n  url &&\n  /(http|https)?:\\/\\/(www\\.)?(player\\.)?vimeo.com\\/(?:channels\\/(?:\\w+\\/)?|groups\\/([^/]*)\\/videos\\/|)(video\\/)?(\\d+)(?:|\\/\\?)/.test(\n    url,\n  );\n\nconst matchDriveUrl = (url) =>\n  url && /^https:\\/\\/drive\\.google\\.com\\/(?:file\\/d\\/|drive\\/(?:u\\/\\d+\\/)?folders\\/|uc\\?id=)([a-zA-Z0-9_-]+)/.test(url);\n\nconst matchSoundCloudUrl = (url) => {\n  if (!url) {\n    return false;\n  }\n\n  const regexp = /^https?:\\/\\/(soundcloud\\.com|snd\\.sc)\\/(.*)$/;\n  return url.match(regexp) && url.match(regexp)[2];\n};\n\nconst makeApiRequest = (url) => {\n  return new Promise((resolve) => {\n    try {\n      fetch(`https://soundcloud.com/oembed?format=json&url=${url}`)\n        .then((response) => response.json())\n        .then((json) => {\n          const d = document.createElement('div');\n\n          d.innerHTML = json.html;\n\n          const iframe = d.querySelector('iframe');\n\n          resolve(iframe.src);\n        })\n        .catch((err) => {\n          resolve('');\n          log(err);\n        });\n    } catch (err) {\n      resolve('');\n    }\n  });\n};\n\nconst typeMap = {\n  video: 'Video',\n  audio: 'Audio',\n};\n\nconst tabsTypeMap = {\n  uploadFile: 'upload-file',\n  insertUrl: 'insert-url',\n};\n\nexport class MediaDialog extends React.Component {\n  static propTypes = {\n    classes: PropTypes.object.isRequired,\n    open: PropTypes.bool,\n    edit: PropTypes.bool,\n    disablePortal: PropTypes.bool,\n    handleClose: PropTypes.func,\n    uploadSoundSupport: PropTypes.shape({\n      add: PropTypes.func,\n      delete: PropTypes.func,\n    }),\n    type: PropTypes.string,\n    src: PropTypes.string,\n    url: PropTypes.string,\n    urlToUse: PropTypes.string,\n    starts: PropTypes.number,\n    ends: PropTypes.number,\n    height: PropTypes.number,\n    width: PropTypes.number,\n  };\n\n  constructor(props) {\n    super(props);\n\n    const { ends, height, src, starts, type, uploadSoundSupport, url, urlToUse, width } = props;\n    const showUploadFile = uploadSoundSupport?.add && uploadSoundSupport?.delete && type !== 'video';\n\n    this.state = {\n      ends: ends || 0,\n      url: url,\n      urlToUse: urlToUse,\n      formattedUrl: src,\n      height: height || 315,\n      invalid: false,\n      starts: starts || 0,\n      width: width || 560,\n      // default selected tab should be upload file if available\n      tabValue: showUploadFile ? tabsTypeMap.uploadFile : tabsTypeMap.insertUrl,\n      fileUpload: {\n        error: null,\n        loading: false,\n        scheduled: false,\n        url: '',\n        mimeType: '',\n      },\n    };\n  }\n\n  componentDidMount() {\n    if (this.props.url) {\n      this.urlChange({\n        target: {\n          value: this.props.url,\n        },\n      });\n    }\n  }\n\n  formatUrl = () => {\n    const { url, urlToUse, starts, ends } = this.state;\n    const isYoutube = matchYoutubeUrl(url);\n    const isVimeo = matchVimeoUrl(url);\n    let formattedUrl = urlToUse;\n\n    if ((isYoutube || isVimeo) && urlToUse) {\n      const params = [];\n\n      let paramName;\n      let paramStart;\n\n      switch (true) {\n        case isVimeo:\n          paramName = 't';\n          paramStart = '#';\n          break;\n        case isYoutube:\n          paramName = 'start';\n          paramStart = '?';\n          break;\n        default:\n          paramName = 'start';\n          paramStart = '?';\n      }\n\n      if (starts) {\n        params.push(`${paramName}=${starts}`);\n      }\n\n      if (ends) {\n        params.push(`end=${ends}`);\n      }\n\n      formattedUrl = `${urlToUse}${params.length ? paramStart : ''}${params.join('&')}`;\n    }\n\n    const callback = () => this.setState({ formattedUrl, updating: false });\n\n    this.setState({ formattedUrl: null, updating: true }, callback);\n  };\n\n  handleStateChange = (newState) => this.setState(newState, this.formatUrl);\n\n  checkAudio = (value) => {\n    if (matchSoundCloudUrl(value)) {\n      makeApiRequest(value)\n        .then((urlToUse) => {\n          this.handleStateChange({\n            urlToUse,\n            invalid: !urlToUse,\n            url: value,\n          });\n        })\n        .catch(log);\n    }\n  };\n\n  checkVideo = (value) => {\n    if (matchYoutubeUrl(value)) {\n      const regExp = /^.*(youtu\\.be\\/|v\\/|u\\/\\w\\/|embed\\/|watch\\?v=|&v=)([^#&?]*).*/;\n      const match = value.match(regExp);\n      const id = match[2];\n      const urlToUse = `https://youtube.com/embed/${id}`;\n\n      log('is youtube');\n\n      this.handleStateChange({\n        urlToUse,\n        url: value,\n        invalid: false,\n      });\n    }\n\n    if (matchVimeoUrl(value)) {\n      const id = value.replace(/.*vimeo.com\\/(.*)/g, '$1');\n      const urlToUse = `https://player.vimeo.com/video/${id}`;\n\n      log('is vimeo');\n\n      this.handleStateChange({\n        urlToUse,\n        url: value,\n        ends: null,\n        invalid: false,\n      });\n    }\n\n    if (matchDriveUrl(value)) {\n      // https://drive.google.com/file/d/11QkK_gUO068amNvZBm9cxZpKX74WYb8q/view\n      const id = value.replace(\n        /^https:\\/\\/drive\\.google\\.com\\/(?:file\\/d\\/|drive\\/(?:u\\/\\d+\\/)?folders\\/|uc\\?id=)([a-zA-Z0-9_-]+)\\/.*/,\n        '$1',\n      );\n      const urlToUse = `https://drive.google.com/file/d/${id}/preview`;\n\n      log('is google drive');\n\n      this.handleStateChange({\n        urlToUse,\n        url: value,\n        ends: null,\n        invalid: false,\n      });\n    }\n  };\n\n  urlChange = (e) => {\n    const { value } = e.target || {};\n    const { type } = this.props;\n\n    if (type && type === 'audio') {\n      this.checkAudio();\n      return;\n    } else if (type && type === 'video') {\n      this.checkVideo(value);\n      return;\n    }\n\n    this.handleStateChange({\n      urlToUse: null,\n      url: null,\n      invalid: true,\n    });\n  };\n\n  changeHandler = (type) => (e) => this.handleStateChange({ [type]: e.target.value });\n\n  handleDone = (val) => {\n    const { handleClose } = this.props;\n    const { tabValue, fileUpload } = this.state;\n    const isInsertURL = tabValue === tabsTypeMap.insertUrl;\n\n    if (!val) {\n      if (fileUpload.url) {\n        this.handleRemoveFile();\n      }\n\n      handleClose(val);\n      return;\n    }\n\n    if (isInsertURL) {\n      const { ends, height, url, urlToUse, formattedUrl, starts, width } = this.state;\n\n      handleClose(val, {\n        tag: 'iframe',\n        ends,\n        height,\n        starts,\n        width,\n        url,\n        urlToUse,\n        src: formattedUrl,\n      });\n      return;\n    }\n\n    if (!fileUpload.loading) {\n      handleClose(val, {\n        tag: 'audio',\n        src: fileUpload.url,\n      });\n      return;\n    }\n\n    this.setState({\n      fileUpload: {\n        ...fileUpload,\n        scheduled: true,\n      },\n    });\n  };\n\n  handleUploadFile = async (e) => {\n    e.preventDefault();\n\n    this.setState({\n      fileUpload: {\n        ...this.state.fileUpload,\n        error: null,\n        loading: true,\n      },\n    });\n\n    const fileChosen = e.target.files[0];\n\n    const reader = new FileReader();\n\n    reader.onload = () => {\n      const dataURL = reader.result;\n\n      this.setState({\n        fileUpload: {\n          ...this.state.fileUpload,\n          url: dataURL,\n          mimeType: fileChosen.type,\n        },\n      });\n    };\n    reader.readAsDataURL(fileChosen);\n\n    this.props.uploadSoundSupport.add({\n      fileChosen,\n      done: (err, src) => {\n        log('done: err:', err);\n        if (err) {\n          //eslint-disable-next-line\n          console.log(err);\n          this.setState({\n            fileUpload: {\n              ...this.state.fileUpload,\n              scheduled: false,\n              loading: false,\n              error: err,\n            },\n          });\n          return;\n        }\n\n        const { fileUpload } = this.state;\n        const callback = fileUpload && fileUpload.scheduled ? this.handleDone.bind(this, true) : undefined;\n\n        this.setState(\n          {\n            fileUpload: {\n              ...fileUpload,\n              scheduled: false,\n              loading: false,\n              url: src,\n            },\n          },\n          callback,\n        );\n      },\n    });\n  };\n\n  handleRemoveFile = async () => {\n    this.props.uploadSoundSupport.delete(this.state.fileUpload.url, (err) => {\n      if (err) {\n        //eslint-disable-next-line\n        console.log(err);\n        this.setState({\n          fileUpload: {\n            ...this.state.fileUpload,\n            error: err,\n          },\n        });\n      }\n    });\n\n    // we should put it inside uploadSoundSupport.delete but we can leave it here for testing purposes\n    this.setState({\n      fileUpload: {\n        ...this.state.fileUpload,\n        loading: false,\n        url: '',\n        mimeType: '',\n      },\n    });\n  };\n\n  render() {\n    const { classes, open, disablePortal, type, edit, uploadSoundSupport } = this.props;\n    const {\n      ends,\n      height,\n      invalid,\n      starts,\n      width,\n      url,\n      mimeType,\n      formattedUrl,\n      updating,\n      tabValue,\n      fileUpload,\n    } = this.state;\n    const isYoutube = matchYoutubeUrl(url);\n    const isInsertURL = tabValue === tabsTypeMap.insertUrl;\n    const isUploadMedia = tabValue === tabsTypeMap.uploadFile;\n    const submitIsDisabled = isInsertURL\n      ? invalid || url === null || url === undefined\n      : !fileUpload.url || fileUpload.scheduled;\n    const showUploadFile = uploadSoundSupport?.add && uploadSoundSupport?.delete && type !== 'video';\n\n    return (\n      <Dialog\n        classes={{\n          paper: classes.paper,\n        }}\n        disablePortal={disablePortal}\n        open={open}\n        onClose={() => this.handleDone(false)}\n        aria-labelledby=\"form-dialog-title\"\n      >\n        <DialogTitle id=\"form-dialog-title\">Insert {typeMap[type]}</DialogTitle>\n        <DialogContent>\n          <div>\n            <div className={classes.row}>\n              <MuiTabs\n                indicatorColor=\"primary\"\n                value={tabValue}\n                onChange={(event, value) => {\n                  this.setState({ tabValue: value });\n                }}\n              >\n                {showUploadFile ? <MuiTab value={tabsTypeMap.uploadFile} label=\"Upload file\" /> : null}\n                <MuiTab\n                  value={tabsTypeMap.insertUrl}\n                  label={type === 'video' ? 'Insert YouTube, Vimeo, or Google Drive URL' : 'Insert SoundCloud URL'}\n                />\n              </MuiTabs>\n            </div>\n            {isInsertURL && (\n              <div>\n                <TextField\n                  autoFocus\n                  error={invalid}\n                  helperText={invalid ? 'Invalid URL' : ''}\n                  margin=\"dense\"\n                  id=\"name\"\n                  label=\"URL\"\n                  placeholder={`Paste URL of ${type}...`}\n                  type=\"text\"\n                  onChange={this.urlChange}\n                  value={url}\n                  fullWidth\n                />\n                {type === 'video' && (\n                  <DialogContent\n                    classes={{\n                      root: classes.properties,\n                    }}\n                  >\n                    <DialogContentText>Video Properties</DialogContentText>\n                    <TextField\n                      autoFocus\n                      margin=\"dense\"\n                      id=\"width\"\n                      label=\"Width\"\n                      type=\"number\"\n                      placeholder=\"Width\"\n                      value={width}\n                      onChange={this.changeHandler('width')}\n                    />\n                    <TextField\n                      autoFocus\n                      margin=\"dense\"\n                      id=\"height\"\n                      label=\"Height\"\n                      type=\"number\"\n                      placeholder=\"Height\"\n                      value={height}\n                      onChange={this.changeHandler('height')}\n                    />\n                  </DialogContent>\n                )}\n                {formattedUrl && (\n                  <iframe\n                    width={width}\n                    height={height}\n                    src={formattedUrl}\n                    frameBorder=\"0\"\n                    allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\"\n                    allowFullScreen\n                  />\n                )}\n                {type === 'video' && (formattedUrl || updating) && !invalid && (\n                  <React.Fragment>\n                    <DialogContent\n                      classes={{\n                        root: classes.properties,\n                      }}\n                    >\n                      <TextField\n                        autoFocus\n                        margin=\"dense\"\n                        id=\"starts\"\n                        label=\"Starts\"\n                        type=\"number\"\n                        placeholder=\"Starts\"\n                        value={starts}\n                        onChange={this.changeHandler('starts')}\n                      />\n                      {isYoutube && (\n                        <TextField\n                          autoFocus\n                          margin=\"dense\"\n                          id=\"ends\"\n                          label=\"Ends\"\n                          type=\"number\"\n                          placeholder=\"Ends\"\n                          value={ends}\n                          onChange={this.changeHandler('ends')}\n                        />\n                      )}\n                    </DialogContent>\n                  </React.Fragment>\n                )}\n              </div>\n            )}\n            {isUploadMedia && (\n              <div className={classes.uploadInput}>\n                <div>\n                  {fileUpload.url ? (\n                    <>\n                      <div className={classes.row}>\n                        <audio controls=\"controls\" controlsList=\"nodownload\">\n                          <source type={mimeType} src={fileUpload.url} />\n                        </audio>\n                        <IconButton aria-label=\"delete\" className={classes.deleteIcon} onClick={this.handleRemoveFile}>\n                          <ActionDelete />\n                        </IconButton>\n                      </div>\n                      {!fileUpload.scheduled && fileUpload.loading ? (\n                        <Typography variant=\"subheading\">Loading...</Typography>\n                      ) : null}\n                      {fileUpload.scheduled ? (\n                        <Typography variant=\"subheading\">\n                          Waiting for Upload to finish, then inserting item...\n                        </Typography>\n                      ) : null}\n                    </>\n                  ) : !fileUpload.loading ? (\n                    <input accept=\"audio/*\" className={classes.input} onChange={this.handleUploadFile} type=\"file\" />\n                  ) : null}\n                  {!!fileUpload.error && (\n                    <Typography className={classes.error} variant=\"caption\">\n                      {fileUpload.error}\n                    </Typography>\n                  )}\n                </div>\n              </div>\n            )}\n          </div>\n        </DialogContent>\n        <DialogActions>\n          <Button onClick={() => this.handleDone(false)} color=\"primary\">\n            Cancel\n          </Button>\n          <Button disabled={submitIsDisabled} onClick={() => this.handleDone(true)} color=\"primary\">\n            {edit ? 'Update' : 'Insert'}\n          </Button>\n        </DialogActions>\n      </Dialog>\n    );\n  }\n}\n\nconst styles = (theme) => ({\n  paper: {\n    minWidth: '500px',\n  },\n  properties: {\n    padding: 0,\n  },\n  row: {\n    display: 'flex',\n    flexDirection: 'space-between',\n  },\n  rowItem: {\n    marginRight: theme.spacing.unit * 1.5,\n    cursor: 'pointer',\n  },\n  active: {\n    color: color.primary(),\n    borderBottom: `2px solid ${color.primary()}`,\n  },\n  uploadInput: {\n    marginTop: theme.spacing.unit * 1.5,\n  },\n  error: {\n    marginTop: theme.spacing.unit * 1.5,\n    color: theme.palette.error.main,\n  },\n  deleteIcon: {\n    marginLeft: theme.spacing.unit * 1.5,\n  },\n});\n\nexport default withStyles(styles)(MediaDialog);\n"]}