@atlaskit/adf-schema 28.1.6 → 28.1.8

package/src/schema/nodes/types/inline-content.ts

@@ -0,0 +1,56 @@
+import { HardBreakDefinition as HardBreak } from '../hard-break';
+import { MentionDefinition as Mention } from '../mention';
+import { EmojiDefinition as Emoji } from '../emoji';
+import { InlineExtensionDefinition } from '../inline-extension';
+import { DateDefinition as Date } from '../date';
+import { PlaceholderDefinition as Placeholder } from '../placeholder';
+import { InlineCardDefinition as InlineCard } from '../inline-card';
+import { StatusDefinition as Status } from '../status';
+import { TextDefinition as Text } from '../text';
+import { MarksObject } from './mark';
+import {
+  AnnotationMarkDefinition as Annotation,
+  CodeDefinition as Code,
+  EmDefinition as Em,
+  LinkDefinition as Link,
+  StrikeDefinition as Strike,
+  StrongDefinition as Strong,
+  SubSupDefinition as SubSup,
+  TextColorDefinition as TextColor,
+  UnderlineDefinition as Underline,
+} from '../../marks';
+import { MediaInlineDefinition } from '../media-inline';
+
+/**
+ * @name formatted_text_inline_node
+ */
+export type InlineFormattedText = Text &
+  MarksObject<
+    Link | Em | Strong | Strike | SubSup | Underline | TextColor | Annotation
+  >;
+/**
+ * @name link_text_inline_node
+ */
+export type InlineLinkText = Text & MarksObject<Link>;
+/**
+ * @name code_inline_node
+ */
+export type InlineCode = Text & MarksObject<Code | Link | Annotation>;
+
+/**
+ * @name atomic_inline_node
+ */
+export type InlineAtomic =
+  | HardBreak
+  | Mention
+  | Emoji
+  | InlineExtensionDefinition
+  | Date
+  | Placeholder
+  | InlineCard
+  | Status
+  | MediaInlineDefinition;
+/**
+ * @name inline_node
+ */
+export type Inline = InlineFormattedText | InlineCode | InlineAtomic;

package/src/schema/nodes/types/list.ts

@@ -0,0 +1,54 @@
+import { ParagraphDefinition as Paragraph } from '../paragraph';
+import { MediaSingleDefinition as MediaSingle } from '../media-single';
+import { CodeBlockDefinition as CodeBlock } from '../code-block';
+
+export interface ListItemArray
+  extends Array<
+    | Paragraph
+    | OrderedListDefinition
+    | BulletListDefinition
+    | MediaSingle
+    | CodeBlock
+  > {
+  0: Paragraph | MediaSingle | CodeBlock;
+}
+
+/**
+ * @name listItem_node
+ */
+export interface ListItemDefinition {
+  type: 'listItem';
+  /**
+   * @minItems 1
+   * @allowUnsupportedBlock true
+   */
+  content: ListItemArray;
+}
+
+/**
+ * @name bulletList_node
+ */
+export interface BulletListDefinition {
+  type: 'bulletList';
+  /**
+   * @minItems 1
+   */
+  content: Array<ListItemDefinition>;
+}
+
+/**
+ * @name orderedList_node
+ */
+export interface OrderedListDefinition {
+  type: 'orderedList';
+  /**
+   * @minItems 1
+   */
+  content: Array<ListItemDefinition>;
+  attrs?: {
+    /**
+     * @minimum 0
+     */
+    order?: number;
+  };
+}

package/src/schema/nodes/types/mark.ts

@@ -0,0 +1,16 @@
+/**
+ * @additionalProperties true
+ */
+export interface MarksObject<T> {
+  marks?: Array<T>;
+}
+
+/**
+ * @additionalProperties true
+ */
+export interface NoMark {
+  /**
+   * @maxItems 0
+   */
+  marks?: Array<any>;
+}

package/src/schema/nodes/types/non-nestable-block-content.ts

