@atlaskit/editor-core/dist/esm/create-editor/create-editor.js

A package contains Atlassian editor core functionality

import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import { ErrorReporter } from '@atlaskit/editor-common/error-reporter';
import { sortByOrder } from '@atlaskit/editor-common/legacy-rank-plugins';
import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
import { createEditorNativeAnchorSupportPlugin } from './editorNativeAnchorSupportPlugin';
import { createEditorStateNotificationPlugin } from './editorStateNotificationPlugin';
export function sortByRank(a, b) {
  return a.rank - b.rank;
}
export function fixExcludes(marks) {
  var markKeys = Object.keys(marks);
  var markGroups = new Set(markKeys.map(function (mark) {
    return marks[mark].group;
  }));
  markKeys.forEach(function (markKey) {
    var mark = marks[markKey];
    if (mark.excludes) {
      // eslint-disable-next-line @atlassian/perf-linting/no-expensive-split-replace -- Ignored via go/ees017 (to be fixed)
      mark.excludes = mark.excludes.split(' ').filter(function (group) {
        return markGroups.has(group);
      }).join(' ');
    }
  });
  return marks;
}
export function processPluginsList(plugins) {
  /**
   * First pass to collect pluginsOptions
   */
  var pluginsOptions = plugins.reduce(function (acc, plugin) {
    if (plugin.pluginsOptions) {
      Object.keys(plugin.pluginsOptions).forEach(function (pluginName) {
        if (!acc[pluginName]) {
          acc[pluginName] = [];
        }
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
        acc[pluginName].push(plugin.pluginsOptions[pluginName]);
      });
    }
    return acc;
  }, {});

  /**
   * Process plugins
   */
  return plugins.reduce(function (acc, plugin) {
    if (plugin.pmPlugins) {
      var _acc$pmPlugins;
      (_acc$pmPlugins = acc.pmPlugins).push.apply(_acc$pmPlugins, _toConsumableArray(plugin.pmPlugins(plugin.name ? pluginsOptions[plugin.name] : undefined)));
    }
    if (plugin.nodes) {
      var _acc$nodes;
      (_acc$nodes = acc.nodes).push.apply(_acc$nodes, _toConsumableArray(plugin.nodes()));
    }
    if (plugin.marks) {
      var _acc$marks;
      (_acc$marks = acc.marks).push.apply(_acc$marks, _toConsumableArray(plugin.marks()));
    }
    if (plugin.contentComponent) {
      acc.contentComponents.push(plugin.contentComponent);
    }
    if (plugin.usePluginHook) {
      // Wrap with .bind(null) so we can annotate the function with the
      // plugin name without mutating the plugin's original hook reference.
      // MountPluginHooks reads `pluginName` to derive a stable React key.
      var named = plugin.usePluginHook.bind(null);
      named.pluginName = plugin.name;
      acc.pluginHooks.push(named);
    }
    if (plugin.primaryToolbarComponent) {
      acc.primaryToolbarComponents.push(plugin.primaryToolbarComponent);
    }
    if (plugin.secondaryToolbarComponent) {
      acc.secondaryToolbarComponents.push(plugin.secondaryToolbarComponent);
    }
    if (plugin.onEditorViewStateUpdated) {
      acc.onEditorViewStateUpdatedCallbacks.push({
        pluginName: plugin.name,
        callback: plugin.onEditorViewStateUpdated
      });
    }
    return acc;
  }, {
    nodes: [],
    marks: [],
    pmPlugins: [],
    contentComponents: [],
    pluginHooks: [],
    primaryToolbarComponents: [],
    secondaryToolbarComponents: [],
    onEditorViewStateUpdatedCallbacks: []
  });
}
export function createPMPlugins(config) {
  var editorConfig = config.editorConfig;
  var pmPlugins = editorConfig.pmPlugins.sort(sortByOrder('plugins')).map(function (_ref) {
    var plugin = _ref.plugin;
    return plugin({
      schema: config.schema,
      dispatch: config.dispatch,
      eventDispatcher: config.eventDispatcher,
      providerFactory: config.providerFactory,
      errorReporter: config.errorReporter,
      portalProviderAPI: config.portalProviderAPI,
      nodeViewPortalProviderAPI: config.nodeViewPortalProviderAPI,
      dispatchAnalyticsEvent: config.dispatchAnalyticsEvent,
      featureFlags: config.featureFlags || {},
      getIntl: config.getIntl
    });
  }).filter(function (plugin) {
    return typeof plugin !== 'undefined';
  });
  if (expValEquals('platform_editor_native_anchor_with_dnd', 'isEnabled', true)) {
    pmPlugins.push(createEditorNativeAnchorSupportPlugin(config.schema));
  }
  if (config.onEditorStateUpdated !== undefined) {
    return [createEditorStateNotificationPlugin(config.onEditorStateUpdated, config.editorConfig.onEditorViewStateUpdatedCallbacks)].concat(_toConsumableArray(pmPlugins));
  }
  return pmPlugins;
}
export function createErrorReporter(errorReporterHandler) {
  var errorReporter = new ErrorReporter();
  if (errorReporterHandler) {
    errorReporter.handler = errorReporterHandler;
  }
  return errorReporter;
}