@atlaskit/adf-schema 28.1.5 → 28.1.7

package/src/steps/table/utils/side-effects/rows.ts

@@ -0,0 +1,327 @@
+import {
+  Node as ProseMirrorNode,
+  Schema,
+} from '@atlaskit/editor-prosemirror/model';
+import {
+  Mappable,
+  StepMap,
+  Transform,
+} from '@atlaskit/editor-prosemirror/transform';
+import { TableRect } from '@atlaskit/editor-tables/table-map';
+import { hasMergedColumns } from '../table-map';
+import { RowSideEffect, RowSideEffectJSON } from './types';
+import { Cell } from '../cells-at-column';
+
+function mergedRanges(first: number[], second: number[]) {
+  const newRanges: number[] = [];
+  const firstLength = first.length;
+  const secondLength = second.length;
+
+  let i = 0;
+  let j = 0;
+  while (i < firstLength && j < secondLength) {
+    if (first[i] < second[j]) {
+      newRanges.push(first[i], first[i + 1], first[i + 2]);
+      i += 3;
+    } else {
+      newRanges.push(second[j], second[j + 1], second[j + 2]);
+      j += 3;
+    }
+  }
+
+  if (i < firstLength) {
+    newRanges.push(...first.slice(i));
+  }
+  if (j < secondLength) {
+    newRanges.push(...second.slice(i));
+  }
+  return newRanges;
+}
+
+function increaseRowSpan(tr: Transform, rect: TableRect, row: number): void {
+  const { map, tableStart } = rect;
+  for (let col = 0; col < map.width; col++) {
+    let index = row * map.width + col;
+    let pos = map.map[index];
+    const mappedPos = tr.mapping.map(pos + tableStart);
+    let attrs = tr.doc.nodeAt(mappedPos)!.attrs;
+    tr.setNodeMarkup(mappedPos, undefined, {
+      ...attrs,
+      rowspan: attrs.rowspan + 1,
+    });
+    col += attrs.colspan - 1;
+  }
+}
+
+function decreaseRowspan(
+  tr: Transform,
+  rect: TableRect,
+  row: number,
+  colToRemove: number,
+): number {
+  let skipRows = 0;
+  const { map, table, tableStart } = rect;
+  for (let col = 0; col < map.width; col++) {
+    let index = row * map.width + col;
+    let pos = map.map[index];
+    if (row > 0 && pos === map.map[index - map.width]) {
+      // If this cell starts in the row above, simply reduce its rowspan
+      const mappedPos = tr.mapping.map(pos + tableStart);
+      let attrs = tr.doc.nodeAt(mappedPos)!.attrs;
+      tr.setNodeMarkup(mappedPos, undefined, {
+        ...attrs,
+        rowspan: attrs.rowspan - 1,
+      });
+      col += attrs.colspan - 1;
+    } else if (col === colToRemove) {
+      skipRows = table.nodeAt(pos)!.attrs.rowspan - 1;
+    }
+  }
+  return skipRows;
+}
+
+function isLastCellInRow(rect: TableRect, row: number, col: number): boolean {
+  const rowNode = rect.table.child(row);
+  if (!rowNode) {
+    return false;
+  }
+  return rowNode.childCount === 1 && !hasMergedColumns(rect.map, row, col);
+}
+
+interface RowsHandler {
+  handle: (
+    tr: Transform,
+    rect: TableRect,
+    row: number,
+    col: number,
+    cell: Cell,
+  ) => {
+    handled: boolean;
+    skipRows?: number;
+  };
+
+  end: (tr: Transform, rect: TableRect, col: number) => void;
+}
+
+function removeRowWithLastCell(
+  tr: Transform,
+  rect: TableRect,
+  row: number,
+  _col: number,
+): {
+  skipRows: number;
+  row: RowSideEffect;
+} {
+  // Get row pos
+  let from = rect.tableStart;
+  for (let i = 0; i < row; i++) {
+    from += rect.table.child(i).nodeSize;
+  }
+  const rowNode = rect.table.child(row);
+  let to = from + rowNode.nodeSize;
+
+  // Create sideEffect and delete the row
+  // We store original row position before modifications
+  tr.delete(tr.mapping.map(from), tr.mapping.map(to));
+
+  // Change rowspan of all cells except current col and get the rows to skip
+  const skipRows = decreaseRowspan(tr, rect, row, _col);
+
+  return {
+    skipRows,
+    row: {
+      from,
+      to,
+      rowNode: rowNode.copy(rowNode.content),
+    },
+  };
+}
+
+function addRow(
+  tr: Transform,
+  rect: TableRect,
+  prevRow: number,
+  rowSideEffect: RowSideEffect,
+): number {
+  const cellNode = rowSideEffect.rowNode.child(0);
+
+  tr.insert(tr.mapping.map(rowSideEffect.from), rowSideEffect.rowNode);
+
+  increaseRowSpan(tr, rect, prevRow);
+  return cellNode.attrs.rowspan - 1;
+}
+
+export class RowsSideEffectHandler {
+  public rows?: RowSideEffect[];
+
+  constructor(rowsSideEffect?: RowSideEffect[]) {
+    this.rows = rowsSideEffect;
+  }
+
+  private deleteHandler = (): RowsHandler => {
+    const newRows: RowSideEffect[] = [];
+    return {
+      handle: (tr, rect, row, col, cell) => {
+        if (!isLastCellInRow(rect, row, col)) {
+          return {
+            handled: false,
+          };
+        }
+
+        const { row: rowSideEffect, skipRows } = removeRowWithLastCell(
+          tr,
+          rect,
+          row,
+          col,
+        );
+        newRows.push(rowSideEffect);
+
+        return { handled: true, skipRows: skipRows };
+      },
+      end: () => {
+        if (newRows.length > 0) {
+          this.rows = newRows;
+        } else {
+          this.rows = undefined;
+        }
+      },
+    };
+  };
+
+  private addHandler = (): RowsHandler => {
+    let lastCellFrom = 0;
+    let i = 0;
+
+    return {
+      handle: (tr, rect, row, col, cell) => {
+        // // If not sideEffects stored return;
+        if (!this.rows || i >= this.rows.length) {
+          return { handled: false };
+        }
+
+        // Next row to add;
+        let skipRows: undefined | number;
+        let nextRow: RowSideEffect;
+        while (
+          (nextRow = this.rows[i]) &&
+          nextRow.from > lastCellFrom &&
+          nextRow.from < cell.from
+        ) {
+          // I am in between of the previous and next row in the table;
+          skipRows = addRow(tr, rect, row - 1, nextRow);
+          i++;
+        }
+        lastCellFrom = cell.from;
+        if (!skipRows || skipRows === 0) {
+          return { handled: false };
+        }
+
+        return {
+          handled: true,
+          skipRows: skipRows - 1,
+        };
+      },
+      end: (tr, rect, col: number) => {
+        if (!this.rows || i >= this.rows.length) {
+          return;
+        }
+
+        // Add rows at the end of the table
+        let nextRow: RowSideEffect;
+        while ((nextRow = this.rows[i])) {
+          addRow(tr, rect, rect.map.height - 1, nextRow);
+          i++;
+        }
+      },
+    };
+  };
+
+  start(isDelete: boolean): RowsHandler {
+    if (isDelete) {
+      return this.deleteHandler();
+    }
+
+    return this.addHandler();
+  }
+
+  addRowRanges(ranges: number[], isDelete: boolean): number[] {
+    if (!this.rows) {
+      return ranges;
+    }
+
+    const rowRanges: number[] = [];
+    for (const row of this.rows) {
+      const { from, to } = row;
+      if (isDelete) {
+        rowRanges.push(from, to - from, 0);
+      } else {
+        rowRanges.push(from, 0, to - from);
+      }
+    }
+
+    // Merged ranges
+    return mergedRanges(ranges, rowRanges);
+  }
+
+  map(mapping: Mappable): RowSideEffect[] {
+    return [];
+  }
+
+  invert(
+    originalDoc: ProseMirrorNode,
+    isDelete: boolean,
+    map: StepMap,
+  ): RowSideEffect[] | undefined {
+    if (!this.rows) {
+      return;
+    }
+    const invertedRows: RowSideEffect[] = [];
+
+    for (const row of this.rows) {
+      if (isDelete) {
+        // Moving from delete to add keep the inverted rows + offset
+        let offset = map.map(row.from) - row.from;
+        invertedRows.push({
+          ...row,
+          from: row.from + offset,
+          to: row.from + offset,
+        });
+      } else {
+        // Moving from add to delete keep
+        // TODO: I think we need to add the respective cell into the cellSteps...... not sure....
+      }
+    }
+    return invertedRows;
+  }
+
+  toJSON(): RowSideEffectJSON[] | undefined {
+    if (!this.rows) {
+      return;
+    }
+    const rowsInJson: RowSideEffectJSON[] = [];
+
+    for (const row of this.rows) {
+      rowsInJson.push({
+        from: row.from,
+        to: row.to,
+        rowNode: row.rowNode.toJSON(),
+      });
+    }
+
+    return rowsInJson;
+  }
+
+  static fromJSON(schema: Schema, json: RowSideEffectJSON[]): RowSideEffect[] {
+    const rowSideEffects: RowSideEffect[] = [];
+
+    for (const row of json) {
+      rowSideEffects.push({
+        from: row.from,
+        to: row.to,
+        rowNode: schema.nodeFromJSON(row.rowNode),
+      });
+    }
+
+    return rowSideEffects;
+  }
+}

