@talrace/ngx-noder 0.0.7 → 0.0.8

package/esm2022/lib/editor/positioning/range.mjs

@@ -0,0 +1,94 @@
+import { CursorParagraph } from './cursor-paragraph';
+import { PositionHelper } from './position.helper';
+export class Range {
+    get isEmpty() {
+        return this.isSingleLine && this.start.column === this.end.column;
+    }
+    get isSingleLine() {
+        return this.start.row === this.end.row;
+    }
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    isEqual(range) {
+        return (this.start.row === range.start.row &&
+            this.end.row === range.end.row &&
+            this.start.column === range.start.column &&
+            this.end.column === range.end.column);
+    }
+    contains(position) {
+        return this.comparePosition(position) === 0;
+    }
+    comparePosition(position) {
+        const compare = this.compareSingleLine(position);
+        return compare ?? this.compareMultiLine(position);
+    }
+    /**
+     * Given the current `Range`,
+     * this function converts those starting and ending cursor positions into screen positions, and then returns a new `Range` object.
+     * @param {EditSession} session The `EditSession` to retrieve coordinates from
+     * @returns {Range}
+     **/
+    toScreenRange(session) {
+        const screenPosStart = PositionHelper.documentToScreen(session, this.start.row, this.start.column);
+        const screenPosEnd = PositionHelper.documentToScreen(session, this.end.row, this.end.column);
+        return new Range(screenPosStart, screenPosEnd);
+    }
+    /**
+     * Returns the part of the current `Range` that occurs within the boundaries of `firstRow` and `lastRow` as a new `Range` object.
+     * @param {Number} firstRow The starting row
+     * @param {Number} lastRow The ending row
+     * @returns {CursorParagraph}
+     **/
+    clipRows(firstRow, lastRow) {
+        let end;
+        if (this.end.row > lastRow) {
+            end = new CursorParagraph(lastRow + 1, 0);
+        }
+        else if (this.end.row < firstRow) {
+            end = new CursorParagraph(firstRow, 0);
+        }
+        let start;
+        if (this.start.row > lastRow) {
+            start = new CursorParagraph(lastRow + 1, 0);
+        }
+        else if (this.start.row < firstRow) {
+            start = new CursorParagraph(firstRow, 0);
+        }
+        return new Range(start || this.start, end || this.end);
+    }
+    compareSingleLine(position) {
+        if (!this.isSingleLine) {
+            return null;
+        }
+        if (position.row === this.start.row) {
+            if (position.column < this.start.column) {
+                return -1;
+            }
+            else if (position.column > this.end.column) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        }
+        return null;
+    }
+    compareMultiLine(position) {
+        if (this.start.row === position.row) {
+            return position.column >= this.start.column ? 0 : -1;
+        }
+        if (this.end.row === position.row) {
+            return position.column <= this.end.column ? 0 : 1;
+        }
+        if (position.row < this.start.row) {
+            return -1;
+        }
+        if (position.row > this.end.row) {
+            return 1;
+        }
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/positioning/range.ts"],"names":[],"mappings":"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","sourcesContent":["import { CursorParagraph } from './cursor-paragraph';\nimport { EditSession } from '../execution/edit.session';\nimport { PositionHelper } from './position.helper';\n\nexport class Range {\n    start: CursorParagraph;\n    end: CursorParagraph;\n\n    cursor: CursorParagraph;\n\n    get isEmpty(): boolean {\n        return this.isSingleLine && this.start.column === this.end.column;\n    }\n\n    get isSingleLine(): boolean {\n        return this.start.row === this.end.row;\n    }\n\n    constructor(start: CursorParagraph, end: CursorParagraph) {\n        this.start = start;\n        this.end = end;\n    }\n\n    public isEqual(range: Range | { start: CursorParagraph; end: CursorParagraph }): boolean {\n        return (\n            this.start.row === range.start.row &&\n            this.end.row === range.end.row &&\n            this.start.column === range.start.column &&\n            this.end.column === range.end.column\n        );\n    }\n\n    contains(position: CursorParagraph): boolean {\n        return this.comparePosition(position) === 0;\n    }\n\n    comparePosition(position: CursorParagraph): number {\n        const compare = this.compareSingleLine(position);\n\n        return compare ?? this.compareMultiLine(position);\n    }\n\n    /**\n     * Given the current `Range`,\n     * this function converts those starting and ending cursor positions into screen positions, and then returns a new `Range` object.\n     * @param {EditSession} session The `EditSession` to retrieve coordinates from\n     * @returns {Range}\n     **/\n    toScreenRange(session: EditSession): Range {\n        const screenPosStart = PositionHelper.documentToScreen(session, this.start.row, this.start.column);\n        const screenPosEnd = PositionHelper.documentToScreen(session, this.end.row, this.end.column);\n\n        return new Range(screenPosStart, screenPosEnd);\n    }\n\n    /**\n     * Returns the part of the current `Range` that occurs within the boundaries of `firstRow` and `lastRow` as a new `Range` object.\n     * @param {Number} firstRow The starting row\n     * @param {Number} lastRow The ending row\n     * @returns {CursorParagraph}\n     **/\n    clipRows(firstRow: number, lastRow: number): Range {\n        let end: CursorParagraph;\n        if (this.end.row > lastRow) {\n            end = new CursorParagraph(lastRow + 1, 0);\n        } else if (this.end.row < firstRow) {\n            end = new CursorParagraph(firstRow, 0);\n        }\n\n        let start: CursorParagraph;\n        if (this.start.row > lastRow) {\n            start = new CursorParagraph(lastRow + 1, 0);\n        } else if (this.start.row < firstRow) {\n            start = new CursorParagraph(firstRow, 0);\n        }\n\n        return new Range(start || this.start, end || this.end);\n    }\n\n    private compareSingleLine(position: CursorParagraph): number {\n        if (!this.isSingleLine) {\n            return null;\n        }\n\n        if (position.row === this.start.row) {\n            if (position.column < this.start.column) {\n                return -1;\n            } else if (position.column > this.end.column) {\n                return 1;\n            } else {\n                return 0;\n            }\n        }\n\n        return null;\n    }\n\n    private compareMultiLine(position: CursorParagraph): number {\n        if (this.start.row === position.row) {\n            return position.column >= this.start.column ? 0 : -1;\n        }\n\n        if (this.end.row === position.row) {\n            return position.column <= this.end.column ? 0 : 1;\n        }\n\n        if (position.row < this.start.row) {\n            return -1;\n        }\n\n        if (position.row > this.end.row) {\n            return 1;\n        }\n\n        return 0;\n    }\n}\n"]}

package/esm2022/lib/editor/positioning/selection.mjs

@@ -0,0 +1,307 @@
+import { ContentHelper } from './content.helper';
+import { CursorParagraph } from './cursor-paragraph';
+import { PositionHelper } from './position.helper';
+import { Range } from './range';
+export class Selection {
+    constructor() {
+        this.anchor = null;
+        this.cursor = new CursorParagraph(0, 0);
+        this.keepLinePositionX = null;
+    }
+    get isEmpty() {
+        return this.anchor === null || (this.anchor.row === this.cursor.row && this.anchor.column === this.cursor.column);
+    }
+    get isBackwards() {
+        return this.anchor.row > this.cursor.row || (this.anchor.row === this.cursor.row && this.anchor.column > this.cursor.column);
+    }
+    get range() {
+        const cursor = new CursorParagraph(this.cursor.row, this.cursor.column);
+        if (this.isEmpty) {
+            return new Range(cursor, cursor);
+        }
+        const anchor = new CursorParagraph(this.anchor.row, this.anchor.column);
+        return this.isBackwards ? new Range(cursor, anchor) : new Range(anchor, cursor);
+    }
+    placeCursor(cursor) {
+        this.cursor = cursor;
+        this.anchor = null;
+        this.keepLinePositionX = null;
+    }
+    moveCursor(cursor) {
+        this.cursor = cursor;
+        this.keepLinePositionX = null;
+    }
+    placeSelection(cursor, anchor) {
+        this.cursor = cursor;
+        this.anchor = anchor;
+        this.keepLinePositionX = null;
+    }
+    moveSelection(position) {
+        if (!this.anchor) {
+            this.anchor = this.cursor;
+        }
+        this.moveCursor(position);
+    }
+    clearSelection() {
+        this.anchor = null;
+        this.keepLinePositionX = null;
+    }
+    selectAll(model) {
+        const last = model.paragraphs.length - 1;
+        const length = last > 0 ? model.contentLength - model.paragraphs[last - 1].insertIndex - 1 : model.contentLength;
+        this.placeSelection(new CursorParagraph(0, 0), new CursorParagraph(last, length));
+    }
+    selectUp(session) {
+        if (!this.anchor) {
+            this.anchor = this.cursor;
+        }
+        this.moveCursorUp(session, this.cursor);
+    }
+    navigateUp(session) {
+        const position = this.isEmpty || this.isBackwards ? this.cursor : this.anchor;
+        this.moveCursorUp(session, position);
+        this.anchor = null;
+    }
+    selectDown(session) {
+        if (!this.anchor) {
+            this.anchor = this.cursor;
+        }
+        this.moveCursorDown(session, this.cursor);
+    }
+    navigateDown(session) {
+        const position = this.isEmpty || !this.isBackwards ? this.cursor : this.anchor;
+        this.moveCursorDown(session, position);
+        this.anchor = null;
+    }
+    selectRight(session) {
+        const position = this.getCursorRight(session);
+        this.moveSelection(position);
+    }
+    navigateRight(session) {
+        if (this.isEmpty) {
+            const position = this.getCursorRight(session);
+            this.placeCursor(position);
+        }
+        else {
+            const position = !this.isBackwards ? this.cursor : this.anchor;
+            this.placeCursor(position);
+        }
+    }
+    selectLeft(session) {
+        const position = this.getCursorLeft(session);
+        this.moveSelection(position);
+    }
+    navigateLeft(session) {
+        if (this.isEmpty) {
+            const position = this.getCursorLeft(session);
+            this.placeCursor(position);
+        }
+        else {
+            const position = this.isBackwards ? this.cursor : this.anchor;
+            this.placeCursor(position);
+        }
+    }
+    selectLineStart(session) {
+        const position = this.getLineStart(session, this.cursor);
+        this.moveSelection(position);
+    }
+    navigateLineStart(session) {
+        const position = this.getLineStart(session, this.cursor);
+        this.placeCursor(position);
+    }
+    selectLineEnd(session) {
+        const position = this.getLineEnd(session, this.cursor);
+        this.moveSelection(position);
+    }
+    navigateLineEnd(session) {
+        const position = this.getLineEnd(session, this.cursor);
+        this.placeCursor(position);
+    }
+    selectFileEnd(session) {
+        const paragraph = session.document.lines.length - 1;
+        const paragraphIndex = session.document.lines[paragraph].length;
+        this.moveSelection(new CursorParagraph(paragraph, paragraphIndex));
+    }
+    navigateFileEnd(session) {
+        const paragraph = session.document.lines.length - 1;
+        const paragraphIndex = session.document.lines[paragraph].length;
+        this.placeCursor(new CursorParagraph(paragraph, paragraphIndex));
+    }
+    selectFileStart() {
+        this.moveSelection(new CursorParagraph(0, 0));
+    }
+    navigateFileStart() {
+        this.placeCursor(new CursorParagraph(0, 0));
+    }
+    selectWordRight(session) {
+        const position = this.getWordRight(session, this.cursor);
+        this.moveSelection(position);
+    }
+    navigateWordRight(session) {
+        const position = this.getWordRight(session, this.cursor);
+        this.placeCursor(position);
+    }
+    selectWordLeft(session) {
+        const position = this.getWordLeft(session, this.cursor);
+        this.moveSelection(position);
+    }
+    navigateWordLeft(session) {
+        const position = this.getWordLeft(session, this.cursor);
+        this.placeCursor(position);
+    }
+    moveCursorUp(session, position) {
+        const line = PositionHelper.documentToScreen(session, position.row, position.column);
+        if (line.row === 0) {
+            this.selectLineStart(session);
+        }
+        else {
+            this.moveToLine(session, line.row - 1, line);
+        }
+    }
+    moveCursorDown(session, position) {
+        const line = PositionHelper.documentToScreen(session, position.row, position.column);
+        const paragraphsCount = session.pagesWrap.paragraphs.length;
+        const lastParagraph = session.pagesWrap.paragraphs[paragraphsCount - 1];
+        const lastParagraphLine = lastParagraph.textLinesInfo[lastParagraph.textLinesInfo.length - 1].screenLine;
+        if (line.row === lastParagraphLine) {
+            this.selectLineEnd(session);
+        }
+        else {
+            this.moveToLine(session, line.row + 1, line);
+        }
+    }
+    moveToLine(session, line, fromLine) {
+        if (!this.keepLinePositionX) {
+            this.keepLinePositionX = PositionHelper.screenToPixel(session, fromLine.row, fromLine.column).pageX;
+        }
+        const column = PositionHelper.getApproximatePosition(session, line, this.keepLinePositionX);
+        this.cursor = PositionHelper.screenToDocument(session, line, column);
+    }
+    getCursorLeft(session) {
+        if (this.cursor.row === 0 && this.cursor.column === 0) {
+            return this.cursor;
+        }
+        const index = ContentHelper.paragraphPositionToDocumentIndex(session.wrapParagraphIndex, this.cursor);
+        return ContentHelper.documentIndexToParagraphIndex(session.wrapParagraphIndex, index - 1);
+    }
+    getCursorRight(session) {
+        const last = session.pagesWrap.paragraphs.length - 1;
+        if (this.cursor.row === last && this.cursor.column === session.document.lines[last].length) {
+            return this.cursor;
+        }
+        const index = ContentHelper.paragraphPositionToDocumentIndex(session.wrapParagraphIndex, this.cursor);
+        return ContentHelper.documentIndexToParagraphIndex(session.wrapParagraphIndex, index + 1);
+    }
+    getLineStart(session, position) {
+        const line = PositionHelper.documentToScreen(session, position.row, position.column);
+        return PositionHelper.screenToDocument(session, line.row, 0);
+    }
+    getLineEnd(session, position) {
+        const line = PositionHelper.documentToScreen(session, position.row, position.column);
+        const paragraphLength = session.document.lines[position.row].length;
+        const linesCount = session.pagesWrap.paragraphs[position.row].textLinesInfo.length;
+        if (linesCount === 1) {
+            return PositionHelper.screenToDocument(session, line.row, paragraphLength);
+        }
+        const paragraphLine = line.row - session.wrapParagraphLine[position.row];
+        let index;
+        if (paragraphLine === 0) {
+            index = session.wrapData[position.row][0];
+        }
+        else if (paragraphLine === linesCount - 1) {
+            index = paragraphLength - session.wrapData[position.row][paragraphLine - 1];
+        }
+        else {
+            index = session.wrapData[position.row][paragraphLine] - session.wrapData[position.row][paragraphLine - 1];
+        }
+        return PositionHelper.screenToDocument(session, line.row, index);
+    }
+    getWordRight(session, position) {
+        let row = position.row;
+        let column = position.column;
+        const line = session.document.lines[row];
+        const documentLength = session.document.lines.length;
+        if (row + 1 >= documentLength && column === line.length) {
+            return position;
+        }
+        let rightOfCursor = line.substring(column);
+        if (column === line.length) {
+            do {
+                row++;
+                rightOfCursor = session.document.lines[row];
+            } while (row < documentLength && /^\s*$/.test(rightOfCursor));
+            if (!/^\s+/.test(rightOfCursor)) {
+                rightOfCursor = '';
+            }
+            column = 0;
+        }
+        const index = this.shortWordEndIndex(session.tokenRe, rightOfCursor);
+        return new CursorParagraph(row, column + index);
+    }
+    getWordLeft(session, position) {
+        let row = position.row;
+        let column = position.column;
+        if (column === 0 && row === 0) {
+            return position;
+        }
+        let line = session.document.lines[row].substring(0, column);
+        if (column === 0) {
+            do {
+                row--;
+                line = session.document.lines[row];
+            } while (row > 0 && /^\s*$/.test(line));
+            column = line.length;
+            if (!/\s+$/.test(line)) {
+                line = '';
+            }
+        }
+        const leftOfCursor = line.split('').reverse().join('');
+        const index = this.shortWordEndIndex(session.tokenRe, leftOfCursor);
+        return new CursorParagraph(row, column - index);
+    }
+    shortWordEndIndex(tokenRe, rightOfCursor) {
+        let index;
+        tokenRe.lastIndex = 0;
+        if (tokenRe.exec(rightOfCursor)) {
+            index = tokenRe.lastIndex;
+        }
+        else {
+            index = this.handleNoTokenFound(tokenRe, rightOfCursor);
+        }
+        tokenRe.lastIndex = 0;
+        return index;
+    }
+    handleNoTokenFound(tokenRe, rightOfCursor) {
+        const whitespaceRe = /\s/;
+        let index = 0;
+        while (rightOfCursor[index] && whitespaceRe.test(rightOfCursor[index])) {
+            index++;
+        }
+        if (index < 1) {
+            index = this.handleNoWhitespaceFound(tokenRe, rightOfCursor, whitespaceRe);
+        }
+        return index;
+    }
+    handleNoWhitespaceFound(tokenRe, rightOfCursor, whitespaceRe) {
+        let index = 0;
+        tokenRe.lastIndex = 0;
+        while (rightOfCursor[index] && !tokenRe.test(rightOfCursor[index])) {
+            tokenRe.lastIndex = 0;
+            index++;
+            if (whitespaceRe.test(rightOfCursor[index])) {
+                if (index > 2) {
+                    index--;
+                    break;
+                }
+                while (rightOfCursor[index] && whitespaceRe.test(rightOfCursor[index])) {
+                    index++;
+                }
+                if (index > 2) {
+                    break;
+                }
+            }
+        }
+        return index;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/positioning/selection.ts"],"names":[],"mappings":"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","sourcesContent":["import { ContentHelper } from './content.helper';\nimport { ContentsInterface } from '../content/contents.interface';\nimport { CursorParagraph } from './cursor-paragraph';\nimport { EditSession } from '../execution/edit.session';\nimport { PositionHelper } from './position.helper';\nimport { Range } from './range';\n\nexport class Selection {\n    anchor: CursorParagraph | null = null;\n\n    cursor = new CursorParagraph(0, 0);\n\n    private keepLinePositionX: number | null = null;\n\n    get isEmpty(): boolean {\n        return this.anchor === null || (this.anchor.row === this.cursor.row && this.anchor.column === this.cursor.column);\n    }\n\n    get isBackwards(): boolean {\n        return this.anchor.row > this.cursor.row || (this.anchor.row === this.cursor.row && this.anchor.column > this.cursor.column);\n    }\n\n    get range(): Range {\n        const cursor = new CursorParagraph(this.cursor.row, this.cursor.column);\n        if (this.isEmpty) {\n            return new Range(cursor, cursor);\n        }\n\n        const anchor = new CursorParagraph(this.anchor.row, this.anchor.column);\n        return this.isBackwards ? new Range(cursor, anchor) : new Range(anchor, cursor);\n    }\n\n    placeCursor(cursor: CursorParagraph): void {\n        this.cursor = cursor;\n        this.anchor = null;\n        this.keepLinePositionX = null;\n    }\n\n    moveCursor(cursor: CursorParagraph): void {\n        this.cursor = cursor;\n        this.keepLinePositionX = null;\n    }\n\n    placeSelection(cursor: CursorParagraph, anchor: CursorParagraph): void {\n        this.cursor = cursor;\n        this.anchor = anchor;\n        this.keepLinePositionX = null;\n    }\n\n    moveSelection(position: CursorParagraph): void {\n        if (!this.anchor) {\n            this.anchor = this.cursor;\n        }\n        this.moveCursor(position);\n    }\n\n    clearSelection(): void {\n        this.anchor = null;\n        this.keepLinePositionX = null;\n    }\n\n    selectAll(model: ContentsInterface): void {\n        const last = model.paragraphs.length - 1;\n        const length = last > 0 ? model.contentLength - model.paragraphs[last - 1].insertIndex - 1 : model.contentLength;\n        this.placeSelection(new CursorParagraph(0, 0), new CursorParagraph(last, length));\n    }\n\n    selectUp(session: EditSession): void {\n        if (!this.anchor) {\n            this.anchor = this.cursor;\n        }\n        this.moveCursorUp(session, this.cursor);\n    }\n\n    navigateUp(session: EditSession): void {\n        const position = this.isEmpty || this.isBackwards ? this.cursor : this.anchor;\n        this.moveCursorUp(session, position);\n        this.anchor = null;\n    }\n\n    selectDown(session: EditSession): void {\n        if (!this.anchor) {\n            this.anchor = this.cursor;\n        }\n        this.moveCursorDown(session, this.cursor);\n    }\n\n    navigateDown(session: EditSession): void {\n        const position = this.isEmpty || !this.isBackwards ? this.cursor : this.anchor;\n        this.moveCursorDown(session, position);\n        this.anchor = null;\n    }\n\n    selectRight(session: EditSession): void {\n        const position = this.getCursorRight(session);\n        this.moveSelection(position);\n    }\n\n    navigateRight(session: EditSession): void {\n        if (this.isEmpty) {\n            const position = this.getCursorRight(session);\n            this.placeCursor(position);\n        } else {\n            const position = !this.isBackwards ? this.cursor : this.anchor;\n            this.placeCursor(position);\n        }\n    }\n\n    selectLeft(session: EditSession): void {\n        const position = this.getCursorLeft(session);\n        this.moveSelection(position);\n    }\n\n    navigateLeft(session: EditSession): void {\n        if (this.isEmpty) {\n            const position = this.getCursorLeft(session);\n            this.placeCursor(position);\n        } else {\n            const position = this.isBackwards ? this.cursor : this.anchor;\n            this.placeCursor(position);\n        }\n    }\n\n    selectLineStart(session: EditSession): void {\n        const position = this.getLineStart(session, this.cursor);\n        this.moveSelection(position);\n    }\n\n    navigateLineStart(session: EditSession): void {\n        const position = this.getLineStart(session, this.cursor);\n        this.placeCursor(position);\n    }\n\n    selectLineEnd(session: EditSession): void {\n        const position = this.getLineEnd(session, this.cursor);\n        this.moveSelection(position);\n    }\n\n    navigateLineEnd(session: EditSession): void {\n        const position = this.getLineEnd(session, this.cursor);\n        this.placeCursor(position);\n    }\n\n    selectFileEnd(session: EditSession): void {\n        const paragraph = session.document.lines.length - 1;\n        const paragraphIndex = session.document.lines[paragraph].length;\n        this.moveSelection(new CursorParagraph(paragraph, paragraphIndex));\n    }\n\n    navigateFileEnd(session: EditSession): void {\n        const paragraph = session.document.lines.length - 1;\n        const paragraphIndex = session.document.lines[paragraph].length;\n        this.placeCursor(new CursorParagraph(paragraph, paragraphIndex));\n    }\n\n    selectFileStart(): void {\n        this.moveSelection(new CursorParagraph(0, 0));\n    }\n\n    navigateFileStart(): void {\n        this.placeCursor(new CursorParagraph(0, 0));\n    }\n\n    selectWordRight(session: EditSession): void {\n        const position = this.getWordRight(session, this.cursor);\n        this.moveSelection(position);\n    }\n\n    navigateWordRight(session: EditSession): void {\n        const position = this.getWordRight(session, this.cursor);\n        this.placeCursor(position);\n    }\n\n    selectWordLeft(session: EditSession): void {\n        const position = this.getWordLeft(session, this.cursor);\n        this.moveSelection(position);\n    }\n\n    navigateWordLeft(session: EditSession): void {\n        const position = this.getWordLeft(session, this.cursor);\n        this.placeCursor(position);\n    }\n\n    private moveCursorUp(session: EditSession, position: CursorParagraph): void {\n        const line = PositionHelper.documentToScreen(session, position.row, position.column);\n        if (line.row === 0) {\n            this.selectLineStart(session);\n        } else {\n            this.moveToLine(session, line.row - 1, line);\n        }\n    }\n\n    private moveCursorDown(session: EditSession, position: CursorParagraph): void {\n        const line = PositionHelper.documentToScreen(session, position.row, position.column);\n        const paragraphsCount = session.pagesWrap.paragraphs.length;\n        const lastParagraph = session.pagesWrap.paragraphs[paragraphsCount - 1];\n        const lastParagraphLine = lastParagraph.textLinesInfo[lastParagraph.textLinesInfo.length - 1].screenLine;\n        if (line.row === lastParagraphLine) {\n            this.selectLineEnd(session);\n        } else {\n            this.moveToLine(session, line.row + 1, line);\n        }\n    }\n\n    private moveToLine(session: EditSession, line: number, fromLine: CursorParagraph): void {\n        if (!this.keepLinePositionX) {\n            this.keepLinePositionX = PositionHelper.screenToPixel(session, fromLine.row, fromLine.column).pageX;\n        }\n        const column = PositionHelper.getApproximatePosition(session, line, this.keepLinePositionX);\n        this.cursor = PositionHelper.screenToDocument(session, line, column);\n    }\n\n    private getCursorLeft(session: EditSession): CursorParagraph {\n        if (this.cursor.row === 0 && this.cursor.column === 0) {\n            return this.cursor;\n        }\n        const index = ContentHelper.paragraphPositionToDocumentIndex(session.wrapParagraphIndex, this.cursor);\n        return ContentHelper.documentIndexToParagraphIndex(session.wrapParagraphIndex, index - 1);\n    }\n\n    private getCursorRight(session: EditSession): CursorParagraph {\n        const last = session.pagesWrap.paragraphs.length - 1;\n        if (this.cursor.row === last && this.cursor.column === session.document.lines[last].length) {\n            return this.cursor;\n        }\n        const index = ContentHelper.paragraphPositionToDocumentIndex(session.wrapParagraphIndex, this.cursor);\n        return ContentHelper.documentIndexToParagraphIndex(session.wrapParagraphIndex, index + 1);\n    }\n\n    private getLineStart(session: EditSession, position: CursorParagraph): CursorParagraph {\n        const line = PositionHelper.documentToScreen(session, position.row, position.column);\n        return PositionHelper.screenToDocument(session, line.row, 0);\n    }\n\n    private getLineEnd(session: EditSession, position: CursorParagraph): CursorParagraph {\n        const line = PositionHelper.documentToScreen(session, position.row, position.column);\n        const paragraphLength = session.document.lines[position.row].length;\n        const linesCount = session.pagesWrap.paragraphs[position.row].textLinesInfo.length;\n        if (linesCount === 1) {\n            return PositionHelper.screenToDocument(session, line.row, paragraphLength);\n        }\n        const paragraphLine = line.row - session.wrapParagraphLine[position.row];\n        let index: number;\n        if (paragraphLine === 0) {\n            index = session.wrapData[position.row][0];\n        } else if (paragraphLine === linesCount - 1) {\n            index = paragraphLength - session.wrapData[position.row][paragraphLine - 1];\n        } else {\n            index = session.wrapData[position.row][paragraphLine] - session.wrapData[position.row][paragraphLine - 1];\n        }\n        return PositionHelper.screenToDocument(session, line.row, index);\n    }\n\n    private getWordRight(session: EditSession, position: CursorParagraph): CursorParagraph {\n        let row = position.row;\n        let column = position.column;\n        const line = session.document.lines[row];\n        const documentLength = session.document.lines.length;\n        if (row + 1 >= documentLength && column === line.length) {\n            return position;\n        }\n        let rightOfCursor = line.substring(column);\n        if (column === line.length) {\n            do {\n                row++;\n                rightOfCursor = session.document.lines[row];\n            } while (row < documentLength && /^\\s*$/.test(rightOfCursor));\n            if (!/^\\s+/.test(rightOfCursor)) {\n                rightOfCursor = '';\n            }\n            column = 0;\n        }\n        const index = this.shortWordEndIndex(session.tokenRe, rightOfCursor);\n        return new CursorParagraph(row, column + index);\n    }\n\n    private getWordLeft(session: EditSession, position: CursorParagraph): CursorParagraph {\n        let row = position.row;\n        let column = position.column;\n        if (column === 0 && row === 0) {\n            return position;\n        }\n        let line = session.document.lines[row].substring(0, column);\n        if (column === 0) {\n            do {\n                row--;\n                line = session.document.lines[row];\n            } while (row > 0 && /^\\s*$/.test(line));\n            column = line.length;\n            if (!/\\s+$/.test(line)) {\n                line = '';\n            }\n        }\n        const leftOfCursor = line.split('').reverse().join('');\n        const index = this.shortWordEndIndex(session.tokenRe, leftOfCursor);\n        return new CursorParagraph(row, column - index);\n    }\n\n    private shortWordEndIndex(tokenRe: RegExp, rightOfCursor: string): number {\n        let index: number;\n        tokenRe.lastIndex = 0;\n        if (tokenRe.exec(rightOfCursor)) {\n            index = tokenRe.lastIndex;\n        } else {\n            index = this.handleNoTokenFound(tokenRe, rightOfCursor);\n        }\n        tokenRe.lastIndex = 0;\n        return index;\n    }\n\n    private handleNoTokenFound(tokenRe: RegExp, rightOfCursor: string): number {\n        const whitespaceRe = /\\s/;\n        let index = 0;\n        while (rightOfCursor[index] && whitespaceRe.test(rightOfCursor[index])) {\n            index++;\n        }\n        if (index < 1) {\n            index = this.handleNoWhitespaceFound(tokenRe, rightOfCursor, whitespaceRe);\n        }\n        return index;\n    }\n\n    private handleNoWhitespaceFound(tokenRe: RegExp, rightOfCursor: string, whitespaceRe: RegExp): number {\n        let index = 0;\n        tokenRe.lastIndex = 0;\n        while (rightOfCursor[index] && !tokenRe.test(rightOfCursor[index])) {\n            tokenRe.lastIndex = 0;\n            index++;\n            if (whitespaceRe.test(rightOfCursor[index])) {\n                if (index > 2) {\n                    index--;\n                    break;\n                }\n                while (rightOfCursor[index] && whitespaceRe.test(rightOfCursor[index])) {\n                    index++;\n                }\n                if (index > 2) {\n                    break;\n                }\n            }\n        }\n        return index;\n    }\n}\n"]}

package/esm2022/lib/editor/revision.helper.mjs

@@ -0,0 +1,91 @@
+import { ContentStyleHelper } from './content/helpers/content-style.helper';
+import { DEFAULT_HEADINGS, DEFAULT_PARAGRAPH_STYLE, DEFAULT_TEXT_STYLE } from './content/constants/editor.const';
+import { DocumentInfo } from './content/constants/document-info.const';
+import { DocxModel } from '../models/generated/docx.model';
+import { FormatModel } from '../models/generated/format.model';
+import { MarginModel } from './content/margin.model';
+import { OperationsHelper } from './operations/operations-helper.helper';
+import { ParagraphModel } from '../models/generated/paragraph.model';
+import { ParagraphStyleModel } from '../models/generated/paragraph-style.model';
+export class RevisionHelper {
+    static applyOperationsToRevision(revision, operations) {
+        operations.sort((a, b) => a.createTime - b.createTime);
+        const actions = operations.map(x => x.command);
+        OperationsHelper.applyOperations(revision.content, actions);
+    }
+    static fillTablesDefaultStyles(tables) {
+        for (const table of tables) {
+            for (const row of table.rows) {
+                for (const cell of row.cells) {
+                    this.fillDefaultStyles(cell);
+                }
+            }
+        }
+    }
+    static fillEdgesDefaultStyles(headers, footers) {
+        for (const header of headers) {
+            this.fillDefaultStyles(header);
+        }
+        for (const footer of footers) {
+            this.fillDefaultStyles(footer);
+        }
+    }
+    static fillDefaultStyles(contents) {
+        for (const format of contents.formats) {
+            format.textStyle = ContentStyleHelper.combineTextStyles(format.textStyle, DEFAULT_TEXT_STYLE);
+        }
+        for (const paragraph of contents.paragraphs) {
+            paragraph.paragraphStyle = this.fillParagraphStyleModel(paragraph.paragraphStyle);
+        }
+    }
+    static fillParagraphStyleModel(paragraphStyle) {
+        return new ParagraphStyleModel({
+            alignment: paragraphStyle.alignment ?? DEFAULT_PARAGRAPH_STYLE.alignment,
+            backgroundColor: paragraphStyle.backgroundColor ?? DEFAULT_PARAGRAPH_STYLE.backgroundColor,
+            headingStyleId: paragraphStyle.headingStyleId,
+            indentFirstLine: paragraphStyle.indentFirstLine ?? DEFAULT_PARAGRAPH_STYLE.indentFirstLine,
+            indentHanging: paragraphStyle.indentHanging ?? DEFAULT_PARAGRAPH_STYLE.indentHanging,
+            indentLeft: paragraphStyle.indentLeft ?? DEFAULT_PARAGRAPH_STYLE.indentLeft,
+            indentRight: paragraphStyle.indentRight ?? DEFAULT_PARAGRAPH_STYLE.indentRight,
+            lineSpacing: paragraphStyle.lineSpacing ?? DEFAULT_PARAGRAPH_STYLE.lineSpacing,
+            spaceAfter: paragraphStyle.spaceAfter ?? DEFAULT_PARAGRAPH_STYLE.spaceAfter,
+            spaceBefore: paragraphStyle.spaceBefore ?? DEFAULT_PARAGRAPH_STYLE.spaceBefore,
+            contextualSpacing: paragraphStyle.contextualSpacing ?? DEFAULT_PARAGRAPH_STYLE.contextualSpacing,
+            beforeAutospacing: paragraphStyle.beforeAutospacing ?? DEFAULT_PARAGRAPH_STYLE.beforeAutospacing,
+            afterAutospacing: paragraphStyle.afterAutospacing ?? DEFAULT_PARAGRAPH_STYLE.afterAutospacing,
+            numberingId: paragraphStyle.numberingId ?? DEFAULT_PARAGRAPH_STYLE.numberingId,
+            numberingLevel: paragraphStyle.numberingLevel ?? DEFAULT_PARAGRAPH_STYLE.numberingLevel
+        });
+    }
+    static getEmptyDocxModel() {
+        const pageMargin = new MarginModel();
+        return new DocxModel({
+            content: '',
+            contentLength: 0,
+            headings: DEFAULT_HEADINGS,
+            pageHeight: DocumentInfo.height,
+            pageWidth: DocumentInfo.width,
+            paragraphs: [
+                new ParagraphModel({
+                    insertIndex: 0,
+                    paragraphStyle: DEFAULT_PARAGRAPH_STYLE
+                })
+            ],
+            breaks: [],
+            elements: [],
+            formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: DEFAULT_TEXT_STYLE })],
+            images: [],
+            links: [],
+            marginBottom: pageMargin.bottom,
+            marginFooter: pageMargin.footer,
+            marginHeader: pageMargin.header,
+            marginLeft: pageMargin.left,
+            marginRight: pageMargin.right,
+            marginTop: pageMargin.top,
+            tables: [],
+            numberings: [],
+            tabs: []
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"revision.helper.js","sourceRoot":"","sources":["../../../../../projects/ngx-noder/src/lib/editor/revision.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { ContentsInterface } from './content/contents.interface';\nimport { ContentStyleHelper } from './content/helpers/content-style.helper';\nimport { DEFAULT_HEADINGS, DEFAULT_PARAGRAPH_STYLE, DEFAULT_TEXT_STYLE } from './content/constants/editor.const';\nimport { DocumentInfo } from './content/constants/document-info.const';\nimport { DocxModel } from '../models/generated/docx.model';\nimport { EdgeModel } from '../models/generated/edge.model';\nimport { FormatModel } from '../models/generated/format.model';\nimport { MarginModel } from './content/margin.model';\nimport { OperationModel } from '../models/generated/operation.model';\nimport { OperationsHelper } from './operations/operations-helper.helper';\nimport { ParagraphModel } from '../models/generated/paragraph.model';\nimport { ParagraphStyleModel } from '../models/generated/paragraph-style.model';\nimport { RevisionModel } from '../models/generated/revision.model';\nimport { TableModel } from '../models/generated/table.model';\n\nexport class RevisionHelper {\n    static applyOperationsToRevision(revision: RevisionModel, operations: OperationModel[]): void {\n        operations.sort((a, b) => a.createTime - b.createTime);\n        const actions = operations.map(x => x.command);\n        OperationsHelper.applyOperations(revision.content, actions);\n    }\n\n    static fillTablesDefaultStyles(tables: TableModel[]): void {\n        for (const table of tables) {\n            for (const row of table.rows) {\n                for (const cell of row.cells) {\n                    this.fillDefaultStyles(cell);\n                }\n            }\n        }\n    }\n\n    static fillEdgesDefaultStyles(headers: EdgeModel[], footers: EdgeModel[]): void {\n        for (const header of headers) {\n            this.fillDefaultStyles(header);\n        }\n\n        for (const footer of footers) {\n            this.fillDefaultStyles(footer);\n        }\n    }\n\n    static fillDefaultStyles(contents: ContentsInterface): void {\n        for (const format of contents.formats) {\n            format.textStyle = ContentStyleHelper.combineTextStyles(format.textStyle, DEFAULT_TEXT_STYLE);\n        }\n\n        for (const paragraph of contents.paragraphs) {\n            paragraph.paragraphStyle = this.fillParagraphStyleModel(paragraph.paragraphStyle);\n        }\n    }\n\n    static fillParagraphStyleModel(paragraphStyle: ParagraphStyleModel): ParagraphStyleModel {\n        return new ParagraphStyleModel({\n            alignment: paragraphStyle.alignment ?? DEFAULT_PARAGRAPH_STYLE.alignment,\n            backgroundColor: paragraphStyle.backgroundColor ?? DEFAULT_PARAGRAPH_STYLE.backgroundColor,\n            headingStyleId: paragraphStyle.headingStyleId,\n            indentFirstLine: paragraphStyle.indentFirstLine ?? DEFAULT_PARAGRAPH_STYLE.indentFirstLine,\n            indentHanging: paragraphStyle.indentHanging ?? DEFAULT_PARAGRAPH_STYLE.indentHanging,\n            indentLeft: paragraphStyle.indentLeft ?? DEFAULT_PARAGRAPH_STYLE.indentLeft,\n            indentRight: paragraphStyle.indentRight ?? DEFAULT_PARAGRAPH_STYLE.indentRight,\n            lineSpacing: paragraphStyle.lineSpacing ?? DEFAULT_PARAGRAPH_STYLE.lineSpacing,\n            spaceAfter: paragraphStyle.spaceAfter ?? DEFAULT_PARAGRAPH_STYLE.spaceAfter,\n            spaceBefore: paragraphStyle.spaceBefore ?? DEFAULT_PARAGRAPH_STYLE.spaceBefore,\n            contextualSpacing: paragraphStyle.contextualSpacing ?? DEFAULT_PARAGRAPH_STYLE.contextualSpacing,\n            beforeAutospacing: paragraphStyle.beforeAutospacing ?? DEFAULT_PARAGRAPH_STYLE.beforeAutospacing,\n            afterAutospacing: paragraphStyle.afterAutospacing ?? DEFAULT_PARAGRAPH_STYLE.afterAutospacing,\n            numberingId: paragraphStyle.numberingId ?? DEFAULT_PARAGRAPH_STYLE.numberingId,\n            numberingLevel: paragraphStyle.numberingLevel ?? DEFAULT_PARAGRAPH_STYLE.numberingLevel\n        });\n    }\n\n    static getEmptyDocxModel(): DocxModel {\n        const pageMargin = new MarginModel();\n        return new DocxModel({\n            content: '',\n            contentLength: 0,\n            headings: DEFAULT_HEADINGS,\n            pageHeight: DocumentInfo.height,\n            pageWidth: DocumentInfo.width,\n            paragraphs: [\n                new ParagraphModel({\n                    insertIndex: 0,\n                    paragraphStyle: DEFAULT_PARAGRAPH_STYLE\n                })\n            ],\n            breaks: [],\n            elements: [],\n            formats: [new FormatModel({ startIndex: 0, endIndex: 0, textStyle: DEFAULT_TEXT_STYLE })],\n            images: [],\n            links: [],\n            marginBottom: pageMargin.bottom,\n            marginFooter: pageMargin.footer,\n            marginHeader: pageMargin.header,\n            marginLeft: pageMargin.left,\n            marginRight: pageMargin.right,\n            marginTop: pageMargin.top,\n            tables: [],\n            numberings: [],\n            tabs: []\n        });\n    }\n}\n"]}

package/esm2022/lib/models/generated/cell.model.mjs

@@ -9,4 +9,4 @@ export class CellModel {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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