@atlaskit/editor-core 178.1.0 → 178.1.2

package/dist/es2019/plugins/extension/context-panel.js

@@ -8,24 +8,21 @@ import { duplicateSelection } from '../../utils/selection';
 import { clearEditingContext, forceAutoSave, updateState } from './commands';
 import { buildExtensionNode } from './actions';
 import { SaveIndicator } from './ui/SaveIndicator/SaveIndicator';
-
 const areParametersEqual = (firstParameters, secondParameters) => {
   if (typeof firstParameters === 'object' && typeof secondParameters === 'object' && firstParameters !== null && secondParameters !== null) {
     const firstKeys = Object.keys(firstParameters);
     const secondKeys = Object.keys(secondParameters);
     return firstKeys.length === secondKeys.length && firstKeys.every(key => firstParameters[key] === secondParameters[key]);
   }
-
   return firstParameters === secondParameters;
 };
-
 export const getContextPanel = allowAutoSave => state => {
-  const nodeWithPos = getSelectedExtension(state, true); // Adding checks to bail out early
+  const nodeWithPos = getSelectedExtension(state, true);
 
+  // Adding checks to bail out early
   if (!nodeWithPos) {
     return;
   }
-
   const extensionState = getPluginState(state);
   const {
     autoSaveResolve,
@@ -35,7 +32,6 @@ export const getContextPanel = allowAutoSave => state => {
     processParametersBefore,
     processParametersAfter
   } = extensionState;
-
   if (extensionState && showContextPanel && extensionProvider && processParametersAfter) {
     const {
       extensionType,
@@ -54,11 +50,9 @@ export const getContextPanel = allowAutoSave => state => {
       return /*#__PURE__*/React.createElement(WithEditorActions, {
         render: actions => {
           const editorView = actions._privateGetEditorView();
-
           if (!editorView) {
             return null;
           }
-
           return /*#__PURE__*/React.createElement(ConfigPanelLoader, {
             showHeader: true,
             closeOnEsc: true,
@@ -74,11 +68,9 @@ export const getContextPanel = allowAutoSave => state => {
             onChange: async updatedParameters => {
               await onChangeAction(editorView, updatedParameters, parameters, nodeWithPos, onSaveStarted);
               onSaveEnded();
-
               if (autoSaveResolve) {
                 autoSaveResolve();
               }
-
               if (!allowAutoSave) {
                 clearEditingContext(editorView.state, editorView.dispatch);
               }
@@ -95,7 +87,6 @@ export const getContextPanel = allowAutoSave => state => {
                   console.error(`Autosave failed with error`, e);
                 }
               }
-
               clearEditingContext(editorView.state, editorView.dispatch);
             }
           });
@@ -110,74 +101,68 @@ export async function onChangeAction(editorView, updatedParameters = {}, oldPara
     processParametersAfter,
     processParametersBefore
   } = getPluginState(editorView.state);
-
   if (!processParametersAfter) {
     return;
   }
-
-  const unwrappedOldParameters = processParametersBefore ? processParametersBefore(oldParameters) : oldParameters; // todo: update to only check parameters which are in the manifest's field definitions
-
+  const unwrappedOldParameters = processParametersBefore ? processParametersBefore(oldParameters) : oldParameters;
+  // todo: update to only check parameters which are in the manifest's field definitions
   if (areParametersEqual(unwrappedOldParameters, updatedParameters)) {
     return;
   }
-
   if (onSaving) {
     onSaving();
   }
-
   const key = Date.now();
   const {
     positions: previousPositions
   } = getPluginState(editorView.state);
   await updateState({
-    positions: { ...previousPositions,
+    positions: {
+      ...previousPositions,
       [key]: nodeWithPos.pos
     }
-  })(editorView.state, editorView.dispatch); // WARNING: after this, editorView.state may have changed
+  })(editorView.state, editorView.dispatch);
 
+  // WARNING: after this, editorView.state may have changed
   const newParameters = await processParametersAfter(updatedParameters);
   const {
     positions
   } = getPluginState(editorView.state);
-
   if (!positions) {
     return;
   }
-
   if (!(key in positions)) {
     return;
   }
-
   const {
     node
   } = nodeWithPos;
-  const newNode = buildExtensionNode(nodeWithPos.node.toJSON().type, editorView.state.schema, { ...node.attrs,
-    parameters: { ...oldParameters,
+  const newNode = buildExtensionNode(nodeWithPos.node.toJSON().type, editorView.state.schema, {
+    ...node.attrs,
+    parameters: {
+      ...oldParameters,
       ...newParameters
     }
   }, node.content, node.marks);
-
   if (!newNode) {
     return;
   }
-
   const positionUpdated = positions[key];
-  const transaction = editorView.state.tr.replaceWith(positionUpdated, positionUpdated + newNode.nodeSize, newNode); // Ensure we preserve the selection, tr.replaceWith causes it to be lost in some cases
-  // when replacing the node
+  const transaction = editorView.state.tr.replaceWith(positionUpdated, positionUpdated + newNode.nodeSize, newNode);
 
+  // Ensure we preserve the selection, tr.replaceWith causes it to be lost in some cases
+  // when replacing the node
   const {
     selection: prevSelection
   } = editorView.state;
-
   if (!prevSelection.eq(transaction.selection)) {
     const selection = duplicateSelection(prevSelection, transaction.doc);
-
     if (selection) {
       transaction.setSelection(selection);
     }
   }
-
-  const positionsLess = { ...getPluginState(editorView.state).positions
+  const positionsLess = {
+    ...getPluginState(editorView.state).positions
   };
   delete positionsLess[key];
   await updateState({

package/dist/es2019/plugins/extension/extension-api.js

@@ -17,21 +17,16 @@ export const getEditInLegacyMacroBrowser = ({
     if (!view) {
       throw new Error(`Missing view. Can't update without EditorView`);
     }
-
     if (!macroProvider) {
       throw new Error(`Missing macroProvider. Can't use the macro browser for updates`);
     }
-
     const nodeWithPos = getSelectedExtension(view.state, true);
-
     if (!nodeWithPos) {
       throw new Error(`Missing nodeWithPos. Can't determine position of node`);
     }
-
     insertMacroFromMacroBrowser(macroProvider, nodeWithPos.node, true)(view);
   };
 };
-
 const extensionAPICallPayload = functionName => ({
   action: ACTION.INVOKED,
   actionSubject: ACTION_SUBJECT.EXTENSION,
@@ -41,38 +36,34 @@ const extensionAPICallPayload = functionName => ({
   },
   eventType: EVENT_TYPE.TRACK
 });
-
 export const createExtensionAPI = options => {
   const validate = validator();
+
   /**
    * Finds the node and its position by `localId`. Throws if the node could not be found.
    *
    * @returns {NodeWithPos}
    */
-
   const ensureNodePosByLocalId = (localId, {
     opName
   }) => {
     // Be extra cautious since 3rd party devs can use regular JS without type safety
     if (typeof localId !== 'string' || localId === '') {
       throw new Error(`${opName}(): Invalid localId '${localId}'.`);
-    } // Find the node + position matching the given ID
-
+    }
 
+    // Find the node + position matching the given ID
     const {
       editorView: {
         state
       }
     } = options;
     const nodePos = findNodePosWithLocalId(state, localId);
-
     if (!nodePos) {
       throw new Error(`${opName}(): Could not find node with ID '${localId}'.`);
     }
-
     return nodePos;
   };
-
   const doc = {
     insertAfter: (localId, adf, opt) => {
       try {
@@ -80,7 +71,6 @@ export const createExtensionAPI = options => {
       } catch (e) {
         throw new Error(`insertAfter(): Invalid ADF given.`);
       }
-
       const nodePos = ensureNodePosByLocalId(localId, {
         opName: 'insertAfter'
       });
@@ -90,39 +80,38 @@ export const createExtensionAPI = options => {
       const {
         dispatch,
         state
-      } = editorView; // Validate the given ADF
+      } = editorView;
 
+      // Validate the given ADF
       const {
         tr,
         schema
       } = state;
       const nodeType = schema.nodes[adf.type];
-
       if (!nodeType) {
         throw new Error(`insertAfter(): Invalid ADF type '${adf.type}'.`);
       }
-
       const fragment = Fragment.fromJSON(schema, adf.content);
       const marks = (adf.marks || []).map(markEntity => Mark.fromJSON(schema, markEntity));
       const newNode = nodeType === null || nodeType === void 0 ? void 0 : nodeType.createChecked(adf.attrs, fragment, marks);
-
       if (!newNode) {
         throw new Error('insertAfter(): Could not create a node for given ADFEntity.');
       }
-
       const insertPosition = nodePos.pos + nodePos.node.nodeSize;
-      tr.insert(insertPosition, newNode); // Validate if the document is valid at this point
+      tr.insert(insertPosition, newNode);
 
+      // Validate if the document is valid at this point
       try {
         tr.doc.check();
       } catch (err) {
         throw new Error(`insertAfter(): The given ADFEntity cannot be inserted in the current position.\n${err}`);
-      } // Analytics - tracking the api call
-
+      }
 
+      // Analytics - tracking the api call
       const apiCallPayload = extensionAPICallPayload('insertAfter');
-      addAnalytics(state, tr, apiCallPayload); // Analytics - tracking node types added
+      addAnalytics(state, tr, apiCallPayload);
 
+      // Analytics - tracking node types added
       const nodesAdded = [newNode];
       newNode.descendants(node => {
         nodesAdded.push(node);
@@ -136,8 +125,9 @@ export const createExtensionAPI = options => {
         const dataConsumerMark = getDataConsumerMark(node);
         const stringIds = (dataConsumerMark === null || dataConsumerMark === void 0 ? void 0 : dataConsumerMark.attrs.sources.map(sourceId => sourceId)) || [];
         const hasReferentiality = !!dataConsumerMark;
-        const nodeTypesReferenced = hasReferentiality ? getNodeTypesReferenced(stringIds, state) : undefined; // fire off analytics for this ADF
+        const nodeTypesReferenced = hasReferentiality ? getNodeTypesReferenced(stringIds, state) : undefined;
 
+        // fire off analytics for this ADF
         const payload = {
           action: ACTION.INSERTED,
           actionSubject: ACTION_SUBJECT.DOCUMENT,
@@ -154,18 +144,17 @@ export const createExtensionAPI = options => {
         };
         addAnalytics(state, tr, payload);
       });
-
       if (opt && opt.allowSelectionToNewNode) {
         tr.setSelection(new NodeSelection(tr.doc.resolve(insertPosition)));
       }
-
       dispatch(tr);
     },
     scrollTo: localId => {
       const nodePos = ensureNodePosByLocalId(localId, {
         opName: 'scrollTo'
-      }); // Analytics - tracking the api call
+      });
 
+      // Analytics - tracking the api call
       const apiCallPayload = extensionAPICallPayload('scrollTo');
       const {
         editorView: {
@@ -183,7 +172,6 @@ export const createExtensionAPI = options => {
     },
     update: (localId, mutationCallback) => {
       var _changedValues$marks;
-
       const {
         node,
         pos
@@ -210,34 +198,30 @@ export const createExtensionAPI = options => {
       const {
         parent
       } = state.doc.resolve(pos);
-
       const ensureValidMark = mark => {
         if (typeof mark !== 'object' || Array.isArray(mark)) {
           throw new Error(`update(): Invalid mark given.`);
-        } // Ensure that the given mark is present in the schema
-
+        }
 
+        // Ensure that the given mark is present in the schema
         const markType = schema.marks[mark.type];
-
         if (!markType) {
           throw new Error(`update(): Invalid ADF mark type '${mark.type}'.`);
         }
-
         if (!parent.type.allowsMarkType(markType)) {
           throw new Error(`update(): Parent of type '${parent.type.name}' does not allow marks of type '${mark.type}'.`);
         }
-
         return {
           mark: markType,
           attrs: mark.attrs
         };
       };
-
       const newMarks = (_changedValues$marks = changedValues.marks) === null || _changedValues$marks === void 0 ? void 0 : _changedValues$marks.map(ensureValidMark).map(({
         mark,
         attrs
-      }) => mark.create(attrs)); // Validate if the new attributes and marks result in a valid node and adf.
+      }) => mark.create(attrs));
 
+      // Validate if the new attributes and marks result in a valid node and adf.
       try {
         const newNode = node.type.createChecked(changedValues.attrs, node.content, newMarks);
         const newNodeAdf = new JSONTransformer().encodeNode(newNode);
@@ -245,9 +229,9 @@ export const createExtensionAPI = options => {
       } catch (err) {
         throw new Error(`update(): The given ADFEntity cannot be inserted in the current position.\n${err}`);
       }
+      tr.setNodeMarkup(pos, undefined, changedValues.attrs, newMarks);
 
-      tr.setNodeMarkup(pos, undefined, changedValues.attrs, newMarks); // Analytics - tracking the api call
-
+      // Analytics - tracking the api call
       const apiCallPayload = extensionAPICallPayload('update');
       addAnalytics(state, tr, apiCallPayload);
       dispatch(tr);
@@ -265,7 +249,6 @@ export const createExtensionAPI = options => {
         editorView
       } = options;
       let editInLegacy = options.editInLegacyMacroBrowser;
-
       if (!editInLegacy) {
         const macroState = macroPluginKey.getState(editorView.state);
         editInLegacy = getEditInLegacyMacroBrowser({
@@ -273,7 +256,6 @@ export const createExtensionAPI = options => {
           macroProvider: (macroState === null || macroState === void 0 ? void 0 : macroState.macroProvider) || undefined
         });
       }
-
       editInLegacy();
     },
     doc

package/dist/es2019/plugins/extension/index.js

@@ -4,10 +4,8 @@ import keymapPlugin from './pm-plugins/keymap';
 import { createPlugin as createUniqueIdPlugin } from './pm-plugins/unique-id';
 import { getToolbarConfig } from './toolbar';
 import { getContextPanel } from './context-panel';
-
 const extensionPlugin = (options = {}) => ({
   name: 'extension',
-
   nodes() {
     return [{
       name: 'extension',
@@ -20,7 +18,6 @@ const extensionPlugin = (options = {}) => ({
       node: inlineExtension
     }];
   },
-
   pmPlugins() {
     return [{
       name: 'extension',
@@ -43,11 +40,9 @@ const extensionPlugin = (options = {}) => ({
       plugin: () => createUniqueIdPlugin()
     }];
   },
-
   pluginsOptions: {
     floatingToolbar: getToolbarConfig(options.breakoutEnabled),
     contextPanel: getContextPanel(options.allowAutoSave)
   }
 });
-
 export default extensionPlugin;

package/dist/es2019/plugins/extension/nodeviews/extension.js

@@ -15,27 +15,24 @@ export class ExtensionNode extends ReactNodeView {
     // children a chance to recalc
     return this.node.type.isAtom || mutation.type !== 'selection' && mutation.attributeName !== 'data-layout';
   }
-
   getContentDOM() {
     if (this.node.isInline) {
       return;
     }
-
     const dom = document.createElement('div');
     dom.className = `${this.node.type.name}-content-dom-wrapper`;
     return {
       dom
     };
   }
-
   render(props, forwardRef) {
     var _props$extensionNodeV;
-
     return /*#__PURE__*/React.createElement(ExtensionNodeWrapper, {
       nodeType: this.node.type.name
     }, /*#__PURE__*/React.createElement(Extension, {
       editorView: this.view,
-      node: this.node // The getPos arg is always a function when used with nodes
+      node: this.node
+      // The getPos arg is always a function when used with nodes
       // the version of the types we use has a union with the type
       // for marks.
       // This has been fixed in later versions of the definitly typed
@@ -49,7 +46,6 @@ export class ExtensionNode extends ReactNodeView {
       editorAppearance: (_props$extensionNodeV = props.extensionNodeViewOptions) === null || _props$extensionNodeV === void 0 ? void 0 : _props$extensionNodeV.appearance
     }));
   }
-
 }
 export default function ExtensionNodeView(portalProviderAPI, eventDispatcher, providerFactory, extensionHandlers, extensionNodeViewOptions) {
   return (node, view, getPos) => {

package/dist/es2019/plugins/extension/plugin-factory.js

@@ -6,23 +6,20 @@ const factory = pluginFactory(pluginKey, reducer, {
     const {
       positions: previousPositions
     } = state;
-
     if (!previousPositions) {
       return state;
     }
-
-    const positions = { ...previousPositions
+    const positions = {
+      ...previousPositions
     };
-
     for (const key in positions) {
       positions[key] = tr.mapping.map(positions[key]);
     }
-
-    return { ...state,
+    return {
+      ...state,
       positions
     };
   }
-
 });
 export const createPluginState = factory.createPluginState;
 export const createCommand = factory.createCommand;

package/dist/es2019/plugins/extension/pm-plugins/keymap.js

@@ -6,11 +6,9 @@ export default function keymapPlugin() {
   const list = {};
   keymaps.bindKeymapWithCommand(keymaps.escape.common, (state, dispatch) => {
     const extensionState = getPluginState(state);
-
     if (!extensionState.showContextPanel) {
       return false;
     }
-
     return clearEditingContext(state, dispatch);
   }, list);
   return keymap(list);

package/dist/es2019/plugins/extension/pm-plugins/main.js

@@ -6,26 +6,21 @@ import { updateState, clearEditingContext } from '../commands';
 import { getSelectedExtension, getSelectedDomElement } from '../utils';
 import { createPluginState, getPluginState, createCommand } from '../plugin-factory';
 import { pluginKey } from '../plugin-key';
-
 const maybeGetUpdateMethodFromExtensionProvider = async (view, extensionProvider) => {
   const nodeWithPos = getSelectedExtension(view.state, true);
-
   if (!nodeWithPos) {
     throw new Error('There is no selection');
   }
-
   const {
     extensionType,
     extensionKey
   } = nodeWithPos.node.attrs;
   const extensionModuleNode = await getExtensionModuleNode(extensionProvider, extensionType, extensionKey);
   const newNodeWithPos = getSelectedExtension(view.state, true);
-
   if (newNodeWithPos && newNodeWithPos.node.attrs.extensionType === extensionType && newNodeWithPos.node.attrs.extensionKey === extensionKey && newNodeWithPos.pos === nodeWithPos.pos && extensionModuleNode) {
     return extensionModuleNode.update;
   }
 };
-
 export const updateEditButton = async (view, extensionProvider) => {
   try {
     const updateMethod = await maybeGetUpdateMethodFromExtensionProvider(view, extensionProvider);
@@ -34,21 +29,18 @@ export const updateEditButton = async (view, extensionProvider) => {
       updateExtension: updateMethod && Promise.resolve(updateMethod) || undefined
     })(view.state, view.dispatch);
     return updateMethod;
-  } catch {// this exception is not important for this case, fail silently
+  } catch {
+    // this exception is not important for this case, fail silently
   }
 };
-
 const shouldShowEditButton = (extensionHandler, extensionProvider) => {
   const usesLegacyMacroBrowser = !extensionHandler && !extensionProvider || typeof extensionHandler === 'function';
   const usesModernUpdateMethod = typeof extensionHandler === 'object' && typeof extensionHandler.update === 'function';
-
   if (usesLegacyMacroBrowser || usesModernUpdateMethod) {
     return true;
   }
-
   return false;
 };
-
 const getUpdateExtensionPromise = async (view, extensionHandler, extensionProvider) => {
   if (extensionHandler && typeof extensionHandler === 'object') {
     // Old API with the `update` function
@@ -56,15 +48,12 @@ const getUpdateExtensionPromise = async (view, extensionHandler, extensionProvid
   } else if (extensionProvider) {
     // New API with or without the `update` function, we don't know at this point
     const updateMethod = await updateEditButton(view, extensionProvider);
-
     if (updateMethod) {
       return updateMethod;
     }
   }
-
   throw new Error('No update method available');
 };
-
 export const createExtensionProviderHandler = view => async (name, provider) => {
   if (name === 'extensionProvider' && provider) {
     try {
@@ -94,7 +83,6 @@ export const createContextIdentifierProviderHandler = view => async (name, provi
     }
   }
 };
-
 const createPlugin = (dispatch, providerFactory, extensionHandlers, portalProviderAPI, eventDispatcher, useLongPressSelection = false, options = {}) => {
   const state = createPluginState(dispatch, {
     showEditButton: false,
@@ -122,47 +110,48 @@ const createPlugin = (dispatch, providerFactory, extensionHandlers, portalProvid
             localId,
             extensionProvider,
             showContextPanel
-          } = getPluginState(state); // This fetches the selected extension node, either by keyboard selection or click for all types of extensions
+          } = getPluginState(state);
 
+          // This fetches the selected extension node, either by keyboard selection or click for all types of extensions
           const selectedExtension = getSelectedExtension(state, true);
-
           if (!selectedExtension) {
             if (showContextPanel) {
               clearEditingContext(state, dispatch);
-            } // if an extension is no longer selected, but the plugin has cached the previous selected extension id/ref
+            }
+
+            // if an extension is no longer selected, but the plugin has cached the previous selected extension id/ref
             // then this should clear those values so that if an exention is selected again, then this sees it as a change
             // and updates the state correctly.
-
-
             if (!!localId || !!element) {
               updateState({
                 localId: undefined,
                 element: undefined
               })(state, dispatch);
             }
-
             return;
           }
-
           const {
             node
           } = selectedExtension;
-          const newElement = getSelectedDomElement(state.schema, domAtPos, selectedExtension); // New node is selection
+          const newElement = getSelectedDomElement(state.schema, domAtPos, selectedExtension);
 
-          if (node.attrs.localId ? localId !== node.attrs.localId : // This is the current assumption and it's wrong but we are keeping it
+          // New node is selection
+          if (node.attrs.localId ? localId !== node.attrs.localId :
+          // This is the current assumption and it's wrong but we are keeping it
           // as fallback in case we need to turn off `allowLocalIdGeneration`
           element !== newElement) {
             if (showContextPanel) {
               clearEditingContext(state, dispatch);
             }
-
             const {
               extensionType
             } = node.attrs;
-            const extensionHandler = extensionHandlers[extensionType]; // showEditButton might change async based on results from extension providers
+            const extensionHandler = extensionHandlers[extensionType];
 
+            // showEditButton might change async based on results from extension providers
             const showEditButton = shouldShowEditButton(extensionHandler, extensionProvider);
-            const updateExtension = getUpdateExtensionPromise(view, extensionHandler, extensionProvider).catch(() => {// do nothing;
+            const updateExtension = getUpdateExtensionPromise(view, extensionHandler, extensionProvider).catch(() => {
+              // do nothing;
             });
             updateState({
               localId: node.attrs.localId,
@@ -171,13 +160,13 @@ const createPlugin = (dispatch, providerFactory, extensionHandlers, portalProvid
               showEditButton,
               updateExtension
             })(state, dispatch);
-          } // New DOM element doesn't necessarily mean it's a new Node
+          }
+          // New DOM element doesn't necessarily mean it's a new Node
           else if (element !== newElement) {
             updateState({
               element: newElement
             })(state, dispatch);
           }
-
           return true;
         },
         destroy: () => {
@@ -202,5 +191,4 @@ const createPlugin = (dispatch, providerFactory, extensionHandlers, portalProvid
     }
   });
 };
-
 export { pluginKey, createPlugin, createCommand, getPluginState };