@atlaskit/adf-schema 19.2.0

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

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TableSideEffectHandler = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var TableSideEffectHandler = /*#__PURE__*/function () {
+  function TableSideEffectHandler(tableSideEffect) {
+    (0, _classCallCheck2.default)(this, TableSideEffectHandler);
+
+    if (tableSideEffect) {
+      this.table = tableSideEffect;
+    }
+  }
+
+  (0, _createClass2.default)(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 _prosemirrorTransform.StepMap([from, to - from, 0]);
+      }
+
+      return new _prosemirrorTransform.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;
+}();
+
+exports.TableSideEffectHandler = TableSideEffectHandler;

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

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasMergedColumns = hasMergedColumns;
+exports.hasMergedRows = hasMergedRows;
+exports.isRootRow = isRootRow;
+exports.isRootCol = isRootCol;
+exports.getCellIndex = void 0;
+
+var getCellIndex = function getCellIndex(map, row, col) {
+  return row * map.width + col;
+};
+
+exports.getCellIndex = getCellIndex;
+
+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];
+}
+
+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];
+}
+
+function isRootRow(map, row, col) {
+  var index = getCellIndex(map, row, col);
+  return row > 0 ? map.map[index - map.width] !== map.map[index] : true;
+}
+
+function isRootCol(map, row, col) {
+  var index = getCellIndex(map, row, col);
+  return row > 0 ? map.map[index - 1] !== map.map[index] : true;
+}

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

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InsertTypeAheadStep = exports.InsertTypeAheadStages = exports.insertTypeAheadStepType = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _prosemirrorModel = require("prosemirror-model");
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var insertTypeAheadStepType = 'atlaskit-insert-type-ahead';
+exports.insertTypeAheadStepType = insertTypeAheadStepType;
+var InsertTypeAheadStages;
+exports.InsertTypeAheadStages = InsertTypeAheadStages;
+
+(function (InsertTypeAheadStages) {
+  InsertTypeAheadStages["DELETING_RAW_QUERY"] = "DELETING_RAW_QUERY";
+  InsertTypeAheadStages["INSERTING_ITEM"] = "INSERTING_ITEM";
+})(InsertTypeAheadStages || (exports.InsertTypeAheadStages = InsertTypeAheadStages = {}));
+
+var InsertTypeAheadStep = /*#__PURE__*/function (_Step) {
+  (0, _inherits2.default)(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;
+    (0, _classCallCheck2.default)(this, InsertTypeAheadStep);
+    _this = _super.call(this);
+    _this.isInvertStep = isInvertStep;
+    _this.stage = stage;
+    _this.query = query;
+    _this.trigger = trigger;
+    _this.selectedIndex = selectedIndex;
+    return _this;
+  }
+
+  (0, _createClass2.default)(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 _prosemirrorTransform.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 _prosemirrorTransform.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 _prosemirrorTransform.ReplaceStep(0, 0, _prosemirrorModel.Slice.empty);
+    }
+  }]);
+  return InsertTypeAheadStep;
+}(_prosemirrorTransform.Step);
+/** Register this step with Prosemirror */
+
+
+exports.InsertTypeAheadStep = InsertTypeAheadStep;
+
+_prosemirrorTransform.Step.jsonID(insertTypeAheadStepType, InsertTypeAheadStep);

package/dist/cjs/steps.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TableSortOrder", {
+  enumerable: true,
+  get: function get() {
+    return _constants.SortOrder;
+  }
+});
+Object.defineProperty(exports, "TableSortStep", {
+  enumerable: true,
+  get: function get() {
+    return _sortColumn.TableSortStep;
+  }
+});
+Object.defineProperty(exports, "InsertTypeAheadStages", {
+  enumerable: true,
+  get: function get() {
+    return _typeAhead.InsertTypeAheadStages;
+  }
+});
+Object.defineProperty(exports, "InsertTypeAheadStep", {
+  enumerable: true,
+  get: function get() {
+    return _typeAhead.InsertTypeAheadStep;
+  }
+});
+Object.defineProperty(exports, "AddColumnStep", {
+  enumerable: true,
+  get: function get() {
+    return _addColumn.AddColumnStep;
+  }
+});
+Object.defineProperty(exports, "SetAttrsStep", {
+  enumerable: true,
+  get: function get() {
+    return _setAttrs.SetAttrsStep;
+  }
+});
+Object.defineProperty(exports, "AnalyticsStep", {
+  enumerable: true,
+  get: function get() {
+    return _analytics.AnalyticsStep;
+  }
+});
+
+var _constants = require("./steps/table/constants");
+
+var _sortColumn = require("./steps/table/sort-column");
+
+var _typeAhead = require("./steps/type-ahead");
+
+var _addColumn = require("./steps/table/add-column");
+
+var _setAttrs = require("./steps/set-attrs");
+
+var _analytics = require("./steps/analytics");

