@modusoperandi/licit 0.14.18 → 1.0.0

package/TableCellColorCommand.js

@@ -0,0 +1,81 @@
+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 nullthrows from 'nullthrows';
+import { EditorState } from 'prosemirror-state';
+import { setCellAttr } from 'prosemirror-tables';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import { ColorEditor } from '@modusoperandi/licit-ui-commands';
+import { atAnchorRight } from '@modusoperandi/licit-ui-commands';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+import { createPopUp } from '@modusoperandi/licit-ui-commands';
+var setCellBackgroundBlack = setCellAttr('background', '#000000');
+var TableCellColorCommand = /*#__PURE__*/function (_UICommand) {
+  _inherits(TableCellColorCommand, _UICommand);
+  function TableCellColorCommand() {
+    var _this;
+    _classCallCheck(this, TableCellColorCommand);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, TableCellColorCommand, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "_popUp", null);
+    _defineProperty(_assertThisInitialized(_this), "shouldRespondToUIEvent", function (e) {
+      return e.type === UICommand.EventType.MOUSEENTER;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isEnabled", function (state) {
+      return setCellBackgroundBlack(state.tr);
+    });
+    _defineProperty(_assertThisInitialized(_this), "waitForUserInput", function (state, dispatch, view, event) {
+      if (_this._popUp) {
+        return Promise.resolve(undefined);
+      }
+      var target = nullthrows(event).currentTarget;
+      if (!(target instanceof HTMLElement)) {
+        return Promise.resolve(undefined);
+      }
+      var anchor = event ? event.currentTarget : null;
+      return new Promise(function (resolve) {
+        _this._popUp = createPopUp(ColorEditor, null, {
+          anchor: anchor,
+          position: atAnchorRight,
+          onClose: function onClose(val) {
+            if (_this._popUp) {
+              _this._popUp = null;
+              resolve(val);
+            }
+          }
+        });
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "executeWithUserInput", function (state, dispatch, view, hex) {
+      if (dispatch && hex !== undefined) {
+        var cmd = setCellAttr('background', hex);
+        cmd(state, dispatch, view);
+        return true;
+      }
+      return false;
+    });
+    return _this;
+  }
+  _createClass(TableCellColorCommand, [{
+    key: "cancel",
+    value: function cancel() {
+      return null;
+    }
+  }]);
+  return TableCellColorCommand;
+}(UICommand);
+export default TableCellColorCommand;

package/TableCellColorCommand.js.flow

@@ -0,0 +1,75 @@
+// @flow
+
+import nullthrows from 'nullthrows';
+import { EditorState } from 'prosemirror-state';
+import { setCellAttr } from 'prosemirror-tables';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+
+import { ColorEditor } from '@modusoperandi/licit-ui-commands';
+import { atAnchorRight } from '@modusoperandi/licit-ui-commands';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+import { createPopUp } from '@modusoperandi/licit-ui-commands';
+
+const setCellBackgroundBlack = setCellAttr('background', '#000000');
+
+class TableCellColorCommand extends UICommand {
+  _popUp = null;
+
+  shouldRespondToUIEvent = (e: SyntheticEvent<> | MouseEvent): boolean => {
+    return e.type === UICommand.EventType.MOUSEENTER;
+  };
+
+  isEnabled = (state: EditorState): boolean => {
+    return setCellBackgroundBlack(state.tr);
+  };
+
+  waitForUserInput = (
+    state: EditorState,
+    dispatch: ?(tr: Transform) => void,
+    view: ?EditorView,
+    event: ?SyntheticEvent<>
+  ): Promise<any> => {
+    if (this._popUp) {
+      return Promise.resolve(undefined);
+    }
+    const target = nullthrows(event).currentTarget;
+    if (!(target instanceof HTMLElement)) {
+      return Promise.resolve(undefined);
+    }
+
+    const anchor = event ? event.currentTarget : null;
+    return new Promise((resolve) => {
+      this._popUp = createPopUp(ColorEditor, null, {
+        anchor,
+        position: atAnchorRight,
+        onClose: (val) => {
+          if (this._popUp) {
+            this._popUp = null;
+            resolve(val);
+          }
+        },
+      });
+    });
+  };
+
+  executeWithUserInput = (
+    state: EditorState,
+    dispatch: ?(tr: Transform) => void,
+    view: ?EditorView,
+    hex: ?string
+  ): boolean => {
+    if (dispatch && hex !== undefined) {
+      const cmd = setCellAttr('background', hex);
+      cmd(state, dispatch, view);
+      return true;
+    }
+    return false;
+  };
+
+  cancel(): void {
+    return null;
+  }
+}
+
+export default TableCellColorCommand;

package/TableCellMenuPlugin.js

@@ -0,0 +1,137 @@
+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 _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); }
+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 _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 { EditorState, Plugin, PluginKey } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+/* eslint-disable-next-line */
+import * as React from 'react';
+import findActionableCell from './findActionableCell.js';
+import { atAnchorTopRight } from '@modusoperandi/licit-ui-commands';
+import TableCellMenu from './ui/TableCellMenu.js';
+import bindScrollHandler from './ui/bindScrollHandler.js';
+import { createPopUp } from '@modusoperandi/licit-ui-commands';
+import isElementFullyVisible from './ui/isElementFullyVisible.js';
+import '@modusoperandi/licit-ui-commands/ui/czi-pop-up.css';
+import { CellSelection } from 'prosemirror-tables';
+var TableCellTooltipView = /*#__PURE__*/function () {
+  function TableCellTooltipView(editorView) {
+    var _this = this;
+    _classCallCheck(this, TableCellTooltipView);
+    _defineProperty(this, "_cellElement", void 0);
+    _defineProperty(this, "_popUp", null);
+    _defineProperty(this, "_scrollHandle", null);
+    _defineProperty(this, "destroy", function () {
+      _this._popUp && _this._popUp.close();
+      _this._popUp = null;
+    });
+    _defineProperty(this, "_onOpen", function () {
+      var cellEl = _this._cellElement;
+      if (!cellEl) {
+        return;
+      }
+      _this._scrollHandle = bindScrollHandler(cellEl, _this._onScroll);
+    });
+    _defineProperty(this, "_onClose", function () {
+      _this._popUp = null;
+      _this._scrollHandle && _this._scrollHandle.dispose();
+      _this._scrollHandle = null;
+    });
+    _defineProperty(this, "_onScroll", function () {
+      var popUp = _this._popUp;
+      var cellEl = _this._cellElement;
+      if (!popUp || !cellEl) {
+        return;
+      }
+      if (!isElementFullyVisible(cellEl)) {
+        popUp.close();
+      }
+    });
+    this.update(editorView, null);
+  }
+  _createClass(TableCellTooltipView, [{
+    key: "update",
+    value: function update(view, lastState) {
+      var state = view.state,
+        readOnly = view.readOnly;
+      var result = findActionableCell(state);
+      if (!result || readOnly) {
+        this.destroy();
+        return;
+      }
+
+      // These is screen coordinate.
+      var domFound = view.domAtPos(result.pos + 1);
+      if (!domFound) {
+        this.destroy();
+        return;
+      }
+      var cellEl = domFound.node;
+      var popUp = this._popUp;
+      var actionNode = null;
+      if (result && state.selection instanceof CellSelection) {
+        actionNode = state.selection.$anchorCell.node(-1);
+      }
+      var viewPops = {
+        editorState: state,
+        editorView: view,
+        pluginView: this,
+        actionNode: actionNode
+      };
+      if (cellEl && !isElementFullyVisible(cellEl)) {
+        cellEl = null;
+      }
+      if (!cellEl) {
+        // Closes the popup.
+        popUp && popUp.close();
+        this._cellElement = null;
+      } else if (popUp && cellEl === this._cellElement) {
+        // Updates the popup.
+        popUp.update(viewPops);
+      } else {
+        // Creates a new popup.
+        popUp && popUp.close();
+        this._cellElement = cellEl;
+        // [FS] IRAD-1009 2020-07-16
+        // Does not allow Table Menu Popuup button in disable mode
+        if (!view.disabled) {
+          this._popUp = createPopUp(TableCellMenu, viewPops, {
+            anchor: cellEl,
+            autoDismiss: false,
+            onClose: this._onClose,
+            position: atAnchorTopRight
+          });
+          this._onOpen();
+        }
+      }
+    }
+  }]);
+  return TableCellTooltipView;
+}(); // https://prosemirror.net/examples/tooltip/
+var SPEC = {
+  // [FS] IRAD-1005 2020-07-07
+  // Upgrade outdated packages.
+  key: new PluginKey('TableCellMenuPlugin'),
+  view: function view(editorView) {
+    return new TableCellTooltipView(editorView);
+  }
+};
+var TableCellMenuPlugin = /*#__PURE__*/function (_Plugin) {
+  _inherits(TableCellMenuPlugin, _Plugin);
+  function TableCellMenuPlugin() {
+    _classCallCheck(this, TableCellMenuPlugin);
+    return _callSuper(this, TableCellMenuPlugin, [SPEC]);
+  }
+  return _createClass(TableCellMenuPlugin);
+}(Plugin);
+export default TableCellMenuPlugin;

