@atlaskit/adf-schema 19.2.0

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

@@ -0,0 +1,113 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { StepMap } from 'prosemirror-transform';
+export var TableSideEffectHandler = /*#__PURE__*/function () {
+  function TableSideEffectHandler(tableSideEffect) {
+    _classCallCheck(this, TableSideEffectHandler);
+
+    if (tableSideEffect) {
+      this.table = tableSideEffect;
+    }
+  }
+
+  _createClass(TableSideEffectHandler, [{
+    key: "addTableSideEffect",
+    value: function addTableSideEffect(from, to, node) {
+      this.table = {
+        from: from,
+        to: to,
+        node: node
+      };
+    }
+  }, {
+    key: "handleAddTable",
+    value: function handleAddTable(tr, isDelete) {
+      if (isDelete || !this.table) {
+        return false;
+      }
+
+      tr.insert(this.table.from, this.table.node);
+      return true;
+    }
+  }, {
+    key: "handleRemoveTable",
+    value: function 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;
+    }
+  }, {
+    key: "getTableMap",
+    value: function getTableMap(isDelete) {
+      if (!this.table) {
+        return;
+      }
+
+      var _this$table = this.table,
+          from = _this$table.from,
+          to = _this$table.to;
+
+      if (isDelete) {
+        return new StepMap([from, to - from, 0]);
+      }
+
+      return new StepMap([from, 0, to - from]);
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      if (!this.table) {
+        return;
+      }
+
+      return {
+        from: mapping.map(this.table.from),
+        to: mapping.map(this.table.to),
+        node: this.table.node
+      };
+    }
+  }, {
+    key: "invert",
+    value: function invert(doc) {
+      if (!this.table) {
+        return;
+      }
+
+      var tableNode = doc.nodeAt(this.table.from);
+      return {
+        from: this.table.from,
+        to: this.table.from + tableNode.nodeSize,
+        node: tableNode.copy(tableNode.content)
+      };
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      if (!this.table) {
+        return;
+      }
+
+      return {
+        from: this.table.from,
+        to: this.table.to,
+        node: this.table.node.toJSON()
+      };
+    }
+  }], [{
+    key: "fromJSON",
+    value: function fromJSON(schema, json) {
+      return {
+        from: json.from,
+        to: json.to,
+        node: schema.nodeFromJSON(json.node)
+      };
+    }
+  }]);
+
+  return TableSideEffectHandler;
+}();

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

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

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

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

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

@@ -0,0 +1,117 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import { Slice } from 'prosemirror-model';
+import { ReplaceStep, Step, StepMap, StepResult } from 'prosemirror-transform';
+export var insertTypeAheadStepType = 'atlaskit-insert-type-ahead';
+export var InsertTypeAheadStages;
+
+(function (InsertTypeAheadStages) {
+  InsertTypeAheadStages["DELETING_RAW_QUERY"] = "DELETING_RAW_QUERY";
+  InsertTypeAheadStages["INSERTING_ITEM"] = "INSERTING_ITEM";
+})(InsertTypeAheadStages || (InsertTypeAheadStages = {}));
+
+export var InsertTypeAheadStep = /*#__PURE__*/function (_Step) {
+  _inherits(InsertTypeAheadStep, _Step);
+
+  var _super = _createSuper(InsertTypeAheadStep);
+
+  function InsertTypeAheadStep(_ref) {
+    var _this;
+
+    var stage = _ref.stage,
+        query = _ref.query,
+        trigger = _ref.trigger,
+        selectedIndex = _ref.selectedIndex;
+    var isInvertStep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+    _classCallCheck(this, InsertTypeAheadStep);
+
+    _this = _super.call(this);
+    _this.isInvertStep = isInvertStep;
+    _this.stage = stage;
+    _this.query = query;
+    _this.trigger = trigger;
+    _this.selectedIndex = selectedIndex;
+    return _this;
+  }
+
+  _createClass(InsertTypeAheadStep, [{
+    key: "invert",
+    value: function invert() {
+      var config = {
+        stage: this.stage,
+        query: this.query,
+        trigger: this.trigger,
+        selectedIndex: this.selectedIndex
+      };
+      return new InsertTypeAheadStep(config, !this.isInvertStep);
+    }
+  }, {
+    key: "apply",
+    value: function apply(doc) {
+      return StepResult.ok(doc);
+    }
+  }, {
+    key: "merge",
+    value: function merge() {
+      return null;
+    }
+  }, {
+    key: "isInsertionStep",
+    value: function isInsertionStep() {
+      return !this.isInvertStep;
+    }
+  }, {
+    key: "isUndoingStep",
+    value: function isUndoingStep() {
+      return this.isInvertStep;
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      var 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);
+    }
+  }, {
+    key: "getMap",
+    value: function getMap() {
+      return new StepMap([0, 0, 0]);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      // When serialized we should create a noop Replace step
+      return {
+        stepType: 'replace',
+        from: 0,
+        to: 0
+      };
+    }
+  }], [{
+    key: "fromJSON",
+    value: function 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);
+    }
+  }]);
+
+  return InsertTypeAheadStep;
+}(Step);
+/** Register this step with Prosemirror */
+
+Step.jsonID(insertTypeAheadStepType, InsertTypeAheadStep);

