@atlaskit/adf-schema 28.1.6 → 28.1.8

package/src/steps/analytics.ts

@@ -0,0 +1,189 @@
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import {
+  Step,
+  StepResult,
+  StepMap,
+  ReplaceStep,
+  Mappable,
+} from '@atlaskit/editor-prosemirror/transform';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+
+export const analyticsStepType = 'atlaskit-analytics';
+export const analyticsInvertStepType = 'atlaskit-analytics-invert';
+
+export interface AnalyticsPayload {
+  action: string;
+  actionSubject: string;
+  actionSubjectId?: string | null;
+  attributes?: Record<string, any>;
+  eventType: string;
+}
+
+export interface AnalyticsWithChannel<P extends AnalyticsPayload> {
+  payload: P;
+  channel: string;
+}
+
+enum HISTORY_ACTIONS {
+  UNDID = 'undid',
+  REDID = 'redid',
+}
+interface UndoAnalyticsEventPayload {
+  action: HISTORY_ACTIONS.UNDID;
+  actionSubject: string;
+  actionSubjectId?: string;
+  attributes?: Record<string, any>;
+  eventType: string;
+}
+interface RedoAnalyticsEventPayload {
+  action: HISTORY_ACTIONS.REDID;
+  actionSubject: string;
+  actionSubjectId?: string;
+  attributes?: Record<string, any>;
+  eventType: string;
+}
+
+type AnalyticsInvertPayload =
+  | UndoAnalyticsEventPayload
+  | RedoAnalyticsEventPayload;
+type AnalyticsInvert = AnalyticsWithChannel<AnalyticsInvertPayload>;
+
+/** Creates undo event from a normal analytics event */
+function createUndoEvent<P extends AnalyticsPayload>(
+  analyticsEvent: AnalyticsWithChannel<P>,
+): AnalyticsWithChannel<UndoAnalyticsEventPayload> {
+  return {
+    ...analyticsEvent,
+    payload: {
+      action: HISTORY_ACTIONS.UNDID,
+      actionSubject: analyticsEvent.payload.actionSubject,
+      actionSubjectId: analyticsEvent.payload.action,
+      attributes: {
+        ...analyticsEvent.payload.attributes,
+        actionSubjectId: analyticsEvent.payload.actionSubjectId,
+        inputMethod: analyticsEvent.payload.attributes?.inputMethod || '',
+      },
+      eventType: 'track',
+    },
+  };
+}
+
+/** Toggles event action between undo & redo */
+const toggleEventAction = (
+  analyticsEvent: AnalyticsWithChannel<
+    UndoAnalyticsEventPayload | RedoAnalyticsEventPayload
+  >,
+): AnalyticsInvert => ({
+  ...analyticsEvent,
+  payload: {
+    ...analyticsEvent.payload,
+    action:
+      analyticsEvent.payload.action === HISTORY_ACTIONS.UNDID
+        ? HISTORY_ACTIONS.REDID
+        : HISTORY_ACTIONS.UNDID,
+  },
+});
+
+function isHistoryAnalyticsEvent(
+  event: AnalyticsWithChannel<AnalyticsPayload>,
+): event is AnalyticsWithChannel<
+  UndoAnalyticsEventPayload | RedoAnalyticsEventPayload
+> {
+  return (
+    event.payload.action === HISTORY_ACTIONS.UNDID ||
+    event.payload.action === HISTORY_ACTIONS.REDID
+  );
+}
+
+export type AnalyticsInvertStep = AnalyticsStep<AnalyticsInvertPayload>;
+
+/**
+ * Custom Prosemirror Step to fire our GAS V3 analytics events
+ * Using a Step means that it will work with prosemirror-history and we get
+ * undo/redo events for free
+ */
+export class AnalyticsStep<P extends AnalyticsPayload> extends Step {
+  public analyticsEvents: AnalyticsWithChannel<P>[] = [];
+  pos?: number;
+  private actionsToIgnore: string[] = [];
+
+  constructor(
+    analyticsEvents: AnalyticsWithChannel<P>[],
+    actionsToIgnore: string[] = [],
+    pos?: number, // Used to create the map, prevent splitting history.
+  ) {
+    super();
+    this.analyticsEvents = analyticsEvents;
+    this.actionsToIgnore = actionsToIgnore;
+    this.pos = pos;
+  }
+
+  /**
+   * Generate new undo/redo analytics event when step is inverted
+   */
+  invert() {
+    const analyticsEvents: AnalyticsInvert[] = this.analyticsEvents
+      .filter(
+        (analyticsEvent) =>
+          this.actionsToIgnore.indexOf(analyticsEvent.payload.action) === -1,
+      )
+      .map((analyticsEvent) => {
+        if (isHistoryAnalyticsEvent(analyticsEvent)) {
+          return toggleEventAction(analyticsEvent);
+        } else {
+          return createUndoEvent(analyticsEvent);
+        }
+      });
+
+    return new AnalyticsStep(analyticsEvents, []);
+  }
+
+  apply(doc: PMNode) {
+    return StepResult.ok(doc);
+  }
+
+  map(mapping: Mappable) {
+    let newPos = this.pos;
+    if (typeof newPos === 'number') {
+      newPos = mapping.map(newPos);
+    }
+    // Return the same events, this step will never be removed
+    return new AnalyticsStep(
+      this.analyticsEvents,
+      this.actionsToIgnore,
+      newPos,
+    );
+  }
+
+  getMap() {
+    if (typeof this.pos === 'number') {
+      return new StepMap([this.pos, 0, 0]);
+    }
+    return new StepMap([]);
+  }
+
+  merge(other: Step): AnalyticsStep<P> | null {
+    if (other instanceof AnalyticsStep) {
+      const otherAnalyticsEvents = (other as AnalyticsStep<P>)
+        .analyticsEvents as AnalyticsWithChannel<P>[];
+      return new AnalyticsStep([
+        ...otherAnalyticsEvents,
+        ...this.analyticsEvents,
+      ]);
+    }
+    return null;
+  }
+
+  toJSON() {
+    return {
+      stepType: analyticsStepType,
+    };
+  }
+
+  static fromJSON() {
+    return new ReplaceStep(0, 0, Slice.empty);
+  }
+}
+
+/** Register this step with Prosemirror */
+Step.jsonID(analyticsStepType, AnalyticsStep);

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