package/src/steps/table/utils/side-effects/side-effects.ts

@@ -0,0 +1,90 @@
+import {
+  Node as ProseMirrorNode,
+  Schema,
+} from '@atlaskit/editor-prosemirror/model';
+import { Mappable, StepMap } from '@atlaskit/editor-prosemirror/transform';
+import { SideEffects, SideEffectsJSON } from './types';
+import { TableSideEffectHandler } from './table';
+import { RowsSideEffectHandler } from './rows';
+
+export class SideEffectsHandler {
+  public table: TableSideEffectHandler;
+  public rows: RowsSideEffectHandler;
+
+  constructor(sideEffects?: SideEffects) {
+    this.table = new TableSideEffectHandler(sideEffects && sideEffects.table);
+    this.rows = new RowsSideEffectHandler(sideEffects && sideEffects.rows);
+  }
+
+  getTableMap(isDelete: boolean): StepMap | undefined {
+    return this.table.getTableMap(isDelete);
+  }
+
+  map(mapping: Mappable): SideEffects {
+    const sideEffects: SideEffects = {};
+    const tableSideEffect = this.table.map(mapping);
+    const rowsSideEffect = this.rows.map(mapping);
+
+    if (tableSideEffect) {
+      sideEffects.table = tableSideEffect;
+    }
+
+    if (rowsSideEffect) {
+      sideEffects.rows = rowsSideEffect;
+    }
+    return sideEffects;
+  }
+
+  invert(
+    originalDoc: ProseMirrorNode,
+    isDelete: boolean,
+    map: StepMap,
+  ): SideEffects {
+    const sideEffects: SideEffects = {};
+
+    const tableSideEffect = this.table.invert(originalDoc);
+    if (tableSideEffect) {
+      sideEffects.table = tableSideEffect;
+    }
+
+    const rowsSideEffect = this.rows.invert(originalDoc, isDelete, map);
+    if (rowsSideEffect) {
+      sideEffects.rows = rowsSideEffect;
+    }
+
+    return sideEffects;
+  }
+
+  toJSON(): SideEffectsJSON | undefined {
+    const tableSideEffectJson = this.table.toJSON();
+    const rowsSideEffectJson = this.rows.toJSON();
+
+    if (!tableSideEffectJson && !rowsSideEffectJson) {
+      return;
+    }
+
+    const sideEffectsJSON: SideEffectsJSON = {};
+    if (tableSideEffectJson) {
+      sideEffectsJSON.table = tableSideEffectJson;
+    }
+    if (rowsSideEffectJson) {
+      sideEffectsJSON.rows = rowsSideEffectJson;
+    }
+
+    return sideEffectsJSON;
+  }
+
+  static fromJSON(schema: Schema, json: SideEffectsJSON): SideEffects {
+    const sideEffects: SideEffects = {};
+
+    if (json.table) {
+      sideEffects.table = TableSideEffectHandler.fromJSON(schema, json.table);
+    }
+
+    if (json.rows) {
+      sideEffects.rows = RowsSideEffectHandler.fromJSON(schema, json.rows);
+    }
+
+    return sideEffects;
+  }
+}