package/dist/esm/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/esm/utils/colors.js

@@ -0,0 +1,160 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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 var R50 = '#FFEBE6';
+export var R75 = '#FFBDAD';
+export var R100 = '#FF8F73';
+export var R300 = '#FF5630';
+export var R400 = '#DE350B';
+export var R500 = '#BF2600';
+export var Y50 = '#FFFAE6';
+export var Y75 = '#FFF0B3';
+export var Y200 = '#FFC400';
+export var Y400 = '#FF991F';
+export var Y500 = '#FF8B00';
+export var G50 = '#E3FCEF';
+export var G75 = '#ABF5D1';
+export var G200 = '#57D9A3';
+export var G300 = '#36B37E';
+export var G400 = '#00875A';
+export var G500 = '#006644';
+export var B50 = '#DEEBFF';
+export var B75 = '#B3D4FF';
+export var B100 = '#4C9AFF';
+export var B400 = '#0052CC';
+export var B500 = '#0747A6';
+export var N0 = '#FFFFFF';
+export var N20 = '#F4F5F7';
+export var N30 = '#EBECF0';
+export var N40 = '#DFE1E6';
+export var N50 = '#C1C7D0';
+export var N60 = '#B3BAC5';
+export var N80 = '#97A0AF';
+export var N90 = '#8993A4';
+export var N200 = '#6B778C';
+export var N300 = '#5E6C84';
+export var N500 = '#42526E';
+export var N800 = '#172B4D';
+export var P50 = '#EAE6FF';
+export var P75 = '#C0B6F2';
+export var P100 = '#998DD9';
+export var P300 = '#6554C0';
+export var P400 = '#5243AA';
+export var P500 = '#403294';
+export var T50 = '#E6FCFF';
+export var T75 = '#B3F5FF';
+export var T100 = '#79E2F2';
+export var T300 = '#00B8D9';
+export var 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(function (c) {
+        return c === '#' ? '#' : "".concat(c).concat(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;
+  }
+
+  var colorBits = color.substring(1).split('');
+
+  if (colorBits.length === 3) {
+    colorBits = [colorBits[0], colorBits[0], colorBits[1], colorBits[1], colorBits[2], colorBits[2]];
+  }
+
+  var rgb = Number("0x".concat(colorBits.join(''))); // eslint-disable-next-line no-bitwise
+
+  return "rgb(".concat(rgb >> 16 & 255, ",").concat(rgb >> 8 & 255, ",").concat(rgb & 255, ")");
+}
+/**
+ * Converts hex color format to rgba.
+ *
+ * @param hex - hex color string (#xxx, or #xxxxxx)
+ */
+
+export function hexToRgba(rawColor, alpha) {
+  var color = normalizeHexColor(rawColor);
+
+  if (!color) {
+    return null;
+  }
+
+  var hex2rgb = function hex2rgb(color) {
+    return color.match(/[a-z0-9]{2}/gi).map(function (hex) {
+      return parseInt(hex, 16);
+    });
+  };
+
+  return "rgba(".concat(hex2rgb(color).concat(alpha).join(','), ")");
+}
+export function rgbToHex(value) {
+  var matches = value.match(/(0?\.?\d{1,3})%?\b/g);
+
+  if (matches && matches.length >= 3) {
+    var _matches$map = matches.map(Number),
+        _matches$map2 = _slicedToArray(_matches$map, 3),
+        red = _matches$map2[0],
+        green = _matches$map2[1],
+        blue = _matches$map2[2];
+
+    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);
+}

package/dist/esm/utils/confluence/emoji.js

@@ -0,0 +1,85 @@
+// Default emoji id for Confluence glyphs that has no match to Fabric Emoji
+var DEFAULT_EMOJI_ID = '2b50'; // Default ac:name for emoticons as a fallback is `blue-star`
+
+var DEFAULT_EMOJI_ACNAME = 'blue-star'; // ac:hipchat-emoticon prefix when converting to Emoji ID
+
+var HC_EMOTICON_PREFIX = 'atlassian-';
+/**
+ * Confluence glyphs ac:name of <ac:emoticon /> map to new emojis
+ * {
+ *   [ac:name] : ['emoji-id', 'emoji-shortName', 'emoji-fallback']
+ *   ...
+ * }
+ * Glyphs that do not map to Fabric Emoji
+ * will be mapped to Emoji Id '2b50' (:star:) with preserving ac:name as shortName attribute;
+ */
+
+var acNameToEmojiMap = {
+  smile: ['1f642', ':slight_smile:', "\uD83D\uDE42"],
+  sad: ['1f641', ':slight_frown:', "\uD83D\uDE41"],
+  cheeky: ['1f61b', ':stuck_out_tongue:', "\uD83D\uDE1B"],
+  laugh: ['1f600', ':grinning:', "\uD83D\uDE00"],
+  wink: ['1f609', ':wink:', "\uD83D\uDE09"],
+  information: ['2139', ':information_source:', "\u2139"],
+  tick: ['2705', ':white_check_mark:', "\u2705"],
+  cross: ['274c', ':x:', "\u274C"],
+  warning: ['26a0', ':warning:', "\u26A0"],
+  plus: ['2795', ':heavy_plus_sign:', "\u2795"],
+  minus: ['2796', ':heavy_minus_sign:', "\u2796"],
+  question: ['2753', ':question:', "?"],
+  'thumbs-up': ['1f44d', ':thumbsup:', "\uD83D\uDC4D"],
+  'thumbs-down': ['1f44e', ':thumbsdown:', "\uD83D\uDC4E"],
+  'light-on': ['1f4a1', ':bulb:', "\uD83D\uDCA1"],
+  'yellow-star': ['2b50', ':star:', "\uD83D\uDC9B"],
+  'light-off': ['1f6ab', ':no_entry_sign:', "\uD83D\uDEAB"],
+  'red-star': ['2764', ':heart:', "\u2764\uFE0F"],
+  'green-star': ['1f49a', ':green_heart:', "\uD83D\uDC9A"],
+  'blue-star': ['1f499', ':blue_heart:', "\uD83D\uDC99"],
+  heart: ['2764', ':heart:', "\u2764\uFE0F"],
+  'broken-heart': ['1f494', ':broken_heart:', "\uD83D\uDC94"]
+};
+export function acNameToEmoji(acName) {
+  var emojiData = acNameToEmojiMap[acName];
+  return emojiData ? {
+    id: emojiData[0],
+    shortName: emojiData[1],
+    text: emojiData[2]
+  } : {
+    id: DEFAULT_EMOJI_ID,
+    shortName: ":".concat(acName, ":"),
+    text: ''
+  };
+}
+export function emojiIdToAcName(emojiId) {
+  var filterEmojis = function filterEmojis(acName) {
+    return acNameToEmojiMap[acName] ? acNameToEmojiMap[acName][0] === emojiId : false;
+  };
+
+  return Object.keys(acNameToEmojiMap).filter(filterEmojis)[0];
+}
+export function acShortcutToEmoji(hipchatEmoticonShortName) {
+  return {
+    id: "".concat(HC_EMOTICON_PREFIX).concat(hipchatEmoticonShortName),
+    shortName: ":".concat(hipchatEmoticonShortName, ":"),
+    text: ''
+  };
+}
+
+function getAcNameFromShortName(shortName) {
+  return shortName.slice(shortName[0] === ':' ? 1 : 0, shortName[shortName.length - 1] === ':' ? -1 : shortName.length);
+}
+
+export function getEmojiAcName(_ref) {
+  var id = _ref.id,
+      shortName = _ref.shortName;
+
+  if (DEFAULT_EMOJI_ID === id) {
+    var possibleName = getAcNameFromShortName(shortName);
+
+    if (possibleName in acNameToEmojiMap) {
+      return possibleName;
+    }
+  }
+
+  return emojiIdToAcName(id) || DEFAULT_EMOJI_ACNAME;
+}