@modusoperandi/licit 0.14.18 → 1.0.1

package/HistoryRedoCommand.js

@@ -0,0 +1,49 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { redo } from 'prosemirror-history';
+import { EditorState } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import * as React from 'react';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+var HistoryRedoCommand = /*#__PURE__*/function (_UICommand) {
+  _inherits(HistoryRedoCommand, _UICommand);
+  function HistoryRedoCommand() {
+    var _this;
+    _classCallCheck(this, HistoryRedoCommand);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, HistoryRedoCommand, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "execute", function (state, dispatch, view) {
+      return redo(state, dispatch);
+    });
+    _defineProperty(_assertThisInitialized(_this), "waitForUserInput", function (_state, _dispatch, _view, _event) {
+      return Promise.resolve(undefined);
+    });
+    _defineProperty(_assertThisInitialized(_this), "executeWithUserInput", function (_state, _dispatch, _view, _inputs) {
+      return false;
+    });
+    return _this;
+  }
+  _createClass(HistoryRedoCommand, [{
+    key: "cancel",
+    value: function cancel() {
+      return null;
+    }
+  }]);
+  return HistoryRedoCommand;
+}(UICommand);
+export default HistoryRedoCommand;

package/HistoryRedoCommand.js.flow

@@ -0,0 +1,41 @@
+// @flow
+
+import { redo } from 'prosemirror-history';
+import { EditorState } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import * as React from 'react';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+
+class HistoryRedoCommand extends UICommand {
+  execute = (
+    state: EditorState,
+    dispatch: ?(tr: Transform) => void,
+    view: ?EditorView
+  ): boolean => {
+    return redo(state, dispatch);
+  };
+  waitForUserInput = (
+    _state: EditorState,
+    _dispatch: ?(tr: Transform) => void,
+    _view: ?EditorView,
+    _event: ?React.SyntheticEvent
+  ): Promise<undefined> => {
+    return Promise.resolve(undefined);
+  };
+
+  executeWithUserInput = (
+    _state: EditorState,
+    _dispatch: ?(tr: Transform) => void,
+    _view: ?EditorView,
+    _inputs: ?string
+  ): boolean => {
+    return false;
+  };
+
+  cancel(): void {
+    return null;
+  }
+}
+
+export default HistoryRedoCommand;

package/HistoryUndoCommand.js

@@ -0,0 +1,49 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { undo } from 'prosemirror-history';
+import { EditorState } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import * as React from 'react';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+var HistoryUndoCommand = /*#__PURE__*/function (_UICommand) {
+  _inherits(HistoryUndoCommand, _UICommand);
+  function HistoryUndoCommand() {
+    var _this;
+    _classCallCheck(this, HistoryUndoCommand);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, HistoryUndoCommand, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "execute", function (state, dispatch, view) {
+      return undo(state, dispatch);
+    });
+    _defineProperty(_assertThisInitialized(_this), "waitForUserInput", function (_state, _dispatch, _view, _event) {
+      return Promise.resolve(undefined);
+    });
+    _defineProperty(_assertThisInitialized(_this), "executeWithUserInput", function (_state, _dispatch, _view, _inputs) {
+      return false;
+    });
+    return _this;
+  }
+  _createClass(HistoryUndoCommand, [{
+    key: "cancel",
+    value: function cancel() {
+      return null;
+    }
+  }]);
+  return HistoryUndoCommand;
+}(UICommand);
+export default HistoryUndoCommand;

package/HistoryUndoCommand.js.flow

@@ -0,0 +1,41 @@
+// @flow
+
+import { undo } from 'prosemirror-history';
+import { EditorState } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import * as React from 'react';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+
+class HistoryUndoCommand extends UICommand {
+  execute = (
+    state: EditorState,
+    dispatch: ?(tr: Transform) => void,
+    view: ?EditorView
+  ): boolean => {
+    return undo(state, dispatch);
+  };
+  waitForUserInput = (
+    _state: EditorState,
+    _dispatch: ?(tr: Transform) => void,
+    _view: ?EditorView,
+    _event: ?React.SyntheticEvent
+  ): Promise<undefined> => {
+    return Promise.resolve(undefined);
+  };
+
+  executeWithUserInput = (
+    _state: EditorState,
+    _dispatch: ?(tr: Transform) => void,
+    _view: ?EditorView,
+    _inputs: ?string
+  ): boolean => {
+    return false;
+  };
+
+  cancel(): void {
+    return null;
+  }
+}
+
+export default HistoryUndoCommand;

package/HorizontalRuleCommand.js

