@atlaskit/adf-schema 19.2.0

package/dist/es2019/schema/nodes/task-item.js

@@ -0,0 +1,38 @@
+import { uuid } from '../../utils/uuid';
+export const taskItem = {
+  content: 'inline*',
+  defining: true,
+  selectable: false,
+  marks: '_',
+  attrs: {
+    localId: {
+      default: ''
+    },
+    state: {
+      default: 'TODO'
+    }
+  },
+  parseDOM: [{
+    tag: 'div[data-task-local-id]',
+    // Default priority is 50. We normally don't change this but since this node type is
+    // also used by list-item we need to make sure that we run this parser first.
+    priority: 100,
+    getAttrs: dom => ({
+      localId: uuid.generate(),
+      state: dom.getAttribute('data-task-state') || 'TODO'
+    })
+  }],
+
+  toDOM(node) {
+    const {
+      localId,
+      state
+    } = node.attrs;
+    const attrs = {
+      'data-task-local-id': localId || 'local-task',
+      'data-task-state': state || 'TODO'
+    };
+    return ['div', attrs, 0];
+  }
+
+};

package/dist/es2019/schema/nodes/task-list.js

@@ -0,0 +1,37 @@
+import { uuid } from '../../utils/uuid';
+const name = 'actionList';
+export const taskListSelector = `[data-node-type="${name}"]`;
+export const taskList = {
+  group: 'block',
+  defining: true,
+  selectable: false,
+  content: '(taskItem|unsupportedBlock)+ (taskItem|taskList|unsupportedBlock)*',
+  marks: 'unsupportedMark unsupportedNodeAttribute',
+  attrs: {
+    localId: {
+      default: ''
+    }
+  },
+  parseDOM: [{
+    tag: `div${taskListSelector}`,
+    // Default priority is 50. We normally don't change this but since this node type is
+    // also used by ordered-list we need to make sure that we run this parser first.
+    priority: 100,
+    getAttrs: () => ({
+      localId: uuid.generate()
+    })
+  }],
+
+  toDOM(node) {
+    const {
+      localId
+    } = node.attrs;
+    const attrs = {
+      'data-node-type': name,
+      'data-task-list-local-id': localId || 'local-task-list',
+      style: 'list-style: none; padding-left: 0'
+    };
+    return ['div', attrs, 0];
+  }
+
+};

package/dist/es2019/schema/nodes/text.js

@@ -0,0 +1,7 @@
+/**
+ * @name text_node
+ */
+export const text = {
+  group: 'inline',
+  toDebugString: process.env.NODE_ENV !== 'production' ? undefined : () => 'text_node'
+};

package/dist/es2019/schema/nodes/types/block-content.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/schema/nodes/types/extensions.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/schema/nodes/types/inline-content.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/schema/nodes/types/mark.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/schema/nodes/types/non-nestable-block-content.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/schema/nodes/types/rich-media-common.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/schema/nodes/unknown-block.js

@@ -0,0 +1,16 @@
+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}"]`
+  }]
+};

package/dist/es2019/schema/nodes/unsupported-block.js

@@ -0,0 +1,26 @@
+export const unsupportedBlock = {
+  inline: false,
+  group: 'block',
+  atom: true,
+  selectable: true,
+  attrs: {
+    originalValue: {
+      default: {}
+    }
+  },
+  parseDOM: [{
+    tag: '[data-node-type="unsupportedBlock"]',
+    getAttrs: dom => ({
+      originalValue: JSON.parse(dom.getAttribute('data-original-value') || '{}')
+    })
+  }],
+
+  toDOM(node) {
+    const attrs = {
+      'data-node-type': 'unsupportedBlock',
+      'data-original-value': JSON.stringify(node.attrs.originalValue)
+    };
+    return ['div', attrs, 'Unsupported content'];
+  }
+
+};

package/dist/es2019/schema/nodes/unsupported-inline.js

