Convert editor to TypeScript

Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>

src/editor/position.ts

@@ -0,0 +1,136 @@
+/*
+Copyright 2019 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import DocumentOffset from "./offset";
+import EditorModel from "./model";
+import {BasePart} from "./parts";
+
+export interface IPosition {
+    index: number;
+    offset: number;
+}
+
+type Callback = (part: BasePart, startIdx: number, endIdx: number) => void;
+type Predicate = (index: number, offset: number, part: BasePart) => boolean;
+
+export default class DocumentPosition implements IPosition {
+    constructor(public readonly index: number, public readonly offset: number) {
+    }
+
+    compare(otherPos: DocumentPosition) {
+        if (this.index === otherPos.index) {
+            return this.offset - otherPos.offset;
+        } else {
+            return this.index - otherPos.index;
+        }
+    }
+
+    iteratePartsBetween(other: DocumentPosition, model: EditorModel, callback: Callback) {
+        if (this.index === -1 || other.index === -1) {
+            return;
+        }
+        const [startPos, endPos] = this.compare(other) < 0 ? [this, other] : [other, this];
+        if (startPos.index === endPos.index) {
+            callback(model.parts[this.index], startPos.offset, endPos.offset);
+        } else {
+            const firstPart = model.parts[startPos.index];
+            callback(firstPart, startPos.offset, firstPart.text.length);
+            for (let i = startPos.index + 1; i < endPos.index; ++i) {
+                const part = model.parts[i];
+                callback(part, 0, part.text.length);
+            }
+            const lastPart = model.parts[endPos.index];
+            callback(lastPart, 0, endPos.offset);
+        }
+    }
+
+    forwardsWhile(model: EditorModel, predicate: Predicate) {
+        if (this.index === -1) {
+            return this;
+        }
+
+        let {index, offset} = this;
+        const {parts} = model;
+        while (index < parts.length) {
+            const part = parts[index];
+            while (offset < part.text.length) {
+                if (!predicate(index, offset, part)) {
+                    return new DocumentPosition(index, offset);
+                }
+                offset += 1;
+            }
+            // end reached
+            if (index === (parts.length - 1)) {
+                return new DocumentPosition(index, offset);
+            } else {
+                index += 1;
+                offset = 0;
+            }
+        }
+    }
+
+    backwardsWhile(model: EditorModel, predicate: Predicate) {
+        if (this.index === -1) {
+            return this;
+        }
+
+        let {index, offset} = this;
+        const parts = model.parts;
+        while (index >= 0) {
+            const part = parts[index];
+            while (offset > 0) {
+                if (!predicate(index, offset - 1, part)) {
+                    return new DocumentPosition(index, offset);
+                }
+                offset -= 1;
+            }
+            // start reached
+            if (index === 0) {
+                return new DocumentPosition(index, offset);
+            } else {
+                index -= 1;
+                offset = parts[index].text.length;
+            }
+        }
+    }
+
+    asOffset(model: EditorModel) {
+        if (this.index === -1) {
+            return new DocumentOffset(0, true);
+        }
+        let offset = 0;
+        for (let i = 0; i < this.index; ++i) {
+            offset += model.parts[i].text.length;
+        }
+        offset += this.offset;
+        const lastPart = model.parts[this.index];
+        const atEnd = !lastPart || offset >= lastPart.text.length; // if no last part, we're at the end
+        return new DocumentOffset(offset, atEnd);
+    }
+
+    isAtEnd(model: EditorModel) {
+        if (model.parts.length === 0) {
+            return true;
+        }
+        const lastPartIdx = model.parts.length - 1;
+        const lastPart = model.parts[lastPartIdx];
+        return this.index === lastPartIdx && this.offset === lastPart.text.length;
+    }
+
+    isAtStart() {
+        return this.index === 0 && this.offset === 0;
+    }
+}