@@ -0,0 +1,105 @@
+import {
+  Node as PMNode,
+  Schema,
+  Slice,
+} from '@atlaskit/editor-prosemirror/model';
+import {
+  ReplaceStep,
+  Step,
+  StepMap,
+  StepResult,
+  Mappable,
+} from '@atlaskit/editor-prosemirror/transform';
+
+export const stepType = 'editor-linking-meta';
+export const invertStepType = 'editor-linking-meta-invert';
+
+export type LinkStepMetadata = {
+  /**
+   * Editor action performed
+   */
+  action?: string;
+  /**
+   * Editor input method that triggered the transaction
+   */
+  inputMethod?: string;
+  /**
+   * The applicable card action for this step
+   * if is RESOLVE then the undo/redo steps should be considered "updates" of a link
+   */
+  cardAction?: 'RESOLVE';
+  /**
+   * Source UI that tiggered this step, if available/applicable
+   */
+  sourceEvent?: unknown;
+};
+
+/**
+ * Custom Prosemirror Step to attach metadata about user interactions with links
+ * Using a Step means that it will work with prosemirror-history and we get utilise when
+ * firing events on history change
+ */
+export class LinkMetaStep extends Step {
+  constructor(
+    private pos: number | null,
+    private metadata: LinkStepMetadata,
+    private isInverted: boolean = false,
+  ) {
+    super();
+  }
+
+  public getMetadata() {
+    return this.metadata;
+  }
+
+  /**
+   * Generate new undo/redo analytics event when step is inverted
+   */
+  invert() {
+    /**
+     * Omit sourceEvent in history
+     */
+    const { sourceEvent, ...metadata } = this.metadata;
+    return new LinkMetaStep(this.pos, metadata, true);
+  }
+
+  // Should make no modifications to the doc
+  apply(doc: PMNode) {
+    return StepResult.ok(doc);
+  }
+
+  map(mapping: Mappable) {
+    let newPos = this.pos;
+    if (typeof newPos === 'number') {
+      newPos = mapping.map(newPos);
+    }
+    // Return the same events, this step will never be removed
+    return new LinkMetaStep(newPos, this.metadata, this.isInverted);
+  }
+  getMap() {
+    return new StepMap([this.pos || 0, 0, 0]);
+  }
+
+  // Return null to avoid merging events
+  merge(): null {
+    return null;
+  }
+
+  toJSON() {
+    // When serialized we should create a noop Replace step
+    return {
+      stepType: 'replace',
+      from: 0,
+      to: 0,
+    };
+  }
+
+  static fromJSON<S extends Schema = any>(_: S, __: { [key: string]: any }) {
+    // This is a "local custom step" once serialized
+    // we need to transform it in a no-operation action
+    return new ReplaceStep(0, 0, Slice.empty);
+  }
+}
+
+/** Register this step with Prosemirror */
+Step.jsonID(stepType, LinkMetaStep);

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

