element-web/src/editor/position.ts

/*
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 {Part} from "./parts";

export interface IPosition {
    index: number;
    offset: number;
}

type Callback = (part: Part, startIdx: number, endIdx: number) => void;
export type Predicate = (index: number, offset: number, part: Part) => 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;
    }
}