@atlaskit/editor-plugin-base 0.1.0

package/.eslintrc.js

@@ -0,0 +1,14 @@
+module.exports = {
+  rules: {
+    '@typescript-eslint/no-duplicate-imports': 'error',
+    '@typescript-eslint/no-explicit-any': 'error',
+  },
+  overrides: [
+    {
+      files: ['**/__tests__/**/*.{js,ts,tsx}', '**/examples/**/*.{js,ts,tsx}'],
+      rules: {
+        '@typescript-eslint/no-explicit-any': 'off',
+      },
+    },
+  ],
+};

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @atlaskit/editor-plugin-base
+
+## 0.1.0
+
+### Minor Changes
+
+- [`f8e7203eec6`](https://bitbucket.org/atlassian/atlassian-frontend/commits/f8e7203eec6) - ED-19618 Extract base plugin from editor-core
+
+### Patch Changes
+
+- Updated dependencies

package/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,33 @@
+# Editor Base Plugin
+
+Base plugin for @atlaskit/editor-core
+
+**Note:** This component is designed for internal Atlassian development.
+External contributors will be able to use this component but will not be able to submit issues.
+
+## Install
+---
+- **Install** - *yarn add @atlaskit/editor-plugin-base*
+- **npm** - [@atlaskit/editor-plugin-base](https://www.npmjs.com/package/@atlaskit/editor-plugin-base)
+- **Source** - [Bitbucket](https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/editor/editor-plugin-base)
+- **Bundle** - [unpkg.com](https://unpkg.com/@atlaskit/editor-plugin-base/dist/)
+
+## Usage
+---
+
+**Internal use only**
+
+@atlaskit/editor-plugin-base is intended for internal use by the @atlaskit/editor-core and as a plugin dependency of the Editor within your product.
+
+Direct use of this component is not supported.
+
+Please see [Atlaskit - Editor plugin base](https://atlaskit.atlassian.com/packages/editor/editor-plugin-base) for documentation and examples for this package.
+
+## Support
+---
+
+For internal Atlassian, visit the slack channel [#help-editor](https://atlassian.slack.com/archives/CFG3PSQ9E) for support or visit [go/editor-help](https://go/editor-help) to submit a bug.
+
+## License
+---
+Please see [Atlassian Frontend - License](https://developer.atlassian.com/cloud/framework/atlassian-frontend/#license) for more licensing information.

package/dist/cjs/commands.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setKeyboardHeight = void 0;
+var _pluginKey = require("./pm-plugins/scroll-gutter/plugin-key");
+var setKeyboardHeight = function setKeyboardHeight(keyboardHeight) {
+  return function (state, dispatch) {
+    var tr = state.tr;
+    tr.setMeta(_pluginKey.scrollGutterPluginKey, {
+      keyboardHeight: keyboardHeight
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};
+exports.setKeyboardHeight = setKeyboardHeight;

package/dist/cjs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DEGRADED_SEVERITY_THRESHOLD", {
+  enumerable: true,
+  get: function get() {
+    return _frozenEditor.DEGRADED_SEVERITY_THRESHOLD;
+  }
+});
+Object.defineProperty(exports, "NORMAL_SEVERITY_THRESHOLD", {
+  enumerable: true,
+  get: function get() {
+    return _frozenEditor.NORMAL_SEVERITY_THRESHOLD;
+  }
+});
+Object.defineProperty(exports, "basePlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugin.default;
+  }
+});
+Object.defineProperty(exports, "setKeyboardHeight", {
+  enumerable: true,
+  get: function get() {
+    return _commands.setKeyboardHeight;
+  }
+});
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _frozenEditor = require("./pm-plugins/frozen-editor");
+var _commands = require("./commands");

package/dist/cjs/plugin.js

@@ -0,0 +1,143 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isChromeWithSelectionBug = exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _adfSchema = require("@atlaskit/adf-schema");
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+var _utils = require("@atlaskit/editor-common/utils");
+var _commands = require("@atlaskit/editor-prosemirror/commands");
+var _history = require("@atlaskit/editor-prosemirror/history");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _contextIdentifier = _interopRequireWildcard(require("./pm-plugins/context-identifier"));
+var _disableSpellChecking = _interopRequireDefault(require("./pm-plugins/disable-spell-checking"));
+var _filterSteps = _interopRequireDefault(require("./pm-plugins/filter-steps"));
+var _fixChrome88Selection = _interopRequireDefault(require("./pm-plugins/fix-chrome-88-selection"));
+var _frozenEditor = _interopRequireDefault(require("./pm-plugins/frozen-editor"));
+var _inlineCursorTarget = _interopRequireDefault(require("./pm-plugins/inline-cursor-target"));
+var _newlinePreserveMarks = _interopRequireDefault(require("./pm-plugins/newline-preserve-marks"));
+var _scrollGutter = _interopRequireWildcard(require("./pm-plugins/scroll-gutter"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// Chrome >= 88
+var isChromeWithSelectionBug = _utils.browser.chrome && _utils.browser.chrome_version >= 88;
+exports.isChromeWithSelectionBug = isChromeWithSelectionBug;
+var basePlugin = function basePlugin(_ref) {
+  var _api$featureFlags;
+  var options = _ref.config,
+    api = _ref.api;
+  var featureFlags = (api === null || api === void 0 ? void 0 : (_api$featureFlags = api.featureFlags) === null || _api$featureFlags === void 0 ? void 0 : _api$featureFlags.sharedState.currentState()) || {};
+  return {
+    name: 'base',
+    getSharedState: function getSharedState(editorState) {
+      return {
+        contextIdentifier: (0, _contextIdentifier.getContextIdentifier)(editorState),
+        keyboardHeight: (0, _scrollGutter.getKeyboardHeight)(editorState)
+      };
+    },
+    pmPlugins: function pmPlugins() {
+      var plugins = [{
+        name: 'filterStepsPlugin',
+        plugin: function plugin(_ref2) {
+          var dispatchAnalyticsEvent = _ref2.dispatchAnalyticsEvent;
+          return (0, _filterSteps.default)(dispatchAnalyticsEvent);
+        }
+      }];
+
+      // In Chrome, when the selection is placed between adjacent nodes which are not contenteditatble
+      // the cursor appears at the right most point of the parent container.
+      // In Firefox, when the selection is placed between adjacent nodes which are not contenteditatble
+      // no cursor is presented to users.
+      // In Safari, when the selection is placed between adjacent nodes which are not contenteditatble
+      // it is not possible to navigate with arrow keys.
+      // This plugin works around the issues by inserting decorations between
+      // inline nodes which are set as contenteditable, and have a zero width space.
+      plugins.push({
+        name: 'inlineCursorTargetPlugin',
+        plugin: function plugin() {
+          return options && options.allowInlineCursorTarget ? (0, _inlineCursorTarget.default)() : undefined;
+        }
+      });
+      plugins.push({
+        name: 'newlinePreserveMarksPlugin',
+        plugin: _newlinePreserveMarks.default
+      }, {
+        name: 'frozenEditor',
+        plugin: function plugin(_ref3) {
+          var _options$inputTrackin;
+          var dispatchAnalyticsEvent = _ref3.dispatchAnalyticsEvent;
+          return options !== null && options !== void 0 && (_options$inputTrackin = options.inputTracking) !== null && _options$inputTrackin !== void 0 && _options$inputTrackin.enabled || options !== null && options !== void 0 && options.ufo ? (0, _frozenEditor.default)(dispatchAnalyticsEvent, options.inputTracking, options.browserFreezeTracking, options.ufo) : undefined;
+        }
+      }, {
+        name: 'history',
+        plugin: function plugin() {
+          return (0, _history.history)();
+        }
+      },
+      // should be last :(
+      {
+        name: 'codeBlockIndent',
+        plugin: function plugin() {
+          return (0, _keymaps.keymap)(_objectSpread(_objectSpread({}, _commands.baseKeymap), {}, {
+            'Mod-[': function Mod() {
+              return true;
+            },
+            'Mod-]': function Mod() {
+              return true;
+            }
+          }));
+        }
+      }, {
+        name: 'contextIdentifier',
+        plugin: function plugin(_ref4) {
+          var dispatch = _ref4.dispatch,
+            providerFactory = _ref4.providerFactory;
+          return (0, _contextIdentifier.default)(dispatch, providerFactory);
+        }
+      });
+      if (options && options.allowScrollGutter) {
+        plugins.push({
+          name: 'scrollGutterPlugin',
+          plugin: function plugin() {
+            return (0, _scrollGutter.default)(options.allowScrollGutter);
+          }
+        });
+      }
+      if (isChromeWithSelectionBug && !(0, _platformFeatureFlags.getBooleanFF)('platform.editor.disable-chrome-88-selection-fix_uk53m')) {
+        plugins.push({
+          name: 'fixChrome88SelectionPlugin',
+          plugin: function plugin() {
+            return (0, _fixChrome88Selection.default)();
+          }
+        });
+      }
+      plugins.push({
+        name: 'disableSpellcheckingPlugin',
+        plugin: function plugin() {
+          return (0, _disableSpellChecking.default)(featureFlags);
+        }
+      });
+      return plugins;
+    },
+    nodes: function nodes() {
+      return [{
+        name: 'doc',
+        node: _adfSchema.doc
+      }, {
+        name: 'paragraph',
+        node: _adfSchema.paragraph
+      }, {
+        name: 'text',
+        node: _adfSchema.text
+      }];
+    }
+  };
+};
+var _default = basePlugin;
+exports.default = _default;

package/dist/cjs/pm-plugins/context-identifier.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stateKey = exports.getContextIdentifier = exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _state = require("@atlaskit/editor-prosemirror/state");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var stateKey = new _state.PluginKey('contextIdentiferPlugin');
+exports.stateKey = stateKey;
+var getContextIdentifier = function getContextIdentifier(state) {
+  if (state) {
+    var _stateKey$getState;
+    return (_stateKey$getState = stateKey.getState(state)) === null || _stateKey$getState === void 0 ? void 0 : _stateKey$getState.contextIdentifierProvider;
+  }
+};
+exports.getContextIdentifier = getContextIdentifier;
+var _default = function _default(dispatch, providerFactory) {
+  return new _safePlugin.SafePlugin({
+    key: stateKey,
+    state: {
+      init: function init() {
+        return {};
+      },
+      apply: function apply(tr, pluginState) {
+        if (tr.getMeta(stateKey)) {
+          return tr.getMeta(stateKey);
+        }
+        return pluginState;
+      }
+    },
+    view: function view(_view) {
+      var providerPromiseHandler = function providerPromiseHandler(name, providerPromise) {
+        if (providerPromise && name === 'contextIdentifierProvider') {
+          providerPromise.then(function (provider) {
+            var tr = _view.state.tr.setMeta(stateKey, {
+              contextIdentifierProvider: _objectSpread({}, provider)
+            });
+            _view.dispatch(tr);
+          });
+        }
+      };
+      if (providerFactory) {
+        providerFactory.subscribe('contextIdentifierProvider', providerPromiseHandler);
+      }
+      return {
+        destroy: function destroy() {
+          providerFactory && providerFactory.unsubscribe('contextIdentifierProvider', providerPromiseHandler);
+        }
+      };
+    }
+  });
+};
+exports.default = _default;

package/dist/cjs/pm-plugins/disable-spell-checking.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+function getCurrentBrowserAndVersion() {
+  switch (true) {
+    case _utils.browser.chrome === true:
+      return {
+        browser: 'chrome',
+        version: _utils.browser.chrome_version
+      };
+    case _utils.browser.ie === true:
+      return {
+        browser: 'ie',
+        version: _utils.browser.ie_version
+      };
+    case _utils.browser.gecko === true:
+      return {
+        browser: 'gecko',
+        version: _utils.browser.gecko_version
+      };
+    case _utils.browser.safari === true:
+      return {
+        browser: 'safari',
+        version: _utils.browser.safari_version
+      };
+  }
+  return undefined;
+}
+var _default = function _default(featureFlags) {
+  return new _safePlugin.SafePlugin({
+    key: new _state.PluginKey('disableSpellchecking'),
+    props: {
+      attributes: function attributes(editorState) {
+        if (!featureFlags) {
+          return {};
+        }
+        var browserConfigFeatureFlag = featureFlags.disableSpellcheckByBrowser;
+        var userCurrentBrowserAndVersion = getCurrentBrowserAndVersion();
+        if (!userCurrentBrowserAndVersion || !browserConfigFeatureFlag) {
+          return {};
+        }
+        var browserVersionDisableRange = browserConfigFeatureFlag[userCurrentBrowserAndVersion.browser];
+        if (!browserVersionDisableRange || !_utils.browser[userCurrentBrowserAndVersion.browser]) {
+          return {};
+        }
+        var shouldDisableSpellcheck = !!browserVersionDisableRange.maximum ? userCurrentBrowserAndVersion.version >= browserVersionDisableRange.minimum && userCurrentBrowserAndVersion.version <= browserVersionDisableRange.maximum : _utils.browser[userCurrentBrowserAndVersion.browser] && userCurrentBrowserAndVersion.version >= browserVersionDisableRange.minimum;
+        if (shouldDisableSpellcheck) {
+          return {
+            spellcheck: 'false'
+          };
+        }
+        return {};
+      }
+    }
+  });
+};
+exports.default = _default;

package/dist/cjs/pm-plugins/filter-steps.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var hasInvalidSteps = function hasInvalidSteps(tr) {
+  return (tr.steps || []).some(function (step) {
+    return step.from > step.to;
+  });
+};
+var _default = function _default(dispatchAnalyticsEvent) {
+  return new _safePlugin.SafePlugin({
+    filterTransaction: function filterTransaction(transaction) {
+      if (hasInvalidSteps(transaction)) {
+        // eslint-disable-next-line no-console
+        console.warn('The transaction was blocked because it contains invalid steps', transaction.steps);
+        dispatchAnalyticsEvent({
+          action: _analytics.ACTION.DISCARDED_INVALID_STEPS_FROM_TRANSACTION,
+          actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+          attributes: {
+            analyticsEventPayloads: (0, _analytics.getAnalyticsEventsFromTransaction)(transaction)
+          },
+          eventType: _analytics.EVENT_TYPE.OPERATIONAL
+        });
+        return false;
+      }
+      return true;
+    }
+  });
+};
+exports.default = _default;

package/dist/cjs/pm-plugins/fix-chrome-88-selection.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fixChromeSelectionKey = exports.default = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+function isDivHTMLElement(elm) {
+  return elm.tagName.toLowerCase() === 'div';
+}
+var fixChromeSelectionKey = new _state.PluginKey('fixChromeSelectionPlugin');
+exports.fixChromeSelectionKey = fixChromeSelectionKey;
+var _default = function _default() {
+  return new _safePlugin.SafePlugin({
+    key: fixChromeSelectionKey,
+    props: {
+      handleDOMEvents: {
+        focus: function focus(view) {
+          // We don't need to reset when there's a NodeSelection
+          // It creates other problem. @see HOT-94478
+          if (isDivHTMLElement(view.dom) && !(0, _utils.isNodeSelection)(view.state.selection)) {
+            view.dom.style.display = 'inline-block';
+            view.dom.offsetHeight;
+            view.dom.style.display = 'block';
+          }
+          return false;
+        }
+      }
+    }
+  });
+};
+exports.default = _default;