@@ -0,0 +1,39 @@
+import { PanelDefinition as Panel } from '../panel';
+import { ParagraphDefinition as Paragraph } from '../paragraph';
+import { BlockQuoteDefinition as Blockquote } from '../blockquote';
+import { OrderedListDefinition as OrderedList } from '../types/list';
+import { BulletListDefinition as BulletList } from '../types/list';
+import { RuleDefinition as Rule } from '../rule';
+import { HeadingDefinition as Heading } from '../heading';
+import { CodeBlockDefinition as CodeBlock } from '../code-block';
+import { MediaGroupDefinition as MediaGroup } from '../media-group';
+import { MediaSingleDefinition as MediaSingle } from '../media-single';
+import { DecisionListDefinition as DecisionList } from '../decision-list';
+import { TaskListDefinition as TaskList } from '../task-list';
+import { TableDefinition as Table } from '../tableNodes';
+import { ExtensionDefinition as Extension } from '../extension';
+import { BlockCardDefinition as BlockCard } from '../block-card';
+import { EmbedCardDefinition as EmbedCard } from '../embed-card';
+
+// We don't want paragraphs/headings with block marks inside bodied extensions or expands.
+// We also don't want to allow nesting of expands or bodied extensions.
+/**
+ * @name non_nestable_block_content
+ */
+export type NonNestableBlockContent =
+  | Panel
+  | Paragraph
+  | Blockquote
+  | OrderedList
+  | BulletList
+  | Rule
+  | Heading
+  | CodeBlock
+  | MediaGroup
+  | MediaSingle
+  | DecisionList
+  | TaskList
+  | Table
+  | Extension
+  | BlockCard
+  | EmbedCard;

package/src/schema/nodes/types/rich-media-common.ts

@@ -0,0 +1,51 @@
+export type Layout =
+  | 'wrap-right'
+  | 'center'
+  | 'wrap-left'
+  | 'wide'
+  | 'full-width'
+  | 'align-end'
+  | 'align-start';
+
+export interface RichMediaAttributes {
+  /**
+   * @minimum 0
+   * @maximum 100
+   */
+  width?: number;
+  layout: Layout;
+}
+
+export interface OptionalRichMediaAttributes {
+  width?: number;
+  layout?: Layout;
+}
+interface DefaultMediaAttributes extends RichMediaAttributes {
+  /**
+   * @stage 0
+   * @description optional widthType attribute for media with percentage layout
+   */
+  widthType?: 'percentage';
+}
+
+/**
+ * @stage 0
+ * @description The widthType attribute is used to support fixed with media single
+ */
+interface FixedLayoutMediaAttributes {
+  /**
+   * @minimum 0
+   */
+  width: number;
+  widthType: 'pixel';
+  layout: Layout;
+}
+
+export enum WidthType {
+  PIXEL = 'pixel',
+  PERCENTAGE = 'percentage',
+}
+
+export type ExtendedMediaAttributes =
+  | DefaultMediaAttributes
+  | FixedLayoutMediaAttributes;

package/src/schema/nodes/unknown-block.ts

@@ -0,0 +1,13 @@
+import { NodeSpec } from '@atlaskit/editor-prosemirror/model';
+
+const name = 'unknownBlock';
+
+export default {
+  group: 'block',
+  content: 'inline+',
+  marks: '_',
+  toDOM() {
+    return ['div', { 'data-node-type': name }, 0];
+  },
+  parseDOM: [{ tag: `div[data-node-type="${name}"]` }],
+} as NodeSpec;

package/src/schema/nodes/unsupported-block.ts

