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:
+239
@@ -0,0 +1,239 @@
|
||||
'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); }
|
||||
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
||||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
||||
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 _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
|
||||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
||||
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; } }
|
||||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
||||
var prosemirrorKeymap = require('prosemirror-keymap');
|
||||
var prosemirrorState = require('prosemirror-state');
|
||||
var prosemirrorModel = require('prosemirror-model');
|
||||
var prosemirrorView = require('prosemirror-view');
|
||||
var GapCursor = function (_prosemirrorState$Sel) {
|
||||
_inherits(GapCursor, _prosemirrorState$Sel);
|
||||
var _super = _createSuper(GapCursor);
|
||||
function GapCursor($pos) {
|
||||
_classCallCheck(this, GapCursor);
|
||||
return _super.call(this, $pos, $pos);
|
||||
}
|
||||
_createClass(GapCursor, [{
|
||||
key: "map",
|
||||
value: function map(doc, mapping) {
|
||||
var $pos = doc.resolve(mapping.map(this.head));
|
||||
return GapCursor.valid($pos) ? new GapCursor($pos) : prosemirrorState.Selection.near($pos);
|
||||
}
|
||||
}, {
|
||||
key: "content",
|
||||
value: function content() {
|
||||
return prosemirrorModel.Slice.empty;
|
||||
}
|
||||
}, {
|
||||
key: "eq",
|
||||
value: function eq(other) {
|
||||
return other instanceof GapCursor && other.head == this.head;
|
||||
}
|
||||
}, {
|
||||
key: "toJSON",
|
||||
value: function toJSON() {
|
||||
return {
|
||||
type: "gapcursor",
|
||||
pos: this.head
|
||||
};
|
||||
}
|
||||
}, {
|
||||
key: "getBookmark",
|
||||
value: function getBookmark() {
|
||||
return new GapBookmark(this.anchor);
|
||||
}
|
||||
}], [{
|
||||
key: "fromJSON",
|
||||
value: function fromJSON(doc, json) {
|
||||
if (typeof json.pos != "number") throw new RangeError("Invalid input for GapCursor.fromJSON");
|
||||
return new GapCursor(doc.resolve(json.pos));
|
||||
}
|
||||
}, {
|
||||
key: "valid",
|
||||
value: function valid($pos) {
|
||||
var parent = $pos.parent;
|
||||
if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos)) return false;
|
||||
var override = parent.type.spec.allowGapCursor;
|
||||
if (override != null) return override;
|
||||
var deflt = parent.contentMatchAt($pos.index()).defaultType;
|
||||
return deflt && deflt.isTextblock;
|
||||
}
|
||||
}, {
|
||||
key: "findGapCursorFrom",
|
||||
value: function findGapCursorFrom($pos, dir) {
|
||||
var mustMove = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
||||
search: for (;;) {
|
||||
if (!mustMove && GapCursor.valid($pos)) return $pos;
|
||||
var pos = $pos.pos,
|
||||
next = null;
|
||||
for (var d = $pos.depth;; d--) {
|
||||
var parent = $pos.node(d);
|
||||
if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
|
||||
next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);
|
||||
break;
|
||||
} else if (d == 0) {
|
||||
return null;
|
||||
}
|
||||
pos += dir;
|
||||
var $cur = $pos.doc.resolve(pos);
|
||||
if (GapCursor.valid($cur)) return $cur;
|
||||
}
|
||||
for (;;) {
|
||||
var inside = dir > 0 ? next.firstChild : next.lastChild;
|
||||
if (!inside) {
|
||||
if (next.isAtom && !next.isText && !prosemirrorState.NodeSelection.isSelectable(next)) {
|
||||
$pos = $pos.doc.resolve(pos + next.nodeSize * dir);
|
||||
mustMove = false;
|
||||
continue search;
|
||||
}
|
||||
break;
|
||||
}
|
||||
next = inside;
|
||||
pos += dir;
|
||||
var _$cur = $pos.doc.resolve(pos);
|
||||
if (GapCursor.valid(_$cur)) return _$cur;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}]);
|
||||
return GapCursor;
|
||||
}(prosemirrorState.Selection);
|
||||
GapCursor.prototype.visible = false;
|
||||
GapCursor.findFrom = GapCursor.findGapCursorFrom;
|
||||
prosemirrorState.Selection.jsonID("gapcursor", GapCursor);
|
||||
var GapBookmark = function () {
|
||||
function GapBookmark(pos) {
|
||||
_classCallCheck(this, GapBookmark);
|
||||
this.pos = pos;
|
||||
}
|
||||
_createClass(GapBookmark, [{
|
||||
key: "map",
|
||||
value: function map(mapping) {
|
||||
return new GapBookmark(mapping.map(this.pos));
|
||||
}
|
||||
}, {
|
||||
key: "resolve",
|
||||
value: function resolve(doc) {
|
||||
var $pos = doc.resolve(this.pos);
|
||||
return GapCursor.valid($pos) ? new GapCursor($pos) : prosemirrorState.Selection.near($pos);
|
||||
}
|
||||
}]);
|
||||
return GapBookmark;
|
||||
}();
|
||||
function needsGap(type) {
|
||||
return type.isAtom || type.spec.isolating || type.spec.createGapCursor;
|
||||
}
|
||||
function closedBefore($pos) {
|
||||
for (var d = $pos.depth; d >= 0; d--) {
|
||||
var index = $pos.index(d),
|
||||
parent = $pos.node(d);
|
||||
if (index == 0) {
|
||||
if (parent.type.spec.isolating) return true;
|
||||
continue;
|
||||
}
|
||||
for (var before = parent.child(index - 1);; before = before.lastChild) {
|
||||
if (before.childCount == 0 && !before.inlineContent || needsGap(before.type)) return true;
|
||||
if (before.inlineContent) return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function closedAfter($pos) {
|
||||
for (var d = $pos.depth; d >= 0; d--) {
|
||||
var index = $pos.indexAfter(d),
|
||||
parent = $pos.node(d);
|
||||
if (index == parent.childCount) {
|
||||
if (parent.type.spec.isolating) return true;
|
||||
continue;
|
||||
}
|
||||
for (var after = parent.child(index);; after = after.firstChild) {
|
||||
if (after.childCount == 0 && !after.inlineContent || needsGap(after.type)) return true;
|
||||
if (after.inlineContent) return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function gapCursor() {
|
||||
return new prosemirrorState.Plugin({
|
||||
props: {
|
||||
decorations: drawGapCursor,
|
||||
createSelectionBetween: function createSelectionBetween(_view, $anchor, $head) {
|
||||
return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;
|
||||
},
|
||||
handleClick: handleClick,
|
||||
handleKeyDown: handleKeyDown,
|
||||
handleDOMEvents: {
|
||||
beforeinput: beforeinput
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
var handleKeyDown = prosemirrorKeymap.keydownHandler({
|
||||
"ArrowLeft": arrow("horiz", -1),
|
||||
"ArrowRight": arrow("horiz", 1),
|
||||
"ArrowUp": arrow("vert", -1),
|
||||
"ArrowDown": arrow("vert", 1)
|
||||
});
|
||||
function arrow(axis, dir) {
|
||||
var dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
|
||||
return function (state, dispatch, view) {
|
||||
var sel = state.selection;
|
||||
var $start = dir > 0 ? sel.$to : sel.$from,
|
||||
mustMove = sel.empty;
|
||||
if (sel instanceof prosemirrorState.TextSelection) {
|
||||
if (!view.endOfTextblock(dirStr) || $start.depth == 0) return false;
|
||||
mustMove = false;
|
||||
$start = state.doc.resolve(dir > 0 ? $start.after() : $start.before());
|
||||
}
|
||||
var $found = GapCursor.findGapCursorFrom($start, dir, mustMove);
|
||||
if (!$found) return false;
|
||||
if (dispatch) dispatch(state.tr.setSelection(new GapCursor($found)));
|
||||
return true;
|
||||
};
|
||||
}
|
||||
function handleClick(view, pos, event) {
|
||||
if (!view || !view.editable) return false;
|
||||
var $pos = view.state.doc.resolve(pos);
|
||||
if (!GapCursor.valid($pos)) return false;
|
||||
var clickPos = view.posAtCoords({
|
||||
left: event.clientX,
|
||||
top: event.clientY
|
||||
});
|
||||
if (clickPos && clickPos.inside > -1 && prosemirrorState.NodeSelection.isSelectable(view.state.doc.nodeAt(clickPos.inside))) return false;
|
||||
view.dispatch(view.state.tr.setSelection(new GapCursor($pos)));
|
||||
return true;
|
||||
}
|
||||
function beforeinput(view, event) {
|
||||
if (event.inputType != "insertCompositionText" || !(view.state.selection instanceof GapCursor)) return false;
|
||||
var $from = view.state.selection.$from;
|
||||
var insert = $from.parent.contentMatchAt($from.index()).findWrapping(view.state.schema.nodes.text);
|
||||
if (!insert) return false;
|
||||
var frag = prosemirrorModel.Fragment.empty;
|
||||
for (var i = insert.length - 1; i >= 0; i--) frag = prosemirrorModel.Fragment.from(insert[i].createAndFill(null, frag));
|
||||
var tr = view.state.tr.replace($from.pos, $from.pos, new prosemirrorModel.Slice(frag, 0, 0));
|
||||
tr.setSelection(prosemirrorState.TextSelection.near(tr.doc.resolve($from.pos + 1)));
|
||||
view.dispatch(tr);
|
||||
return false;
|
||||
}
|
||||
function drawGapCursor(state) {
|
||||
if (!(state.selection instanceof GapCursor)) return null;
|
||||
var node = document.createElement("div");
|
||||
node.className = "ProseMirror-gapcursor";
|
||||
return prosemirrorView.DecorationSet.create(state.doc, [prosemirrorView.Decoration.widget(state.selection.head, node, {
|
||||
key: "gapcursor"
|
||||
})]);
|
||||
}
|
||||
exports.GapCursor = GapCursor;
|
||||
exports.gapCursor = gapCursor;
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
import { Selection, Plugin } from 'prosemirror-state';
|
||||
import { ResolvedPos, Node, Slice } from 'prosemirror-model';
|
||||
import { Mappable } from 'prosemirror-transform';
|
||||
|
||||
/**
|
||||
Gap cursor selections are represented using this class. Its
|
||||
`$anchor` and `$head` properties both point at the cursor position.
|
||||
*/
|
||||
declare class GapCursor extends Selection {
|
||||
/**
|
||||
Create a gap cursor.
|
||||
*/
|
||||
constructor($pos: ResolvedPos);
|
||||
map(doc: Node, mapping: Mappable): Selection;
|
||||
content(): Slice;
|
||||
eq(other: Selection): boolean;
|
||||
toJSON(): any;
|
||||
}
|
||||
|
||||
/**
|
||||
Create a gap cursor plugin. When enabled, this will capture clicks
|
||||
near and arrow-key-motion past places that don't have a normally
|
||||
selectable position nearby, and create a gap cursor selection for
|
||||
them. The cursor is drawn as an element with class
|
||||
`ProseMirror-gapcursor`. You can either include
|
||||
`style/gapcursor.css` from the package's directory or add your own
|
||||
styles to make it visible.
|
||||
*/
|
||||
declare function gapCursor(): Plugin;
|
||||
|
||||
export { GapCursor, gapCursor };
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
import { Selection, Plugin } from 'prosemirror-state';
|
||||
import { ResolvedPos, Node, Slice } from 'prosemirror-model';
|
||||
import { Mappable } from 'prosemirror-transform';
|
||||
|
||||
/**
|
||||
Gap cursor selections are represented using this class. Its
|
||||
`$anchor` and `$head` properties both point at the cursor position.
|
||||
*/
|
||||
declare class GapCursor extends Selection {
|
||||
/**
|
||||
Create a gap cursor.
|
||||
*/
|
||||
constructor($pos: ResolvedPos);
|
||||
map(doc: Node, mapping: Mappable): Selection;
|
||||
content(): Slice;
|
||||
eq(other: Selection): boolean;
|
||||
toJSON(): any;
|
||||
}
|
||||
|
||||
/**
|
||||
Create a gap cursor plugin. When enabled, this will capture clicks
|
||||
near and arrow-key-motion past places that don't have a normally
|
||||
selectable position nearby, and create a gap cursor selection for
|
||||
them. The cursor is drawn as an element with class
|
||||
`ProseMirror-gapcursor`. You can either include
|
||||
`style/gapcursor.css` from the package's directory or add your own
|
||||
styles to make it visible.
|
||||
*/
|
||||
declare function gapCursor(): Plugin;
|
||||
|
||||
export { GapCursor, gapCursor };
|
||||
+239
@@ -0,0 +1,239 @@
|
||||
import { keydownHandler } from 'prosemirror-keymap';
|
||||
import { Selection, NodeSelection, TextSelection, Plugin } from 'prosemirror-state';
|
||||
import { Slice, Fragment } from 'prosemirror-model';
|
||||
import { DecorationSet, Decoration } from 'prosemirror-view';
|
||||
|
||||
/**
|
||||
Gap cursor selections are represented using this class. Its
|
||||
`$anchor` and `$head` properties both point at the cursor position.
|
||||
*/
|
||||
class GapCursor extends Selection {
|
||||
/**
|
||||
Create a gap cursor.
|
||||
*/
|
||||
constructor($pos) {
|
||||
super($pos, $pos);
|
||||
}
|
||||
map(doc, mapping) {
|
||||
let $pos = doc.resolve(mapping.map(this.head));
|
||||
return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);
|
||||
}
|
||||
content() { return Slice.empty; }
|
||||
eq(other) {
|
||||
return other instanceof GapCursor && other.head == this.head;
|
||||
}
|
||||
toJSON() {
|
||||
return { type: "gapcursor", pos: this.head };
|
||||
}
|
||||
/**
|
||||
@internal
|
||||
*/
|
||||
static fromJSON(doc, json) {
|
||||
if (typeof json.pos != "number")
|
||||
throw new RangeError("Invalid input for GapCursor.fromJSON");
|
||||
return new GapCursor(doc.resolve(json.pos));
|
||||
}
|
||||
/**
|
||||
@internal
|
||||
*/
|
||||
getBookmark() { return new GapBookmark(this.anchor); }
|
||||
/**
|
||||
@internal
|
||||
*/
|
||||
static valid($pos) {
|
||||
let parent = $pos.parent;
|
||||
if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos))
|
||||
return false;
|
||||
let override = parent.type.spec.allowGapCursor;
|
||||
if (override != null)
|
||||
return override;
|
||||
let deflt = parent.contentMatchAt($pos.index()).defaultType;
|
||||
return deflt && deflt.isTextblock;
|
||||
}
|
||||
/**
|
||||
@internal
|
||||
*/
|
||||
static findGapCursorFrom($pos, dir, mustMove = false) {
|
||||
search: for (;;) {
|
||||
if (!mustMove && GapCursor.valid($pos))
|
||||
return $pos;
|
||||
let pos = $pos.pos, next = null;
|
||||
// Scan up from this position
|
||||
for (let d = $pos.depth;; d--) {
|
||||
let parent = $pos.node(d);
|
||||
if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
|
||||
next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);
|
||||
break;
|
||||
}
|
||||
else if (d == 0) {
|
||||
return null;
|
||||
}
|
||||
pos += dir;
|
||||
let $cur = $pos.doc.resolve(pos);
|
||||
if (GapCursor.valid($cur))
|
||||
return $cur;
|
||||
}
|
||||
// And then down into the next node
|
||||
for (;;) {
|
||||
let inside = dir > 0 ? next.firstChild : next.lastChild;
|
||||
if (!inside) {
|
||||
if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {
|
||||
$pos = $pos.doc.resolve(pos + next.nodeSize * dir);
|
||||
mustMove = false;
|
||||
continue search;
|
||||
}
|
||||
break;
|
||||
}
|
||||
next = inside;
|
||||
pos += dir;
|
||||
let $cur = $pos.doc.resolve(pos);
|
||||
if (GapCursor.valid($cur))
|
||||
return $cur;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
GapCursor.prototype.visible = false;
|
||||
GapCursor.findFrom = GapCursor.findGapCursorFrom;
|
||||
Selection.jsonID("gapcursor", GapCursor);
|
||||
class GapBookmark {
|
||||
constructor(pos) {
|
||||
this.pos = pos;
|
||||
}
|
||||
map(mapping) {
|
||||
return new GapBookmark(mapping.map(this.pos));
|
||||
}
|
||||
resolve(doc) {
|
||||
let $pos = doc.resolve(this.pos);
|
||||
return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);
|
||||
}
|
||||
}
|
||||
function needsGap(type) {
|
||||
return type.isAtom || type.spec.isolating || type.spec.createGapCursor;
|
||||
}
|
||||
function closedBefore($pos) {
|
||||
for (let d = $pos.depth; d >= 0; d--) {
|
||||
let index = $pos.index(d), parent = $pos.node(d);
|
||||
// At the start of this parent, look at next one
|
||||
if (index == 0) {
|
||||
if (parent.type.spec.isolating)
|
||||
return true;
|
||||
continue;
|
||||
}
|
||||
// See if the node before (or its first ancestor) is closed
|
||||
for (let before = parent.child(index - 1);; before = before.lastChild) {
|
||||
if ((before.childCount == 0 && !before.inlineContent) || needsGap(before.type))
|
||||
return true;
|
||||
if (before.inlineContent)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// Hit start of document
|
||||
return true;
|
||||
}
|
||||
function closedAfter($pos) {
|
||||
for (let d = $pos.depth; d >= 0; d--) {
|
||||
let index = $pos.indexAfter(d), parent = $pos.node(d);
|
||||
if (index == parent.childCount) {
|
||||
if (parent.type.spec.isolating)
|
||||
return true;
|
||||
continue;
|
||||
}
|
||||
for (let after = parent.child(index);; after = after.firstChild) {
|
||||
if ((after.childCount == 0 && !after.inlineContent) || needsGap(after.type))
|
||||
return true;
|
||||
if (after.inlineContent)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
Create a gap cursor plugin. When enabled, this will capture clicks
|
||||
near and arrow-key-motion past places that don't have a normally
|
||||
selectable position nearby, and create a gap cursor selection for
|
||||
them. The cursor is drawn as an element with class
|
||||
`ProseMirror-gapcursor`. You can either include
|
||||
`style/gapcursor.css` from the package's directory or add your own
|
||||
styles to make it visible.
|
||||
*/
|
||||
function gapCursor() {
|
||||
return new Plugin({
|
||||
props: {
|
||||
decorations: drawGapCursor,
|
||||
createSelectionBetween(_view, $anchor, $head) {
|
||||
return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;
|
||||
},
|
||||
handleClick,
|
||||
handleKeyDown,
|
||||
handleDOMEvents: { beforeinput: beforeinput }
|
||||
}
|
||||
});
|
||||
}
|
||||
const handleKeyDown = keydownHandler({
|
||||
"ArrowLeft": arrow("horiz", -1),
|
||||
"ArrowRight": arrow("horiz", 1),
|
||||
"ArrowUp": arrow("vert", -1),
|
||||
"ArrowDown": arrow("vert", 1)
|
||||
});
|
||||
function arrow(axis, dir) {
|
||||
const dirStr = axis == "vert" ? (dir > 0 ? "down" : "up") : (dir > 0 ? "right" : "left");
|
||||
return function (state, dispatch, view) {
|
||||
let sel = state.selection;
|
||||
let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;
|
||||
if (sel instanceof TextSelection) {
|
||||
if (!view.endOfTextblock(dirStr) || $start.depth == 0)
|
||||
return false;
|
||||
mustMove = false;
|
||||
$start = state.doc.resolve(dir > 0 ? $start.after() : $start.before());
|
||||
}
|
||||
let $found = GapCursor.findGapCursorFrom($start, dir, mustMove);
|
||||
if (!$found)
|
||||
return false;
|
||||
if (dispatch)
|
||||
dispatch(state.tr.setSelection(new GapCursor($found)));
|
||||
return true;
|
||||
};
|
||||
}
|
||||
function handleClick(view, pos, event) {
|
||||
if (!view || !view.editable)
|
||||
return false;
|
||||
let $pos = view.state.doc.resolve(pos);
|
||||
if (!GapCursor.valid($pos))
|
||||
return false;
|
||||
let clickPos = view.posAtCoords({ left: event.clientX, top: event.clientY });
|
||||
if (clickPos && clickPos.inside > -1 && NodeSelection.isSelectable(view.state.doc.nodeAt(clickPos.inside)))
|
||||
return false;
|
||||
view.dispatch(view.state.tr.setSelection(new GapCursor($pos)));
|
||||
return true;
|
||||
}
|
||||
// This is a hack that, when a composition starts while a gap cursor
|
||||
// is active, quickly creates an inline context for the composition to
|
||||
// happen in, to avoid it being aborted by the DOM selection being
|
||||
// moved into a valid position.
|
||||
function beforeinput(view, event) {
|
||||
if (event.inputType != "insertCompositionText" || !(view.state.selection instanceof GapCursor))
|
||||
return false;
|
||||
let { $from } = view.state.selection;
|
||||
let insert = $from.parent.contentMatchAt($from.index()).findWrapping(view.state.schema.nodes.text);
|
||||
if (!insert)
|
||||
return false;
|
||||
let frag = Fragment.empty;
|
||||
for (let i = insert.length - 1; i >= 0; i--)
|
||||
frag = Fragment.from(insert[i].createAndFill(null, frag));
|
||||
let tr = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0));
|
||||
tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + 1)));
|
||||
view.dispatch(tr);
|
||||
return false;
|
||||
}
|
||||
function drawGapCursor(state) {
|
||||
if (!(state.selection instanceof GapCursor))
|
||||
return null;
|
||||
let node = document.createElement("div");
|
||||
node.className = "ProseMirror-gapcursor";
|
||||
return DecorationSet.create(state.doc, [Decoration.widget(state.selection.head, node, { key: "gapcursor" })]);
|
||||
}
|
||||
|
||||
export { GapCursor, gapCursor };
|
||||
Reference in New Issue
Block a user