package/TableCellMenuPlugin.js.flow

@@ -0,0 +1,132 @@
+// @flow
+
+import { EditorState, Plugin, PluginKey } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+/* eslint-disable-next-line */
+import * as React from 'react';
+
+import findActionableCell from './findActionableCell.js';
+import { atAnchorTopRight } from '@modusoperandi/licit-ui-commands';
+import TableCellMenu from './ui/TableCellMenu.js';
+import bindScrollHandler from './ui/bindScrollHandler.js';
+import { createPopUp } from '@modusoperandi/licit-ui-commands';
+import isElementFullyVisible from './ui/isElementFullyVisible.js';
+
+import '@modusoperandi/licit-ui-commands/ui/czi-pop-up.css';
+import { CellSelection } from 'prosemirror-tables';
+
+class TableCellTooltipView {
+  _cellElement: null;
+  _popUp = null;
+  _scrollHandle = null;
+
+  constructor(editorView: EditorView) {
+    this.update(editorView, null);
+  }
+
+  update(view: EditorView, lastState: EditorState): void {
+    const { state, readOnly } = view;
+    const result = findActionableCell(state);
+
+    if (!result || readOnly) {
+      this.destroy();
+      return;
+    }
+
+    // These is screen coordinate.
+    const domFound = view.domAtPos(result.pos + 1);
+    if (!domFound) {
+      this.destroy();
+      return;
+    }
+
+    let cellEl = domFound.node;
+    const popUp = this._popUp;
+    let actionNode = null;
+    if (result && state.selection instanceof CellSelection) {
+      actionNode = state.selection.$anchorCell.node(-1);
+    }
+    const viewPops = {
+      editorState: state,
+      editorView: view,
+      pluginView: this,
+      actionNode,
+    };
+
+    if (cellEl && !isElementFullyVisible(cellEl)) {
+      cellEl = null;
+    }
+
+    if (!cellEl) {
+      // Closes the popup.
+      popUp && popUp.close();
+      this._cellElement = null;
+    } else if (popUp && cellEl === this._cellElement) {
+      // Updates the popup.
+      popUp.update(viewPops);
+    } else {
+      // Creates a new popup.
+      popUp && popUp.close();
+      this._cellElement = cellEl;
+      // [FS] IRAD-1009 2020-07-16
+      // Does not allow Table Menu Popuup button in disable mode
+      if (!view.disabled) {
+        this._popUp = createPopUp(TableCellMenu, viewPops, {
+          anchor: cellEl,
+          autoDismiss: false,
+          onClose: this._onClose,
+          position: atAnchorTopRight,
+        });
+        this._onOpen();
+      }
+    }
+  }
+
+  destroy = (): void => {
+    this._popUp && this._popUp.close();
+    this._popUp = null;
+  };
+
+  _onOpen = (): void => {
+    const cellEl = this._cellElement;
+    if (!cellEl) {
+      return;
+    }
+    this._scrollHandle = bindScrollHandler(cellEl, this._onScroll);
+  };
+
+  _onClose = (): void => {
+    this._popUp = null;
+    this._scrollHandle && this._scrollHandle.dispose();
+    this._scrollHandle = null;
+  };
+
+  _onScroll = (): void => {
+    const popUp = this._popUp;
+    const cellEl = this._cellElement;
+    if (!popUp || !cellEl) {
+      return;
+    }
+    if (!isElementFullyVisible(cellEl)) {
+      popUp.close();
+    }
+  };
+}
+
+// https://prosemirror.net/examples/tooltip/
+const SPEC = {
+  // [FS] IRAD-1005 2020-07-07
+  // Upgrade outdated packages.
+  key: new PluginKey('TableCellMenuPlugin'),
+  view(editorView: EditorView) {
+    return new TableCellTooltipView(editorView);
+  },
+};
+
+class TableCellMenuPlugin extends Plugin {
+  constructor() {
+    super(SPEC);
+  }
+}
+
+export default TableCellMenuPlugin;

