How to use the @remirror/core.ExtensionManager.create function in @remirror/core

test('ReactSerializer.fromExtensionManager', () => {
  expect(serializer).toBeInstanceOf(ReactSerializer);
  expect(serializer.nodes.paragraph).toBeFunction();
  expect(serializer.marks.bold).toBeFunction();

  // fills in for a missing text
  const altExtensions = [
    { extension: new DocExtension(), priority: 2 },
    { extension: new ParagraphExtension(), priority: 2 },
    { extension: new TextExtension(), priority: 2 },
    { extension: new BoldExtension(), priority: 2 },
    { extension: new CodeBlockExtension(), priority: 2 },
  ];
  const altManager = ExtensionManager.create(altExtensions);
  expect(ReactSerializer.fromExtensionManager(altManager).nodes.text).toBeFunction();
});

historyActions.redo;
// @dts-jest:pass:snap
historyActions.undo;
// @dts-jest:fail:snap
historyActions.undo({});

type PositionTrackerExtensionHelpers = HelpersFromExtensions;
const trackerHelpers: PositionTrackerExtensionHelpers = Object.create(null);

// @dts-jest:pass:snap
trackerHelpers.addPositionTracker({ id: 'yo' });
// @dts-jest:pass:snap
trackerHelpers.clearPositionTrackers();

// @dts-jest:pass:snap
ExtensionManager.create([
  new HistoryExtension(),
  new ParagraphExtension(),
  new BoldExtension(),
  new CodeBlockExtension(),
  new PositionTrackerExtension(),
  { priority: 1, extension: new TextExtension() },
  { priority: 0, extension: new DocExtension() },
]);

const manager1 = ExtensionManager.create([
  new HistoryExtension(),
  new ParagraphExtension(),
  new BoldExtension(),
  new CodeBlockExtension(),
  new PositionTrackerExtension(),
  { priority: 1, extension: new TextExtension() },

return [...acc, ...Children.toArray(child.props.children)];
      } else {
        return [...acc, child];
      }
    }, []);

    resolvedChildren.forEach(child => {
      if (!isRemirrorExtension(child)) {
        return;
      }

      const { Constructor, children: _, priority = 2, ...options } = child.props;
      extensions.push({ extension: new Constructor(options), priority });
    });

    const newManager = ExtensionManager.create(
      this.withBaseExtensions([
        ...extensions,
        ...(this.props.extensions ?? []).map(convertToPrioritizedExtension),
      ]),
    );

    // Only update the manager when it has changed to prevent unnecessary re-rendering
    if (newManager.isEqual(this.cachedManager)) {
      return this.cachedManager;
    }

    this.cachedManager = newManager;
    return newManager;
  }

trackerHelpers.addPositionTracker({ id: 'yo' });
// @dts-jest:pass:snap
trackerHelpers.clearPositionTrackers();

// @dts-jest:pass:snap
ExtensionManager.create([
  new HistoryExtension(),
  new ParagraphExtension(),
  new BoldExtension(),
  new CodeBlockExtension(),
  new PositionTrackerExtension(),
  { priority: 1, extension: new TextExtension() },
  { priority: 0, extension: new DocExtension() },
]);

const manager1 = ExtensionManager.create([
  new HistoryExtension(),
  new ParagraphExtension(),
  new BoldExtension(),
  new CodeBlockExtension(),
  new PositionTrackerExtension(),
  { priority: 1, extension: new TextExtension() },
  { priority: 0, extension: new DocExtension() },
]);

// @dts-jest:fail:snap
manager1.nodes.awesome;
// @dts-jest:pass:snap
manager1.nodes.paragraph;

// @dts-jest:pass:snap
manager1.data.actions;

import { ExtensionManager, fromHTML, toHTML } from '@remirror/core';
import { extensions, helpers } from '@test-fixtures/schema-helpers';

import { Mention } from '../';

const manager = ExtensionManager.create({
  ...helpers,
  extensions: [...extensions, new Mention({ name: 'mentionAt' })],
});
const schema = manager.createSchema();

const { paragraph, mentionAt, doc } = schema.nodes;

test('can create the required dom node', () => {
  const node = mentionAt.create({ id: 'test', label: '@label' });
  expect(toHTML({ node, schema })).toBe('<a data-mention-at-id="test" class="mention mention-at">@label</a>');
});

test('can parse the dom structure and find itself', () =&gt; {
  const node = fromHTML({
    schema,
    content: '<a data-mention-at-id="awesome" class="mention mention-at">@awesome</a>',

export const ExtensionMap = {
  nodes: {
    blockquote: new BlockquoteExtension(),
    heading: new HeadingExtension(),
  },
  marks: {
    bold: new BoldExtension(),
    italic: new ItalicExtension(),
    underline: new UnderlineExtension(),
  },
};

/**
 * @deprecated Causes issues when multiple tests use this. Prefer {@link createTestManager}
 */
export const manager = ExtensionManager.create(extensions).init(helpers);

export const createBaseTestManager = (
  extra: GFlexibleList = [] as any,
) => ExtensionManager.create([...baseExtensions, ...extra]);

export const createTestManager = (
  extra: GFlexibleList = [] as any,
) => ExtensionManager.create([...extensions, ...extra]);

export const { schema, plugins } = manager.data;
export const testDocument = minDocument;
export const initialJson = {
  type: 'doc',
  content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Better docs to come soon...' }] }],
};

expect(() =>
    render(
      
        {() =&gt; <div>}
      ,
    ),
  ).not.toThrowError();</div>

others = Cast([]),
  }: Partial<
    CreateTestEditorExtensions
  > = Object.create(null),
  props: Partial, 'manager'>> = Object.create(null),
): GReturn => {
  const innerNodeExtensions = nodeExtensions.filter(({ name }) => !plainNodes.some(ext => ext.name === name));
  const extensions = [
    ...innerNodeExtensions,
    ...others,
    ...plainMarks,
    ...plainNodes,
    ...attrMarks,
    ...attrNodes,
  ].map(extension => ({ extension, priority: 2 }));
  const manager = ExtensionManager.create(extensions);
  let returnedParams!: InjectedRemirrorProps;

  const utils = render(
    
      {params => {
        returnedParams = params as any;

        if (props.children) {
          return props.children(params as any);
        }

        return <div>;
      }}
    ,
  );
</div>

export const renderSSREditor = (
  extensions: GExtension[] = [],
  props: Partial, 'manager'>> = Object.create(null),
): string => {
  const manager = ExtensionManager.create([...nodeExtensions, ...extensions]);

  return renderToString(
    
      {params => {
        if (props.children) {
          return props.children(params);
        }
        return <div>;
      }}
    ,
  );
};
</div>

() =>
      ExtensionManager.create([
        { priority: 1, extension: new DocExtension({ content: 'block' }) },
        {
          priority: 1,
          extension: new CodeBlockExtension({ defaultLanguage: 'markdown', toggleType: 'codeBlock' }),
        },
        { priority: 1, extension: new TextExtension() },
        { extension: new CompositionExtension(), priority: 3 },
        { extension: new HistoryExtension(), priority: 3 },
        { extension: new GapCursorExtension(), priority: 10 },
        { extension: new BaseKeymapExtension(), priority: 10 },
      ]),
    [],