@atlaskit/adf-schema
Version:
Shared package that contains the ADF-schema (json) and ProseMirror node/mark specs
307 lines (302 loc) • 11.5 kB
JavaScript
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
import { hasMergedColumns } from '../table-map';
function mergedRanges(first, second) {
var newRanges = [];
var firstLength = first.length;
var secondLength = second.length;
var i = 0;
var 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.apply(newRanges, _toConsumableArray(first.slice(i)));
}
if (j < secondLength) {
newRanges.push.apply(newRanges, _toConsumableArray(second.slice(i)));
}
return newRanges;
}
function increaseRowSpan(tr, rect, row) {
var map = rect.map,
tableStart = rect.tableStart;
for (var _col2 = 0; _col2 < map.width; _col2++) {
var index = row * map.width + _col2;
var pos = map.map[index];
var mappedPos = tr.mapping.map(pos + tableStart);
var attrs = tr.doc.nodeAt(mappedPos).attrs;
tr.setNodeMarkup(mappedPos, undefined, _objectSpread(_objectSpread({}, attrs), {}, {
rowspan: attrs.rowspan + 1
}));
_col2 += attrs.colspan - 1;
}
}
function decreaseRowspan(tr, rect, row, colToRemove) {
var skipRows = 0;
var map = rect.map,
table = rect.table,
tableStart = rect.tableStart;
for (var _col3 = 0; _col3 < map.width; _col3++) {
var index = row * map.width + _col3;
var 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
var mappedPos = tr.mapping.map(pos + tableStart);
var attrs = tr.doc.nodeAt(mappedPos).attrs;
tr.setNodeMarkup(mappedPos, undefined, _objectSpread(_objectSpread({}, attrs), {}, {
rowspan: attrs.rowspan - 1
}));
_col3 += attrs.colspan - 1;
} else if (_col3 === colToRemove) {
skipRows = table.nodeAt(pos).attrs.rowspan - 1;
}
}
return skipRows;
}
function isLastCellInRow(rect, row, col) {
var rowNode = rect.table.child(row);
if (!rowNode) {
return false;
}
return rowNode.childCount === 1 && !hasMergedColumns(rect.map, row, col);
}
function removeRowWithLastCell(tr, rect, row, _col) {
// Get row pos
var from = rect.tableStart;
for (var i = 0; i < row; i++) {
from += rect.table.child(i).nodeSize;
}
var rowNode = rect.table.child(row);
var 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
var skipRows = decreaseRowspan(tr, rect, row, _col);
return {
skipRows: skipRows,
row: {
from: from,
to: to,
rowNode: rowNode.copy(rowNode.content)
}
};
}
function addRow(tr, rect, prevRow, rowSideEffect) {
var cellNode = rowSideEffect.rowNode.child(0);
tr.insert(tr.mapping.map(rowSideEffect.from), rowSideEffect.rowNode);
increaseRowSpan(tr, rect, prevRow);
return cellNode.attrs.rowspan - 1;
}
export var RowsSideEffectHandler = /*#__PURE__*/function () {
function RowsSideEffectHandler(rowsSideEffect) {
var _this = this;
_classCallCheck(this, RowsSideEffectHandler);
_defineProperty(this, "deleteHandler", function () {
var newRows = [];
return {
handle: function handle(tr, rect, row, col, cell) {
if (!isLastCellInRow(rect, row, col)) {
return {
handled: false
};
}
var _removeRowWithLastCel = removeRowWithLastCell(tr, rect, row, col),
rowSideEffect = _removeRowWithLastCel.row,
skipRows = _removeRowWithLastCel.skipRows;
newRows.push(rowSideEffect);
return {
handled: true,
skipRows: skipRows
};
},
end: function end() {
if (newRows.length > 0) {
_this.rows = newRows;
} else {
_this.rows = undefined;
}
}
};
});
_defineProperty(this, "addHandler", function () {
var lastCellFrom = 0;
var i = 0;
return {
handle: function 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;
var skipRows;
var nextRow;
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: function end(tr, rect, col) {
if (!_this.rows || i >= _this.rows.length) {
return;
}
// Add rows at the end of the table
var nextRow;
while (nextRow = _this.rows[i]) {
addRow(tr, rect, rect.map.height - 1, nextRow);
i++;
}
}
};
});
this.rows = rowsSideEffect;
}
_createClass(RowsSideEffectHandler, [{
key: "start",
value: function start(isDelete) {
if (isDelete) {
return this.deleteHandler();
}
return this.addHandler();
}
}, {
key: "addRowRanges",
value: function addRowRanges(ranges, isDelete) {
if (!this.rows) {
return ranges;
}
var rowRanges = [];
var _iterator = _createForOfIteratorHelper(this.rows),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var _row = _step.value;
var from = _row.from,
to = _row.to;
if (isDelete) {
rowRanges.push(from, to - from, 0);
} else {
rowRanges.push(from, 0, to - from);
}
}
// Merged ranges
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
return mergedRanges(ranges, rowRanges);
}
}, {
key: "map",
value: function map(mapping) {
return [];
}
}, {
key: "invert",
value: function invert(originalDoc, isDelete, map) {
if (!this.rows) {
return;
}
var invertedRows = [];
var _iterator2 = _createForOfIteratorHelper(this.rows),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var _row2 = _step2.value;
if (isDelete) {
// Moving from delete to add keep the inverted rows + offset
var offset = map.map(_row2.from) - _row2.from;
invertedRows.push(_objectSpread(_objectSpread({}, _row2), {}, {
from: _row2.from + offset,
to: _row2.from + offset
}));
} else {
// Moving from add to delete keep
// TODO: I think we need to add the respective cell into the cellSteps...... not sure....
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
return invertedRows;
}
}, {
key: "toJSON",
value: function toJSON() {
if (!this.rows) {
return;
}
var rowsInJson = [];
var _iterator3 = _createForOfIteratorHelper(this.rows),
_step3;
try {
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
var _row3 = _step3.value;
rowsInJson.push({
from: _row3.from,
to: _row3.to,
rowNode: _row3.rowNode.toJSON()
});
}
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
return rowsInJson;
}
}], [{
key: "fromJSON",
value: function fromJSON(schema, json) {
var rowSideEffects = [];
var _iterator4 = _createForOfIteratorHelper(json),
_step4;
try {
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
var _row4 = _step4.value;
rowSideEffects.push({
from: _row4.from,
to: _row4.to,
rowNode: schema.nodeFromJSON(_row4.rowNode)
});
}
} catch (err) {
_iterator4.e(err);
} finally {
_iterator4.f();
}
return rowSideEffects;
}
}]);
return RowsSideEffectHandler;
}();