npm - @atlaskit/editor-core - Versions diffs - 178.1.1 → 178.1.2 - Mend

@atlaskit/editor-core 178.1.1 → 178.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2514) hide show

package/dist/es2019/plugins/card/pm-plugins/doc.js CHANGED Viewed

@@ -11,10 +11,10 @@ import { appearanceForNodeType } from '../utils';
 import { queueCards, resolveCard } from './actions';
 import { pluginKey } from './plugin-key';
 import { shouldReplaceLink } from './shouldReplaceLink';
 /**
  * Attempt to replace the link into the respective card.
  */
 function replaceLinksToCards(tr, cardAdf, schema, request) {
   const {
     inlineCard
@@ -22,78 +22,66 @@ function replaceLinksToCards(tr, cardAdf, schema, request) {
   const {
     url
   } = request;
   if (!isSafeUrl(url)) {
     return;
-  } // replace all the outstanding links with their cards
+  }
+  // replace all the outstanding links with their cards
   const pos = tr.mapping.map(request.pos);
   const $pos = tr.doc.resolve(pos);
   const node = tr.doc.nodeAt(pos);
   if (!node || !node.type.isText) {
     return;
   }
   const replaceLink = request.shouldReplaceLink || shouldReplaceLink(node, request.compareLinkText, url);
   if (!replaceLink) {
     return;
-  } // ED-5638: add an extra space after inline cards to avoid re-rendering them
+  }
+  // ED-5638: add an extra space after inline cards to avoid re-rendering them
   const nodes = [cardAdf];
   if (cardAdf.type === inlineCard) {
     nodes.push(schema.text(' '));
   }
   tr.replaceWith(pos, pos + (node.text || url).length, nodes);
   return $pos.node($pos.depth - 1).type.name;
 }
 export const replaceQueuedUrlWithCard = (url, cardData, analyticsAction, createAnalyticsEvent) => (editorState, dispatch) => {
   const state = pluginKey.getState(editorState);
   if (!state) {
     return false;
-  } // find the requests for this URL
+  }
-  const requests = state.requests.filter(req => req.url === url); // try to transform response to ADF
+  // find the requests for this URL
+  const requests = state.requests.filter(req => req.url === url);
+  // try to transform response to ADF
   const schema = editorState.schema;
   const cardAdf = processRawValue(schema, cardData);
   let tr = editorState.tr;
   if (cardAdf) {
     // Should prevent any other node than cards? [inlineCard, blockCard].includes(cardAdf.type)
     const nodeContexts = requests.map(request => replaceLinksToCards(tr, cardAdf, schema, request)).filter(context => !!context); // context exist
-    // Send analytics information
+    // Send analytics information
     if (nodeContexts.length) {
       const nodeContext = nodeContexts.every(context => context === nodeContexts[0]) ? nodeContexts[0] : 'mixed';
-      /** For block links v1, default to inline links */
+      /** For block links v1, default to inline links */
       const nodeType = 'inlineCard';
       const [,, domainName] = url.split('/');
       if (state.smartLinkEvents) {
         state.smartLinkEvents.insertSmartLink(domainName, 'inline', state.createAnalyticsEvent);
       }
       addAnalytics(editorState, tr, {
         action: analyticsAction || ACTION.INSERTED,
         actionSubject: ACTION_SUBJECT.DOCUMENT,
         actionSubjectId: ACTION_SUBJECT_ID.SMART_LINK,
         eventType: EVENT_TYPE.TRACK,
         attributes: {
-          inputMethod: requests[0].source
-          /* TODO: what if each request has a different source?
-           unlikely, but need to define behaviour.
-            ignore analytics event? take first? provide 'mixed' as well?*/
-          ,
+          inputMethod: requests[0].source /* TODO: what if each request has a different source?
+                                           unlikely, but need to define behaviour.
+                                            ignore analytics event? take first? provide 'mixed' as well?*/,
           nodeType,
           nodeContext: nodeContext,
           domainName,
@@ -102,27 +90,21 @@ export const replaceQueuedUrlWithCard = (url, cardData, analyticsAction, createA
       });
     }
   }
   if (dispatch) {
     dispatch(resolveCard(url)(closeHistory(tr)));
   }
   return true;
 };
 export const handleFallbackWithAnalytics = (url, source) => (editorState, dispatch) => {
   const state = pluginKey.getState(editorState);
   if (!state) {
     return false;
   }
   const tr = editorState.tr;
   addAnalytics(editorState, tr, getLinkCreationAnalyticsEvent(source, url));
   if (dispatch) {
     dispatch(resolveCard(url)(tr));
   }
   return true;
 };
 export const queueCardsFromChangedTr = (state, tr, source, normalizeLinkText = true) => {
@@ -137,14 +119,11 @@ export const queueCardsFromChangedTr = (state, tr, source, normalizeLinkText = t
     if (!node.isText) {
       return true;
     }
     const linkMark = node.marks.find(mark => mark.type === link);
     if (linkMark) {
       if (!shouldReplaceLink(node, normalizeLinkText)) {
         return false;
       }
       requests.push({
         url: linkMark.attrs.href,
         pos,
@@ -153,7 +132,6 @@ export const queueCardsFromChangedTr = (state, tr, source, normalizeLinkText = t
         source
       });
     }
     return false;
   });
   return queueCards(requests)(tr);
@@ -168,7 +146,6 @@ export const convertHyperlinkToSmartCard = (state, source, appearance, normalize
   const requests = [];
   state.tr.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos) => {
     const linkMark = node.marks.find(mark => mark.type === link);
     if (linkMark) {
       const request = {
         url: linkMark.attrs.href,
@@ -186,15 +163,12 @@ export const convertHyperlinkToSmartCard = (state, source, appearance, normalize
 };
 export const changeSelectedCardToLink = (text, href, sendAnalytics, node, pos) => (state, dispatch) => {
   let tr;
   if (node && pos) {
     tr = cardNodeToLinkWithTransaction(state, text, href, node, pos);
   } else {
     tr = cardToLinkWithTransaction(state, text, href);
   }
   const selectedNode = state.selection instanceof NodeSelection && state.selection.node;
   if (sendAnalytics) {
     if (selectedNode) {
       addAnalytics(state, tr, {
@@ -208,22 +182,18 @@ export const changeSelectedCardToLink = (text, href, sendAnalytics, node, pos) =
       });
     }
   }
   if (dispatch) {
     dispatch(tr.scrollIntoView());
   }
   return true;
 };
 export const changeSelectedCardToLinkFallback = (text, href, sendAnalytics, node, pos) => (state, dispatch) => {
   let tr;
   if (node && pos) {
     tr = cardNodeToLinkWithTransaction(state, text, href, node, pos);
   } else {
     tr = cardToLinkWithTransaction(state, text, href);
   }
   if (sendAnalytics) {
     addAnalytics(state, tr, {
       action: ACTION.ERRORED,
@@ -234,37 +204,28 @@ export const changeSelectedCardToLinkFallback = (text, href, sendAnalytics, node
       }
     });
   }
   if (dispatch) {
     dispatch(tr.scrollIntoView());
   }
   return true;
 };
 export const updateCard = href => (state, dispatch) => {
   const selectedNode = state.selection instanceof NodeSelection && state.selection.node;
   if (!selectedNode) {
     return false;
   }
   const tr = cardToLinkWithTransaction(state, href, href);
   queueCardsFromChangedTr(state, tr, INPUT_METHOD.MANUAL);
   if (dispatch) {
     dispatch(tr.scrollIntoView());
   }
   return true;
 };
 function cardToLinkWithTransaction(state, text, href) {
   const selectedNode = state.selection instanceof NodeSelection && state.selection.node;
   if (!selectedNode) {
     return state.tr;
   }
   const {
     link
   } = state.schema.marks;
@@ -274,7 +235,6 @@ function cardToLinkWithTransaction(state, text, href) {
   })]), false);
   return tr;
 }
 function cardNodeToLinkWithTransaction(state, text, href, node, pos) {
   const {
     link
@@ -284,45 +244,35 @@ function cardNodeToLinkWithTransaction(state, text, href, node, pos) {
     href: href || url
   })]));
 }
 export const changeSelectedCardToText = text => (state, dispatch) => {
   const selectedNode = state.selection instanceof NodeSelection && state.selection.node;
   if (!selectedNode) {
     return false;
   }
   const tr = state.tr.replaceSelectionWith(state.schema.text(text), false);
   if (dispatch) {
     dispatch(addAnalytics(state, tr.scrollIntoView(), unlinkPayload(ACTION_SUBJECT_ID.CARD_INLINE)));
   }
   return true;
 };
 export const setSelectedCardAppearance = appearance => (state, dispatch) => {
   var _previousNode$type;
   const selectedNode = state.selection instanceof NodeSelection && state.selection.node;
   if (!selectedNode) {
     // When there is no selected node, we insert a new one
     // and replace the existing blue link
     const tr = convertHyperlinkToSmartCard(state, INPUT_METHOD.MANUAL, appearance);
     if (dispatch) {
       dispatch(tr.scrollIntoView());
     }
     return false;
   }
   if (appearanceForNodeType(selectedNode.type) === appearance) {
     return false;
   }
   const isEmbed = appearance === 'embed';
-  const attrs = isEmbed ? { ...selectedNode.attrs,
+  const attrs = isEmbed ? {
+    ...selectedNode.attrs,
     layout: 'center'
   } : selectedNode.attrs;
   const {
@@ -330,20 +280,18 @@ export const setSelectedCardAppearance = appearance => (state, dispatch) => {
     to
   } = state.selection;
   const nodeType = getLinkNodeType(appearance, state.schema.nodes);
-  const tr = state.tr.setNodeMarkup(from, nodeType, attrs, selectedNode.marks); // When the selected card is the last element in the doc we add a new paragraph after it for consistent replacement
+  const tr = state.tr.setNodeMarkup(from, nodeType, attrs, selectedNode.marks);
+  // When the selected card is the last element in the doc we add a new paragraph after it for consistent replacement
   if (tr.doc.nodeSize - 2 === to) {
     tr.insertText(' ', to);
   }
   tr.setSelection(TextSelection.create(tr.doc, to + 1));
   const previousNodePos = from - 1 > 0 ? from - 1 : 0;
   const previousNode = tr.doc.nodeAt(previousNodePos);
   if ((previousNode === null || previousNode === void 0 ? void 0 : (_previousNode$type = previousNode.type) === null || _previousNode$type === void 0 ? void 0 : _previousNode$type.name) === 'paragraph') {
     tr.delete(previousNodePos, from);
   }
   addAnalytics(state, tr, {
     action: ACTION.CHANGED_TYPE,
     actionSubject: ACTION_SUBJECT.SMART_LINK,
@@ -353,22 +301,17 @@ export const setSelectedCardAppearance = appearance => (state, dispatch) => {
       previousType: appearanceForNodeType(selectedNode.type)
     }
   });
   if (dispatch) {
     dispatch(tr.scrollIntoView());
   }
   return true;
 };
 const getLinkNodeType = (appearance, linkNodes) => {
   switch (appearance) {
     case 'inline':
       return linkNodes.inlineCard;
     case 'block':
       return linkNodes.blockCard;
     case 'embed':
       return linkNodes.embedCard;
   }

package/dist/es2019/plugins/card/pm-plugins/keymap.js CHANGED Viewed

@@ -4,10 +4,8 @@ import * as keymaps from '../../../keymaps';
 import { findChildren, flatten } from 'prosemirror-utils';
 import { browser } from '@atlaskit/editor-common/utils';
 const lookupPixel = 10;
 const getClosestInlineCardPos = (state, editorView, direction) => {
   var _editorView$posAtCoor;
   const {
     selection
   } = state;
@@ -15,58 +13,47 @@ const getClosestInlineCardPos = (state, editorView, direction) => {
     parent
   } = selection.$from;
   const inlineCardType = state.schema.nodes.inlineCard;
   if (!flatten(parent, false).some(({
     node
   }) => node.type === inlineCardType)) {
     return null;
   }
   const coord = editorView.coordsAtPos(selection.$anchor.pos);
   const nearPos = (_editorView$posAtCoor = editorView.posAtCoords({
     left: coord.left,
     top: direction === 'up' ? coord.top - lookupPixel : coord.bottom + lookupPixel
   })) === null || _editorView$posAtCoor === void 0 ? void 0 : _editorView$posAtCoor.pos;
   if (nearPos) {
     const newNode = state.doc.nodeAt(nearPos);
     if (newNode) {
       if (newNode.type !== inlineCardType || findChildren(parent, node => node === newNode, false).length === 0 || newNode === selection.node) {
         return null;
       }
       return nearPos;
     }
   }
   return null;
 };
 const selectAboveBelowInlineCard = direction => {
   return (state, dispatch, editorView) => {
     if (!editorView || !dispatch) {
       return false;
     }
     const pos = getClosestInlineCardPos(state, editorView, direction);
     if (pos) {
       dispatch(state.tr.setSelection(new NodeSelection(state.doc.resolve(pos))));
       return true;
     }
     return false;
   };
 };
 export function cardKeymap(featureFlags) {
-  const list = {}; // https://bugs.chromium.org/p/chromium/issues/detail?id=1227468 introduced since Chrome 91
+  const list = {};
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=1227468 introduced since Chrome 91
   if (browser.chrome && browser.chrome_version > 90 && featureFlags.chromeCursorHandlerFixedVersion && browser.chrome_version < featureFlags.chromeCursorHandlerFixedVersion) {
     keymaps.bindKeymapWithCommand(keymaps.moveUp.common, selectAboveBelowInlineCard('up'), list);
     keymaps.bindKeymapWithCommand(keymaps.moveDown.common, selectAboveBelowInlineCard('down'), list);
   }
   return keymap(list);
 }

package/dist/es2019/plugins/card/pm-plugins/main.js CHANGED Viewed

@@ -29,40 +29,32 @@ export const createPlugin = options => pmPluginFactoryParams => {
           createAnalyticsEvent
         };
       },
       apply(tr, pluginState) {
         // Update all the positions of outstanding requests and
         // cards in the plugin state.
-        const pluginStateWithUpdatedPos = getPluginStateWithUpdatedPos(pluginState, tr); // apply any actions
+        const pluginStateWithUpdatedPos = getPluginStateWithUpdatedPos(pluginState, tr);
+        // apply any actions
         const meta = tr.getMeta(pluginKey);
         if (meta) {
           const nextPluginState = reducer(pluginStateWithUpdatedPos, meta);
           return nextPluginState;
         }
         return pluginStateWithUpdatedPos;
       }
     },
     view(view) {
       const outstandingRequests = {};
       const subscriptionHandler = (name, provider) => handleProvider(name, provider, view);
       const rafCancellationCallbacks = [];
       pmPluginFactoryParams.providerFactory.subscribe('cardProvider', subscriptionHandler);
       return {
         update(view, prevState) {
           const currentState = getPluginState(view.state);
           const oldState = getPluginState(prevState);
           if (currentState && currentState.provider) {
             // Find requests in this state that weren't in the old one.
-            const newRequests = getNewRequests(oldState, currentState); // Ask the CardProvider to resolve all new requests.
+            const newRequests = getNewRequests(oldState, currentState);
+            // Ask the CardProvider to resolve all new requests.
             const {
               provider
             } = currentState;
@@ -82,18 +74,16 @@ export const createPlugin = options => pmPluginFactoryParams => {
             });
           }
         },
         destroy() {
           // Cancel all outstanding requests
-          Object.keys(outstandingRequests).forEach(url => Promise.reject(outstandingRequests[url])); // Cancel any outstanding raf callbacks.
+          Object.keys(outstandingRequests).forEach(url => Promise.reject(outstandingRequests[url]));
+          // Cancel any outstanding raf callbacks.
           rafCancellationCallbacks.forEach(cancellationCallback => cancellationCallback());
           pmPluginFactoryParams.providerFactory.unsubscribe('cardProvider', subscriptionHandler);
         }
       };
     },
     props: {
       nodeViews: {
         inlineCard: getInlineNodeViewProducer({

package/dist/es2019/plugins/card/pm-plugins/reducers.js CHANGED Viewed

@@ -1,63 +1,57 @@
 const queue = (state, action) => {
-  return { ...state,
+  return {
+    ...state,
     requests: state.requests.concat(action.requests)
   };
 };
 const resolve = (state, action) => {
   const requests = state.requests.reduce((requests, request) => {
     if (request.url !== action.url) {
       requests.push(request);
     }
     return requests;
   }, []);
-  return { ...state,
+  return {
+    ...state,
     requests
   };
 };
 const register = (state, action) => {
-  return { ...state,
+  return {
+    ...state,
     cards: state.cards.filter(card => card.pos !== action.info.pos).concat(action.info)
   };
 };
 const setProvider = (state, action) => {
-  return { ...state,
+  return {
+    ...state,
     provider: action.provider
   };
 };
 const registerEvents = (state, action) => {
-  return { ...state,
+  return {
+    ...state,
     smartLinkEvents: action.smartLinkEvents
   };
 };
 const setLinkToolbar = (state, action) => {
-  return { ...state,
+  return {
+    ...state,
     showLinkingToolbar: action.type === 'SHOW_LINK_TOOLBAR'
   };
 };
 export default ((state, action) => {
   switch (action.type) {
     case 'QUEUE':
       return queue(state, action);
     case 'SET_PROVIDER':
       return setProvider(state, action);
     case 'RESOLVE':
       return resolve(state, action);
     case 'REGISTER':
       return register(state, action);
     case 'REGISTER_EVENTS':
       return registerEvents(state, action);
     case 'SHOW_LINK_TOOLBAR':
     case 'HIDE_LINK_TOOLBAR':
       return setLinkToolbar(state, action);

package/dist/es2019/plugins/card/pm-plugins/shouldReplaceLink.js CHANGED Viewed

@@ -2,28 +2,24 @@ import { normalizeUrl } from '@atlaskit/adf-schema';
 import { md } from '../../paste/md';
 export function shouldReplaceLink(node, compareLinkText = true, compareToUrl) {
   const linkMark = node.marks.find(mark => mark.type.name === 'link');
   if (!linkMark) {
     // not a link anymore
     return false;
-  } // ED-6041: compare normalised link text after linkfy from Markdown transformer
-  // instead, since it always decodes URL ('%20' -> ' ') on the link text
+  }
+  // ED-6041: compare normalised link text after linkfy from Markdown transformer
+  // instead, since it always decodes URL ('%20' -> ' ') on the link text
   const normalisedHref = normalizeUrl(md.normalizeLinkText(linkMark.attrs.href));
   const normalizedLinkText = normalizeUrl(md.normalizeLinkText(node.text || ''));
   if (compareLinkText && normalisedHref !== normalizedLinkText) {
     return false;
   }
   if (compareToUrl) {
     const normalizedUrl = normalizeUrl(md.normalizeLinkText(compareToUrl));
     if (normalizedUrl !== normalisedHref) {
       return false;
     }
   }
   return true;
 }

package/dist/es2019/plugins/card/pm-plugins/util/resolve.js CHANGED Viewed

@@ -7,7 +7,8 @@ import { replaceQueuedUrlWithCard, handleFallbackWithAnalytics } from '../doc';
 // ============================================================================ //
 export const resolveWithProvider = (view, outstandingRequests, provider, request, options) => {
   // When user manually changes appearance from blue link to smart link, we should respect that,
-  let shouldForceAppearance = // This flag is set to true only in one place atm:
+  let shouldForceAppearance =
+  // This flag is set to true only in one place atm:
   // packages/editor/editor-core/src/plugins/card/pm-plugins/doc.ts @ convertHyperlinkToSmartCard
   // Which is used when user switching from URL to smart link appearance.
   !!request.shouldReplaceLink;
@@ -18,29 +19,25 @@ export const resolveWithProvider = (view, outstandingRequests, provider, request
   outstandingRequests[request.url] = handleResolve;
   return handleResolve;
 };
 const updateCardType = (resolvedCard, options) => {
   if ((resolvedCard === null || resolvedCard === void 0 ? void 0 : resolvedCard.type) === 'blockCard' && !options.allowBlockCards || (resolvedCard === null || resolvedCard === void 0 ? void 0 : resolvedCard.type) === 'embedCard' && !options.allowEmbeds) {
     resolvedCard.type = 'inlineCard';
   }
 };
 const handleResolved = (view, request, options) => resolvedCard => {
   updateCardType(resolvedCard, options);
   replaceQueuedUrlWithCard(request.url, resolvedCard, request.analyticsAction)(view.state, view.dispatch);
   return resolvedCard;
 };
 const handleRejected = (view, request) => () => {
   handleFallbackWithAnalytics(request.url, request.source)(view.state, view.dispatch);
-}; // listen for card provider changes
+};
+// listen for card provider changes
 export const handleProvider = (_, provider, view) => {
   if (!provider) {
     return;
   }
   provider.then(cardProvider => {
     const {
       state,

package/dist/es2019/plugins/card/pm-plugins/util/state.js CHANGED Viewed

@@ -1,15 +1,19 @@
-import { pluginKey } from '../plugin-key'; // ============================================================================ //
+import { pluginKey } from '../plugin-key';
+// ============================================================================ //
 // ============================== PLUGIN STATE ================================ //
 // ============================================================================ //
 // Used for interactions with the Card Plugin's state.
 // ============================================================================ //
 export const getPluginState = editorState => pluginKey.getState(editorState);
-export const getPluginStateWithUpdatedPos = (pluginState, tr) => ({ ...pluginState,
-  requests: pluginState.requests.map(request => ({ ...request,
+export const getPluginStateWithUpdatedPos = (pluginState, tr) => ({
+  ...pluginState,
+  requests: pluginState.requests.map(request => ({
+    ...request,
     pos: tr.mapping.map(request.pos)
   })),
-  cards: pluginState.cards.map(card => ({ ...card,
+  cards: pluginState.cards.map(card => ({
+    ...card,
     pos: tr.mapping.map(card.pos)
   }))
 });
@@ -17,8 +21,6 @@ export const getNewRequests = (oldState, currentState) => {
   if (oldState) {
     return currentState.requests.filter(req => !oldState.requests.find(oldReq => isSameRequest(oldReq, req)));
   }
   return currentState.requests;
 };
 const isSameRequest = (requestA, requestB) => requestA.url === requestB.url && requestA.pos === requestB.pos;