package/src/steps/table/utils/side-effects/table.ts

@@ -0,0 +1,112 @@
+import {
+  Node as ProseMirrorNode,
+  Schema,
+} from '@atlaskit/editor-prosemirror/model';
+import {
+  Mappable,
+  StepMap,
+  Transform,
+} from '@atlaskit/editor-prosemirror/transform';
+import { TableRect } from '@atlaskit/editor-tables/table-map';
+import { TableSideEffect, TableSideEffectJSON } from './types';
+
+export class TableSideEffectHandler {
+  public table?: TableSideEffect;
+
+  constructor(tableSideEffect?: TableSideEffect) {
+    if (tableSideEffect) {
+      this.table = tableSideEffect;
+    }
+  }
+
+  private addTableSideEffect(from: number, to: number, node: ProseMirrorNode) {
+    this.table = { from, to, node };
+  }
+
+  handleAddTable(tr: Transform, isDelete: boolean): boolean {
+    if (isDelete || !this.table) {
+      return false;
+    }
+
+    tr.insert(this.table.from, this.table.node);
+    return true;
+  }
+
+  handleRemoveTable(
+    tr: Transform,
+    tablePos: number,
+    tableRect: TableRect,
+    column: number | null,
+    isDelete: boolean,
+  ) {
+    if (isDelete && tableRect.map.width === 1 && column === 0) {
+      // Add side effect
+      this.addTableSideEffect(
+        tablePos,
+        tablePos + tableRect.table.nodeSize,
+        tableRect.table.copy(tableRect.table.content),
+      );
+
+      tr.delete(tablePos, tablePos + tableRect.table.nodeSize);
+      return true;
+    }
+    return false;
+  }
+
+  getTableMap(isDelete: boolean): StepMap | undefined {
+    if (!this.table) {
+      return;
+    }
+    const { from, to } = this.table;
+    if (isDelete) {
+      return new StepMap([from, to - from, 0]);
+    }
+
+    return new StepMap([from, 0, to - from]);
+  }
+
+  map(mapping: Mappable): TableSideEffect | undefined {
+    if (!this.table) {
+      return;
+    }
+
+    return {
+      from: mapping.map(this.table.from),
+      to: mapping.map(this.table.to),
+      node: this.table.node,
+    };
+  }
+
+  invert(doc: ProseMirrorNode): TableSideEffect | undefined {
+    if (!this.table) {
+      return;
+    }
+    const tableNode = doc.nodeAt(this.table.from)!;
+
+    return {
+      from: this.table.from,
+      to: this.table.from + tableNode.nodeSize,
+      node: tableNode.copy(tableNode.content),
+    };
+  }
+
+  toJSON(): TableSideEffectJSON | undefined {
+    if (!this.table) {
+      return;
+    }
+
+    return {
+      from: this.table.from,
+      to: this.table.to,
+      node: this.table.node.toJSON(),
+    };
+  }
+
+  static fromJSON(schema: Schema, json: TableSideEffectJSON): TableSideEffect {
+    return {
+      from: json.from,
+      to: json.to,
+      node: schema.nodeFromJSON(json.node),
+    };
+  }
+}

