@atlaskit/editor-common 72.2.0 → 72.2.2

package/dist/es2019/icons/shared/PanelSuccessIcon.js

@@ -1,7 +1,6 @@
 import _extends from "@babel/runtime/helpers/extends";
 import React from 'react';
 import Icon from '@atlaskit/icon';
-
 const PanelSuccessGlyph = props => {
   return /*#__PURE__*/React.createElement("svg", _extends({
     width: "24",
@@ -16,7 +15,6 @@ const PanelSuccessGlyph = props => {
     fill: "currentColor"
   }));
 };
-
 export const PanelSuccessIcon = props => {
   return /*#__PURE__*/React.createElement(Icon, _extends({
     glyph: PanelSuccessGlyph

package/dist/es2019/icons/shared/PanelWarningIcon.js

@@ -1,7 +1,6 @@
 import _extends from "@babel/runtime/helpers/extends";
 import React from 'react';
 import Icon from '@atlaskit/icon';
-
 const PanelWarningGlyph = props => {
   return /*#__PURE__*/React.createElement("svg", _extends({
     width: "24",
@@ -16,7 +15,6 @@ const PanelWarningGlyph = props => {
     fill: "currentColor"
   }));
 };
-
 export const PanelWarningIcon = props => {
   return /*#__PURE__*/React.createElement(Icon, _extends({
     glyph: PanelWarningGlyph

package/dist/es2019/keymaps/index.js

@@ -85,32 +85,26 @@ const tooltipShortcutStyle = css`
 
 function formatShortcut(keymap) {
   let shortcut;
-
   if (browser.mac) {
     // for reference: https://wincent.com/wiki/Unicode_representations_of_modifier_keys
     shortcut = keymap.mac.replace(/Cmd/i, '\u2318').replace(/Shift/i, '\u21E7').replace(/Ctrl/i, '\u2303').replace(/Alt/i, '\u2325').replace(/Backspace/i, '\u232B').replace(/Enter/i, '\u23CE');
   } else {
     shortcut = keymap.windows.replace(/Backspace/i, '\u232B');
   }
-
   const keys = shortcut.split('-');
   let lastKey = keys[keys.length - 1];
-
   if (lastKey.length === 1) {
     // capitalise single letters
     lastKey = lastKey.toUpperCase();
   }
-
   keys[keys.length - 1] = arrowKeysMap[lastKey.toUpperCase()] || lastKey;
   return keys.join(browser.mac ? '' : '+');
 }
-
 export function tooltip(keymap, description) {
   if (keymap) {
     const shortcut = formatShortcut(keymap);
     return description ? `${description} ${shortcut}` : shortcut;
   }
-
   return;
 }
 export const ToolTipContent = /*#__PURE__*/React.memo(({
@@ -129,59 +123,45 @@ export function findKeymapByDescription(description) {
 }
 export function findShortcutByDescription(description) {
   const keymap = findKeymapByDescription(description);
-
   if (keymap) {
     return findShortcutByKeymap(keymap);
   }
-
   return;
 }
 export function findShortcutByKeymap(keymap) {
   if (browser.mac) {
     return keymap.mac;
   }
-
   return keymap.windows;
 }
 export function getAriaKeyshortcuts(keymap) {
   let keyShortcuts;
-
   if (typeof keymap === 'string') {
     keyShortcuts = keymap;
   } else if (typeof keymap === 'object') {
     keyShortcuts = keymap[browser.mac ? 'mac' : 'windows'];
   }
-
   if (keyShortcuts) {
     return keyShortcuts.toLowerCase().split('-').map(modifier => {
       switch (modifier) {
         case 'cmd':
           return 'Meta';
-
         case 'ctrl':
           return 'Control';
-
         case 'alt':
           return 'Alt';
-
         case 'shift':
           return 'Shift';
-
         case 'enter':
           return 'Enter';
-
         case 'esc':
           return 'Esc';
-
         case 'tab':
           return 'Tab';
-
         case 'space':
           return 'Space';
-
         case 'backspace':
           return 'Backspace';
-
         default:
           return modifier.split('').join(' ');
       }
@@ -207,13 +187,11 @@ export function makeKeyMapWithCommon(description, common) {
 export function bindKeymapWithCommand(shortcut, cmd, keymap) {
   const oldCmd = keymap[shortcut];
   let newCmd = cmd;
-
   if (keymap[shortcut]) {
     newCmd = (state, dispatch, editorView) => {
       return oldCmd(state, dispatch) || cmd(state, dispatch, editorView);
     };
   }
-
   keymap[shortcut] = newCmd;
 }
 export function findKeyMapForBrowser(keyMap) {
@@ -221,10 +199,8 @@ export function findKeyMapForBrowser(keyMap) {
     if (browser.mac) {
       return keyMap.mac;
     }
-
     return keyMap.windows;
   }
-
   return;
 }
 export { DOWN, HEADING_KEYS, KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, LEFT, RIGHT, UP } from './consts';

package/dist/es2019/node-width/index.js

@@ -3,34 +3,28 @@ import { akEditorFullWidthLayoutWidth, akLayoutGutterOffset, gridMediumMaxWidth
 import { BODIED_EXT_PADDING } from '../styles/shared/extension';
 import { LAYOUT_COLUMN_PADDING, LAYOUT_SECTION_MARGIN } from '../styles/shared/layout';
 import { absoluteBreakoutWidth } from '../utils/breakout';
+
 /**
  * Calculates width of parent node of a nested node (inside layouts, extension)
  * If current node selection is not nested will return undefined
  */
-
 export const getParentNodeWidth = (pos, state, containerWidth, isFullWidthModeEnabled) => {
   if (!pos) {
     return;
   }
-
   const node = getNestedParentNode(pos, state);
-
   if (!node) {
     return;
   }
-
   let layout = node.attrs.layout || 'default';
   const {
     schema
   } = state;
   const breakoutMark = schema.marks.breakout && schema.marks.breakout.isInSet(node.marks);
-
   if (breakoutMark && breakoutMark.attrs.mode) {
     layout = breakoutMark.attrs.mode;
   }
-
   let parentWidth = calcBreakoutNodeWidth(layout, containerWidth, isFullWidthModeEnabled);
-
   if (node.type === schema.nodes.layoutSection) {
     parentWidth += akLayoutGutterOffset * 2; // extra width that gets added to layout
 
@@ -39,36 +33,31 @@ export const getParentNodeWidth = (pos, state, containerWidth, isFullWidthModeEn
 
       const $pos = state.doc.resolve(pos);
       const column = findParentNodeOfTypeClosestToPos($pos, [state.schema.nodes.layoutColumn]);
-
       if (column && column.node && !isNaN(column.node.attrs.width)) {
         // get exact width of parent layout column using node attrs
         parentWidth = Math.round(parentWidth * column.node.attrs.width * 0.01);
       }
     }
-  } // account for the padding of the parent node
-
+  }
 
+  // account for the padding of the parent node
   if (node.type === schema.nodes.layoutSection) {
     parentWidth -= LAYOUT_COLUMN_PADDING * 2;
   } else if (node.type === schema.nodes.bodiedExtension) {
     parentWidth -= BODIED_EXT_PADDING * 2;
   }
-
   parentWidth -= 2; // border
 
   return parentWidth;
 };
-
 const getNestedParentNode = (tablePos, state) => {
   if (tablePos === undefined) {
     return null;
   }
-
   const $pos = state.doc.resolve(tablePos);
   const parent = findParentNodeOfTypeClosestToPos($pos, [state.schema.nodes.bodiedExtension, state.schema.nodes.layoutSection, state.schema.nodes.expand]);
   return parent ? parent.node : null;
 };
-
 const calcBreakoutNodeWidth = (layout, containerWidth, isFullWidthModeEnabled) => {
   return isFullWidthModeEnabled ? Math.min(containerWidth.lineLength, akEditorFullWidthLayoutWidth) : absoluteBreakoutWidth(layout, containerWidth.width);
 };

package/dist/es2019/normalize-feature-flags.js

@@ -1,24 +1,21 @@
 import camelCase from 'lodash/camelCase';
 import kebabCase from 'lodash/kebabCase';
 const EMPTY = {};
-
 function isObjectFlagKey(key, value, objectFlagKeys) {
   return Boolean(typeof value === 'string' && (objectFlagKeys === null || objectFlagKeys === void 0 ? void 0 : objectFlagKeys.includes(key)));
 }
-
 function isValidJSONObject(value) {
   try {
     let result = JSON.parse(value);
-
     if (typeof result === 'object' && result !== null) {
       return true;
     }
-
     return false;
   } catch (err) {
     return false;
   }
 }
+
 /**
  * Normalise and filter a free Record<string, unknown> to match
  * the rules for feature flags in editor and renderer
@@ -33,32 +30,25 @@ function isValidJSONObject(value) {
  *
  * @param rawFeatureFlags
  */
-
-
 export function normalizeFeatureFlags(rawFeatureFlags, options) {
   if (!rawFeatureFlags) {
     return EMPTY;
   }
-
   return Object.entries(rawFeatureFlags).filter(e => {
     if (typeof e[1] === 'boolean') {
       return true;
     }
-
     if (isObjectFlagKey(camelCase(e[0]), e[1], options === null || options === void 0 ? void 0 : options.objectFlagKeys) && isValidJSONObject(e[1])) {
       return true;
     }
-
     return false;
   }).filter(([key]) => kebabCase(key) === key).map(([key, value]) => [camelCase(key), value]).reduce((flags, [key, value]) => {
     if (isObjectFlagKey(key, value, options === null || options === void 0 ? void 0 : options.objectFlagKeys)) {
       flags[key] = JSON.parse(value);
     }
-
     if (typeof value === 'boolean') {
       flags[key] = value;
     }
-
     return flags;
   }, {});
 }

package/dist/es2019/provider-factory/context.js

@@ -10,7 +10,6 @@ export const useProvider = name => {
     const providerHandler = (_, provider) => {
       setProvider(provider);
     };
-
     providerFactory.subscribe(name, providerHandler);
     return () => {
       providerFactory.unsubscribe(name, providerHandler);

package/dist/es2019/provider-factory/provider-factory.js

@@ -1,16 +1,12 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
 function isUndefined(x) {
   return x === undefined;
 }
-
 export default class ProviderFactory {
   constructor() {
     _defineProperty(this, "providers", new Map());
-
     _defineProperty(this, "subscribers", new Map());
   }
-
   static create(providers) {
     const providerFactory = new ProviderFactory();
     const keys = Object.keys(providers);
@@ -19,91 +15,70 @@ export default class ProviderFactory {
     });
     return providerFactory;
   }
-
   destroy() {
     this.providers.clear();
     this.subscribers.clear();
   }
-
   isEmpty() {
     return !this.providers.size && !this.subscribers.size;
   }
-
   setProvider(name, provider) {
     // Do not trigger notifyUpdate if provider is the same.
     if (this.providers.get(name) === provider) {
       return;
     }
-
     if (!isUndefined(provider)) {
       this.providers.set(name, provider);
     } else {
       this.providers.delete(name);
     }
-
     this.notifyUpdated(name, provider);
   }
-
   removeProvider(name) {
     this.providers.delete(name);
     this.notifyUpdated(name);
   }
-
   subscribe(name, handler) {
     const handlers = this.subscribers.get(name) || [];
     handlers.push(handler);
     this.subscribers.set(name, handlers);
     const provider = this.providers.get(name);
-
     if (provider) {
       handler(name, provider);
     }
   }
-
   unsubscribe(name, handler) {
     const handlers = this.subscribers.get(name);
-
     if (!handlers) {
       return;
     }
-
     const index = handlers.indexOf(handler);
-
     if (index !== -1) {
       handlers.splice(index, 1);
     }
-
     if (handlers.length === 0) {
       this.subscribers.delete(name);
     } else {
       this.subscribers.set(name, handlers);
     }
   }
-
   unsubscribeAll(name) {
     const handlers = this.subscribers.get(name);
-
     if (!handlers) {
       return;
     }
-
     this.subscribers.delete(name);
   }
-
   hasProvider(name) {
     return this.providers.has(name);
   }
-
   notifyUpdated(name, provider) {
     const handlers = this.subscribers.get(name);
-
     if (!handlers) {
       return;
     }
-
     handlers.forEach(handler => {
       handler(name, provider);
     });
   }
-
 }

package/dist/es2019/provider-factory/with-providers.js

@@ -3,19 +3,18 @@ import { PureComponent } from 'react';
 export class WithProviders extends PureComponent {
   constructor(props) {
     super(props);
-
     _defineProperty(this, "handleProvider", (name, provider) => {
       this.setState(({
         providers
       }) => {
         return {
-          providers: { ...providers,
+          providers: {
+            ...providers,
             [name]: provider
           }
         };
       });
     });
-
     const _providers = {};
     this.props.providers.forEach(name => {
       _providers[name] = undefined;
@@ -24,7 +23,6 @@ export class WithProviders extends PureComponent {
       providers: _providers
     };
   }
-
   UNSAFE_componentWillMount() {
     const {
       providers,
@@ -34,7 +32,6 @@ export class WithProviders extends PureComponent {
       providerFactory.subscribe(name, this.handleProvider);
     });
   }
-
   componentWillUnmount() {
     const {
       providers,
@@ -44,7 +41,6 @@ export class WithProviders extends PureComponent {
       providerFactory.unsubscribe(name, this.handleProvider);
     });
   }
-
   render() {
     const {
       state,
@@ -55,7 +51,5 @@ export class WithProviders extends PureComponent {
     } = props;
     return renderNode(state.providers);
   }
-
 }
-
 _defineProperty(WithProviders, "displayName", 'WithProviders');

package/dist/es2019/provider-helpers/combine-providers.js

@@ -1,60 +1,50 @@
 import { getOnlyFulfilled, waitForAllPromises, waitForFirstFulfilledPromise } from './promise-helpers';
-
 const flatten = arr => [].concat(...arr);
+
 /**
  * Allow to run methods from the given provider interface across all providers seamlessly.
  * Handles promise racing and discards rejected promises safely.
  */
-
-
 export default (providers => {
   if (providers.length === 0) {
     throw new Error('At least one provider must be provided');
   }
-
   const getFulfilledProviders = async () => {
     const results = await waitForAllPromises(providers.map(result => Promise.resolve(result)));
     return getOnlyFulfilled(results);
   };
-
   const runInAllProviders = async mapFunction => {
     return (await getFulfilledProviders()).map(provider => mapFunction(provider));
   };
-
   const createCallback = (methodName, args) => provider => {
     const method = provider[methodName];
-
     if (typeof method === 'function') {
       return method.apply(provider, args);
     }
-
     throw new Error(`"${methodName}" isn't a function of the provider`);
   };
+
   /**
    * Run a method from the provider which expects to return a single item
    * @param methodName
    * @param args
    */
-
-
   const invokeSingle = async (methodName, args) => {
     const callback = createCallback(methodName, args);
     return waitForFirstFulfilledPromise(await runInAllProviders(callback));
   };
+
   /**
    * Run a method in the provider which expectes to return a list of items
    * @param methodName
    * @param args
    */
-
-
   const invokeList = async (methodName, args) => {
     const callback = createCallback(methodName, args);
     const results = await waitForAllPromises(await runInAllProviders(callback));
     const fulfilledResults = getOnlyFulfilled(results);
     return flatten(fulfilledResults).filter(result => result);
   };
-
   return {
     invokeSingle,
     invokeList

package/dist/es2019/provider-helpers/promise-helpers.js

@@ -1,21 +1,18 @@
 export let ResultStatus;
-
 (function (ResultStatus) {
   ResultStatus["FULFILLED"] = "fulfilled";
   ResultStatus["FAILED"] = "failed";
 })(ResultStatus || (ResultStatus = {}));
-
 const isFullfilled = result => result.status === ResultStatus.FULFILLED;
-
 const markFullfilled = value => ({
   status: ResultStatus.FULFILLED,
   value: value
 });
-
 const markRejected = error => ({
   status: ResultStatus.FAILED,
   reason: error
 });
+
 /**
  * Will wait for all promises to resolve or reject, wrapping their real results in
  * object containing the status so it's easy to filter it later. Loosely inspired by
@@ -23,17 +20,15 @@ const markRejected = error => ({
  * which can replace this implementation once it makes to the browsers.
  * @param promises
  */
-
-
 export const waitForAllPromises = promises => {
   return Promise.all(promises.map(result => result.then(markFullfilled).catch(markRejected)));
 };
+
 /**
  * Will resolve on the first fulfilled promise and disregard the remaining ones. Similar to `Promise.race` but won't
  * care about rejected promises.
  * @param promises
  */
-
 export const waitForFirstFulfilledPromise = promises => {
   const rejectReasons = [];
   return new Promise((resolve, reject) => {
@@ -41,20 +36,18 @@ export const waitForFirstFulfilledPromise = promises => {
       if (typeof value === 'undefined' || value === null) {
         throw new Error(`Result was not found but the method didn't reject/throw. Please ensure that it doesn't return null or undefined.`);
       }
-
       resolve(value);
     }).catch(reason => {
       rejectReasons.push(reason);
-
       if (rejectReasons.length === promises.length) {
         reject(reason);
       }
     }));
   });
 };
+
 /**
  * Find all fullfilled promises and return their values
  * @param results
  */
-
 export const getOnlyFulfilled = results => results.filter(isFullfilled).map(result => result.value);