package/TableInsertCommand.js

@@ -0,0 +1,124 @@
+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 nullthrows from 'nullthrows';
+import { EditorState } from 'prosemirror-state';
+import { TextSelection } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import { Fragment } from 'prosemirror-model';
+import insertTable from './insertTable.js';
+import { atAnchorRight } from '@modusoperandi/licit-ui-commands';
+import TableGridSizeEditor from './ui/TableGridSizeEditor.js';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+import { createPopUp } from '@modusoperandi/licit-ui-commands';
+import { PARAGRAPH } from './NodeNames.js';
+var TableInsertCommand = /*#__PURE__*/function (_UICommand) {
+  _inherits(TableInsertCommand, _UICommand);
+  function TableInsertCommand() {
+    var _this;
+    _classCallCheck(this, TableInsertCommand);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, TableInsertCommand, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "_popUp", null);
+    _defineProperty(_assertThisInitialized(_this), "shouldRespondToUIEvent", function (e) {
+      return e.type === UICommand.EventType.MOUSEENTER;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isEnabled", function (state) {
+      var tr = state;
+      var bOK = false;
+      var selection = tr.selection;
+      if (selection instanceof TextSelection) {
+        bOK = selection.from === selection.to;
+        // [FS] IRAD-1065 2020-09-18
+        // Disable create table menu if the selection is inside a table.
+        if (bOK) {
+          var $head = selection.$head;
+          for (var d = $head.depth; d > 0; d--) {
+            if ($head.node(d).type.spec.tableRole == 'row') {
+              return false;
+            }
+          }
+        }
+        return bOK;
+      }
+      return bOK;
+    });
+    _defineProperty(_assertThisInitialized(_this), "waitForUserInput", function (state, dispatch, view, event) {
+      if (_this._popUp) {
+        return Promise.resolve(undefined);
+      }
+      var target = nullthrows(event).currentTarget;
+      if (!(target instanceof HTMLElement)) {
+        return Promise.resolve(undefined);
+      }
+      var anchor = event ? event.currentTarget : null;
+      return new Promise(function (resolve) {
+        _this._popUp = createPopUp(TableGridSizeEditor, null, {
+          anchor: anchor,
+          position: atAnchorRight,
+          onClose: function onClose(val) {
+            if (_this._popUp) {
+              _this._popUp = null;
+              resolve(val);
+            }
+          }
+        });
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "executeWithUserInput", function (state, dispatch, view, inputs) {
+      if (dispatch) {
+        var selection = state.selection,
+          schema = state.schema;
+        var _tr = state.tr;
+        if (inputs) {
+          var rows = inputs.rows,
+            cols = inputs.cols;
+          _tr = _tr.setSelection(selection);
+          _tr = insertTable(_tr, schema, rows, cols);
+          _tr = insertParagraph(state, _tr);
+        }
+        dispatch(_tr);
+      }
+      return false;
+    });
+    return _this;
+  }
+  _createClass(TableInsertCommand, [{
+    key: "cancel",
+    value: function cancel() {
+      return null;
+    }
+  }]);
+  return TableInsertCommand;
+}(UICommand); // [FS] 2021-04-01
+// Add empty line after table drop
+// To make easier to enter a line after table
+function insertParagraph(state, tr) {
+  var paragraph = state.schema.nodes[PARAGRAPH];
+  var textNode = state.schema.text(' ');
+  var _tr$selection = tr.selection,
+    from = _tr$selection.from,
+    to = _tr$selection.to;
+  if (from !== to) {
+    return tr;
+  }
+  var paragraphNode = paragraph.create({}, textNode, null);
+  tr = tr.insert(from + tr.selection.$head.node(1).nodeSize - 4, Fragment.from(paragraphNode));
+  return tr;
+}
+export default TableInsertCommand;
+import { bpfrpt_proptype_TableGridSizeEditorValue } from "./ui/TableGridSizeEditor.js";

package/TableInsertCommand.js.flow

@@ -0,0 +1,120 @@
+// @flow
+
+import nullthrows from 'nullthrows';
+import { EditorState } from 'prosemirror-state';
+import { TextSelection } from 'prosemirror-state';
+import { Transform } from 'prosemirror-transform';
+import { EditorView } from 'prosemirror-view';
+import { Fragment } from 'prosemirror-model';
+import insertTable from './insertTable.js';
+import { atAnchorRight } from '@modusoperandi/licit-ui-commands';
+import TableGridSizeEditor from './ui/TableGridSizeEditor.js';
+import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
+import { createPopUp } from '@modusoperandi/licit-ui-commands';
+import {
+  PARAGRAPH
+} from './NodeNames.js';
+import type {
+  TableGridSizeEditorValue
+} from './ui/TableGridSizeEditor.js';
+
+class TableInsertCommand extends UICommand {
+  _popUp = null;
+
+  shouldRespondToUIEvent = (e: SyntheticEvent<> | MouseEvent): boolean => {
+    return e.type === UICommand.EventType.MOUSEENTER;
+  };
+
+  isEnabled = (state: EditorState): boolean => {
+    const tr = state;
+    let bOK = false;
+    const { selection } = tr;
+    if (selection instanceof TextSelection) {
+      bOK = selection.from === selection.to;
+      // [FS] IRAD-1065 2020-09-18
+      // Disable create table menu if the selection is inside a table.
+      if (bOK) {
+        const $head = selection.$head;
+        for (let d = $head.depth; d > 0; d--) {
+          if ($head.node(d).type.spec.tableRole == 'row') {
+            return false;
+          }
+        }
+      }
+      return bOK;
+    }
+    return bOK;
+  };
+
+  waitForUserInput = (
+    state: EditorState,
+    dispatch: ?(tr: Transform) => void,
+    view: ?EditorView,
+    event: ?SyntheticEvent<>
+  ): Promise<any> => {
+    if (this._popUp) {
+      return Promise.resolve(undefined);
+    }
+    const target = nullthrows(event).currentTarget;
+    if (!(target instanceof HTMLElement)) {
+      return Promise.resolve(undefined);
+    }
+
+    const anchor = event ? event.currentTarget : null;
+    return new Promise((resolve) => {
+      this._popUp = createPopUp(TableGridSizeEditor, null, {
+        anchor,
+        position: atAnchorRight,
+        onClose: (val) => {
+          if (this._popUp) {
+            this._popUp = null;
+            resolve(val);
+          }
+        },
+      });
+    });
+  };
+
+  executeWithUserInput = (
+    state: EditorState,
+    dispatch: ?(tr: Transform) => void,
+    view: ?EditorView,
+    inputs: ?TableGridSizeEditorValue
+  ): boolean => {
+    if (dispatch) {
+      const { selection, schema } = state;
+      let { tr } = state;
+      if (inputs) {
+        const { rows, cols } = inputs;
+        tr = tr.setSelection(selection);
+        tr = insertTable(tr, schema, rows, cols);
+        tr = insertParagraph(state, tr);
+      }
+      dispatch(tr);
+    }
+    return false;
+  };
+
+  cancel(): void {
+    return null;
+  }
+}
+
+// [FS] 2021-04-01
+// Add empty line after table drop
+// To make easier to enter a line after table
+function insertParagraph(state, tr) {
+  const paragraph = state.schema.nodes[PARAGRAPH];
+  const textNode = state.schema.text(' ');
+  const { from, to } = tr.selection;
+  if (from !== to) {
+    return tr;
+  }
+  const paragraphNode = paragraph.create({}, textNode, null);
+  tr = tr.insert(
+    from + tr.selection.$head.node(1).nodeSize - 4,
+    Fragment.from(paragraphNode)
+  );
+  return tr;
+}
+export default TableInsertCommand;