@@ -0,0 +1,25 @@
+export const unsupportedInline = {
+  inline: true,
+  group: 'inline',
+  selectable: true,
+  attrs: {
+    originalValue: {
+      default: {}
+    }
+  },
+  parseDOM: [{
+    tag: '[data-node-type="unsupportedInline"]',
+    getAttrs: dom => ({
+      originalValue: JSON.parse(dom.getAttribute('data-original-value') || '{}')
+    })
+  }],
+
+  toDOM(node) {
+    const attrs = {
+      'data-node-type': 'unsupportedInline',
+      'data-original-value': JSON.stringify(node.attrs.originalValue)
+    };
+    return ['span', attrs, 'Unsupported content'];
+  }
+
+};

package/dist/es2019/schema/unsupported.js

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

package/dist/es2019/steps/analytics.js

@@ -0,0 +1,122 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { Step, StepResult, StepMap, ReplaceStep } from 'prosemirror-transform';
+import { Slice } from 'prosemirror-model';
+export const analyticsStepType = 'atlaskit-analytics';
+export const analyticsInvertStepType = 'atlaskit-analytics-invert';
+var HISTORY_ACTIONS;
+
+(function (HISTORY_ACTIONS) {
+  HISTORY_ACTIONS["UNDID"] = "undid";
+  HISTORY_ACTIONS["REDID"] = "redid";
+})(HISTORY_ACTIONS || (HISTORY_ACTIONS = {}));
+
+/** Creates undo event from a normal analytics event */
+function createUndoEvent(analyticsEvent) {
+  var _analyticsEvent$paylo;
+
+  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$paylo = analyticsEvent.payload.attributes) === null || _analyticsEvent$paylo === void 0 ? void 0 : _analyticsEvent$paylo.inputMethod) || ''
+      },
+      eventType: 'track'
+    }
+  };
+}
+/** Toggles event action between undo & redo */
+
+
+const toggleEventAction = analyticsEvent => ({ ...analyticsEvent,
+  payload: { ...analyticsEvent.payload,
+    action: analyticsEvent.payload.action === HISTORY_ACTIONS.UNDID ? HISTORY_ACTIONS.REDID : HISTORY_ACTIONS.UNDID
+  }
+});
+
+function isHistoryAnalyticsEvent(event) {
+  return event.payload.action === HISTORY_ACTIONS.UNDID || event.payload.action === HISTORY_ACTIONS.REDID;
+}
+
+/**
+ * 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 extends Step {
+  constructor(analyticsEvents, actionsToIgnore = [], pos // Used to create the map, prevent splitting history.
+  ) {
+    super();
+
+    _defineProperty(this, "analyticsEvents", []);
+
+    _defineProperty(this, "actionsToIgnore", []);
+
+    this.analyticsEvents = analyticsEvents;
+    this.actionsToIgnore = actionsToIgnore;
+    this.pos = pos;
+  }
+  /**
+   * Generate new undo/redo analytics event when step is inverted
+   */
+
+
+  invert() {
+    const analyticsEvents = 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) {
+    return StepResult.ok(doc);
+  }
+
+  map(mapping) {
+    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) {
+    if (other instanceof AnalyticsStep) {
+      const otherAnalyticsEvents = other.analyticsEvents;
+      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/dist/es2019/steps/set-attrs.js

@@ -0,0 +1,57 @@
+import { Step, StepResult } from 'prosemirror-transform';
+import { Slice, Fragment } from '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 {
+  constructor(pos, attrs) {
+    super();
+    this.pos = pos;
+    this.attrs = attrs;
+  }
+
+  apply(doc) {
+    let target = doc.nodeAt(this.pos);
+
+    if (!target) {
+      return StepResult.fail('No node at given position');
+    }
+
+    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) {
+    let target = doc.nodeAt(this.pos);
+    return new SetAttrsStep(this.pos, target ? target.attrs : {});
+  }
+
+  map(mapping) {
+    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, json) {
+    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/dist/es2019/steps/table/add-column.js

@@ -0,0 +1,349 @@
+import { Step, StepMap, StepResult, Transform } from 'prosemirror-transform';
+import { cellsAtColumn } from './utils/cells-at-column';
+import { findColumn } from './utils/find-column';
+import { getTableRectFromDoc } from './utils/get-table-rect-from-doc';
+import { applyCellStep, createCellStep, getMapFromCellStep, invertCellStep } from './utils/cell-step';
+import { SideEffectsHandler } from './utils/side-effects/side-effects';
+import memoizeOne from 'memoize-one';
+const ADD_COLUMN_STEP = 'ak-add-column';
+
+function printColumnInfo(columnInfo) {
+  let cellsFrom = [];
+
+  for (const cellInfo of columnInfo.values()) {
+    cellsFrom.push(cellInfo.from);
+  }
+
+  return `[${cellsFrom.join(',')}]`;
+}
+
+function createColumnInfo(cellsInfo) {
+  return new Map(cellsInfo.map(cellInfo => [cellInfo.from, cellInfo]));
+}
+
+const getTableRectAndColumnFactory = (doc, pos, columnInfo) => {
+  return memoizeOne(() => {
+    const rect = getTableRectFromDoc(doc, pos);
+    const column = findColumn(columnInfo, rect);
+
+    if (column === null) {
+      throw new Error('no column');
+    }
+
+    return {
+      rect,
+      column
+    };
+  });
+};
+/**
+ * Index and positions looks like
+ * 0    1    2    3   -> Add Column Index
+ * | 5  | 10 | 15 |   -> Table with Positions
+ * | 20 | 25 | 30 |
+ * 0    1    2    x   -> Remove Column Index
+ *
+ */
+
+
+export class AddColumnStep extends Step {
+  constructor(tablePos, addColumnStepInfo, isDelete = false) {
+    super();
+    this.tablePos = tablePos;
+    this.isDelete = isDelete;
+    this.sideEffectsHandler = new SideEffectsHandler(addColumnStepInfo.sideEffects);
+    this.columnInfo = createColumnInfo(addColumnStepInfo.cells);
+  }
+  /**
+   * Detect the column based on all the cells step in column info.
+   * Recreate columnInfo based on the current document. We might need to add new cells added by insert row or unmerge cells.
+   * If isDelete
+   *    Decrease colspan if one row has merged cell
+   *    Remove all the cells using columnInfo.cellStep[].from
+   * else
+   *    Increase colspan if one row had merged cell
+   *    Add all new cells at columnInfo.cellStep[].from,
+   *      if there is columnInfo.cellStep[].newCell use it
+   *      else create an empty cell
+   *
+   * @param doc Current document
+   */
+
+
+  apply(doc) {
+    const {
+      tablePos
+    } = this; // Create transform base on the doc
+
+    const tr = new Transform(doc);
+
+    if (this.sideEffectsHandler.table.handleAddTable(tr, this.isDelete)) {
+      return StepResult.ok(tr.doc);
+    }
+
+    let tableRect;
+
+    try {
+      tableRect = getTableRectFromDoc(doc, tablePos);
+    } catch (e) {
+      return StepResult.fail(e.message);
+    }
+
+    const column = findColumn(this.columnInfo, tableRect);
+
+    if (column === null) {
+      return StepResult.fail(`No column for this cells "${printColumnInfo(this.columnInfo)}" in table at position "${tablePos}".`);
+    }
+
+    if (this.sideEffectsHandler.table.handleRemoveTable(tr, this.tablePos, tableRect, column, this.isDelete)) {
+      return StepResult.ok(tr.doc);
+    }
+
+    this.columnInfo = this.applyCellSteps(tr, tableRect, column, this.isDelete); // Return the document modified.
+
+    return StepResult.ok(tr.doc);
+  }
+  /**
+   * Update tablePos with the new position. If tablePos doesnt exist any more remove the step
+   * Update all the cellStep inside columnInfo. If cellStep.from position gets deleted removed it from column info
+   * if cellStep.length === 0 remove the step
+   * Create a new step with all the position updated
+   * @param mapping
+   */
+
+
+  map(mapping) {
+    const tablePosResult = mapping.mapResult(this.tablePos);
+
+    if (tablePosResult.deleted) {
+      // If table was deleted remove the step
+      return null;
+    }
+
+    const cellSteps = [];
+
+    for (const oldCellStep of this.columnInfo.values()) {
+      const fromResult = mapping.mapResult(oldCellStep.from);
+      const toResult = mapping.mapResult(oldCellStep.to);
+
+      if (fromResult.deleted && toResult.deleted) {
+        continue;
+      }
+
+      const cellStep = { ...oldCellStep,
+        from: fromResult.pos,
+        to: toResult.pos
+      };
+
+      if (oldCellStep.mergeWith !== undefined) {
+        cellStep.mergeWith = mapping.map(oldCellStep.mergeWith);
+      }
+
+      cellSteps.push(cellStep);
+    }
+
+    if (cellSteps.length === 0) {
+      return null;
+    }
+
+    const sideEffects = this.sideEffectsHandler.map(mapping);
+    return new AddColumnStep(tablePosResult.pos, {
+      cells: cellSteps,
+      sideEffects
+    }, this.isDelete);
+  }
+  /**
+   * if isDelete
+   *    Get the original cell node at columnInfo.cellStep[].from to columnInfo.cellStep[].to
+   *    Create a copy of the node
+   *    Create a new cellStep with the same positions but with the clone node as a content
+   *    return new step inverted
+   * else
+   *    Remove the content from each columnInfo.cellStep[].content
+   *    return new step inverted
+   * @param originalDoc
+   */
+
+
+  invert(originalDoc) {
+    const stepMap = this.getMap(); // Memoize function to be called only on delete scenarios
+
+    const getTableRectAndColumn = getTableRectAndColumnFactory(originalDoc, this.tablePos, this.columnInfo); // This is needed because the real pos of the cell in the generated document is affected by the previous operations.
+
+    const newCellSteps = Array.from(this.columnInfo.values(), oldCellStep => {
+      const newCellStep = invertCellStep(originalDoc, getTableRectAndColumn, oldCellStep, this.isDelete, stepMap);
+      return newCellStep;
+    });
+    const sideEffects = this.sideEffectsHandler.invert(originalDoc, this.isDelete, stepMap);
+    return new AddColumnStep(this.tablePos, {
+      cells: newCellSteps,
+      sideEffects
+    }, !this.isDelete);
+  }
+  /**
+   * StepMap is created based on columnInfo.
+   * ColumnInfo is created on constructor and once is applied (the document could have new cells that weren't part of the original set)
+   * if isDelete
+   *    Create range array based on cell info where each range is [cellStep.from, cellStep.from - cellStep.to, 0]
+   * else
+   *    Create range array base on cell info where each range is [cellStep.from, 0, cellStep.content ? cellStep.content.nodeSize : defaultEmptyCellNodeSize]
+   *
+   * Ranges in ProseMirror are represented by each 3 elements in an array.
+   * As [pos, currentSize, newSize, pos2, currentSize2, newSize2] where:
+   * pos: Position in the document
+   * currentSize: Represent the affected range, this will be pos + currentSize
+   * newSize: Represent the new values, pos + newSize
+   */
+
+
+  getMap() {
+    const tableMap = this.sideEffectsHandler.getTableMap(this.isDelete);
+
+    if (tableMap) {
+      return tableMap;
+    }
+
+    let ranges = [];
+
+    for (const cellStep of this.columnInfo.values()) {
+      ranges.push(...getMapFromCellStep(cellStep, this.isDelete));
+    }
+
+    ranges = this.sideEffectsHandler.rows.addRowRanges(ranges, this.isDelete); // If no steps, I create am empty stepMap
+
+    return new StepMap(ranges);
+  }
+  /**
+   * Try to merge this step with another one, to be applied directly
+   * after it. Returns the merged step when possible, null if the
+   * steps can't be merged.
+   */
+
+
+  merge(other) {
+    // We cannot merge add column step at the moment
+    return null;
+  }
+  /**
+   * Create a JSON-serializeable representation of this step. When
+   * defining this for a custom subclass, make sure the result object
+   * includes the step type's [JSON id](#transform.Step^jsonID) under
+   * the `stepType` property.
+   */
+
+
+  toJSON() {
+    const addColumnStepJson = {
+      stepType: ADD_COLUMN_STEP,
+      tablePos: this.tablePos,
+      cells: Array.from(this.columnInfo.values(), cellStep => {
+        const cellStepJson = {
+          from: cellStep.from,
+          to: cellStep.to
+        };
+
+        if (cellStep.mergeWith !== undefined) {
+          cellStepJson.mergeWith = cellStep.mergeWith;
+        }
+
+        if (cellStep.newCell !== undefined) {
+          cellStepJson.newCell = cellStep.newCell.toJSON();
+        }
+
+        return cellStepJson;
+      }),
+      isDelete: this.isDelete
+    };
+    const sideEffectsJSON = this.sideEffectsHandler.toJSON();
+
+    if (sideEffectsJSON) {
+      addColumnStepJson.sideEffects = sideEffectsJSON;
+    }
+
+    return addColumnStepJson;
+  }
+  /**
+   * Deserialize a step from its JSON representation. Will call
+   * through to the step class' own implementation of this method.
+   */
+
+
+  static fromJSON(schema, json) {
+    // TODO: Add validation. Return null if it is invalid. Check in review if this is necessary
+    const cells = json.cells.map(cellsJson => {
+      const cell = { ...cellsJson,
+        newCell: cellsJson.newCell ? schema.nodeFromJSON(cellsJson.newCell) : undefined
+      };
+      return cell;
+    });
+    let sideEffects;
+
+    if (json.sideEffects) {
+      sideEffects = SideEffectsHandler.fromJSON(schema, json.sideEffects);
+    }
+
+    return new AddColumnStep(json.tablePos, {
+      cells,
+      sideEffects
+    }, json.isDelete);
+  }
+
+  static create(doc, tablePos, column, isDelete = false) {
+    const tableRect = getTableRectFromDoc(doc, tablePos); // By default add column will rely on default behaviour (add empty cell).
+    // There is no need to add content
+
+    const cells = [];
+    const iter = cellsAtColumn(tableRect, column);
+    let next = iter.next();
+
+    while (!next.done) {
+      const cell = next.value;
+      cells.push(createCellStep(cell, column, isDelete));
+      let skipRows = 0;
+
+      if (cell.attrs && cell.attrs.rowspan) {
+        skipRows = cell.attrs.rowspan - 1;
+      }
+
+      next = iter.next(skipRows);
+    }
+
+    return new AddColumnStep(tablePos, {
+      cells
+    }, isDelete);
+  }
+
+  applyCellSteps(tr, tableRect, column, isDelete) {
+    const newColumnInfo = new Map();
+    const rowsHandler = this.sideEffectsHandler.rows.start(this.isDelete);
+    const iter = cellsAtColumn(tableRect, column);
+    let next = iter.next(); // Iterate for all the cells in the current document
+
+    while (!next.done) {
+      const cell = next.value;
+      const previousCellStep = this.columnInfo.get(cell.from);
+      const newCellStep = createCellStep(cell, column, isDelete, previousCellStep); // If is the last cell in the row and doesnt have colspan I need to remove the whole row.
+
+      const removeRowResult = rowsHandler.handle(tr, tableRect, cell.row, column, cell);
+
+      if (removeRowResult.handled) {
+        next = iter.next(removeRowResult.skipRows);
+        continue;
+      } // Apply the step, to the pseudo document, get rows to skip, and the cellstep (might be modified, for example, a merge cell that remove the cell instead)
+
+
+      const {
+        skipRows,
+        cellStep
+      } = applyCellStep(tr, tableRect, cell, newCellStep, isDelete, column); // Store the new cell step. This could be an existing one or a new cell.
+
+      newColumnInfo.set(newCellStep.from, cellStep);
+      next = iter.next(skipRows);
+    }
+
+    rowsHandler.end(tr, tableRect, column);
+    return newColumnInfo;
+  }
+
+}
+Step.jsonID(ADD_COLUMN_STEP, AddColumnStep);