8b84368e3a
* Clarify some comments * Don't destructure insertion trigger * Make superscript and subscript use domlib/surround * Create new {Text,Highlight}ColorButton * Use domlib/surround for textcolor - However there's still a crucial bug, when you're breaking existing colored span when unsurrounding, their color is not restored * Add underline format to removeFormats * Simplify type of ElementMatcher and ElementClearer for end users * Add some comments for normalize-insertion-ranges * Split normalize-insertion-ranges into remove-adjacent and remove-within * Factor out find-remove from unsurround.ts * Rename merge-mach, simplify remove-within * Clarify some comments * Refactor first reduce * Refactor reduceRight * Flatten functions in merge-ranges * Move some functionality to merge-ranges and do not export * Refactor merge-ranges * Remove createInitialMergeMatch * Finish refactoring of merge-ranges * Refactor merge-ranges to minimal-ranges and add some unit testing * Move more logic into text-node * Remove most most of the logic from remove-adjacent - remove-adjacent is still part of the "merging" logic, as it increases the scope of the child node ranges * Add some tests for edge cases * Merge remove-adjacent logic into minimal-ranges * Refactor unnecessary list destructuring * Add some TODOs * Put removing nodes and adding new nodes into sequence * Refactor MatchResult to MatchType and return clear from matcher * Inline surround/helpers * Shorten name of param * Add another edge case test * Add an example where commonAncestorContainer != normalization level * Fix bug in find-adjacent when find more than one nested nodes * Allow comments for Along type * Simplify find-adjacent by removing intermediate and/or curried functions * Remove extend-adjacent * Add more tests when find-adjacent finds by descension * Fix find-adjacent descending into block-level elements * Add clarifying comment to refusing to descend into block-level elements * Move shifting logic into find-adjacent * Rename file matcher to match-type * Give a first implemention of TreeVertex * Remove MatchType.ALONG - findAdjacent now directly modifies the range * Rename MatchType.MATCH into MatchType.REMOVE * Implement a version of find-within that utilizies match-tree * Turn child node range into a class * Fix bug in new find-adjacent function * Make all find-adjacent tests test for ranges * Surrounding within farthestMatchingAncestor when available * Fix an issue with negligable elements - also rename "along" elements to "negligable" * Add two TODOs to SurroundFormat interface * Have a messy first implementation of the new tree-node algorithm * Maintain whether formatting nodes are covered or within user selection * Move covered and insideRange into TreeNode superclass * Reimplement findAdjacent logic * Add extension logic * Add an evaluate method to nodes * Introduce BlockNode * Add a first evaluate implementation * Add left shift and inner shift logic * Implement SurroundFormatUser * Allow pass in formatter, ascender and merger from outside * Fix insideRange and covered switch-up * Fix MatchNode.prototype.isAscendable * Fix another switch-up of covered and insideRange... * Remove a lot of old code * Have surround functions only return the range - I still cannot think of a good reason why we should return addedNodes and removedNodes, except for testing. * Create formatting-tree directory * Create build-tree directory + Move find-above up to /domlib * Remove range-anchors * Move unsurround logic into no-splitting * Fix extend-merge * Fix inner shift being eroneusly returned as left shift * Fix oversight in SplitRange * Redefine how ranges are recreated * Rename covered to insideMatch and put as fourth parameter instead of third * Keep track of match holes and match leaves * Rename ChildNodeRange to FlatRange * Change signature of matcher * Fix bug in extend-merge * Improve Match class * Utilize cache in TextColorButton * Implement getBaseSurrounder for TextColorButton * Add matchAncestors field to FormattingNode * Introduce matchAncestors and getCache * Do clearing during parsing already - This way, you know whether elements will be removed before getting to Formatting nodes * Make HighlightColorButton use our surround mechanism * Fix a bug with calling .removeAttribute and .hasAttribute * Add side button to RemoveFormat button * Add disabled to remove format side button * Expose remove formats on RemoveFormat button * Reinvent editor/surround as Surrounder class * Fix split-text when working with insert trigger * Try counteracting the contenteditable's auto surrounding * Remove matching elements before normalizing * Rewrite match-type * Move setting match leaves into build * Change editing strings - So that color strings match bold/italic strings better * Fix border radius of List options menu * Implement extensions functionality * Remove some unnecessary code * Fix split range endOffset * Type MatchType * Reformat MatchType + add docs * Fix domlib/surround/apply * Satisfy last tests * Register Surrounder as package * Clarify some comments * Correctly implement reformat * Reformat with inactive eraser formats * Clear empty spans with RemoveFormatButton * Fix Super/Subscript button * Use ftl string for hardcoded tooltip * Adjust wording
81 lines
2.0 KiB
TypeScript
81 lines
2.0 KiB
TypeScript
// Copyright: Ankitects Pty Ltd and contributors
|
|
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
|
|
import type { TreeNode } from "../tree";
|
|
import { FormattingNode } from "../tree";
|
|
import type { BuildFormat } from "./format";
|
|
|
|
function mergeAppendNode<T>(
|
|
initial: TreeNode[],
|
|
last: FormattingNode<T>,
|
|
format: BuildFormat<T>,
|
|
): TreeNode[] {
|
|
const minimized: TreeNode[] = [last];
|
|
|
|
for (let i = initial.length - 1; i >= 0; i--) {
|
|
const next = initial[i];
|
|
|
|
let merged: FormattingNode<T> | null;
|
|
if (next instanceof FormattingNode && (merged = format.tryMerge(next, last))) {
|
|
minimized[0] = merged;
|
|
} else {
|
|
minimized.unshift(...initial.slice(0, i + 1));
|
|
break;
|
|
}
|
|
}
|
|
|
|
return minimized;
|
|
}
|
|
|
|
/**
|
|
* Tries to merge `last`, into the end of `initial`.
|
|
*/
|
|
export function appendNode<T>(
|
|
initial: TreeNode[],
|
|
last: TreeNode,
|
|
format: BuildFormat<T>,
|
|
): TreeNode[] {
|
|
if (last instanceof FormattingNode) {
|
|
return mergeAppendNode(initial, last, format);
|
|
} else {
|
|
return [...initial, last];
|
|
}
|
|
}
|
|
|
|
function mergeInsertNode<T>(
|
|
first: FormattingNode<T>,
|
|
tail: TreeNode[],
|
|
format: BuildFormat<T>,
|
|
): TreeNode[] {
|
|
const minimized: TreeNode[] = [first];
|
|
|
|
for (let i = 0; i <= tail.length; i++) {
|
|
const next = tail[i];
|
|
|
|
let merged: FormattingNode<T> | null;
|
|
if (next instanceof FormattingNode && (merged = format.tryMerge(first, next))) {
|
|
minimized[0] = merged;
|
|
} else {
|
|
minimized.push(...tail.slice(i));
|
|
break;
|
|
}
|
|
}
|
|
|
|
return minimized;
|
|
}
|
|
|
|
/**
|
|
* Tries to merge `first`, into the start of `tail`.
|
|
*/
|
|
export function insertNode<T>(
|
|
first: TreeNode,
|
|
tail: TreeNode[],
|
|
format: BuildFormat<T>,
|
|
): TreeNode[] {
|
|
if (first instanceof FormattingNode) {
|
|
return mergeInsertNode(first, tail, format);
|
|
} else {
|
|
return [first, ...tail];
|
|
}
|
|
}
|