package/src/steps/table/utils/side-effects/types.ts

@@ -0,0 +1,34 @@
+import { Node as ProseMirrorNode } from '@atlaskit/editor-prosemirror/model';
+
+export interface TableSideEffect {
+  from: number;
+  to: number;
+  node: ProseMirrorNode;
+}
+
+export interface RowSideEffect {
+  from: number;
+  to: number;
+  rowNode: ProseMirrorNode;
+}
+
+export interface TableSideEffectJSON {
+  from: number;
+  to: number;
+  node: { [key: string]: any }; // ToJson type of ProseMirrorNode.toJson()
+}
+
+export interface RowSideEffectJSON {
+  from: number;
+  to: number;
+  rowNode: { [key: string]: any }; // ToJson type of ProseMirrorNode.toJson()
+}
+
+export type SideEffects = {
+  table?: TableSideEffect;
+  rows?: RowSideEffect[];
+};
+export type SideEffectsJSON = {
+  table?: TableSideEffectJSON;
+  rows?: RowSideEffectJSON[];
+};

package/src/steps/table/utils/table-map.ts

@@ -0,0 +1,28 @@
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+
+export const getCellIndex = (map: TableMap, row: number, col: number) => {
+  return row * map.width + col;
+};
+
+export function hasMergedColumns(map: TableMap, row: number, col: number) {
+  const index = getCellIndex(map, row, col);
+  return (
+    (col > 0 && map.map[index - 1] === map.map[index]) ||
+    (col < map.width - 1 && map.map[index + 1] === map.map[index])
+  );
+}
+export function hasMergedRows(map: TableMap, row: number, col: number) {
+  const index = getCellIndex(map, row, col);
+  return (
+    (row > 0 && map.map[index - map.width] !== map.map[index]) ||
+    (row < map.height - 1 && map.map[index + map.width] === map.map[index])
+  );
+}
+export function isRootRow(map: TableMap, row: number, col: number) {
+  const index = getCellIndex(map, row, col);
+  return row > 0 ? map.map[index - map.width] !== map.map[index] : true;
+}
+export function isRootCol(map: TableMap, row: number, col: number) {
+  const index = getCellIndex(map, row, col);
+  return row > 0 ? map.map[index - 1] !== map.map[index] : true;
+}