@@ -0,0 +1,97 @@
+import {
+  Step,
+  StepResult,
+  StepMap,
+} from '@atlaskit/editor-prosemirror/transform';
+import { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+
+type Options = {
+  nextDocument: PMNode;
+  inverted?: boolean;
+};
+
+export const overrideDocumentStepType = 'override-document';
+
+export class OverrideDocumentStep extends Step {
+  public inverted = false;
+  private nextDocument: PMNode;
+  private oldDocumentSize: number = 0;
+
+  constructor(opts: Options) {
+    super();
+
+    const { inverted, nextDocument } = opts;
+
+    if (nextDocument.type.name !== 'doc') {
+      throw new Error(
+        'nextDocument should be the entire prosemirror doc node and not only its content.',
+      );
+    }
+
+    this.nextDocument = nextDocument;
+    this.inverted = Boolean(inverted);
+  }
+
+  apply(doc: PMNode): StepResult {
+    this.oldDocumentSize = doc.content.size;
+
+    return StepResult.ok(this.nextDocument);
+  }
+
+  map(): OverrideDocumentStep {
+    return new OverrideDocumentStep({
+      nextDocument: this.nextDocument,
+      inverted: this.inverted,
+    });
+  }
+
+  getMap(): StepMap {
+    if (!this.nextDocument || !this.oldDocumentSize) {
+      return new StepMap([0, 0, 0]);
+    }
+
+    const oldSize = this.oldDocumentSize;
+    const nextDocumentSize = this.nextDocument.content.size;
+
+    return new StepMap([0, oldSize, nextDocumentSize]);
+  }
+
+  invert(doc: PMNode): OverrideDocumentStep {
+    return new OverrideDocumentStep({
+      nextDocument: doc,
+      inverted: true,
+    });
+  }
+
+  toJSON(): OverrideDocumentStepJSON {
+    return {
+      stepType: overrideDocumentStepType,
+      inverted: this.inverted,
+      nextDocument: this.nextDocument.toJSON(),
+    };
+  }
+
+  static fromJSON(
+    schema: Schema,
+    json: OverrideDocumentStepJSON,
+  ): OverrideDocumentStep {
+    if (!json || json.stepType !== overrideDocumentStepType) {
+      throw new RangeError(
+        'Invalid overrideDocument step OverrideDocumentStep.fromJSON',
+      );
+    }
+
+    return new OverrideDocumentStep({
+      inverted: json.inverted,
+      nextDocument: schema.nodeFromJSON(json.nextDocument),
+    });
+  }
+}
+
+export type OverrideDocumentStepJSON = {
+  stepType: 'override-document';
+  inverted: boolean;
+  nextDocument: { [key: string]: any };
+};
+
+Step.jsonID(overrideDocumentStepType, OverrideDocumentStep);

package/src/steps/set-attrs.tsx

@@ -0,0 +1,74 @@
+import {
+  Mappable,
+  Step,
+  StepResult,
+} from '@atlaskit/editor-prosemirror/transform';
+import {
+  Node as ProseMirrorNode,
+  Slice,
+  Fragment,
+  Schema,
+} from '@atlaskit/editor-prosemirror/model';
+
+/**
+ * For more context on what this is about:
+ * @see https://discuss.prosemirror.net/t/preventing-image-placeholder-replacement-from-being-undone/1394
+ */
+export class SetAttrsStep extends Step {
+  pos: number;
+  attrs: object;
+
+  constructor(pos: number, attrs: object) {
+    super();
+    this.pos = pos;
+    this.attrs = attrs;
+  }
+
+  apply(doc: ProseMirrorNode) {
+    let target = doc.nodeAt(this.pos);
+    if (!target) {
+      return StepResult.fail('No node at given position');
+    }
+
+    if (target.isText) {
+      return StepResult.fail(
+        'Target is a text node. Attributes are not allowed.',
+      );
+    }
+
+    const attrs = {
+      ...(target.attrs || {}),
+      ...(this.attrs || {}),
+    };
+
+    let newNode = target.type.create(attrs, Fragment.empty, target.marks);
+    let slice = new Slice(Fragment.from(newNode), 0, target.isLeaf ? 0 : 1);
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, slice);
+  }
+
+  invert(doc: ProseMirrorNode) {
+    let target = doc.nodeAt(this.pos);
+    return new SetAttrsStep(this.pos, target ? target.attrs : {});
+  }
+
+  map(mapping: Mappable): SetAttrsStep | null {
+    let result = mapping.mapResult(this.pos, 1);
+    return result.deleted ? null : new SetAttrsStep(result.pos, this.attrs);
+  }
+
+  toJSON() {
+    return { stepType: 'setAttrs', pos: this.pos, attrs: this.attrs };
+  }
+
+  static fromJSON(_schema: Schema, json: { pos?: number; attrs: object }) {
+    if (
+      typeof json.pos !== 'number' ||
+      (json.attrs !== null && typeof json.attrs !== 'object')
+    ) {
+      throw new RangeError('Invalid input for SetAttrsStep.fromJSON');
+    }
+    return new SetAttrsStep(json.pos, json.attrs);
+  }
+}
+
+Step.jsonID('setAttrs', SetAttrsStep);

