@atlaskit/adf-schema 28.1.12 → 28.2.0

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

@@ -1,327 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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';