package/src/steps/type-ahead.ts

@@ -0,0 +1,100 @@
+import { Node as PMNode, Slice } from '@atlaskit/editor-prosemirror/model';
+import {
+  Mappable,
+  ReplaceStep,
+  Step,
+  StepMap,
+  StepResult,
+} from '@atlaskit/editor-prosemirror/transform';
+
+export const insertTypeAheadStepType = 'atlaskit-insert-type-ahead';
+
+export enum InsertTypeAheadStages {
+  DELETING_RAW_QUERY = 'DELETING_RAW_QUERY',
+  INSERTING_ITEM = 'INSERTING_ITEM',
+}
+
+type Config = {
+  selectedIndex: number;
+  stage: InsertTypeAheadStages;
+  query: string;
+  trigger: string;
+};
+export class InsertTypeAheadStep extends Step {
+  private isInvertStep: boolean;
+  selectedIndex: number;
+  stage: InsertTypeAheadStages;
+  query: string;
+  trigger: string;
+
+  constructor(
+    { stage, query, trigger, selectedIndex }: Config,
+    isInvertStep: boolean = false,
+  ) {
+    super();
+    this.isInvertStep = isInvertStep;
+    this.stage = stage;
+    this.query = query;
+    this.trigger = trigger;
+    this.selectedIndex = selectedIndex;
+  }
+
+  invert() {
+    const config = {
+      stage: this.stage,
+      query: this.query,
+      trigger: this.trigger,
+      selectedIndex: this.selectedIndex,
+    };
+    return new InsertTypeAheadStep(config, !this.isInvertStep);
+  }
+
+  apply(doc: PMNode) {
+    return StepResult.ok(doc);
+  }
+
+  merge(): null {
+    return null;
+  }
+
+  isInsertionStep() {
+    return !this.isInvertStep;
+  }
+
+  isUndoingStep() {
+    return this.isInvertStep;
+  }
+
+  map(mapping: Mappable) {
+    const config = {
+      stage: this.stage,
+      query: this.query,
+      trigger: this.trigger,
+      selectedIndex: this.selectedIndex,
+    };
+    // Return the same events, this step will never be removed
+    return new InsertTypeAheadStep(config, this.isInvertStep);
+  }
+
+  getMap() {
+    return new StepMap([0, 0, 0]);
+  }
+
+  toJSON() {
+    // When serialized we should create a noop Replace step
+    return {
+      stepType: 'replace',
+      from: 0,
+      to: 0,
+    };
+  }
+
+  static fromJSON() {
+    // 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(insertTypeAheadStepType, InsertTypeAheadStep);

package/src/steps.ts

@@ -0,0 +1,16 @@
+export { SortOrder as TableSortOrder } from './steps/table/constants';
+export { TableSortStep } from './steps/table/sort-column';
+export { InsertTypeAheadStages, InsertTypeAheadStep } from './steps/type-ahead';
+export { AddColumnStep } from './steps/table/add-column';
+export { SetAttrsStep } from './steps/set-attrs';
+export { AnalyticsStep } from './steps/analytics';
+export type { TableColumnOrdering } from './steps/table/types';
+export type {
+  AnalyticsInvertStep,
+  AnalyticsWithChannel,
+  AnalyticsPayload,
+} from './steps/analytics';
+export { LinkMetaStep } from './steps/link-meta-step';
+export type { LinkStepMetadata } from './steps/link-meta-step';
+export { OverrideDocumentStep } from './steps/override-document-step';
+export type { OverrideDocumentStepJSON } from './steps/override-document-step';