package/dist/cjs/utils/colors.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeHexColor = normalizeHexColor;
+exports.hexToRgb = hexToRgb;
+exports.hexToRgba = hexToRgba;
+exports.rgbToHex = rgbToHex;
+exports.isRgb = isRgb;
+exports.isHex = isHex;
+exports.T500 = exports.T300 = exports.T100 = exports.T75 = exports.T50 = exports.P500 = exports.P400 = exports.P300 = exports.P100 = exports.P75 = exports.P50 = exports.N800 = exports.N500 = exports.N300 = exports.N200 = exports.N90 = exports.N80 = exports.N60 = exports.N50 = exports.N40 = exports.N30 = exports.N20 = exports.N0 = exports.B500 = exports.B400 = exports.B100 = exports.B75 = exports.B50 = exports.G500 = exports.G400 = exports.G300 = exports.G200 = exports.G75 = exports.G50 = exports.Y500 = exports.Y400 = exports.Y200 = exports.Y75 = exports.Y50 = exports.R500 = exports.R400 = exports.R300 = exports.R100 = exports.R75 = exports.R50 = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var namedColors = _interopRequireWildcard(require("css-color-names"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+// 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
+ */
+var R50 = '#FFEBE6';
+exports.R50 = R50;
+var R75 = '#FFBDAD';
+exports.R75 = R75;
+var R100 = '#FF8F73';
+exports.R100 = R100;
+var R300 = '#FF5630';
+exports.R300 = R300;
+var R400 = '#DE350B';
+exports.R400 = R400;
+var R500 = '#BF2600';
+exports.R500 = R500;
+var Y50 = '#FFFAE6';
+exports.Y50 = Y50;
+var Y75 = '#FFF0B3';
+exports.Y75 = Y75;
+var Y200 = '#FFC400';
+exports.Y200 = Y200;
+var Y400 = '#FF991F';
+exports.Y400 = Y400;
+var Y500 = '#FF8B00';
+exports.Y500 = Y500;
+var G50 = '#E3FCEF';
+exports.G50 = G50;
+var G75 = '#ABF5D1';
+exports.G75 = G75;
+var G200 = '#57D9A3';
+exports.G200 = G200;
+var G300 = '#36B37E';
+exports.G300 = G300;
+var G400 = '#00875A';
+exports.G400 = G400;
+var G500 = '#006644';
+exports.G500 = G500;
+var B50 = '#DEEBFF';
+exports.B50 = B50;
+var B75 = '#B3D4FF';
+exports.B75 = B75;
+var B100 = '#4C9AFF';
+exports.B100 = B100;
+var B400 = '#0052CC';
+exports.B400 = B400;
+var B500 = '#0747A6';
+exports.B500 = B500;
+var N0 = '#FFFFFF';
+exports.N0 = N0;
+var N20 = '#F4F5F7';
+exports.N20 = N20;
+var N30 = '#EBECF0';
+exports.N30 = N30;
+var N40 = '#DFE1E6';
+exports.N40 = N40;
+var N50 = '#C1C7D0';
+exports.N50 = N50;
+var N60 = '#B3BAC5';
+exports.N60 = N60;
+var N80 = '#97A0AF';
+exports.N80 = N80;
+var N90 = '#8993A4';
+exports.N90 = N90;
+var N200 = '#6B778C';
+exports.N200 = N200;
+var N300 = '#5E6C84';
+exports.N300 = N300;
+var N500 = '#42526E';
+exports.N500 = N500;
+var N800 = '#172B4D';
+exports.N800 = N800;
+var P50 = '#EAE6FF';
+exports.P50 = P50;
+var P75 = '#C0B6F2';
+exports.P75 = P75;
+var P100 = '#998DD9';
+exports.P100 = P100;
+var P300 = '#6554C0';
+exports.P300 = P300;
+var P400 = '#5243AA';
+exports.P400 = P400;
+var P500 = '#403294';
+exports.P500 = P500;
+var T50 = '#E6FCFF';
+exports.T50 = T50;
+var T75 = '#B3F5FF';
+exports.T75 = T75;
+var T100 = '#79E2F2';
+exports.T100 = T100;
+var T300 = '#00B8D9';
+exports.T300 = T300;
+var T500 = '#008DA6';
+/**
+ * @return String with HEX-coded color
+ */
+
+exports.T500 = T500;
+
+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)
+ */
+
+
+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)
+ */
+
+
+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(','), ")");
+}
+
+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 = (0, _slicedToArray2.default)(_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;
+}
+
+function isRgb(color) {
+  return /rgba?\(/.test(color);
+}
+
+function isHex(color) {
+  return /^#([A-Fa-f0-9]{3}){1,2}$/.test(color);
+}