@@ -0,0 +1,78 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Fragment, Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import * as React from 'react';
+import { HORIZONTAL_RULE } from './NodeNames.js';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+function insertHorizontalRule(tr, schema) {
+  var _tr = tr,
+    selection = _tr.selection;
+  if (!selection) {
+    return tr;
+  }
+  var from = selection.from,
+    to = selection.to;
+  if (from !== to) {
+    return tr;
+  }
+  var horizontalRule = schema.nodes[HORIZONTAL_RULE];
+  if (!horizontalRule) {
+    return tr;
+  }
+  var node = horizontalRule.create({}, null, null);
+  var frag = Fragment.from(node);
+  tr = tr.insert(from, frag);
+  return tr;
+}
+var HorizontalRuleCommand = /*#__PURE__*/function (_UICommand) {
+  _inherits(HorizontalRuleCommand, _UICommand);
+  function HorizontalRuleCommand() {
+    var _this;
+    _classCallCheck(this, HorizontalRuleCommand);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, HorizontalRuleCommand, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "execute", function (state, dispatch, view) {
+      var selection = state.selection,
+        schema = state.schema;
+      var tr = insertHorizontalRule(state.tr.setSelection(selection), schema);
+      if (tr.docChanged) {
+        dispatch && dispatch(tr);
+        return true;
+      } else {
+        return false;
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "waitForUserInput", function (_state, _dispatch, _view, _event) {
+      return Promise.resolve(undefined);
+    });
+    _defineProperty(_assertThisInitialized(_this), "executeWithUserInput", function (_state, _dispatch, _view, _inputs) {
+      return false;
+    });
+    return _this;
+  }
+  _createClass(HorizontalRuleCommand, [{
+    key: "cancel",
+    value: function cancel() {
+      return null;
+    }
+  }]);
+  return HorizontalRuleCommand;
+}(UICommand);
+export default HorizontalRuleCommand;

package/HorizontalRuleCommand.js.flow

@@ -0,0 +1,71 @@
+// @flow
+
+import { Fragment, Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import * as React from 'react';
+import { HORIZONTAL_RULE } from './NodeNames.js';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+
+function insertHorizontalRule(tr: Transform, schema: Schema): Transform {
+  const { selection } = tr;
+  if (!selection) {
+    return tr;
+  }
+  const { from, to } = selection;
+  if (from !== to) {
+    return tr;
+  }
+
+  const horizontalRule = schema.nodes[HORIZONTAL_RULE];
+  if (!horizontalRule) {
+    return tr;
+  }
+
+  const node = horizontalRule.create({}, null, null);
+  const frag = Fragment.from(node);
+  tr = tr.insert(from, frag);
+  return tr;
+}
+
+class HorizontalRuleCommand extends UICommand {
+  execute = (
+    state: EditorState,
+    dispatch: ?(tr: Transform) => void,
+    view: ?EditorView
+  ): boolean => {
+    const { selection, schema } = state;
+    const tr = insertHorizontalRule(state.tr.setSelection(selection), schema);
+    if (tr.docChanged) {
+      dispatch && dispatch(tr);
+      return true;
+    } else {
+      return false;
+    }
+  };
+
+  waitForUserInput = (
+    _state: EditorState,
+    _dispatch: ?(tr: Transform) => void,
+    _view: ?EditorView,
+    _event: ?React.SyntheticEvent
+  ): Promise<undefined> => {
+    return Promise.resolve(undefined);
+  };
+
+  executeWithUserInput = (
+    _state: EditorState,
+    _dispatch: ?(tr: Transform) => void,
+    _view: ?EditorView,
+    _inputs: ?string
+  ): boolean => {
+    return false;
+  };
+
+  cancel(): void {
+    return null;
+  }
+}
+
+export default HorizontalRuleCommand;

package/HorizontalRuleNodeSpec.js

@@ -0,0 +1,31 @@
+import { Node } from 'prosemirror-model';
+var DOM_ATTRIBUTE_PAGE_BREAK = 'data-page-break';
+function getAttrs(dom) {
+  var attrs = {};
+  if (dom.getAttribute(DOM_ATTRIBUTE_PAGE_BREAK) || dom.style.pageBreakBefore === 'always') {
+    // Google Doc exports page break as HTML:
+    // `<hr style="page-break-before:always;display:none; />`.
+    attrs.pageBreak = true;
+  }
+  return attrs;
+}
+var HorizontalRuleNode = {
+  attrs: {
+    pageBreak: {
+      "default": null
+    }
+  },
+  group: 'block',
+  parseDOM: [{
+    tag: 'hr',
+    getAttrs: getAttrs
+  }],
+  toDOM: function toDOM(node) {
+    var domAttrs = {};
+    if (node.attrs.pageBreak) {
+      domAttrs[DOM_ATTRIBUTE_PAGE_BREAK] = 'true';
+    }
+    return ['hr', domAttrs];
+  }
+};
+export default HorizontalRuleNode;

package/ImageUploadPlaceholderPlugin.js

@@ -0,0 +1,181 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } 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() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+import nullthrows from 'nullthrows';
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { EditorState, TextSelection } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { EditorView } from 'prosemirror-view';
+import { IMAGE } from './NodeNames.js';
+import uuid from './ui/uuid.js';
+import './ui/czi-image-upload-placeholder.css';
+var IMAGE_FILE_TYLES = new Set(['image/jpeg', 'image/gif', 'image/png', 'image/jpg']);
+var TITLE = 'Uploading...';
+var INNER_HTML = new Array(4).join('<div class="czi-image-upload-placeholder-child"></div>');
+function isImageUploadPlaceholderPlugin(plugin) {
+  return plugin instanceof ImageUploadPlaceholderPlugin;
+}
+function isImageFileType(file) {
+  return file && IMAGE_FILE_TYLES.has(file.type);
+}
+function findImageUploadPlaceholder(placeholderPlugin, state, id) {
+  var decos = placeholderPlugin.getState(state);
+  var found = decos.find(null, null, function (spec) {
+    return spec.id === id;
+  });
+  return found.length ? found[0].from : null;
+}
+function defer(fn) {
+  return function () {
+    setTimeout(fn, 0);
+  };
+}
+export function uploadImageFiles(view, files, coords) {
+  var runtime = view.runtime,
+    state = view.state,
+    readOnly = view.readOnly,
+    disabled = view.disabled;
+  var schema = state.schema,
+    plugins = state.plugins;
+  if (readOnly || disabled || !runtime || !runtime.canUploadImage) {
+    return false;
+  }
+  var imageType = schema.nodes[IMAGE];
+  if (!imageType) {
+    return false;
+  }
+  var uploadImage = runtime.uploadImage,
+    canUploadImage = runtime.canUploadImage;
+  if (!uploadImage || !canUploadImage) {
+    return false;
+  }
+  var imageFiles = Array.from(files).filter(isImageFileType);
+  if (!imageFiles.length) {
+    return false;
+  }
+  var placeholderPlugin = plugins.find(isImageUploadPlaceholderPlugin);
+  if (!placeholderPlugin) {
+    return false;
+  }
+
+  // A fresh object to act as the ID for this upload.
+  var id = {
+    debugId: 'image_upload_' + uuid()
+  };
+  var uploadNext = defer(function () {
+    var done = function done(imageInfo) {
+      var pos = findImageUploadPlaceholder(placeholderPlugin, view.state, id);
+      var trNext = view.state.tr;
+      if (pos && !view.readOnly && !view.disabled) {
+        var imageNode = imageType.create(imageInfo);
+        trNext = trNext.replaceWith(pos, pos, imageNode);
+      } else {
+        // Upload was cancelled.
+        imageFiles.length = 0;
+      }
+      if (imageFiles.length) {
+        uploadNext();
+      } else {
+        // Remove the placeholder.
+        trNext = trNext.setMeta(placeholderPlugin, {
+          remove: {
+            id: id
+          }
+        });
+      }
+      view.dispatch(trNext);
+    };
+    var ff = nullthrows(imageFiles.shift());
+    uploadImage(ff).then(done)["catch"](done.bind(null, {
+      src: null
+    }));
+  });
+  uploadNext();
+  var tr = state.tr;
+
+  // Replace the selection with a placeholder
+  var from = 0;
+
+  // Adjust the cursor to the dropped position.
+  if (coords) {
+    var dropPos = view.posAtCoords({
+      left: coords.x,
+      top: coords.y
+    });
+    if (!dropPos) {
+      return false;
+    }
+    from = dropPos.pos;
+    tr = tr.setSelection(TextSelection.create(tr.doc, from, from));
+  } else {
+    from = tr.selection.to;
+    tr = tr.setSelection(TextSelection.create(tr.doc, from, from));
+  }
+  var meta = {
+    add: {
+      id: id,
+      pos: from
+    }
+  };
+  tr = tr.setMeta(placeholderPlugin, meta);
+  view.dispatch(tr);
+  return true;
+}
+
+// https://prosemirror.net/examples/upload/
+var ImageUploadPlaceholderPlugin = /*#__PURE__*/function (_Plugin) {
+  _inherits(ImageUploadPlaceholderPlugin, _Plugin);
+  function ImageUploadPlaceholderPlugin() {
+    _classCallCheck(this, ImageUploadPlaceholderPlugin);
+    return _callSuper(this, ImageUploadPlaceholderPlugin, [{
+      // [FS] IRAD-1005 2020-07-07
+      // Upgrade outdated packages.
+      key: new PluginKey('ImageUploadPlaceholderPlugin'),
+      state: {
+        init: function init() {
+          return DecorationSet.empty;
+        },
+        apply: function apply(tr, set) {
+          // Adjust decoration positions to changes made by the transaction
+          set = set.map(tr.mapping, tr.doc);
+          // See if the transaction adds or removes any placeholders
+          var action = tr.getMeta(this);
+          if (action && action.add) {
+            var el = document.createElement('div');
+            el.title = TITLE;
+            el.className = 'czi-image-upload-placeholder';
+            el.innerHTML = INNER_HTML;
+            var deco = Decoration.widget(action.add.pos, el, {
+              id: action.add.id
+            });
+            set = set.add(tr.doc, [deco]);
+          } else if (action && action.remove) {
+            var finder = function finder(spec) {
+              return spec.id == action.remove.id;
+            };
+            set = set.remove(set.find(null, null, finder));
+          }
+          return set;
+        }
+      },
+      props: {
+        decorations: function decorations(state) {
+          return this.getState(state);
+        }
+      }
+    }]);
+  }
+  return _createClass(ImageUploadPlaceholderPlugin);
+}(Plugin);
+export default ImageUploadPlaceholderPlugin;