@atlaskit/editor-plugin-emoji 0.1.2 → 0.3.0

package/dist/es2019/plugin.js

@@ -0,0 +1,386 @@
+import React from 'react';
+import { emoji } from '@atlaskit/adf-schema';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { toolbarInsertBlockMessages as messages } from '@atlaskit/editor-common/messages';
+import { IconEmoji } from '@atlaskit/editor-common/quick-insert';
+import { getInlineNodeViewProducer } from '@atlaskit/editor-common/react-node-view';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { EmojiTypeAheadItem, recordSelectionFailedSli, recordSelectionSucceededSli, SearchSort } from '@atlaskit/emoji';
+import { insertEmoji } from './commands/insert-emoji';
+import { EmojiNodeView } from './nodeviews/emoji';
+import { inputRulePlugin as asciiInputRulePlugin } from './pm-plugins/ascii-input-rules';
+export const emojiToTypeaheadItem = (emoji, emojiProvider) => ({
+  title: emoji.shortName || '',
+  key: emoji.id || emoji.shortName,
+  render({
+    isSelected,
+    onClick,
+    onHover
+  }) {
+    return /*#__PURE__*/React.createElement(EmojiTypeAheadItem, {
+      emoji: emoji,
+      selected: isSelected,
+      onMouseMove: onHover,
+      onSelection: onClick,
+      emojiProvider: emojiProvider
+    });
+  },
+  emoji
+});
+export function memoize(fn) {
+  // Cache results here
+  const seen = new Map();
+  function memoized(emoji, emojiProvider) {
+    // Check cache for hits
+    const hit = seen.get(emoji.id || emoji.shortName);
+    if (hit) {
+      return hit;
+    }
+
+    // Generate new result and cache it
+    const result = fn(emoji, emojiProvider);
+    seen.set(emoji.id || emoji.shortName, result);
+    return result;
+  }
+  return {
+    call: memoized,
+    clear: seen.clear.bind(seen)
+  };
+}
+const memoizedToItem = memoize(emojiToTypeaheadItem);
+export const defaultListLimit = 50;
+const isFullShortName = query => query && query.length > 1 && query.charAt(0) === ':' && query.charAt(query.length - 1) === ':';
+const TRIGGER = ':';
+
+/**
+ * Emoji plugin to be added to an `EditorPresetBuilder` and used with `ComposableEditor`
+ * from `@atlaskit/editor-core`.
+ */
+export const emojiPlugin = ({
+  config: options,
+  api
+}) => {
+  var _api$analytics5;
+  const typeAhead = {
+    id: TypeAheadAvailableNodes.EMOJI,
+    trigger: TRIGGER,
+    // Custom regex must have a capture group around trigger
+    // so it's possible to use it without needing to scan through all triggers again
+    customRegex: '\\(?(:)',
+    headless: options ? options.headless : undefined,
+    getItems({
+      query,
+      editorState
+    }) {
+      const pluginState = getEmojiPluginState(editorState);
+      const emojiProvider = pluginState.emojiProvider;
+      if (!emojiProvider) {
+        return Promise.resolve([]);
+      }
+      return new Promise(resolve => {
+        const emojiProviderChangeHandler = {
+          result(emojiResult) {
+            if (!emojiResult || !emojiResult.emojis) {
+              resolve([]);
+            } else {
+              const emojiItems = emojiResult.emojis.map(emoji => memoizedToItem.call(emoji, emojiProvider));
+              resolve(emojiItems);
+            }
+            emojiProvider.unsubscribe(emojiProviderChangeHandler);
+          }
+        };
+        emojiProvider.subscribe(emojiProviderChangeHandler);
+        emojiProvider.filter(TRIGGER.concat(query), {
+          limit: defaultListLimit,
+          skinTone: emojiProvider.getSelectedTone(),
+          sort: !query.length ? SearchSort.UsageFrequency : SearchSort.Default
+        });
+      });
+    },
+    forceSelect({
+      query,
+      items,
+      editorState
+    }) {
+      const {
+        asciiMap
+      } = emojiPluginKey.getState(editorState) || {};
+      const normalizedQuery = TRIGGER.concat(query);
+
+      // if the query has space at the end
+      // check the ascii map for emojis
+      if (asciiMap && normalizedQuery.length >= 3 && normalizedQuery.endsWith(' ') && asciiMap.has(normalizedQuery.trim())) {
+        const emoji = asciiMap.get(normalizedQuery.trim());
+        return {
+          title: (emoji === null || emoji === void 0 ? void 0 : emoji.name) || '',
+          emoji
+        };
+      }
+      const matchedItem = isFullShortName(normalizedQuery) ? items.find(item => item.title.toLowerCase() === normalizedQuery) : undefined;
+      return matchedItem;
+    },
+    selectItem(state, item, insert, {
+      mode
+    }) {
+      var _api$analytics3;
+      const {
+        id = '',
+        fallback,
+        shortName
+      } = item.emoji;
+      const text = fallback || shortName;
+      const emojiPluginState = emojiPluginKey.getState(state);
+      if (emojiPluginState.emojiProvider && emojiPluginState.emojiProvider.recordSelection && item.emoji) {
+        var _api$analytics$shared, _api$analytics, _api$analytics$shared2, _api$analytics$shared3, _api$analytics2, _api$analytics2$share;
+        emojiPluginState.emojiProvider.recordSelection(item.emoji).then(recordSelectionSucceededSli({
+          createAnalyticsEvent: (_api$analytics$shared = api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : (_api$analytics$shared2 = _api$analytics.sharedState.currentState()) === null || _api$analytics$shared2 === void 0 ? void 0 : _api$analytics$shared2.createAnalyticsEvent) !== null && _api$analytics$shared !== void 0 ? _api$analytics$shared : undefined
+        })).catch(recordSelectionFailedSli({
+          createAnalyticsEvent: (_api$analytics$shared3 = api === null || api === void 0 ? void 0 : (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : (_api$analytics2$share = _api$analytics2.sharedState.currentState()) === null || _api$analytics2$share === void 0 ? void 0 : _api$analytics2$share.createAnalyticsEvent) !== null && _api$analytics$shared3 !== void 0 ? _api$analytics$shared3 : undefined
+        }));
+      }
+      const emojiNode = state.schema.nodes.emoji.createChecked({
+        shortName,
+        id,
+        text
+      });
+      const space = state.schema.text(' ');
+      const tr = insert(Fragment.from([emojiNode, space]));
+      api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions.attachAnalyticsEvent({
+        action: ACTION.INSERTED,
+        actionSubject: ACTION_SUBJECT.DOCUMENT,
+        actionSubjectId: ACTION_SUBJECT_ID.EMOJI,
+        attributes: {
+          inputMethod: INPUT_METHOD.TYPEAHEAD
+        },
+        eventType: EVENT_TYPE.TRACK
+      })(tr);
+      return tr;
+    }
+  };
+  return {
+    name: 'emoji',
+    nodes() {
+      return [{
+        name: 'emoji',
+        node: emoji
+      }];
+    },
+    pmPlugins() {
+      return [{
+        name: 'emoji',
+        plugin: pmPluginFactoryParams => createEmojiPlugin(pmPluginFactoryParams)
+      }, {
+        name: 'emojiAsciiInputRule',
+        plugin: ({
+          schema,
+          providerFactory,
+          featureFlags
+        }) => {
+          var _api$analytics4;
+          return asciiInputRulePlugin(schema, providerFactory, featureFlags, api === null || api === void 0 ? void 0 : (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 ? void 0 : _api$analytics4.actions);
+        }
+      }];
+    },
+    getSharedState(editorState) {
+      if (!editorState) {
+        return undefined;
+      }
+      return emojiPluginKey.getState(editorState);
+    },
+    commands: {
+      insertEmoji: insertEmoji(api === null || api === void 0 ? void 0 : (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 ? void 0 : _api$analytics5.actions)
+    },
+    pluginsOptions: {
+      quickInsert: ({
+        formatMessage
+      }) => [{
+        id: 'emoji',
+        title: formatMessage(messages.emoji),
+        description: formatMessage(messages.emojiDescription),
+        priority: 500,
+        keyshortcut: ':',
+        icon: () => /*#__PURE__*/React.createElement(IconEmoji, null),
+        action(insert, state) {
+          var _api$analytics6;
+          const tr = insert(undefined);
+          api === null || api === void 0 ? void 0 : api.typeAhead.commands.openTypeAheadAtCursor({
+            triggerHandler: typeAhead,
+            inputMethod: INPUT_METHOD.QUICK_INSERT
+          })({
+            tr
+          });
+          api === null || api === void 0 ? void 0 : (_api$analytics6 = api.analytics) === null || _api$analytics6 === void 0 ? void 0 : _api$analytics6.actions.attachAnalyticsEvent({
+            action: ACTION.INVOKED,
+            actionSubject: ACTION_SUBJECT.TYPEAHEAD,
+            actionSubjectId: ACTION_SUBJECT_ID.TYPEAHEAD_EMOJI,
+            attributes: {
+              inputMethod: INPUT_METHOD.QUICK_INSERT
+            },
+            eventType: EVENT_TYPE.UI
+          })(tr);
+          return tr;
+        }
+      }],
+      typeAhead
+    }
+  };
+};
+
+/**
+ * Actions
+ */
+
+export const ACTIONS = {
+  SET_PROVIDER: 'SET_PROVIDER',
+  SET_RESULTS: 'SET_RESULTS',
+  SET_ASCII_MAP: 'SET_ASCII_MAP'
+};
+const setAsciiMap = asciiMap => (state, dispatch) => {
+  if (dispatch) {
+    dispatch(state.tr.setMeta(emojiPluginKey, {
+      action: ACTIONS.SET_ASCII_MAP,
+      params: {
+        asciiMap
+      }
+    }));
+  }
+  return true;
+};
+
+/**
+ *
+ * Wrapper to call `onLimitReached` when a specified number of calls of that function
+ * have been made within a time period.
+ *
+ * Note: It does not rate limit
+ *
+ * @param fn Function to wrap
+ * @param limitTime Time limit in milliseconds
+ * @param limitCount Number of function calls before `onRateReached` is called (per time period)
+ * @returns Wrapped function
+ */
+export function createRateLimitReachedFunction(fn, limitTime, limitCount, onLimitReached) {
+  let lastCallTime = 0;
+  let callCount = 0;
+  return function wrappedFn(...args) {
+    const now = Date.now();
+    if (now - lastCallTime < limitTime) {
+      if (++callCount > limitCount) {
+        onLimitReached === null || onLimitReached === void 0 ? void 0 : onLimitReached();
+      }
+    } else {
+      lastCallTime = now;
+      callCount = 1;
+    }
+    return fn(...args);
+  };
+}
+
+// At this stage console.error only
+const logRateWarning = () => {
+  if (process.env.NODE_ENV === 'development') {
+    // eslint-disable-next-line no-console
+    console.error('The emoji provider injected in the Editor is being reloaded frequently, this will cause a slow Editor experience.');
+  }
+};
+export const setProvider = createRateLimitReachedFunction(provider => (state, dispatch) => {
+  if (dispatch) {
+    dispatch(state.tr.setMeta(emojiPluginKey, {
+      action: ACTIONS.SET_PROVIDER,
+      params: {
+        provider
+      }
+    }));
+  }
+  return true;
+},
+// If we change the emoji provider more than three times every 5 seconds we should warn.
+// This seems like a really long time but the performance can be that laggy that we don't
+// even get 3 events in 3 seconds and miss this indicator.
+5000, 3, logRateWarning);
+export const emojiPluginKey = new PluginKey('emojiPlugin');
+export function getEmojiPluginState(state) {
+  return emojiPluginKey.getState(state) || {};
+}
+export function createEmojiPlugin(pmPluginFactoryParams) {
+  return new SafePlugin({
+    key: emojiPluginKey,
+    state: {
+      init() {
+        return {};
+      },
+      apply(tr, pluginState) {
+        const {
+          action,
+          params
+        } = tr.getMeta(emojiPluginKey) || {
+          action: null,
+          params: null
+        };
+        let newPluginState = pluginState;
+        switch (action) {
+          case ACTIONS.SET_PROVIDER:
+            newPluginState = {
+              ...pluginState,
+              emojiProvider: params.provider
+            };
+            pmPluginFactoryParams.dispatch(emojiPluginKey, newPluginState);
+            return newPluginState;
+          case ACTIONS.SET_ASCII_MAP:
+            newPluginState = {
+              ...pluginState,
+              asciiMap: params.asciiMap
+            };
+            pmPluginFactoryParams.dispatch(emojiPluginKey, newPluginState);
+            return newPluginState;
+        }
+        return newPluginState;
+      }
+    },
+    props: {
+      nodeViews: {
+        emoji: getInlineNodeViewProducer({
+          pmPluginFactoryParams,
+          Component: EmojiNodeView,
+          extraComponentProps: {
+            providerFactory: pmPluginFactoryParams.providerFactory
+          }
+        })
+      }
+    },
+    view(editorView) {
+      const providerHandler = (name, providerPromise) => {
+        switch (name) {
+          case 'emojiProvider':
+            if (!providerPromise) {
+              var _setProvider;
+              return setProvider === null || setProvider === void 0 ? void 0 : (_setProvider = setProvider(undefined)) === null || _setProvider === void 0 ? void 0 : _setProvider(editorView.state, editorView.dispatch);
+            }
+            providerPromise.then(provider => {
+              var _setProvider2;
+              setProvider === null || setProvider === void 0 ? void 0 : (_setProvider2 = setProvider(provider)) === null || _setProvider2 === void 0 ? void 0 : _setProvider2(editorView.state, editorView.dispatch);
+              provider.getAsciiMap().then(asciiMap => {
+                setAsciiMap(asciiMap)(editorView.state, editorView.dispatch);
+              });
+            }).catch(() => {
+              var _setProvider3;
+              return setProvider === null || setProvider === void 0 ? void 0 : (_setProvider3 = setProvider(undefined)) === null || _setProvider3 === void 0 ? void 0 : _setProvider3(editorView.state, editorView.dispatch);
+            });
+            break;
+        }
+        return;
+      };
+      pmPluginFactoryParams.providerFactory.subscribe('emojiProvider', providerHandler);
+      return {
+        destroy() {
+          if (pmPluginFactoryParams.providerFactory) {
+            pmPluginFactoryParams.providerFactory.unsubscribe('emojiProvider', providerHandler);
+          }
+        }
+      };
+    }
+  });
+}

package/dist/es2019/pm-plugins/ascii-input-rules.js

@@ -0,0 +1,168 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { createPlugin, createRule, leafNodeReplacementCharacter } from '@atlaskit/prosemirror-input-rules';
+let matcher;
+export function inputRulePlugin(schema, providerFactory, featureFlags, editorAnalyticsAPI) {
+  if (schema.nodes.emoji && providerFactory) {
+    initMatcher(providerFactory);
+    const asciiEmojiRule = createRule(AsciiEmojiMatcher.REGEX, inputRuleHandler(editorAnalyticsAPI));
+    return createPlugin('emoji', [asciiEmojiRule]);
+  }
+  return;
+}
+function initMatcher(providerFactory) {
+  const handleProvider = (_name, provider) => {
+    if (!provider) {
+      return;
+    }
+    provider.then(emojiProvider => {
+      emojiProvider.getAsciiMap().then(map => {
+        matcher = new RecordingAsciiEmojiMatcher(emojiProvider, map);
+      });
+    });
+  };
+  providerFactory.subscribe('emojiProvider', handleProvider);
+}
+const inputRuleHandler = editorAnalyticsAPI => (state, matchParts, start, end) => {
+  if (!matcher) {
+    return null;
+  }
+  const match = matcher.match(matchParts);
+  if (match) {
+    const transactionCreator = new AsciiEmojiTransactionCreator(state, match, start, end, editorAnalyticsAPI);
+    return transactionCreator.create();
+  }
+  return null;
+};
+const REGEX_LEADING_CAPTURE_INDEX = 1;
+const REGEX_EMOJI_LEADING_PARENTHESES = 2;
+const REGEX_EMOJI_ASCII_CAPTURE_INDEX = 3;
+const REGEX_TRAILING_CAPTURE_INDEX = 4;
+const getLeadingString = (match, withParenthesis = true) => match[REGEX_LEADING_CAPTURE_INDEX] + (withParenthesis ? match[REGEX_EMOJI_LEADING_PARENTHESES] : '');
+const getLeadingStringWithoutParentheses = match => getLeadingString(match, false);
+const getAscii = (match, withParentheses = false) => (withParentheses ? match[REGEX_EMOJI_LEADING_PARENTHESES] : '') + match[REGEX_EMOJI_ASCII_CAPTURE_INDEX].trim();
+const getAsciiWithParentheses = matchParts => getAscii(matchParts, true);
+const getTrailingString = match => match[REGEX_TRAILING_CAPTURE_INDEX] || '';
+class AsciiEmojiMatcher {
+  constructor(asciiToEmojiMap) {
+    this.asciiToEmojiMap = asciiToEmojiMap;
+  }
+  match(matchParts) {
+    return this.getAsciiEmojiMatch(getLeadingStringWithoutParentheses(matchParts), getAsciiWithParentheses(matchParts), getTrailingString(matchParts)) || this.getAsciiEmojiMatch(getLeadingString(matchParts), getAscii(matchParts), getTrailingString(matchParts));
+  }
+  getAsciiEmojiMatch(leading, ascii, trailing) {
+    const emoji = this.asciiToEmojiMap.get(ascii);
+    return emoji ? {
+      emoji,
+      leadingString: leading,
+      trailingString: trailing
+    } : undefined;
+  }
+}
+
+/**
+ * A matcher that will record ascii matches as usages of the matched emoji.
+ */
+/**
+ * This regex matches 2 scenarios:
+ * 1. an emoticon starting with a colon character (e.g. :D => 😃)
+ * 2. an emoticon not starting with a colon character (e.g. 8-D => 😎)
+ *
+ * Explanation (${leafNodeReplacementCharacter} is replaced with character \ufffc)
+ *
+ *  1st Capturing Group ((?:^|[\s\ufffc])(?:\(*?))
+ *    Non-capturing group (?:^|[\s\ufffc])
+ *      1st Alternative ^
+ *        ^ asserts position at start of the string
+ *      2nd Alternative [\s\ufffc]
+ *        matches a single character present in [\s\ufffc]
+ *    Non-capturing group (?:\(*?)
+ *      matches the character ( literally between zero and unlimited times, as few times as possible, expanding as needed (lazy)
+ *  2nd Capturing Group (\(?)
+ *    matches a single ( if present
+ *  3rd Capturing Group ([^:\s\ufffc\(]\S{1,3}|:\S{1,3}( ))
+ *    1st Alternative [^:\s\ufffc\(]\S{1,3}
+ *      matches a single character not present in [^:\s\ufffc\(] between 1 and 3 times, as many times as possible, giving back as needed (greedy)
+ *    2nd Alternative :\S{1,3}( )
+ *      : matches the character : literally
+ *      \S{1,3} matches any non-whitespace character between 1 and 3 times, as many times as possible, giving back as needed (greedy)
+ *  4th Capturing Group ( )
+ *
+ * See https://regex101.com/r/HRS9O2/4
+ */
+_defineProperty(AsciiEmojiMatcher, "REGEX", new RegExp(`((?:^|[\\s${leafNodeReplacementCharacter}])(?:\\(*?))(\\(?)([^:\\s${leafNodeReplacementCharacter}\\(]\\S{1,3}|:\\S{1,3}( ))$`));
+class RecordingAsciiEmojiMatcher extends AsciiEmojiMatcher {
+  constructor(emojiProvider, asciiToEmojiMap) {
+    super(asciiToEmojiMap);
+    this.emojiProvider = emojiProvider;
+  }
+  match(matchParts) {
+    const match = super.match(matchParts);
+    if (match && this.emojiProvider.recordSelection) {
+      this.emojiProvider.recordSelection(match.emoji);
+    }
+    return match;
+  }
+}
+class AsciiEmojiTransactionCreator {
+  constructor(state, match, start, end, editorAnalyticsAPI) {
+    this.state = state;
+    this.match = match;
+    this.start = start;
+    this.end = end;
+    this.editorAnalyticsAPI = editorAnalyticsAPI;
+  }
+  create() {
+    var _this$editorAnalytics;
+    const tr = this.state.tr.replaceWith(this.from, this.to, this.createNodes());
+    (_this$editorAnalytics = this.editorAnalyticsAPI) === null || _this$editorAnalytics === void 0 ? void 0 : _this$editorAnalytics.attachAnalyticsEvent({
+      action: ACTION.INSERTED,
+      actionSubject: ACTION_SUBJECT.DOCUMENT,
+      actionSubjectId: ACTION_SUBJECT_ID.EMOJI,
+      attributes: {
+        inputMethod: INPUT_METHOD.ASCII
+      },
+      eventType: EVENT_TYPE.TRACK
+    })(tr);
+    return tr;
+  }
+  get from() {
+    return this.start + this.match.leadingString.length;
+  }
+  get to() {
+    return this.end;
+  }
+  createNodes() {
+    const nodes = [this.createEmojiNode()];
+    if (this.trailingTextNodeRequired()) {
+      nodes.push(this.createTrailingTextNode());
+    }
+    return nodes;
+  }
+  createEmojiNode() {
+    const {
+      emoji: emojiTypeNode
+    } = this.state.schema.nodes;
+    return emojiTypeNode.create(this.getEmojiNodeAttrs());
+  }
+  getEmojiNodeAttrs() {
+    const emoji = this.match.emoji;
+    return {
+      id: emoji.id,
+      shortName: emoji.shortName,
+      text: emoji.fallback || emoji.shortName
+    };
+  }
+  trailingTextNodeRequired() {
+    return this.match.trailingString.length > 0;
+  }
+  createTrailingTextNode() {
+    return this.state.schema.text(this.match.trailingString);
+  }
+}
+export const stateKey = new PluginKey('asciiEmojiPlugin');
+const plugins = (schema, providerFactory, featureFlags, editorAnalyticsAPI) => {
+  return [inputRulePlugin(schema, providerFactory, featureFlags, editorAnalyticsAPI)].filter(plugin => !!plugin);
+};
+export default plugins;

package/dist/es2019/ui/Emoji/index.js

@@ -0,0 +1,13 @@
+/** @jsx jsx */
+import { css, jsx } from '@emotion/react';
+import { Emoji } from '@atlaskit/editor-common/emoji';
+// eslint-disable-next-line
+const clickSelectWrapperStyle = css`
+  // eslint-disable-next-line @atlaskit/design-system/consistent-css-prop-usage
+  user-select: all;
+`;
+export default function EmojiNode(props) {
+  return jsx("span", {
+    css: clickSelectWrapperStyle
+  }, jsx(Emoji, props));
+}

package/dist/esm/commands/insert-emoji.js

@@ -0,0 +1,39 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { safeInsert } from '@atlaskit/editor-prosemirror/utils';
+export var insertEmoji = function insertEmoji(editorAnalyticsAPI) {
+  return function (emojiId, inputMethod) {
+    return function (_ref) {
+      var tr = _ref.tr;
+      var doc = tr.doc,
+        selection = tr.selection;
+      var emoji = tr.doc.type.schema.nodes.emoji;
+      if (emoji && emojiId) {
+        var node = emoji.createChecked(_objectSpread(_objectSpread({}, emojiId), {}, {
+          text: emojiId.fallback || emojiId.shortName
+        }));
+        var textNode = doc.type.schema.text(' ');
+        var fragment = Fragment.fromArray([node, textNode]);
+        var newTr = safeInsert(fragment)(tr);
+        if (inputMethod) {
+          editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+            action: ACTION.INSERTED,
+            actionSubject: ACTION_SUBJECT.DOCUMENT,
+            actionSubjectId: ACTION_SUBJECT_ID.EMOJI,
+            attributes: {
+              inputMethod: inputMethod
+            },
+            eventType: EVENT_TYPE.TRACK
+          })(newTr);
+        }
+        newTr.setSelection(Selection.near(newTr.doc.resolve(selection.$from.pos + fragment.size)));
+        return newTr;
+      }
+      return null;
+    };
+  };
+};

package/dist/esm/index.js

@@ -1 +1 @@
-export {};
+export { emojiPlugin } from './plugin';

package/dist/esm/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export var messages = defineMessages({
+  emojiNodeLabel: {
+    id: 'fabric.emoji.label',
+    defaultMessage: 'Emoji',
+    description: 'Label to indicate emoji node to Screen reader users'
+  }
+});

package/dist/esm/nodeviews/emoji.js

@@ -0,0 +1,27 @@
+import React from 'react';
+import { useIntl } from 'react-intl-next';
+import { messages } from '../messages';
+import Emoji from '../ui/Emoji';
+var EmojiAssistiveTextComponent = /*#__PURE__*/React.memo(function (_ref) {
+  var emojiShortName = _ref.emojiShortName;
+  var intl = useIntl();
+  return /*#__PURE__*/React.createElement("span", {
+    className: 'assistive'
+  }, "".concat(intl.formatMessage(messages.emojiNodeLabel), " ").concat(emojiShortName));
+});
+export function EmojiNodeView(props) {
+  var _props$node$attrs = props.node.attrs,
+    shortName = _props$node$attrs.shortName,
+    id = _props$node$attrs.id,
+    text = _props$node$attrs.text;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(EmojiAssistiveTextComponent, {
+    emojiShortName: shortName
+  }), /*#__PURE__*/React.createElement("span", {
+    "aria-hidden": "true"
+  }, /*#__PURE__*/React.createElement(Emoji, {
+    providers: props.providerFactory,
+    id: id,
+    shortName: shortName,
+    fallback: text
+  })));
+}