Small changes (mostly comments and API names)

Author: Zaydek Michels-Gualtieri

src/Editor/Editor.js

@@ -7,9 +7,9 @@ import ReactDOM from "react-dom"
 import ReactRenderer from "./ReactRenderer"
 import useEditor from "./useEditor"
 import uuidv4 from "uuid/v4"
-import { computeCursors } from "./cursors"
-import { computeRange } from "./ranges"
-import { readSpans } from "./spans"
+import { computeDOMRange } from "./ranges"
+import { computeVDOMCursors } from "./cursors"
+import { readVDOMSpans } from "./spans"
 
 import {
 	Anchor,
@@ -168,7 +168,7 @@ const Editor = () => {
 						// No-op
 						return
 					}
-					const range = computeRange(state.cursors[0])
+					const range = computeDOMRange(state.cursors[0])
 					try {
 						const domRange = document.createRange()
 						domRange.setStart(range.container, range.offset)
@@ -194,7 +194,7 @@ const Editor = () => {
 				onFocus={dispatch.focus}
 				onBlur={dispatch.blur}
 				onSelect={() => {
-					const cursors = computeCursors()
+					const cursors = computeVDOMCursors()
 					dispatch.select(cursors)
 				}}
 				onPointerDown={() => {
@@ -205,7 +205,7 @@ const Editor = () => {
 						pointerIsDownRef.current = false
 						return
 					}
-					const cursors = computeCursors()
+					const cursors = computeVDOMCursors()
 					dispatch.select(cursors)
 				}}
 				onPointerUp={() => {
@@ -283,12 +283,12 @@ const Editor = () => {
 				}}
 
 				onInput={() => {
-					const [cursor] = computeCursors()
+					const [cursor] = computeVDOMCursors()
 					const uuidElement = document.getElementById(cursor.uuid)
 					if (!uuidElement) {
 						throw new Error("onInput: no such uuid element")
 					}
-					const spans = readSpans(uuidElement)
+					const spans = readVDOMSpans(uuidElement)
 					dispatch.input(uuidElement.id, spans, cursor)
 				}}
 

src/Editor/cursors.js

@@ -1,28 +1,27 @@
 import ascendToUUIDElement from "./ascendToUUIDElement"
 
-// Creates a new cursor.
-export function newCursor() {
+// Creates a new VDOM cursor.
+export function newVDOMCursor() {
 	const cursor = {
 		uuid: "",
 		offset: 0,
 	}
 	return cursor
 }
 
-// Computes a cursor from a UUID element and a range
+// Computes a VDOM cursor from a UUID element and a range
 // container and offset.
-function computeCursor(uuidElement, { container, offset }) {
+function computeVDOMCursor(uuidElement, { container, offset }) {
 	while (container.nodeType === Node.ELEMENT_NODE && container.childNodes.length) {
 		if (offset === container.childNodes.length) {
 			offset = Math.min(0, container.childNodes.length - 1)
 		}
 		container = container.childNodes[offset]
 		offset = 0
 	}
-
-	const cursor = newCursor()
+	const cursor = newVDOMCursor()
 	if (!uuidElement.id) {
-		throw new Error("computeCursor: no such uuid")
+		throw new Error("computeVDOMCursor: no such uuid")
 	}
 	// Recurses on a DOM node, mutates cursor.
 	const recurse = startDOMNode => {
@@ -50,8 +49,8 @@ function computeCursor(uuidElement, { container, offset }) {
 	return cursor
 }
 
-// Computes cursors from the current range.
-export function computeCursors() {
+// Computes VDOM cursors from the current range.
+export function computeVDOMCursors() {
 	// Get the current range:
 	const selection = document.getSelection()
 	if (!selection || !selection.rangeCount) {
@@ -60,11 +59,17 @@ export function computeCursors() {
 	const range = selection.getRangeAt(0)
 	// Compute cursors:
 	const cursors = []
-	cursors.push(computeCursor(ascendToUUIDElement(range.startContainer), { container: range.startContainer, offset: range.startOffset }))
+	cursors.push(computeVDOMCursor(ascendToUUIDElement(range.startContainer), {
+		container: range.startContainer,
+		offset: range.startOffset,
+	}))
 	if (range.collapsed) {
 		cursors.push(cursors[0])
 	} else {
-		cursors.push(computeCursor(ascendToUUIDElement(range.endContainer), { container: range.endContainer, offset: range.endOffset }))
+		cursors.push(computeVDOMCursor(ascendToUUIDElement(range.endContainer), {
+			container: range.endContainer,
+			offset: range.endOffset,
+		}))
 	}
 	return cursors
 }

src/Editor/ranges.js

@@ -1,5 +1,5 @@
-// Creates a new range.
-export function newRange() {
+// Creates a new DOM range.
+export function newDOMRange() {
 	const range = {
 		container: null,
 		offset: 0,
@@ -17,12 +17,12 @@ function isTextNodeOrBreakElement(domNode) {
 	return ok
 }
 
-// Computes a range from a cursor.
-export function computeRange({ uuid, offset }) { // NOTE: Copy offset -- do not mutate reference
-	const range = newRange()
+// Computes a DOM range from a VDOM cursor.
+export function computeDOMRange({ uuid, offset }) { // NOTE: Copy offset -- do not mutate reference
+	const range = newDOMRange()
 	const uuidElement = document.getElementById(uuid)
 	if (!uuidElement) {
-		throw new Error("computeRange: no such uuid element")
+		throw new Error("computeDOMRange: no such uuid element")
 	}
 	// Recurses on a DOM node, mutates range.
 	const recurse = startDOMNode => {

src/Editor/spans.js

@@ -6,8 +6,8 @@ import formatsEnum from "./formatsEnum"
 // 	continue
 // }
 
-// Reads a span from a DOM node.
-function readSpan(domNode) {
+// Reads a VDOM span from a DOM node.
+function readVDOMSpan(domNode) {
 	const span = {
 		content: domNode.textContent,
 		formats: [],
@@ -36,23 +36,24 @@ function readSpan(domNode) {
 	return span
 }
 
-// Returns whether two spans’ formats and props are equal.
-function formatsAndPropsAreEqual(spanA, spanB) {
-	if (spanA.formats.length !== spanB.formats.length) {
+// Returns whether two VDOM spans’ formats and props are
+// equal.
+function formatsAndPropsAreEqual(s1, s2) {
+	if (s1.formats.length !== s2.formats.length) {
 		return false
 	}
-	for (let x = 0; x < spanA.formats.length; x++) {
-		if (spanA.formats[x] !== spanB.formats[x]) {
+	for (let x = 0; x < s1.formats.length; x++) {
+		if (s1.formats[x] !== s2.formats[x]) {
 			return false
-		} else if (JSON.stringify(spanA[spanA.formats[x]]) !== JSON.stringify(spanB[spanB.formats[x]])) {
+		} else if (JSON.stringify(s1[s1.formats[x]]) !== JSON.stringify(s2[s2.formats[x]])) {
 			return false
 		}
 	}
 	return true
 }
 
-// Merges repeat spans.
-export function mergeRepeatSpans(spans) {
+// Concatenates VDOM spans that share formats and props.
+export function concatenateVDOMSpans(spans) {
 	for (let x = 0; x < spans.length; x++) {
 		if (x && formatsAndPropsAreEqual(spans[x - 1], spans[x])) {
 			spans.splice(x - 1, 2, {
@@ -65,12 +66,11 @@ export function mergeRepeatSpans(spans) {
 }
 
 // Reads spans from a UUID element.
-export function readSpans(uuidElement) {
+export function readVDOMSpans(uuidElement) {
 	const spans = []
 	for (let x = 0; x < uuidElement.childNodes.length; x++) {
-		spans.push(readSpan(uuidElement.childNodes[x]))
+		spans.push(readVDOMSpan(uuidElement.childNodes[x]))
 	}
-	mergeRepeatSpans(spans)
-	console.log(spans)
+	concatenateVDOMSpans(spans)
 	return spans
 }