@atlaskit/adf-schema 19.2.0

package/dist/es2019/steps/table/utils/side-effects/side-effects.js

@@ -0,0 +1,81 @@
+import { TableSideEffectHandler } from './table';
+import { RowsSideEffectHandler } from './rows';
+export class SideEffectsHandler {
+  constructor(sideEffects) {
+    this.table = new TableSideEffectHandler(sideEffects && sideEffects.table);
+    this.rows = new RowsSideEffectHandler(sideEffects && sideEffects.rows);
+  }
+
+  getTableMap(isDelete) {
+    return this.table.getTableMap(isDelete);
+  }
+
+  map(mapping) {
+    const 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, isDelete, map) {
+    const 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() {
+    const tableSideEffectJson = this.table.toJSON();
+    const rowsSideEffectJson = this.rows.toJSON();
+
+    if (!tableSideEffectJson && !rowsSideEffectJson) {
+      return;
+    }
+
+    const sideEffectsJSON = {};
+
+    if (tableSideEffectJson) {
+      sideEffectsJSON.table = tableSideEffectJson;
+    }
+
+    if (rowsSideEffectJson) {
+      sideEffectsJSON.rows = rowsSideEffectJson;
+    }
+
+    return sideEffectsJSON;
+  }
+
+  static fromJSON(schema, json) {
+    const sideEffects = {};
+
+    if (json.table) {
+      sideEffects.table = TableSideEffectHandler.fromJSON(schema, json.table);
+    }
+
+    if (json.rows) {
+      sideEffects.rows = RowsSideEffectHandler.fromJSON(schema, json.rows);
+    }
+
+    return sideEffects;
+  }
+
+}

package/dist/es2019/steps/table/utils/side-effects/table.js

@@ -0,0 +1,99 @@
+import { StepMap } from 'prosemirror-transform';
+export class TableSideEffectHandler {
+  constructor(tableSideEffect) {
+    if (tableSideEffect) {
+      this.table = tableSideEffect;
+    }
+  }
+
+  addTableSideEffect(from, to, node) {
+    this.table = {
+      from,
+      to,
+      node
+    };
+  }
+
+  handleAddTable(tr, isDelete) {
+    if (isDelete || !this.table) {
+      return false;
+    }
+
+    tr.insert(this.table.from, this.table.node);
+    return true;
+  }
+
+  handleRemoveTable(tr, tablePos, tableRect, column, isDelete) {
+    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) {
+    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) {
+    if (!this.table) {
+      return;
+    }
+
+    return {
+      from: mapping.map(this.table.from),
+      to: mapping.map(this.table.to),
+      node: this.table.node
+    };
+  }
+
+  invert(doc) {
+    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() {
+    if (!this.table) {
+      return;
+    }
+
+    return {
+      from: this.table.from,
+      to: this.table.to,
+      node: this.table.node.toJSON()
+    };
+  }
+
+  static fromJSON(schema, json) {
+    return {
+      from: json.from,
+      to: json.to,
+      node: schema.nodeFromJSON(json.node)
+    };
+  }
+
+}

package/dist/es2019/steps/table/utils/side-effects/types.js

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

package/dist/es2019/steps/table/utils/table-map.js

@@ -0,0 +1,19 @@
+export const getCellIndex = (map, row, col) => {
+  return row * map.width + col;
+};
+export function hasMergedColumns(map, row, col) {
+  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, row, col) {
+  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, row, col) {
+  const index = getCellIndex(map, row, col);
+  return row > 0 ? map.map[index - map.width] !== map.map[index] : true;
+}
+export function isRootCol(map, row, col) {
+  const index = getCellIndex(map, row, col);
+  return row > 0 ? map.map[index - 1] !== map.map[index] : true;
+}

package/dist/es2019/steps/type-ahead.js

@@ -0,0 +1,85 @@
+import { Slice } from 'prosemirror-model';
+import { ReplaceStep, Step, StepMap, StepResult } from 'prosemirror-transform';
+export const insertTypeAheadStepType = 'atlaskit-insert-type-ahead';
+export let InsertTypeAheadStages;
+
+(function (InsertTypeAheadStages) {
+  InsertTypeAheadStages["DELETING_RAW_QUERY"] = "DELETING_RAW_QUERY";
+  InsertTypeAheadStages["INSERTING_ITEM"] = "INSERTING_ITEM";
+})(InsertTypeAheadStages || (InsertTypeAheadStages = {}));
+
+export class InsertTypeAheadStep extends Step {
+  constructor({
+    stage,
+    query,
+    trigger,
+    selectedIndex
+  }, isInvertStep = 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) {
+    return StepResult.ok(doc);
+  }
+
+  merge() {
+    return null;
+  }
+
+  isInsertionStep() {
+    return !this.isInvertStep;
+  }
+
+  isUndoingStep() {
+    return this.isInvertStep;
+  }
+
+  map(mapping) {
+    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/dist/es2019/steps.js

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

package/dist/es2019/utils/colors.js

@@ -0,0 +1,148 @@
+import * as namedColors from 'css-color-names'; // eslint-disable-line import/extensions
+
+/**
+ * We're avoding importing these colors from @atlaskit/theme since we
+ * do not want to have react as a dependency of this package.
+ * TODO: Refactor this once tokenization by Core team is ready
+ * https://product-fabric.atlassian.net/browse/CS-908
+ */
+
+export const R50 = '#FFEBE6';
+export const R75 = '#FFBDAD';
+export const R100 = '#FF8F73';
+export const R300 = '#FF5630';
+export const R400 = '#DE350B';
+export const R500 = '#BF2600';
+export const Y50 = '#FFFAE6';
+export const Y75 = '#FFF0B3';
+export const Y200 = '#FFC400';
+export const Y400 = '#FF991F';
+export const Y500 = '#FF8B00';
+export const G50 = '#E3FCEF';
+export const G75 = '#ABF5D1';
+export const G200 = '#57D9A3';
+export const G300 = '#36B37E';
+export const G400 = '#00875A';
+export const G500 = '#006644';
+export const B50 = '#DEEBFF';
+export const B75 = '#B3D4FF';
+export const B100 = '#4C9AFF';
+export const B400 = '#0052CC';
+export const B500 = '#0747A6';
+export const N0 = '#FFFFFF';
+export const N20 = '#F4F5F7';
+export const N30 = '#EBECF0';
+export const N40 = '#DFE1E6';
+export const N50 = '#C1C7D0';
+export const N60 = '#B3BAC5';
+export const N80 = '#97A0AF';
+export const N90 = '#8993A4';
+export const N200 = '#6B778C';
+export const N300 = '#5E6C84';
+export const N500 = '#42526E';
+export const N800 = '#172B4D';
+export const P50 = '#EAE6FF';
+export const P75 = '#C0B6F2';
+export const P100 = '#998DD9';
+export const P300 = '#6554C0';
+export const P400 = '#5243AA';
+export const P500 = '#403294';
+export const T50 = '#E6FCFF';
+export const T75 = '#B3F5FF';
+export const T100 = '#79E2F2';
+export const T300 = '#00B8D9';
+export const T500 = '#008DA6';
+/**
+ * @return String with HEX-coded color
+ */
+
+export function normalizeHexColor(color, defaultColor) {
+  if (!color) {
+    return null;
+  } // Normalize to hex
+
+
+  color = color.trim().toLowerCase();
+
+  if (isHex(color)) {
+    // Normalize 3-hex to 6-hex colours
+    if (color.length === 4) {
+      color = color.split('').map(c => c === '#' ? '#' : `${c}${c}`).join('');
+    }
+  } else if (isRgb(color)) {
+    return rgbToHex(color);
+  } else {
+    // http://dev.w3.org/csswg/css-color/#named-colors
+    if (color === 'default') {
+      return null;
+    } else if (namedColors.default && namedColors.default[color]) {
+      color = namedColors.default[color];
+    } else if (namedColors && namedColors[color]) {
+      color = namedColors[color];
+    } else {
+      return null;
+    }
+  }
+
+  if (color === defaultColor) {
+    return null;
+  }
+
+  return color;
+}
+/**
+ * Converts hex color format to rgb.
+ * Works well with full hex color format and shortcut as well.
+ *
+ * @param hex - hex color string (#xxx, or #xxxxxx)
+ */
+
+export function hexToRgb(color) {
+  if (!isHex(color)) {
+    return null;
+  }
+
+  let colorBits = color.substring(1).split('');
+
+  if (colorBits.length === 3) {
+    colorBits = [colorBits[0], colorBits[0], colorBits[1], colorBits[1], colorBits[2], colorBits[2]];
+  }
+
+  const rgb = Number(`0x${colorBits.join('')}`); // eslint-disable-next-line no-bitwise
+
+  return `rgb(${rgb >> 16 & 255},${rgb >> 8 & 255},${rgb & 255})`;
+}
+/**
+ * Converts hex color format to rgba.
+ *
+ * @param hex - hex color string (#xxx, or #xxxxxx)
+ */
+
+export function hexToRgba(rawColor, alpha) {
+  let color = normalizeHexColor(rawColor);
+
+  if (!color) {
+    return null;
+  }
+
+  const hex2rgb = color => color.match(/[a-z0-9]{2}/gi).map(hex => parseInt(hex, 16));
+
+  return `rgba(${hex2rgb(color).concat(alpha).join(',')})`;
+}
+export function rgbToHex(value) {
+  const matches = value.match(/(0?\.?\d{1,3})%?\b/g);
+
+  if (matches && matches.length >= 3) {
+    const [red, green, blue] = matches.map(Number);
+    return '#' + (blue | green << 8 | red << 16 | 1 << 24).toString(16).slice(1) // eslint-disable-line no-bitwise
+    ;
+  }
+
+  return null;
+}
+export function isRgb(color) {
+  return /rgba?\(/.test(color);
+}
+export function isHex(color) {
+  return /^#([A-Fa-f0-9]{3}){1,2}$/.test(color);
+}