gdpr audit implemented, email log, vollmachten, pdf delete cancel data privacy and vollmachten, removed message no id card in engergy car, and other contracts that are not telecom contracts, added insert counter for engery
This commit is contained in:
+382
@@ -0,0 +1,382 @@
|
||||
'use strict';
|
||||
|
||||
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
|
||||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
||||
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
|
||||
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
|
||||
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
|
||||
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
|
||||
var RopeSequence = require('rope-sequence');
|
||||
var prosemirrorTransform = require('prosemirror-transform');
|
||||
var prosemirrorState = require('prosemirror-state');
|
||||
var max_empty_items = 500;
|
||||
var Branch = function () {
|
||||
function Branch(items, eventCount) {
|
||||
_classCallCheck(this, Branch);
|
||||
this.items = items;
|
||||
this.eventCount = eventCount;
|
||||
}
|
||||
_createClass(Branch, [{
|
||||
key: "popEvent",
|
||||
value: function popEvent(state, preserveItems) {
|
||||
var _this = this;
|
||||
if (this.eventCount == 0) return null;
|
||||
var end = this.items.length;
|
||||
for (;; end--) {
|
||||
var next = this.items.get(end - 1);
|
||||
if (next.selection) {
|
||||
--end;
|
||||
break;
|
||||
}
|
||||
}
|
||||
var remap, mapFrom;
|
||||
if (preserveItems) {
|
||||
remap = this.remapping(end, this.items.length);
|
||||
mapFrom = remap.maps.length;
|
||||
}
|
||||
var transform = state.tr;
|
||||
var selection, remaining;
|
||||
var addAfter = [],
|
||||
addBefore = [];
|
||||
this.items.forEach(function (item, i) {
|
||||
if (!item.step) {
|
||||
if (!remap) {
|
||||
remap = _this.remapping(end, i + 1);
|
||||
mapFrom = remap.maps.length;
|
||||
}
|
||||
mapFrom--;
|
||||
addBefore.push(item);
|
||||
return;
|
||||
}
|
||||
if (remap) {
|
||||
addBefore.push(new Item(item.map));
|
||||
var step = item.step.map(remap.slice(mapFrom)),
|
||||
map;
|
||||
if (step && transform.maybeStep(step).doc) {
|
||||
map = transform.mapping.maps[transform.mapping.maps.length - 1];
|
||||
addAfter.push(new Item(map, undefined, undefined, addAfter.length + addBefore.length));
|
||||
}
|
||||
mapFrom--;
|
||||
if (map) remap.appendMap(map, mapFrom);
|
||||
} else {
|
||||
transform.maybeStep(item.step);
|
||||
}
|
||||
if (item.selection) {
|
||||
selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
|
||||
remaining = new Branch(_this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), _this.eventCount - 1);
|
||||
return false;
|
||||
}
|
||||
}, this.items.length, 0);
|
||||
return {
|
||||
remaining: remaining,
|
||||
transform: transform,
|
||||
selection: selection
|
||||
};
|
||||
}
|
||||
}, {
|
||||
key: "addTransform",
|
||||
value: function addTransform(transform, selection, histOptions, preserveItems) {
|
||||
var newItems = [],
|
||||
eventCount = this.eventCount;
|
||||
var oldItems = this.items,
|
||||
lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
|
||||
for (var i = 0; i < transform.steps.length; i++) {
|
||||
var step = transform.steps[i].invert(transform.docs[i]);
|
||||
var item = new Item(transform.mapping.maps[i], step, selection),
|
||||
merged = void 0;
|
||||
if (merged = lastItem && lastItem.merge(item)) {
|
||||
item = merged;
|
||||
if (i) newItems.pop();else oldItems = oldItems.slice(0, oldItems.length - 1);
|
||||
}
|
||||
newItems.push(item);
|
||||
if (selection) {
|
||||
eventCount++;
|
||||
selection = undefined;
|
||||
}
|
||||
if (!preserveItems) lastItem = item;
|
||||
}
|
||||
var overflow = eventCount - histOptions.depth;
|
||||
if (overflow > DEPTH_OVERFLOW) {
|
||||
oldItems = cutOffEvents(oldItems, overflow);
|
||||
eventCount -= overflow;
|
||||
}
|
||||
return new Branch(oldItems.append(newItems), eventCount);
|
||||
}
|
||||
}, {
|
||||
key: "remapping",
|
||||
value: function remapping(from, to) {
|
||||
var maps = new prosemirrorTransform.Mapping();
|
||||
this.items.forEach(function (item, i) {
|
||||
var mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from ? maps.maps.length - item.mirrorOffset : undefined;
|
||||
maps.appendMap(item.map, mirrorPos);
|
||||
}, from, to);
|
||||
return maps;
|
||||
}
|
||||
}, {
|
||||
key: "addMaps",
|
||||
value: function addMaps(array) {
|
||||
if (this.eventCount == 0) return this;
|
||||
return new Branch(this.items.append(array.map(function (map) {
|
||||
return new Item(map);
|
||||
})), this.eventCount);
|
||||
}
|
||||
}, {
|
||||
key: "rebased",
|
||||
value: function rebased(rebasedTransform, rebasedCount) {
|
||||
if (!this.eventCount) return this;
|
||||
var rebasedItems = [],
|
||||
start = Math.max(0, this.items.length - rebasedCount);
|
||||
var mapping = rebasedTransform.mapping;
|
||||
var newUntil = rebasedTransform.steps.length;
|
||||
var eventCount = this.eventCount;
|
||||
this.items.forEach(function (item) {
|
||||
if (item.selection) eventCount--;
|
||||
}, start);
|
||||
var iRebased = rebasedCount;
|
||||
this.items.forEach(function (item) {
|
||||
var pos = mapping.getMirror(--iRebased);
|
||||
if (pos == null) return;
|
||||
newUntil = Math.min(newUntil, pos);
|
||||
var map = mapping.maps[pos];
|
||||
if (item.step) {
|
||||
var step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
|
||||
var selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
|
||||
if (selection) eventCount++;
|
||||
rebasedItems.push(new Item(map, step, selection));
|
||||
} else {
|
||||
rebasedItems.push(new Item(map));
|
||||
}
|
||||
}, start);
|
||||
var newMaps = [];
|
||||
for (var i = rebasedCount; i < newUntil; i++) newMaps.push(new Item(mapping.maps[i]));
|
||||
var items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
|
||||
var branch = new Branch(items, eventCount);
|
||||
if (branch.emptyItemCount() > max_empty_items) branch = branch.compress(this.items.length - rebasedItems.length);
|
||||
return branch;
|
||||
}
|
||||
}, {
|
||||
key: "emptyItemCount",
|
||||
value: function emptyItemCount() {
|
||||
var count = 0;
|
||||
this.items.forEach(function (item) {
|
||||
if (!item.step) count++;
|
||||
});
|
||||
return count;
|
||||
}
|
||||
}, {
|
||||
key: "compress",
|
||||
value: function compress() {
|
||||
var upto = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.items.length;
|
||||
var remap = this.remapping(0, upto),
|
||||
mapFrom = remap.maps.length;
|
||||
var items = [],
|
||||
events = 0;
|
||||
this.items.forEach(function (item, i) {
|
||||
if (i >= upto) {
|
||||
items.push(item);
|
||||
if (item.selection) events++;
|
||||
} else if (item.step) {
|
||||
var step = item.step.map(remap.slice(mapFrom)),
|
||||
map = step && step.getMap();
|
||||
mapFrom--;
|
||||
if (map) remap.appendMap(map, mapFrom);
|
||||
if (step) {
|
||||
var selection = item.selection && item.selection.map(remap.slice(mapFrom));
|
||||
if (selection) events++;
|
||||
var newItem = new Item(map.invert(), step, selection),
|
||||
merged,
|
||||
last = items.length - 1;
|
||||
if (merged = items.length && items[last].merge(newItem)) items[last] = merged;else items.push(newItem);
|
||||
}
|
||||
} else if (item.map) {
|
||||
mapFrom--;
|
||||
}
|
||||
}, this.items.length, 0);
|
||||
return new Branch(RopeSequence.from(items.reverse()), events);
|
||||
}
|
||||
}]);
|
||||
return Branch;
|
||||
}();
|
||||
Branch.empty = new Branch(RopeSequence.empty, 0);
|
||||
function cutOffEvents(items, n) {
|
||||
var cutPoint;
|
||||
items.forEach(function (item, i) {
|
||||
if (item.selection && n-- == 0) {
|
||||
cutPoint = i;
|
||||
return false;
|
||||
}
|
||||
});
|
||||
return items.slice(cutPoint);
|
||||
}
|
||||
var Item = function () {
|
||||
function Item(map, step, selection, mirrorOffset) {
|
||||
_classCallCheck(this, Item);
|
||||
this.map = map;
|
||||
this.step = step;
|
||||
this.selection = selection;
|
||||
this.mirrorOffset = mirrorOffset;
|
||||
}
|
||||
_createClass(Item, [{
|
||||
key: "merge",
|
||||
value: function merge(other) {
|
||||
if (this.step && other.step && !other.selection) {
|
||||
var step = other.step.merge(this.step);
|
||||
if (step) return new Item(step.getMap().invert(), step, this.selection);
|
||||
}
|
||||
}
|
||||
}]);
|
||||
return Item;
|
||||
}();
|
||||
var HistoryState = _createClass(function HistoryState(done, undone, prevRanges, prevTime, prevComposition) {
|
||||
_classCallCheck(this, HistoryState);
|
||||
this.done = done;
|
||||
this.undone = undone;
|
||||
this.prevRanges = prevRanges;
|
||||
this.prevTime = prevTime;
|
||||
this.prevComposition = prevComposition;
|
||||
});
|
||||
var DEPTH_OVERFLOW = 20;
|
||||
function applyTransaction(history, state, tr, options) {
|
||||
var historyTr = tr.getMeta(historyKey),
|
||||
rebased;
|
||||
if (historyTr) return historyTr.historyState;
|
||||
if (tr.getMeta(closeHistoryKey)) history = new HistoryState(history.done, history.undone, null, 0, -1);
|
||||
var appended = tr.getMeta("appendedTransaction");
|
||||
if (tr.steps.length == 0) {
|
||||
return history;
|
||||
} else if (appended && appended.getMeta(historyKey)) {
|
||||
if (appended.getMeta(historyKey).redo) return new HistoryState(history.done.addTransform(tr, undefined, options, mustPreserveItems(state)), history.undone, rangesFor(tr.mapping.maps), history.prevTime, history.prevComposition);else return new HistoryState(history.done, history.undone.addTransform(tr, undefined, options, mustPreserveItems(state)), null, history.prevTime, history.prevComposition);
|
||||
} else if (tr.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
|
||||
var composition = tr.getMeta("composition");
|
||||
var newGroup = history.prevTime == 0 || !appended && history.prevComposition != composition && (history.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history.prevRanges));
|
||||
var prevRanges = appended ? mapRanges(history.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps);
|
||||
return new HistoryState(history.done.addTransform(tr, newGroup ? state.selection.getBookmark() : undefined, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history.prevComposition : composition);
|
||||
} else if (rebased = tr.getMeta("rebased")) {
|
||||
return new HistoryState(history.done.rebased(tr, rebased), history.undone.rebased(tr, rebased), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);
|
||||
} else {
|
||||
return new HistoryState(history.done.addMaps(tr.mapping.maps), history.undone.addMaps(tr.mapping.maps), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);
|
||||
}
|
||||
}
|
||||
function isAdjacentTo(transform, prevRanges) {
|
||||
if (!prevRanges) return false;
|
||||
if (!transform.docChanged) return true;
|
||||
var adjacent = false;
|
||||
transform.mapping.maps[0].forEach(function (start, end) {
|
||||
for (var i = 0; i < prevRanges.length; i += 2) if (start <= prevRanges[i + 1] && end >= prevRanges[i]) adjacent = true;
|
||||
});
|
||||
return adjacent;
|
||||
}
|
||||
function rangesFor(maps) {
|
||||
var result = [];
|
||||
for (var i = maps.length - 1; i >= 0 && result.length == 0; i--) maps[i].forEach(function (_from, _to, from, to) {
|
||||
return result.push(from, to);
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function mapRanges(ranges, mapping) {
|
||||
if (!ranges) return null;
|
||||
var result = [];
|
||||
for (var i = 0; i < ranges.length; i += 2) {
|
||||
var from = mapping.map(ranges[i], 1),
|
||||
to = mapping.map(ranges[i + 1], -1);
|
||||
if (from <= to) result.push(from, to);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function histTransaction(history, state, redo) {
|
||||
var preserveItems = mustPreserveItems(state);
|
||||
var histOptions = historyKey.get(state).spec.config;
|
||||
var pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);
|
||||
if (!pop) return null;
|
||||
var selection = pop.selection.resolve(pop.transform.doc);
|
||||
var added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
|
||||
var newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0, -1);
|
||||
return pop.transform.setSelection(selection).setMeta(historyKey, {
|
||||
redo: redo,
|
||||
historyState: newHist
|
||||
});
|
||||
}
|
||||
var cachedPreserveItems = false,
|
||||
cachedPreserveItemsPlugins = null;
|
||||
function mustPreserveItems(state) {
|
||||
var plugins = state.plugins;
|
||||
if (cachedPreserveItemsPlugins != plugins) {
|
||||
cachedPreserveItems = false;
|
||||
cachedPreserveItemsPlugins = plugins;
|
||||
for (var i = 0; i < plugins.length; i++) if (plugins[i].spec.historyPreserveItems) {
|
||||
cachedPreserveItems = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return cachedPreserveItems;
|
||||
}
|
||||
function closeHistory(tr) {
|
||||
return tr.setMeta(closeHistoryKey, true);
|
||||
}
|
||||
var historyKey = new prosemirrorState.PluginKey("history");
|
||||
var closeHistoryKey = new prosemirrorState.PluginKey("closeHistory");
|
||||
function history() {
|
||||
var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
||||
config = {
|
||||
depth: config.depth || 100,
|
||||
newGroupDelay: config.newGroupDelay || 500
|
||||
};
|
||||
return new prosemirrorState.Plugin({
|
||||
key: historyKey,
|
||||
state: {
|
||||
init: function init() {
|
||||
return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);
|
||||
},
|
||||
apply: function apply(tr, hist, state) {
|
||||
return applyTransaction(hist, state, tr, config);
|
||||
}
|
||||
},
|
||||
config: config,
|
||||
props: {
|
||||
handleDOMEvents: {
|
||||
beforeinput: function beforeinput(view, e) {
|
||||
var inputType = e.inputType;
|
||||
var command = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
|
||||
if (!command || !view.editable) return false;
|
||||
e.preventDefault();
|
||||
return command(view.state, view.dispatch);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
function buildCommand(redo, scroll) {
|
||||
return function (state, dispatch) {
|
||||
var hist = historyKey.getState(state);
|
||||
if (!hist || (redo ? hist.undone : hist.done).eventCount == 0) return false;
|
||||
if (dispatch) {
|
||||
var tr = histTransaction(hist, state, redo);
|
||||
if (tr) dispatch(scroll ? tr.scrollIntoView() : tr);
|
||||
}
|
||||
return true;
|
||||
};
|
||||
}
|
||||
var undo = buildCommand(false, true);
|
||||
var redo = buildCommand(true, true);
|
||||
var undoNoScroll = buildCommand(false, false);
|
||||
var redoNoScroll = buildCommand(true, false);
|
||||
function undoDepth(state) {
|
||||
var hist = historyKey.getState(state);
|
||||
return hist ? hist.done.eventCount : 0;
|
||||
}
|
||||
function redoDepth(state) {
|
||||
var hist = historyKey.getState(state);
|
||||
return hist ? hist.undone.eventCount : 0;
|
||||
}
|
||||
function isHistoryTransaction(tr) {
|
||||
return tr.getMeta(historyKey) != null;
|
||||
}
|
||||
exports.closeHistory = closeHistory;
|
||||
exports.history = history;
|
||||
exports.isHistoryTransaction = isHistoryTransaction;
|
||||
exports.redo = redo;
|
||||
exports.redoDepth = redoDepth;
|
||||
exports.redoNoScroll = redoNoScroll;
|
||||
exports.undo = undo;
|
||||
exports.undoDepth = undoDepth;
|
||||
exports.undoNoScroll = undoNoScroll;
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
import { Transaction, Plugin, Command, EditorState } from 'prosemirror-state';
|
||||
|
||||
/**
|
||||
Set a flag on the given transaction that will prevent further steps
|
||||
from being appended to an existing history event (so that they
|
||||
require a separate undo command to undo).
|
||||
*/
|
||||
declare function closeHistory(tr: Transaction): Transaction;
|
||||
interface HistoryOptions {
|
||||
/**
|
||||
The amount of history events that are collected before the
|
||||
oldest events are discarded. Defaults to 100.
|
||||
*/
|
||||
depth?: number;
|
||||
/**
|
||||
The delay between changes after which a new group should be
|
||||
started. Defaults to 500 (milliseconds). Note that when changes
|
||||
aren't adjacent, a new group is always started.
|
||||
*/
|
||||
newGroupDelay?: number;
|
||||
}
|
||||
/**
|
||||
Returns a plugin that enables the undo history for an editor. The
|
||||
plugin will track undo and redo stacks, which can be used with the
|
||||
[`undo`](https://prosemirror.net/docs/ref/#history.undo) and [`redo`](https://prosemirror.net/docs/ref/#history.redo) commands.
|
||||
|
||||
You can set an `"addToHistory"` [metadata
|
||||
property](https://prosemirror.net/docs/ref/#state.Transaction.setMeta) of `false` on a transaction
|
||||
to prevent it from being rolled back by undo.
|
||||
*/
|
||||
declare function history(config?: HistoryOptions): Plugin;
|
||||
/**
|
||||
A command function that undoes the last change, if any.
|
||||
*/
|
||||
declare const undo: Command;
|
||||
/**
|
||||
A command function that redoes the last undone change, if any.
|
||||
*/
|
||||
declare const redo: Command;
|
||||
/**
|
||||
A command function that undoes the last change. Don't scroll the
|
||||
selection into view.
|
||||
*/
|
||||
declare const undoNoScroll: Command;
|
||||
/**
|
||||
A command function that redoes the last undone change. Don't
|
||||
scroll the selection into view.
|
||||
*/
|
||||
declare const redoNoScroll: Command;
|
||||
/**
|
||||
The amount of undoable events available in a given state.
|
||||
*/
|
||||
declare function undoDepth(state: EditorState): any;
|
||||
/**
|
||||
The amount of redoable events available in a given editor state.
|
||||
*/
|
||||
declare function redoDepth(state: EditorState): any;
|
||||
/**
|
||||
Returns true if the given transaction was generated by the history
|
||||
plugin.
|
||||
*/
|
||||
declare function isHistoryTransaction(tr: Transaction): boolean;
|
||||
|
||||
export { closeHistory, history, isHistoryTransaction, redo, redoDepth, redoNoScroll, undo, undoDepth, undoNoScroll };
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
import { Transaction, Plugin, Command, EditorState } from 'prosemirror-state';
|
||||
|
||||
/**
|
||||
Set a flag on the given transaction that will prevent further steps
|
||||
from being appended to an existing history event (so that they
|
||||
require a separate undo command to undo).
|
||||
*/
|
||||
declare function closeHistory(tr: Transaction): Transaction;
|
||||
interface HistoryOptions {
|
||||
/**
|
||||
The amount of history events that are collected before the
|
||||
oldest events are discarded. Defaults to 100.
|
||||
*/
|
||||
depth?: number;
|
||||
/**
|
||||
The delay between changes after which a new group should be
|
||||
started. Defaults to 500 (milliseconds). Note that when changes
|
||||
aren't adjacent, a new group is always started.
|
||||
*/
|
||||
newGroupDelay?: number;
|
||||
}
|
||||
/**
|
||||
Returns a plugin that enables the undo history for an editor. The
|
||||
plugin will track undo and redo stacks, which can be used with the
|
||||
[`undo`](https://prosemirror.net/docs/ref/#history.undo) and [`redo`](https://prosemirror.net/docs/ref/#history.redo) commands.
|
||||
|
||||
You can set an `"addToHistory"` [metadata
|
||||
property](https://prosemirror.net/docs/ref/#state.Transaction.setMeta) of `false` on a transaction
|
||||
to prevent it from being rolled back by undo.
|
||||
*/
|
||||
declare function history(config?: HistoryOptions): Plugin;
|
||||
/**
|
||||
A command function that undoes the last change, if any.
|
||||
*/
|
||||
declare const undo: Command;
|
||||
/**
|
||||
A command function that redoes the last undone change, if any.
|
||||
*/
|
||||
declare const redo: Command;
|
||||
/**
|
||||
A command function that undoes the last change. Don't scroll the
|
||||
selection into view.
|
||||
*/
|
||||
declare const undoNoScroll: Command;
|
||||
/**
|
||||
A command function that redoes the last undone change. Don't
|
||||
scroll the selection into view.
|
||||
*/
|
||||
declare const redoNoScroll: Command;
|
||||
/**
|
||||
The amount of undoable events available in a given state.
|
||||
*/
|
||||
declare function undoDepth(state: EditorState): any;
|
||||
/**
|
||||
The amount of redoable events available in a given editor state.
|
||||
*/
|
||||
declare function redoDepth(state: EditorState): any;
|
||||
/**
|
||||
Returns true if the given transaction was generated by the history
|
||||
plugin.
|
||||
*/
|
||||
declare function isHistoryTransaction(tr: Transaction): boolean;
|
||||
|
||||
export { closeHistory, history, isHistoryTransaction, redo, redoDepth, redoNoScroll, undo, undoDepth, undoNoScroll };
|
||||
+453
@@ -0,0 +1,453 @@
|
||||
import RopeSequence from 'rope-sequence';
|
||||
import { Mapping } from 'prosemirror-transform';
|
||||
import { PluginKey, Plugin } from 'prosemirror-state';
|
||||
|
||||
// ProseMirror's history isn't simply a way to roll back to a previous
|
||||
// state, because ProseMirror supports applying changes without adding
|
||||
// them to the history (for example during collaboration).
|
||||
//
|
||||
// To this end, each 'Branch' (one for the undo history and one for
|
||||
// the redo history) keeps an array of 'Items', which can optionally
|
||||
// hold a step (an actual undoable change), and always hold a position
|
||||
// map (which is needed to move changes below them to apply to the
|
||||
// current document).
|
||||
//
|
||||
// An item that has both a step and a selection bookmark is the start
|
||||
// of an 'event' — a group of changes that will be undone or redone at
|
||||
// once. (It stores only the bookmark, since that way we don't have to
|
||||
// provide a document until the selection is actually applied, which
|
||||
// is useful when compressing.)
|
||||
// Used to schedule history compression
|
||||
const max_empty_items = 500;
|
||||
class Branch {
|
||||
constructor(items, eventCount) {
|
||||
this.items = items;
|
||||
this.eventCount = eventCount;
|
||||
}
|
||||
// Pop the latest event off the branch's history and apply it
|
||||
// to a document transform.
|
||||
popEvent(state, preserveItems) {
|
||||
if (this.eventCount == 0)
|
||||
return null;
|
||||
let end = this.items.length;
|
||||
for (;; end--) {
|
||||
let next = this.items.get(end - 1);
|
||||
if (next.selection) {
|
||||
--end;
|
||||
break;
|
||||
}
|
||||
}
|
||||
let remap, mapFrom;
|
||||
if (preserveItems) {
|
||||
remap = this.remapping(end, this.items.length);
|
||||
mapFrom = remap.maps.length;
|
||||
}
|
||||
let transform = state.tr;
|
||||
let selection, remaining;
|
||||
let addAfter = [], addBefore = [];
|
||||
this.items.forEach((item, i) => {
|
||||
if (!item.step) {
|
||||
if (!remap) {
|
||||
remap = this.remapping(end, i + 1);
|
||||
mapFrom = remap.maps.length;
|
||||
}
|
||||
mapFrom--;
|
||||
addBefore.push(item);
|
||||
return;
|
||||
}
|
||||
if (remap) {
|
||||
addBefore.push(new Item(item.map));
|
||||
let step = item.step.map(remap.slice(mapFrom)), map;
|
||||
if (step && transform.maybeStep(step).doc) {
|
||||
map = transform.mapping.maps[transform.mapping.maps.length - 1];
|
||||
addAfter.push(new Item(map, undefined, undefined, addAfter.length + addBefore.length));
|
||||
}
|
||||
mapFrom--;
|
||||
if (map)
|
||||
remap.appendMap(map, mapFrom);
|
||||
}
|
||||
else {
|
||||
transform.maybeStep(item.step);
|
||||
}
|
||||
if (item.selection) {
|
||||
selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
|
||||
remaining = new Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
|
||||
return false;
|
||||
}
|
||||
}, this.items.length, 0);
|
||||
return { remaining: remaining, transform, selection: selection };
|
||||
}
|
||||
// Create a new branch with the given transform added.
|
||||
addTransform(transform, selection, histOptions, preserveItems) {
|
||||
let newItems = [], eventCount = this.eventCount;
|
||||
let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
|
||||
for (let i = 0; i < transform.steps.length; i++) {
|
||||
let step = transform.steps[i].invert(transform.docs[i]);
|
||||
let item = new Item(transform.mapping.maps[i], step, selection), merged;
|
||||
if (merged = lastItem && lastItem.merge(item)) {
|
||||
item = merged;
|
||||
if (i)
|
||||
newItems.pop();
|
||||
else
|
||||
oldItems = oldItems.slice(0, oldItems.length - 1);
|
||||
}
|
||||
newItems.push(item);
|
||||
if (selection) {
|
||||
eventCount++;
|
||||
selection = undefined;
|
||||
}
|
||||
if (!preserveItems)
|
||||
lastItem = item;
|
||||
}
|
||||
let overflow = eventCount - histOptions.depth;
|
||||
if (overflow > DEPTH_OVERFLOW) {
|
||||
oldItems = cutOffEvents(oldItems, overflow);
|
||||
eventCount -= overflow;
|
||||
}
|
||||
return new Branch(oldItems.append(newItems), eventCount);
|
||||
}
|
||||
remapping(from, to) {
|
||||
let maps = new Mapping;
|
||||
this.items.forEach((item, i) => {
|
||||
let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from
|
||||
? maps.maps.length - item.mirrorOffset : undefined;
|
||||
maps.appendMap(item.map, mirrorPos);
|
||||
}, from, to);
|
||||
return maps;
|
||||
}
|
||||
addMaps(array) {
|
||||
if (this.eventCount == 0)
|
||||
return this;
|
||||
return new Branch(this.items.append(array.map(map => new Item(map))), this.eventCount);
|
||||
}
|
||||
// When the collab module receives remote changes, the history has
|
||||
// to know about those, so that it can adjust the steps that were
|
||||
// rebased on top of the remote changes, and include the position
|
||||
// maps for the remote changes in its array of items.
|
||||
rebased(rebasedTransform, rebasedCount) {
|
||||
if (!this.eventCount)
|
||||
return this;
|
||||
let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);
|
||||
let mapping = rebasedTransform.mapping;
|
||||
let newUntil = rebasedTransform.steps.length;
|
||||
let eventCount = this.eventCount;
|
||||
this.items.forEach(item => { if (item.selection)
|
||||
eventCount--; }, start);
|
||||
let iRebased = rebasedCount;
|
||||
this.items.forEach(item => {
|
||||
let pos = mapping.getMirror(--iRebased);
|
||||
if (pos == null)
|
||||
return;
|
||||
newUntil = Math.min(newUntil, pos);
|
||||
let map = mapping.maps[pos];
|
||||
if (item.step) {
|
||||
let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
|
||||
let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
|
||||
if (selection)
|
||||
eventCount++;
|
||||
rebasedItems.push(new Item(map, step, selection));
|
||||
}
|
||||
else {
|
||||
rebasedItems.push(new Item(map));
|
||||
}
|
||||
}, start);
|
||||
let newMaps = [];
|
||||
for (let i = rebasedCount; i < newUntil; i++)
|
||||
newMaps.push(new Item(mapping.maps[i]));
|
||||
let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
|
||||
let branch = new Branch(items, eventCount);
|
||||
if (branch.emptyItemCount() > max_empty_items)
|
||||
branch = branch.compress(this.items.length - rebasedItems.length);
|
||||
return branch;
|
||||
}
|
||||
emptyItemCount() {
|
||||
let count = 0;
|
||||
this.items.forEach(item => { if (!item.step)
|
||||
count++; });
|
||||
return count;
|
||||
}
|
||||
// Compressing a branch means rewriting it to push the air (map-only
|
||||
// items) out. During collaboration, these naturally accumulate
|
||||
// because each remote change adds one. The `upto` argument is used
|
||||
// to ensure that only the items below a given level are compressed,
|
||||
// because `rebased` relies on a clean, untouched set of items in
|
||||
// order to associate old items with rebased steps.
|
||||
compress(upto = this.items.length) {
|
||||
let remap = this.remapping(0, upto), mapFrom = remap.maps.length;
|
||||
let items = [], events = 0;
|
||||
this.items.forEach((item, i) => {
|
||||
if (i >= upto) {
|
||||
items.push(item);
|
||||
if (item.selection)
|
||||
events++;
|
||||
}
|
||||
else if (item.step) {
|
||||
let step = item.step.map(remap.slice(mapFrom)), map = step && step.getMap();
|
||||
mapFrom--;
|
||||
if (map)
|
||||
remap.appendMap(map, mapFrom);
|
||||
if (step) {
|
||||
let selection = item.selection && item.selection.map(remap.slice(mapFrom));
|
||||
if (selection)
|
||||
events++;
|
||||
let newItem = new Item(map.invert(), step, selection), merged, last = items.length - 1;
|
||||
if (merged = items.length && items[last].merge(newItem))
|
||||
items[last] = merged;
|
||||
else
|
||||
items.push(newItem);
|
||||
}
|
||||
}
|
||||
else if (item.map) {
|
||||
mapFrom--;
|
||||
}
|
||||
}, this.items.length, 0);
|
||||
return new Branch(RopeSequence.from(items.reverse()), events);
|
||||
}
|
||||
}
|
||||
Branch.empty = new Branch(RopeSequence.empty, 0);
|
||||
function cutOffEvents(items, n) {
|
||||
let cutPoint;
|
||||
items.forEach((item, i) => {
|
||||
if (item.selection && (n-- == 0)) {
|
||||
cutPoint = i;
|
||||
return false;
|
||||
}
|
||||
});
|
||||
return items.slice(cutPoint);
|
||||
}
|
||||
class Item {
|
||||
constructor(
|
||||
// The (forward) step map for this item.
|
||||
map,
|
||||
// The inverted step
|
||||
step,
|
||||
// If this is non-null, this item is the start of a group, and
|
||||
// this selection is the starting selection for the group (the one
|
||||
// that was active before the first step was applied)
|
||||
selection,
|
||||
// If this item is the inverse of a previous mapping on the stack,
|
||||
// this points at the inverse's offset
|
||||
mirrorOffset) {
|
||||
this.map = map;
|
||||
this.step = step;
|
||||
this.selection = selection;
|
||||
this.mirrorOffset = mirrorOffset;
|
||||
}
|
||||
merge(other) {
|
||||
if (this.step && other.step && !other.selection) {
|
||||
let step = other.step.merge(this.step);
|
||||
if (step)
|
||||
return new Item(step.getMap().invert(), step, this.selection);
|
||||
}
|
||||
}
|
||||
}
|
||||
// The value of the state field that tracks undo/redo history for that
|
||||
// state. Will be stored in the plugin state when the history plugin
|
||||
// is active.
|
||||
class HistoryState {
|
||||
constructor(done, undone, prevRanges, prevTime, prevComposition) {
|
||||
this.done = done;
|
||||
this.undone = undone;
|
||||
this.prevRanges = prevRanges;
|
||||
this.prevTime = prevTime;
|
||||
this.prevComposition = prevComposition;
|
||||
}
|
||||
}
|
||||
const DEPTH_OVERFLOW = 20;
|
||||
// Record a transformation in undo history.
|
||||
function applyTransaction(history, state, tr, options) {
|
||||
let historyTr = tr.getMeta(historyKey), rebased;
|
||||
if (historyTr)
|
||||
return historyTr.historyState;
|
||||
if (tr.getMeta(closeHistoryKey))
|
||||
history = new HistoryState(history.done, history.undone, null, 0, -1);
|
||||
let appended = tr.getMeta("appendedTransaction");
|
||||
if (tr.steps.length == 0) {
|
||||
return history;
|
||||
}
|
||||
else if (appended && appended.getMeta(historyKey)) {
|
||||
if (appended.getMeta(historyKey).redo)
|
||||
return new HistoryState(history.done.addTransform(tr, undefined, options, mustPreserveItems(state)), history.undone, rangesFor(tr.mapping.maps), history.prevTime, history.prevComposition);
|
||||
else
|
||||
return new HistoryState(history.done, history.undone.addTransform(tr, undefined, options, mustPreserveItems(state)), null, history.prevTime, history.prevComposition);
|
||||
}
|
||||
else if (tr.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
|
||||
// Group transforms that occur in quick succession into one event.
|
||||
let composition = tr.getMeta("composition");
|
||||
let newGroup = history.prevTime == 0 ||
|
||||
(!appended && history.prevComposition != composition &&
|
||||
(history.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history.prevRanges)));
|
||||
let prevRanges = appended ? mapRanges(history.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps);
|
||||
return new HistoryState(history.done.addTransform(tr, newGroup ? state.selection.getBookmark() : undefined, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history.prevComposition : composition);
|
||||
}
|
||||
else if (rebased = tr.getMeta("rebased")) {
|
||||
// Used by the collab module to tell the history that some of its
|
||||
// content has been rebased.
|
||||
return new HistoryState(history.done.rebased(tr, rebased), history.undone.rebased(tr, rebased), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);
|
||||
}
|
||||
else {
|
||||
return new HistoryState(history.done.addMaps(tr.mapping.maps), history.undone.addMaps(tr.mapping.maps), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);
|
||||
}
|
||||
}
|
||||
function isAdjacentTo(transform, prevRanges) {
|
||||
if (!prevRanges)
|
||||
return false;
|
||||
if (!transform.docChanged)
|
||||
return true;
|
||||
let adjacent = false;
|
||||
transform.mapping.maps[0].forEach((start, end) => {
|
||||
for (let i = 0; i < prevRanges.length; i += 2)
|
||||
if (start <= prevRanges[i + 1] && end >= prevRanges[i])
|
||||
adjacent = true;
|
||||
});
|
||||
return adjacent;
|
||||
}
|
||||
function rangesFor(maps) {
|
||||
let result = [];
|
||||
for (let i = maps.length - 1; i >= 0 && result.length == 0; i--)
|
||||
maps[i].forEach((_from, _to, from, to) => result.push(from, to));
|
||||
return result;
|
||||
}
|
||||
function mapRanges(ranges, mapping) {
|
||||
if (!ranges)
|
||||
return null;
|
||||
let result = [];
|
||||
for (let i = 0; i < ranges.length; i += 2) {
|
||||
let from = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);
|
||||
if (from <= to)
|
||||
result.push(from, to);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
// Apply the latest event from one branch to the document and shift the event
|
||||
// onto the other branch.
|
||||
function histTransaction(history, state, redo) {
|
||||
let preserveItems = mustPreserveItems(state);
|
||||
let histOptions = historyKey.get(state).spec.config;
|
||||
let pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);
|
||||
if (!pop)
|
||||
return null;
|
||||
let selection = pop.selection.resolve(pop.transform.doc);
|
||||
let added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
|
||||
let newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0, -1);
|
||||
return pop.transform.setSelection(selection).setMeta(historyKey, { redo, historyState: newHist });
|
||||
}
|
||||
let cachedPreserveItems = false, cachedPreserveItemsPlugins = null;
|
||||
// Check whether any plugin in the given state has a
|
||||
// `historyPreserveItems` property in its spec, in which case we must
|
||||
// preserve steps exactly as they came in, so that they can be
|
||||
// rebased.
|
||||
function mustPreserveItems(state) {
|
||||
let plugins = state.plugins;
|
||||
if (cachedPreserveItemsPlugins != plugins) {
|
||||
cachedPreserveItems = false;
|
||||
cachedPreserveItemsPlugins = plugins;
|
||||
for (let i = 0; i < plugins.length; i++)
|
||||
if (plugins[i].spec.historyPreserveItems) {
|
||||
cachedPreserveItems = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return cachedPreserveItems;
|
||||
}
|
||||
/**
|
||||
Set a flag on the given transaction that will prevent further steps
|
||||
from being appended to an existing history event (so that they
|
||||
require a separate undo command to undo).
|
||||
*/
|
||||
function closeHistory(tr) {
|
||||
return tr.setMeta(closeHistoryKey, true);
|
||||
}
|
||||
const historyKey = new PluginKey("history");
|
||||
const closeHistoryKey = new PluginKey("closeHistory");
|
||||
/**
|
||||
Returns a plugin that enables the undo history for an editor. The
|
||||
plugin will track undo and redo stacks, which can be used with the
|
||||
[`undo`](https://prosemirror.net/docs/ref/#history.undo) and [`redo`](https://prosemirror.net/docs/ref/#history.redo) commands.
|
||||
|
||||
You can set an `"addToHistory"` [metadata
|
||||
property](https://prosemirror.net/docs/ref/#state.Transaction.setMeta) of `false` on a transaction
|
||||
to prevent it from being rolled back by undo.
|
||||
*/
|
||||
function history(config = {}) {
|
||||
config = { depth: config.depth || 100,
|
||||
newGroupDelay: config.newGroupDelay || 500 };
|
||||
return new Plugin({
|
||||
key: historyKey,
|
||||
state: {
|
||||
init() {
|
||||
return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);
|
||||
},
|
||||
apply(tr, hist, state) {
|
||||
return applyTransaction(hist, state, tr, config);
|
||||
}
|
||||
},
|
||||
config,
|
||||
props: {
|
||||
handleDOMEvents: {
|
||||
beforeinput(view, e) {
|
||||
let inputType = e.inputType;
|
||||
let command = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
|
||||
if (!command || !view.editable)
|
||||
return false;
|
||||
e.preventDefault();
|
||||
return command(view.state, view.dispatch);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
function buildCommand(redo, scroll) {
|
||||
return (state, dispatch) => {
|
||||
let hist = historyKey.getState(state);
|
||||
if (!hist || (redo ? hist.undone : hist.done).eventCount == 0)
|
||||
return false;
|
||||
if (dispatch) {
|
||||
let tr = histTransaction(hist, state, redo);
|
||||
if (tr)
|
||||
dispatch(scroll ? tr.scrollIntoView() : tr);
|
||||
}
|
||||
return true;
|
||||
};
|
||||
}
|
||||
/**
|
||||
A command function that undoes the last change, if any.
|
||||
*/
|
||||
const undo = buildCommand(false, true);
|
||||
/**
|
||||
A command function that redoes the last undone change, if any.
|
||||
*/
|
||||
const redo = buildCommand(true, true);
|
||||
/**
|
||||
A command function that undoes the last change. Don't scroll the
|
||||
selection into view.
|
||||
*/
|
||||
const undoNoScroll = buildCommand(false, false);
|
||||
/**
|
||||
A command function that redoes the last undone change. Don't
|
||||
scroll the selection into view.
|
||||
*/
|
||||
const redoNoScroll = buildCommand(true, false);
|
||||
/**
|
||||
The amount of undoable events available in a given state.
|
||||
*/
|
||||
function undoDepth(state) {
|
||||
let hist = historyKey.getState(state);
|
||||
return hist ? hist.done.eventCount : 0;
|
||||
}
|
||||
/**
|
||||
The amount of redoable events available in a given editor state.
|
||||
*/
|
||||
function redoDepth(state) {
|
||||
let hist = historyKey.getState(state);
|
||||
return hist ? hist.undone.eventCount : 0;
|
||||
}
|
||||
/**
|
||||
Returns true if the given transaction was generated by the history
|
||||
plugin.
|
||||
*/
|
||||
function isHistoryTransaction(tr) {
|
||||
return tr.getMeta(historyKey) != null;
|
||||
}
|
||||
|
||||
export { closeHistory, history, isHistoryTransaction, redo, redoDepth, redoNoScroll, undo, undoDepth, undoNoScroll };
|
||||
Reference in New Issue
Block a user