@@ -0,0 +1,28 @@
+import { NodeSpec, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+
+export const unsupportedBlock: NodeSpec = {
+  inline: false,
+  group: 'block',
+  atom: true,
+  selectable: true,
+  attrs: {
+    originalValue: { default: {} },
+  },
+  parseDOM: [
+    {
+      tag: '[data-node-type="unsupportedBlock"]',
+      getAttrs: (dom) => ({
+        originalValue: JSON.parse(
+          (dom as HTMLElement).getAttribute('data-original-value') || '{}',
+        ),
+      }),
+    },
+  ],
+  toDOM(node: PMNode) {
+    const attrs = {
+      'data-node-type': 'unsupportedBlock',
+      'data-original-value': JSON.stringify(node.attrs.originalValue),
+    };
+    return ['div', attrs, 'Unsupported content'];
+  },
+};

package/src/schema/nodes/unsupported-inline.ts

@@ -0,0 +1,27 @@
+import { NodeSpec, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+
+export const unsupportedInline: NodeSpec = {
+  inline: true,
+  group: 'inline',
+  selectable: true,
+  attrs: {
+    originalValue: { default: {} },
+  },
+  parseDOM: [
+    {
+      tag: '[data-node-type="unsupportedInline"]',
+      getAttrs: (dom) => ({
+        originalValue: JSON.parse(
+          (dom as HTMLElement).getAttribute('data-original-value') || '{}',
+        ),
+      }),
+    },
+  ],
+  toDOM(node: PMNode) {
+    const attrs = {
+      'data-node-type': 'unsupportedInline',
+      'data-original-value': JSON.stringify(node.attrs.originalValue),
+    };
+    return ['span', attrs, 'Unsupported content'];
+  },
+};

package/src/schema/unsupported.ts

@@ -0,0 +1,4 @@
+export const unsupportedNodeTypesForMediaCards = new Set<string>([
+  'decisionItem',
+  'taskItem',
+]);

package/src/steps/__tests__/unit/analytics.ts

@@ -0,0 +1,72 @@
+import {
+  AnalyticsPayload,
+  AnalyticsStep,
+  AnalyticsWithChannel,
+} from '../../analytics';
+
+describe('Analytics Step', () => {
+  it('should change analytics payload with undo event when inverted', function () {
+    const event: AnalyticsWithChannel<AnalyticsPayload> = {
+      channel: 'test',
+      payload: {
+        action: 'test-action',
+        actionSubject: 'test-action-subject',
+        eventType: 'test-event-type',
+        attributes: {
+          inputMethod: 'keyboard',
+        },
+      },
+    };
+    let analyticsStep = new AnalyticsStep([event]);
+    expect(analyticsStep.analyticsEvents[0]).toEqual(event);
+
+    analyticsStep = analyticsStep.invert();
+    expect(analyticsStep.analyticsEvents[0]).toEqual({
+      ...event,
+      payload: {
+        ...event.payload,
+        action: 'undid',
+        actionSubjectId: event.payload.action,
+        attributes: {
+          ...(event.payload.attributes ? event.payload.attributes : {}),
+          actionSubjectId: event.payload.actionSubjectId,
+          inputMethod: 'keyboard',
+        },
+        eventType: 'track',
+      },
+    });
+  });
+
+  it('should change analytics payload with redid event when inverted twice', function () {
+    const event: AnalyticsWithChannel<AnalyticsPayload> = {
+      channel: 'test',
+      payload: {
+        action: 'test-action',
+        actionSubject: 'test-action-subject',
+        eventType: 'test-event-type',
+        attributes: {
+          inputMethod: 'keyboard',
+        },
+      },
+    };
+
+    let analyticsStep = new AnalyticsStep([event]);
+    expect(analyticsStep.analyticsEvents[0]).toEqual(event);
+
+    analyticsStep = analyticsStep.invert().invert();
+    expect(analyticsStep.analyticsEvents[0]).toEqual({
+      ...event,
+      payload: {
+        ...event.payload,
+        action: 'redid',
+        actionSubjectId: event.payload.action,
+        attributes: {
+          ...(event.payload.attributes ? event.payload.attributes : {}),
+          actionSubjectId: event.payload.actionSubjectId,
+          inputMethod: 'keyboard',
+        },
+        eventType: 'track',
+      },
+    });
+  });
+});

package/src/steps/__tests__/unit/link-meta-step.ts

@@ -0,0 +1,64 @@
+import { ReplaceStep, StepMap } from '@atlaskit/editor-prosemirror/transform';
+
+import { doc, p } from 'adf-test-helpers/src/doc-builder';
+import { defaultSchema } from 'adf-test-helpers/src/schema';
+
+import { LinkMetaStep } from '../../link-meta-step';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+
+describe('LinkMetaStep', () => {
+  it('should expose a `getMetadata` method which returns the stored metadata', () => {
+    const metadata = {
+      action: 'some-action',
+      sourceEvent: 'some-event',
+    };
+
+    const step = new LinkMetaStep(0, metadata);
+
+    expect(step.getMetadata()).toStrictEqual(metadata);
+  });
+
+  it('should not include `sourceEvent` when inverted', () => {
+    const step = new LinkMetaStep(0, {
+      action: 'some-action',
+      sourceEvent: 'some-event',
+    });
+
+    expect(step.getMetadata()).toEqual({
+      action: 'some-action',
+      sourceEvent: 'some-event',
+    });
+
+    const inverted = step.invert();
+
+    expect(inverted.getMetadata()).toEqual({
+      action: 'some-action',
+    });
+  });
+
+  it.each([0, 5, 10])(
+    'should return stepmap with correct ranges based on the position argument %p and with sizes of 0',
+    (pos) => {
+      expect(new LinkMetaStep(pos, {}).getMap()).toStrictEqual(
+        new StepMap([pos, 0, 0]),
+      );
+    },
+  );
+
+  it('should succesfully make no change to the document', () => {
+    const document = doc(p('Some content'))(defaultSchema);
+    const step = new LinkMetaStep(0, {});
+    const result = step.apply(document);
+
+    expect(result.failed).toBeFalsy();
+    expect(document).toStrictEqual(result.doc);
+  });
+
+  it('should serialize and de-serialize into a no-op replace step to avoid affecting collab editting', () => {
+    const step = new LinkMetaStep(0, {});
+
+    expect(LinkMetaStep.fromJSON(defaultSchema, step.toJSON())).toStrictEqual(
+      new ReplaceStep(0, 0, Slice.empty),
+    );
+  });
+});

package/src/steps/__tests__/unit/override-document-step.ts

@@ -0,0 +1,174 @@
+import { StepMap } from '@atlaskit/editor-prosemirror/transform';
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { createEditorState } from 'adf-test-helpers/src/create-editor-state';
+import { doc, p } from 'adf-test-helpers/src/doc-builder';
+import { defaultSchema } from 'adf-test-helpers/src/schema';
+import { OverrideDocumentStep } from '../../override-document-step';
+
+describe('Override Document Step', () => {
+  const currentDocument = doc(p('Hello World'));
+  const nextDocument: PMNode = doc(
+    p('Hey, I am the next document'),
+    p('How are you doing?'),
+  )(defaultSchema);
+
+  describe('when using the Override Document Step in a transaction', () => {
+    it('should succesfully override a document when the step is applied', () => {
+      const state = createEditorState(currentDocument);
+      const tr = state.tr;
+
+      tr.step(
+        new OverrideDocumentStep({
+          nextDocument,
+        }),
+      );
+
+      expect(tr.doc).toEqual(nextDocument);
+      expect(tr.docs[0]).toEqual(currentDocument(defaultSchema));
+    });
+
+    describe('when the inverted step is applied', () => {
+      it('should bring the old document back', () => {
+        const state = createEditorState(currentDocument);
+        const tr = state.tr;
+
+        const step = new OverrideDocumentStep({
+          nextDocument,
+        });
+        const stepInverted = step.invert(tr.doc);
+
+        tr.step(step);
+        tr.step(stepInverted);
+
+        expect(tr.doc).toEqual(currentDocument(defaultSchema));
+        expect(tr.docs[1]).toEqual(nextDocument);
+        expect(tr.docs[0]).toEqual(currentDocument(defaultSchema));
+      });
+    });
+
+    describe('when mapping the selection position', () => {
+      const smallDocument = doc(
+        p('Hello {<>}{cursor}World{nextCursorPosition}'),
+      );
+      const bigDocument = doc(
+        p('Hey, I am the next document'),
+        p('How are you{<>}{cursor} doing?{nextCursorPosition}'),
+      );
+
+      describe('and when replacing a small document with a big one ', () => {
+        it('should proper map the positions', () => {
+          const state = createEditorState(smallDocument);
+          const nextDocument = bigDocument(defaultSchema);
+
+          expect(state.selection.from).toEqual(
+            smallDocument(defaultSchema).refs.cursor,
+          );
+
+          const tr = state.tr;
+
+          tr.step(
+            new OverrideDocumentStep({
+              nextDocument,
+            }),
+          );
+
+          const nextCursorPosition = nextDocument.refs.nextCursorPosition;
+
+          expect(tr.selection.from).toEqual(nextCursorPosition);
+        });
+      });
+
+      describe('and when replacing a big document with a small one ', () => {
+        it('should proper map the positions', () => {
+          const state = createEditorState(bigDocument);
+          const nextDocument = smallDocument(defaultSchema);
+
+          expect(state.selection.from).toEqual(
+            bigDocument(defaultSchema).refs.cursor,
+          );
+
+          const tr = state.tr;
+
+          tr.step(
+            new OverrideDocumentStep({
+              nextDocument,
+            }),
+          );
+
+          const nextCursorPosition = nextDocument.refs.nextCursorPosition;
+
+          expect(tr.selection.from).toEqual(nextCursorPosition);
+        });
+      });
+    });
+  });
+
+  describe('when using the Override Document Step functions', () => {
+    it('should succesfully return the StepResult of nextDocument', () => {
+      const step = new OverrideDocumentStep({
+        nextDocument,
+      });
+
+      const result = step.apply(currentDocument(defaultSchema));
+
+      expect(result.failed).toBeFalsy();
+      expect(nextDocument).toStrictEqual(result.doc);
+    });
+
+    it('should succesfully get StepMap', () => {
+      const step = new OverrideDocumentStep({
+        nextDocument,
+      });
+
+      const oldSize = currentDocument(defaultSchema).content.size;
+      const nextDocumentSize = nextDocument.content.size;
+
+      const result = step.apply(currentDocument(defaultSchema));
+
+      expect(result.failed).toBeFalsy();
+      expect(step.getMap()).toStrictEqual(
+        new StepMap([0, oldSize, nextDocumentSize]),
+      );
+    });
+
+    it('should return new mapped step', () => {
+      const step = new OverrideDocumentStep({
+        nextDocument,
+      });
+
+      const mappedStep = step.map();
+
+      expect(mappedStep).toEqual(step);
+    });
+
+    it('should return new inverted step', () => {
+      const step = new OverrideDocumentStep({
+        nextDocument,
+      });
+
+      const invertedStep = step.invert(currentDocument(defaultSchema));
+
+      expect(invertedStep.inverted).toEqual(true);
+    });
+
+    it('should serialize and de-serialize OverrideDocumentStep', () => {
+      const step = new OverrideDocumentStep({
+        nextDocument,
+      });
+
+      const deserializedStep = OverrideDocumentStep.fromJSON(
+        defaultSchema,
+        step.toJSON(),
+      );
+
+      const stepAppliedResult = step.apply(currentDocument(defaultSchema));
+      const deserializedStepAppliedResult = deserializedStep.apply(
+        currentDocument(defaultSchema),
+      );
+
+      expect(stepAppliedResult.doc).toMatchObject(
+        deserializedStepAppliedResult.doc,
+      );
+    });
+  });
+});

package/src/steps/__tests__/unit/set-attrs.ts

@@ -0,0 +1,71 @@
+import { Transform } from '@atlaskit/editor-prosemirror/transform';
+import { doc, panel, p } from 'adf-test-helpers/src/doc-builder';
+import { defaultSchema } from 'adf-test-helpers/src/schema';
+import { SetAttrsStep } from '../../set-attrs';
+
+describe('SetAttrs Step', () => {
+  const originalDocument = doc(
+    // prettier-ignore
+    panel({ type: 'info' })(
+      p('lol'),
+    ),
+  )(defaultSchema);
+
+  describe('when the step is applied in document', () => {
+    it('should apply the attributes at the node', () => {
+      const step = new SetAttrsStep(0, { type: 'error' });
+      const result = step.apply(originalDocument);
+      expect(result.doc.toJSON()).toEqual(
+        doc(panel({ type: 'error' })(p('lol')))(defaultSchema).toJSON(),
+      );
+    });
+
+    it('should generate a revertable step adding the previous attribute', () => {
+      const step = new SetAttrsStep(0, { type: 'error' });
+
+      const revertStep = step.invert(originalDocument);
+      const result = revertStep.apply(originalDocument);
+
+      expect(result.doc.toJSON()).toEqual(
+        doc(panel({ type: 'info' })(p('lol')))(defaultSchema).toJSON(),
+      );
+    });
+  });
+
+  describe('when the node position changes', () => {
+    it('should map its internal positions', () => {
+      const transformer = new Transform(originalDocument);
+
+      const step = new SetAttrsStep(0, { type: 'error' });
+
+      transformer.insert(0, defaultSchema.text('X'));
+
+      step.map(transformer.mapping);
+
+      const result = step.apply(transformer.doc);
+
+      expect(result.doc.toJSON()).toEqual(
+        // prettier-ignore
+        doc(
+
+          p('X'),
+          panel({ type: 'error' })(
+            p('lol'),
+          ),
+        )(defaultSchema).toJSON(),
+      );
+    });
+  });
+
+  describe('when the target is a text node', () => {
+    it('should return an invalid step', () => {
+      const invalidDocument = doc(p('lol'))(defaultSchema);
+
+      const step = new SetAttrsStep(1, { type: 'error' });
+
+      const result = step.apply(invalidDocument);
+
+      expect(result.failed).toBeTruthy();
+    });
+  });
+});