-
-
Notifications
You must be signed in to change notification settings - Fork 4
/
deleteCurrent.ts
83 lines (80 loc) · 4.92 KB
/
deleteCurrent.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import { Placeholder } from '../../../SyntaxTreeComponents/Placeholder/Placeholder';
import { KeyboardMemory } from '../../KeyboardMemory';
import { getFirstNonEmptyOnLeftOf } from '../helpers/getFirstNonEmptyOnLeftOf';
import { lastOrNull } from '../../../helpers/arrayhelpers/lastOrNull';
import { firstBeforeOrNull } from '../../../helpers/arrayhelpers/firstBeforeOrNull';
import { remove } from '../../../helpers/arrayhelpers/remove';
import { TreeNode } from '../../../SyntaxTreeComponents/Nodes/Base/TreeNode';
import { BranchingNode } from '../../../SyntaxTreeComponents/Nodes/Base/BranchingNode';
import { last } from '../../../helpers/arrayhelpers/last';
import { PartOfNumberWithDigits } from '../../../SyntaxTreeComponents/Nodes/LeafNodes/Base/PartOfNumberWithDigits';
import { encapsulateAllPartsOfNumberWithDigitsLeftOfIndex } from '../helpers/encapsulateAllPartsOfNumberWithDigitsLeftOfIndex';
export function deleteCurrent(k: KeyboardMemory): void {
if (k.current instanceof Placeholder) {
if (k.current.parentNode == null || k.current.nodes.length > 0) {
return;
} else {
const nonEmptyPlaceholderOnLeft: Placeholder | null = getFirstNonEmptyOnLeftOf(k.current.parentNode.placeholders, k.current);
if (nonEmptyPlaceholderOnLeft) {
if (k.current.parentNode.placeholders.length == 2 && k.current === k.current.parentNode.placeholders[1] && k.current.nodes.length == 0) {
deleteOuterBranchingNodeButNotItsContents(k, nonEmptyPlaceholderOnLeft);
} else {
nonEmptyPlaceholderOnLeft.nodes.pop();
k.current = lastOrNull(nonEmptyPlaceholderOnLeft.nodes) ?? nonEmptyPlaceholderOnLeft;
}
} else if (k.current.parentNode.placeholders.every((ph) => ph.nodes.length == 0)) {
const ancestorPlaceholder = k.current.parentNode.parentPlaceholder;
const previousNode = firstBeforeOrNull(ancestorPlaceholder.nodes, k.current.parentNode);
remove(ancestorPlaceholder.nodes, k.current.parentNode);
k.current = previousNode ?? ancestorPlaceholder;
} else if (k.current.parentNode.placeholders[0] === k.current && k.current.nodes.length == 0 && k.current.parentNode.placeholders.some((ph) => ph.nodes.length != 0)) {
const previousNode = firstBeforeOrNull(k.current.parentNode!.parentPlaceholder.nodes, k.current.parentNode);
if (previousNode != null) {
encapsulatePreviousInto(previousNode, k.current);
k.current = last(k.current.nodes);
} else {
const nonEmptySiblingPlaceholders = k.current.parentNode.placeholders.filter((p) => p.nodes.length != 0);
if (nonEmptySiblingPlaceholders.length == 1) {
const nodes = nonEmptySiblingPlaceholders[0].nodes;
const ancestorPlaceholder = k.current.parentNode.parentPlaceholder;
const indexOfParentNode = ancestorPlaceholder.nodes.indexOf(k.current.parentNode);
for (const node of nodes) {
node.parentPlaceholder = ancestorPlaceholder;
}
ancestorPlaceholder.nodes.splice(indexOfParentNode, 1, ...nodes);
k.current = last(nodes);
}
}
}
}
} else {
if (k.current instanceof BranchingNode && k.current.placeholders[0].nodes.length > 0 && k.current.placeholders.slice(1).every((ph) => ph.nodes.length == 0)) {
deleteOuterBranchingNodeButNotItsContents(k, k.current.placeholders[0]);
} else if (k.current instanceof BranchingNode && k.current.placeholders.some((ph) => ph.nodes.length > 0)) {
k.current = last(k.current.placeholders.flatMap((ph) => ph.nodes));
deleteCurrent(k);
} else {
const previousNode: TreeNode | null = firstBeforeOrNull(k.current.parentPlaceholder.nodes, k.current);
remove(k.current.parentPlaceholder.nodes, k.current);
k.current = previousNode ?? k.current.parentPlaceholder;
}
}
}
function encapsulatePreviousInto(previousNode: TreeNode, targetPlaceholder: Placeholder) {
remove(targetPlaceholder.parentNode!.parentPlaceholder.nodes, previousNode);
targetPlaceholder.nodes.push(previousNode);
const previousNodeOldParentPlaceholder = previousNode.parentPlaceholder;
previousNode.parentPlaceholder = targetPlaceholder;
if (previousNode instanceof PartOfNumberWithDigits) {
encapsulateAllPartsOfNumberWithDigitsLeftOfIndex(previousNodeOldParentPlaceholder.nodes.length - 1, previousNodeOldParentPlaceholder.nodes, targetPlaceholder);
}
}
function deleteOuterBranchingNodeButNotItsContents(k: KeyboardMemory, nonEmptyPlaceholder: Placeholder) {
const outerBranchingNode = nonEmptyPlaceholder.parentNode!;
const indexOfOuterBranchingNode = outerBranchingNode.parentPlaceholder.nodes.indexOf(outerBranchingNode);
outerBranchingNode.parentPlaceholder.nodes.splice(indexOfOuterBranchingNode, 1, ...nonEmptyPlaceholder.nodes);
for (const node of nonEmptyPlaceholder.nodes) {
node.parentPlaceholder = outerBranchingNode.parentPlaceholder;
}
k.current = last(nonEmptyPlaceholder.nodes);
}