package/src/steps/table/__tests__/__fixtures__/basic/add-column-at-0.json

@@ -0,0 +1,15 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 0,
+  "isDelete": false,
+  "cells": [
+    {
+      "from": 2,
+      "to":6
+    },
+    {
+      "from": 16,
+      "to": 20
+    }
+  ]
+}

package/src/steps/table/__tests__/__fixtures__/basic/add-column-at-1.json

@@ -0,0 +1,15 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 0,
+  "isDelete": false,
+  "cells": [
+    {
+      "from": 6,
+      "to":10
+    },
+    {
+      "from": 20,
+      "to": 24
+    }
+  ]
+}

package/src/steps/table/__tests__/__fixtures__/basic/add-column-at-2.json

@@ -0,0 +1,15 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 0,
+  "isDelete": false,
+  "cells": [
+    {
+      "from": 10,
+      "to":14
+    },
+    {
+      "from": 24,
+      "to": 28
+    }
+  ]
+}

package/src/steps/table/__tests__/__fixtures__/basic/add-column-at-3.json

@@ -0,0 +1,15 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 0,
+  "isDelete": false,
+  "cells": [
+    {
+      "from": 14,
+      "to":14
+    },
+    {
+      "from": 28,
+      "to": 28
+    }
+  ]
+}

package/src/steps/table/__tests__/__fixtures__/basic/remove-column-at-0.json

@@ -0,0 +1,9 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 0,
+  "cells": [
+    { "from": 2, "to": 6 },
+    { "from": 16, "to": 20 }
+  ],
+  "isDelete": true
+}

package/src/steps/table/__tests__/__fixtures__/basic/remove-column-at-1.json

@@ -0,0 +1,9 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 0,
+  "cells": [
+    { "from": 6, "to": 10 },
+    { "from": 20, "to": 24 }
+  ],
+  "isDelete": true
+}

package/src/steps/table/__tests__/__fixtures__/basic/remove-column-at-2.json

@@ -0,0 +1,9 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 0,
+  "cells": [
+    { "from": 10, "to": 14 },
+    { "from": 24, "to": 28 }
+  ],
+  "isDelete": true
+}

package/src/steps/table/__tests__/__fixtures__/basic/remove-table/remove-last-row-inverted.json

@@ -0,0 +1,98 @@
+{
+  "stepType": "ak-add-column",
+  "tablePos": 2,
+  "cells": [
+    {
+      "from": 2,
+      "to": 6,
+      "newCell": {
+        "type": "tableCell",
+        "attrs": {
+          "colspan": 1,
+          "rowspan": 1,
+          "colwidth": null,
+          "background": "#AAAAAA"
+        },
+        "content": [
+          {
+            "type": "paragraph"
+          }
+        ]
+      }
+    }
+  ],
+  "isDelete": false,
+  "sideEffects": {
+    "table": {
+      "from": 2,
+      "to": 22,
+      "node": {
+        "type": "table",
+        "attrs": {
+          "isNumberColumnEnabled": false,
+          "layout": "default",
+          "__autoSize": false
+        },
+        "content": [
+          {
+            "type": "tableRow",
+            "content": [
+              {
+                "type": "tableCell",
+                "attrs": {
+                  "colspan": 1,
+                  "rowspan": 1,
+                  "colwidth": null,
+                  "background": "#AAAAAA"
+                },
+                "content": [
+                  {
+                    "type": "paragraph"
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "type": "tableRow",
+            "content": [
+              {
+                "type": "tableCell",
+                "attrs": {
+                  "colspan": 1,
+                  "rowspan": 1,
+                  "colwidth": null,
+                  "background": "#AAAAAA"
+                },
+                "content": [
+                  {
+                    "type": "paragraph"
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "type": "tableRow",
+            "content": [
+              {
+                "type": "tableCell",
+                "attrs": {
+                  "colspan": 1,
+                  "rowspan": 1,
+                  "colwidth": null,
+                  "background": "#AAAAAA"
+                },
+                "content": [
+                  {
+                    "type": "paragraph"
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    }
+  }
+}