@talrace/ngx-noder 0.0.2

package/esm2022/lib/+shared/editor/core/renderer.mjs

@@ -0,0 +1,217 @@
+import { CursorLayer } from './layers/cursor.layer';
+import { DistanceModel } from './models/distance.model';
+import { DomHelper } from './helpers/dom.helper';
+import { EventEmitting } from './base/event-emitting';
+import { PositionHelper } from './helpers/position.helper';
+import { RenderChangesModel } from './models/render-changes.model';
+import { RenderLoop } from './layers/renderloop';
+import { SelectionLayer } from './layers/selection.layer';
+import { TextLayer } from './layers/text.layer';
+export class Renderer extends EventEmitting {
+    constructor(parentContainer, editorService) {
+        super();
+        this.editorService = editorService;
+        this.layerConfig = {
+            width: 1,
+            contentRange: new DistanceModel({ start: 0, end: 0 }),
+            minHeight: 1,
+            maxHeight: 1,
+            offset: 0,
+            height: 1,
+            scrollTop: 0,
+            pages: [],
+            visibleRange: {
+                startParagraph: 0,
+                startLine: 0,
+                startScreenLine: 0,
+                startScreenFullLine: 0,
+                endParagraph: 0,
+                endLine: 0,
+                endScreenLine: 0,
+                endScreenFullLine: 0
+            }
+        };
+        this.changes = new RenderChangesModel();
+        this.textareaSize = {
+            height: 1,
+            width: 1
+        };
+        this.pagesCountChangedHandler = () => {
+            this.loop.schedule({ lines: true, selection: true });
+        };
+        this.container = parentContainer;
+        this.container.className += ' ace-editor';
+        this.createContentContainer();
+        this.createLayers();
+        this.createRenderLoop();
+    }
+    renderChanges(changes, force) {
+        changes.apply(this.changes);
+        this.changes = new RenderChangesModel();
+        if (!this.session || (!changes.any && !force)) {
+            this.changes.apply(changes);
+            return;
+        }
+        // text, scrolling and resize changes can cause the view port size to change
+        if (changes.full || changes.size || changes.text || changes.lines || changes.scroll) {
+            changes.apply(this.computeLayerConfig());
+            DomHelper.translate(this.content, 0, -this.layerConfig.offset);
+            DomHelper.setStyle(this.content.style, 'width', `${this.layerConfig.width}px`);
+            DomHelper.setStyle(this.content.style, 'height', `${this.layerConfig.height}px`);
+        }
+        // full
+        if (changes.full) {
+            this.renderFull();
+            this.editorService.rendererUpdated(this.session.sessionId);
+            return;
+        }
+        if (changes.text || changes.scroll) {
+            this.renderText();
+        }
+        if (changes.cursor) {
+            this.renderCursor();
+        }
+        if (changes.marker || changes.selection) {
+            this.renderSelection();
+        }
+        this.editorService.rendererUpdated(this.session.sessionId);
+    }
+    /**
+     * Triggers a partial update of the text, from the range given by the two parameters.
+     **/
+    updateLines(firstRow, lastRow) {
+        // If the change happened offscreen above us then it's possible
+        // that a new line wrap will affect the position of the lines on our
+        // screen, so they need redrawn.
+        if (lastRow < this.layerConfig.contentRange.start || firstRow > this.layerConfig.contentRange.end) {
+            return;
+        }
+        this.loop.schedule({ lines: true });
+    }
+    moveTextAreaToCursor() {
+        if (this.isMousePressed || !this.textarea) {
+            return;
+        }
+        let cursorPosition = this.cursorLayer.cursorPosition;
+        if (!cursorPosition) {
+            return;
+        }
+        const posTop = cursorPosition.pageY - this.layerConfig.offset;
+        if (posTop < 0 || posTop > this.layerConfig.height - this.textareaSize.height) {
+            DomHelper.translate(this.textarea, 0, 0);
+            return;
+        }
+        DomHelper.setStyle(this.textarea.style, 'height', `${this.textareaSize.height}px`);
+        DomHelper.setStyle(this.textarea.style, 'width', `${this.textareaSize.width}px`);
+        DomHelper.translate(this.textarea, Math.min(cursorPosition.pageX, this.textareaSize.width), Math.min(posTop, this.textareaSize.height));
+    }
+    setSession(session) {
+        this.session = session;
+        this.textLayer.setSession(session);
+        this.cursorLayer.setSession(session);
+        this.selectionLayer.setSession(session);
+        this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+    }
+    updateSelection(range) {
+        if (range.isEmpty && this.selectionLayer.marker) {
+            this.selectionLayer.marker = null;
+            this.loop.schedule({ selection: true });
+        }
+        else if (!range.isEmpty && !this.selectionLayer.marker?.isEqual(range)) {
+            this.selectionLayer.marker = range;
+            this.loop.schedule({ selection: true });
+        }
+    }
+    /**
+     * Triggers a full update of the text, for all the rows.
+     **/
+    updateText() {
+        this.loop.schedule({ text: true });
+    }
+    /**
+     * Triggers a full update of all the layers, for all the rows.
+     **/
+    updateFull(force) {
+        if (force) {
+            this.renderChanges(new RenderChangesModel({ full: true }), true);
+            return;
+        }
+        this.loop.schedule({ full: true });
+    }
+    updateCursor() {
+        this.loop.schedule({ cursor: true });
+    }
+    screenToTextCoordinates(x, y) {
+        const screen = PositionHelper.pixelToScreen(this.session, x, y, this.container.getBoundingClientRect());
+        return PositionHelper.screenToDocument(this.session, screen.row, screen.column);
+    }
+    showCursor() {
+        this.cursorLayer.showCursor();
+        DomHelper.addCssClass(this.container, 'ace_focus');
+        this.editorService.rendererUpdated(this.session.sessionId);
+    }
+    hideCursor() {
+        this.cursorLayer.hideCursor();
+        DomHelper.removeCssClass(this.container, 'ace_focus');
+        this.editorService.rendererUpdated(this.session.sessionId);
+    }
+    destroy() {
+        this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+        this.textLayer.destroy();
+        DomHelper.removeChildren(this.container);
+    }
+    renderFull() {
+        this.textLayer.update(this.layerConfig);
+        this.selectionLayer.update(this.layerConfig);
+        this.cursorLayer.update(this.layerConfig);
+        this.moveTextAreaToCursor();
+    }
+    renderText() {
+        this.textLayer.update(this.layerConfig);
+        this.cursorLayer.detectVisibility();
+    }
+    renderCursor() {
+        this.cursorLayer.update(this.layerConfig);
+        this.moveTextAreaToCursor();
+    }
+    renderSelection() {
+        this.selectionLayer.update(this.layerConfig);
+        this.cursorLayer.detectVisibility();
+    }
+    computeLayerConfig() {
+        const pagesWrap = this.session.pagesWrap;
+        const maxHeight = pagesWrap.allPagesHeight;
+        const minHeight = pagesWrap.minHeight;
+        const changes = new RenderChangesModel({ scroll: true });
+        this.layerConfig = {
+            width: this.session.pagesWrap.contentWidth + pagesWrap.documentMargin.left + pagesWrap.documentMargin.right,
+            height: pagesWrap.defaultVerticalData.contentHeight,
+            contentRange: new DistanceModel({ start: 0, end: pagesWrap.paragraphs.length - 1 }),
+            minHeight,
+            maxHeight,
+            offset: 0,
+            scrollTop: this.session.scrollTop
+        };
+        return changes;
+    }
+    createContentContainer() {
+        this.content = document.createElement('div');
+        this.content.className = 'ace-content';
+        if (this.container.firstChild) {
+            this.container.firstChild.appendChild(this.content);
+        }
+        else {
+            this.container.appendChild(this.content);
+        }
+    }
+    createLayers() {
+        this.textLayer = new TextLayer(this.content);
+        this.selectionLayer = new SelectionLayer(this.content, 'text-selection');
+        this.cursorLayer = new CursorLayer(this.content);
+    }
+    createRenderLoop() {
+        this.loop = new RenderLoop(changes => this.renderChanges(changes));
+        this.loop.schedule({ text: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { CursorLayer } from './layers/cursor.layer';\nimport { DistanceModel } from './models/distance.model';\nimport { DomHelper } from './helpers/dom.helper';\nimport { EditorService } from '../interaction/editor.service';\nimport { EditSession } from './edit.session';\nimport { EventEmitting } from './base/event-emitting';\nimport { ILayerConfig } from './interfaces/layer.config';\nimport { Point } from './point';\nimport { PositionHelper } from './helpers/position.helper';\nimport { Range } from './range';\nimport { RenderChangesModel } from './models/render-changes.model';\nimport { RenderLoop } from './layers/renderloop';\nimport { SelectionLayer } from './layers/selection.layer';\nimport { TextLayer } from './layers/text.layer';\n\nexport class Renderer extends EventEmitting {\n    isMousePressed: boolean;\n\n    container: HTMLElement;\n\n    content: HTMLElement;\n\n    cursorLayer: CursorLayer;\n\n    textLayer: TextLayer;\n\n    selectionLayer: SelectionLayer;\n\n    session: EditSession;\n\n    loop: RenderLoop;\n\n    textarea: HTMLElement;\n\n    layerConfig: ILayerConfig = {\n        width: 1,\n        contentRange: new DistanceModel({ start: 0, end: 0 }),\n        minHeight: 1,\n        maxHeight: 1,\n        offset: 0,\n        height: 1,\n        scrollTop: 0,\n        pages: [],\n        visibleRange: {\n            startParagraph: 0,\n            startLine: 0,\n            startScreenLine: 0,\n            startScreenFullLine: 0,\n            endParagraph: 0,\n            endLine: 0,\n            endScreenLine: 0,\n            endScreenFullLine: 0\n        }\n    };\n\n    changes = new RenderChangesModel();\n\n    readonly textareaSize = {\n        height: 1,\n        width: 1\n    };\n\n    constructor(parentContainer: HTMLElement, private editorService: EditorService) {\n        super();\n        this.container = parentContainer;\n        this.container.className += ' ace-editor';\n        this.createContentContainer();\n        this.createLayers();\n        this.createRenderLoop();\n    }\n\n    renderChanges(changes: RenderChangesModel, force?: boolean): void {\n        changes.apply(this.changes);\n        this.changes = new RenderChangesModel();\n\n        if (!this.session || (!changes.any && !force)) {\n            this.changes.apply(changes);\n\n            return;\n        }\n\n        // text, scrolling and resize changes can cause the view port size to change\n        if (changes.full || changes.size || changes.text || changes.lines || changes.scroll) {\n            changes.apply(this.computeLayerConfig());\n\n            DomHelper.translate(this.content, 0, -this.layerConfig.offset);\n\n            DomHelper.setStyle(this.content.style, 'width', `${this.layerConfig.width}px`);\n            DomHelper.setStyle(this.content.style, 'height', `${this.layerConfig.height}px`);\n        }\n\n        // full\n        if (changes.full) {\n            this.renderFull();\n            this.editorService.rendererUpdated(this.session.sessionId);\n\n            return;\n        }\n\n        if (changes.text || changes.scroll) {\n            this.renderText();\n        }\n\n        if (changes.cursor) {\n            this.renderCursor();\n        }\n\n        if (changes.marker || changes.selection) {\n            this.renderSelection();\n        }\n\n        this.editorService.rendererUpdated(this.session.sessionId);\n    }\n\n    /**\n     * Triggers a partial update of the text, from the range given by the two parameters.\n     **/\n    updateLines(firstRow: number, lastRow: number): void {\n        // If the change happened offscreen above us then it's possible\n        // that a new line wrap will affect the position of the lines on our\n        // screen, so they need redrawn.\n        if (lastRow < this.layerConfig.contentRange.start || firstRow > this.layerConfig.contentRange.end) {\n            return;\n        }\n\n        this.loop.schedule({ lines: true });\n    }\n\n    moveTextAreaToCursor(): void {\n        if (this.isMousePressed || !this.textarea) {\n            return;\n        }\n\n        let cursorPosition = this.cursorLayer.cursorPosition;\n        if (!cursorPosition) {\n            return;\n        }\n\n        const posTop = cursorPosition.pageY - this.layerConfig.offset;\n        if (posTop < 0 || posTop > this.layerConfig.height - this.textareaSize.height) {\n            DomHelper.translate(this.textarea, 0, 0);\n            return;\n        }\n\n        DomHelper.setStyle(this.textarea.style, 'height', `${this.textareaSize.height}px`);\n        DomHelper.setStyle(this.textarea.style, 'width', `${this.textareaSize.width}px`);\n        DomHelper.translate(\n            this.textarea,\n            Math.min(cursorPosition.pageX, this.textareaSize.width),\n            Math.min(posTop, this.textareaSize.height)\n        );\n    }\n\n    setSession(session: EditSession): void {\n        this.session = session;\n        this.textLayer.setSession(session);\n        this.cursorLayer.setSession(session);\n        this.selectionLayer.setSession(session);\n        this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n    }\n\n    updateSelection(range: Range): void {\n        if (range.isEmpty && this.selectionLayer.marker) {\n            this.selectionLayer.marker = null;\n            this.loop.schedule({ selection: true });\n        } else if (!range.isEmpty && !this.selectionLayer.marker?.isEqual(range)) {\n            this.selectionLayer.marker = range;\n            this.loop.schedule({ selection: true });\n        }\n    }\n\n    /**\n     * Triggers a full update of the text, for all the rows.\n     **/\n    updateText(): void {\n        this.loop.schedule({ text: true });\n    }\n\n    /**\n     * Triggers a full update of all the layers, for all the rows.\n     **/\n    updateFull(force?: boolean): void {\n        if (force) {\n            this.renderChanges(new RenderChangesModel({ full: true }), true);\n\n            return;\n        }\n\n        this.loop.schedule({ full: true });\n    }\n\n    updateCursor(): void {\n        this.loop.schedule({ cursor: true });\n    }\n\n    screenToTextCoordinates(x: number, y: number): Point {\n        const screen = PositionHelper.pixelToScreen(this.session, x, y, this.container.getBoundingClientRect());\n\n        return PositionHelper.screenToDocument(this.session, screen.row, screen.column);\n    }\n\n    showCursor(): void {\n        this.cursorLayer.showCursor();\n        DomHelper.addCssClass(this.container, 'ace_focus');\n        this.editorService.rendererUpdated(this.session.sessionId);\n    }\n\n    hideCursor(): void {\n        this.cursorLayer.hideCursor();\n        DomHelper.removeCssClass(this.container, 'ace_focus');\n        this.editorService.rendererUpdated(this.session.sessionId);\n    }\n\n    destroy(): void {\n        this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n        this.textLayer.destroy();\n        DomHelper.removeChildren(this.container);\n    }\n\n    renderFull(): void {\n        this.textLayer.update(this.layerConfig);\n        this.selectionLayer.update(this.layerConfig);\n        this.cursorLayer.update(this.layerConfig);\n        this.moveTextAreaToCursor();\n    }\n\n    renderText(): void {\n        this.textLayer.update(this.layerConfig);\n        this.cursorLayer.detectVisibility();\n    }\n\n    renderCursor(): void {\n        this.cursorLayer.update(this.layerConfig);\n        this.moveTextAreaToCursor();\n    }\n\n    renderSelection(): void {\n        this.selectionLayer.update(this.layerConfig);\n        this.cursorLayer.detectVisibility();\n    }\n\n    private computeLayerConfig(): RenderChangesModel {\n        const pagesWrap = this.session.pagesWrap;\n        const maxHeight = pagesWrap.allPagesHeight;\n        const minHeight = pagesWrap.minHeight;\n\n        const changes = new RenderChangesModel({ scroll: true });\n        this.layerConfig = {\n            width: this.session.pagesWrap.contentWidth + pagesWrap.documentMargin.left + pagesWrap.documentMargin.right,\n            height: pagesWrap.defaultVerticalData.contentHeight,\n            contentRange: new DistanceModel({ start: 0, end: pagesWrap.paragraphs.length - 1 }),\n            minHeight,\n            maxHeight,\n            offset: 0,\n            scrollTop: this.session.scrollTop\n        };\n\n        return changes;\n    }\n\n    private pagesCountChangedHandler = (): void => {\n        this.loop.schedule({ lines: true, selection: true });\n    };\n\n    private createContentContainer(): void {\n        this.content = document.createElement('div');\n        this.content.className = 'ace-content';\n\n        if (this.container.firstChild) {\n            this.container.firstChild.appendChild(this.content);\n        } else {\n            this.container.appendChild(this.content);\n        }\n    }\n\n    private createLayers(): void {\n        this.textLayer = new TextLayer(this.content);\n        this.selectionLayer = new SelectionLayer(this.content, 'text-selection');\n        this.cursorLayer = new CursorLayer(this.content);\n    }\n\n    private createRenderLoop(): void {\n        this.loop = new RenderLoop(changes => this.renderChanges(changes));\n        this.loop.schedule({ text: true });\n    }\n}\n"]}

package/esm2022/lib/+shared/editor/core/search.mjs

@@ -0,0 +1,231 @@
+import { Point } from './point';
+import { Range } from './range';
+export class SearchOptions {
+}
+export class Search {
+    constructor() {
+        this.options = {};
+    }
+    set(options) {
+        this.options = Object.assign({}, options);
+    }
+    find(session) {
+        const options = this.options;
+        this.setMatchIterator(session, options);
+        const iterator = this.forEach;
+        if (!iterator) {
+            return null;
+        }
+        let firstRange = null;
+        iterator((startRow, startColumn, endRow, endColumn) => {
+            firstRange = new Range(new Point(startRow, startColumn), new Point(endRow, endColumn));
+            if (startColumn === endColumn &&
+                options.start instanceof Range &&
+                options.start.start &&
+                options.skipCurrent !== false &&
+                firstRange.isEqual(options.start)) {
+                firstRange = null;
+                return false;
+            }
+            return true;
+        });
+        return firstRange;
+    }
+    assembleRegExp(options) {
+        let needle = options.term;
+        if (!options.term) {
+            options.regex = null;
+            return options.regex;
+        }
+        let modifier = 'gmi';
+        options.isMultiLine = /[\n\r]/.test(needle);
+        if (options.isMultiLine) {
+            options.regex = this.assembleMultilineRegExp(needle, modifier);
+            return options.regex;
+        }
+        let regular;
+        try {
+            regular = new RegExp(needle, modifier);
+        }
+        catch (e) {
+            regular = null;
+        }
+        options.regex = regular;
+        return options.regex;
+    }
+    assembleMultilineRegExp(needle, modifier) {
+        const parts = needle.replace(/\r\n|\r|\n/g, '$\n^').split('\n');
+        const regex = [];
+        for (const element of parts) {
+            try {
+                regex.push(new RegExp(element, modifier));
+            }
+            catch (e) {
+                return [];
+            }
+        }
+        return regex;
+    }
+    setMatchIterator(session, options) {
+        const regex = this.assembleRegExp(options);
+        if (!regex) {
+            return null;
+        }
+        const backwards = options.backwards ?? false;
+        const skipCurrent = options.skipCurrent ?? false;
+        let start = options.start;
+        if (!start) {
+            start = session.selection.range;
+        }
+        let startPoint;
+        if (start instanceof Range && start.start) {
+            startPoint = start[skipCurrent !== backwards ? 'end' : 'start'];
+        }
+        let firstRow = 0;
+        let lastRow = session.document.getLinesCount() - 1;
+        this.setForEach(backwards, startPoint, options, firstRow, lastRow);
+        const singleRe = regex;
+        this.setForEachInLine(regex, options, backwards, session, singleRe);
+    }
+    setForEach(backwards, startPoint, options, firstRow, lastRow) {
+        if (backwards) {
+            this.setForEachForBackwards(startPoint, options, firstRow, lastRow);
+            return;
+        }
+        this.setDefaultForEach(startPoint, options, firstRow, lastRow);
+    }
+    setDefaultForEach(startPoint, options, firstRow, lastRow) {
+        this.forEach = callback => {
+            let row = startPoint.row;
+            if (this.forEachInLine(row, startPoint.column, callback)) {
+                return;
+            }
+            for (row = row + 1; row <= lastRow; row++) {
+                if (this.forEachInLine(row, 0, callback)) {
+                    return;
+                }
+            }
+            if (options.wrap === false) {
+                return;
+            }
+            for (row = firstRow, lastRow = startPoint.row; row <= lastRow; row++) {
+                if (this.forEachInLine(row, 0, callback)) {
+                    return;
+                }
+            }
+        };
+    }
+    setForEachForBackwards(startPoint, options, firstRow, lastRow) {
+        this.forEach = callback => {
+            let row = startPoint.row;
+            if (this.forEachInLine(row, startPoint.column, callback)) {
+                return;
+            }
+            for (row--; row >= firstRow; row--) {
+                if (this.forEachInLine(row, Number.MAX_VALUE, callback)) {
+                    return;
+                }
+            }
+            if (options.wrap === false) {
+                return;
+            }
+            for (row = lastRow, firstRow = startPoint.row; row >= firstRow; row--) {
+                if (this.forEachInLine(row, Number.MAX_VALUE, callback)) {
+                    return;
+                }
+            }
+        };
+    }
+    setForEachInLine(re, options, backwards, session, singleRe) {
+        if (Array.isArray(re) && options.isMultiLine) {
+            this.setForEachInLineForRegArray(re, backwards, session);
+        }
+        else if (backwards) {
+            this.setForEachInLineForBackwards(session, singleRe);
+        }
+        else {
+            this.setDefaultForEachInLine(session, singleRe);
+        }
+    }
+    setForEachInLineForRegArray(regex, backwards, session) {
+        let regularLength = regex.length;
+        this.forEachInLine = (row, offset, callback) => {
+            let startRow = backwards ? row - regularLength + 1 : row;
+            if (startRow < 0) {
+                return false;
+            }
+            let line = session.document.getLine(session.document.lines, startRow);
+            let startIndex = line.search(regex[0]);
+            if ((!backwards && startIndex < offset) || startIndex === -1) {
+                return false;
+            }
+            for (let i = 1; i < regularLength; i++) {
+                line = session.document.getLine(session.document.lines, startRow + i);
+                if (line.search(regex[i]) === -1) {
+                    return false;
+                }
+            }
+            let endIndex = line.match(regex[regularLength - 1])[0].length;
+            if (backwards && endIndex > offset) {
+                return false;
+            }
+            if (callback(startRow, startIndex, startRow + regularLength - 1, endIndex)) {
+                return true;
+            }
+            return false;
+        };
+    }
+    setForEachInLineForBackwards(session, singleRe) {
+        this.forEachInLine = (row, endIndex, callback) => {
+            let line = session.document.getLine(session.document.lines, row);
+            let matches = [];
+            let regexResult, last = 0;
+            singleRe.lastIndex = 0;
+            while ((regexResult = singleRe.exec(line))) {
+                let length = regexResult[0].length;
+                last = regexResult.index;
+                if (!length) {
+                    if (last >= line.length) {
+                        break;
+                    }
+                    singleRe.lastIndex = last + 1;
+                }
+                if (regexResult.index + length > endIndex) {
+                    break;
+                }
+                matches.push(regexResult.index, length);
+            }
+            for (let i = matches.length - 1; i >= 0; i -= 2) {
+                let column = matches[i - 1];
+                let length = matches[i];
+                if (callback(row, column, row, column + length)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+    setDefaultForEachInLine(session, singleRe) {
+        this.forEachInLine = (row, startIndex, callback) => {
+            let line = session.document.getLine(session.document.lines, row);
+            let last;
+            let regexResult;
+            singleRe.lastIndex = startIndex;
+            while ((regexResult = singleRe.exec(line))) {
+                let length = regexResult[0].length;
+                last = regexResult.index;
+                if (callback(row, last, row, last + length)) {
+                    return true;
+                }
+                if (!length) {
+                    singleRe.lastIndex = last += 1;
+                    if (last >= line.length) {
+                        return false;
+                    }
+                }
+            }
+            return false;
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/search.ts"],"names":[],"mappings":"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","sourcesContent":["import { EditSession } from './edit.session';\nimport { Point } from './point';\nimport { Range } from './range';\n\nexport class SearchOptions {\n    term?: string;\n    backwards?: boolean;\n    start?: Point | Range;\n    skipCurrent?: boolean;\n    wrap?: boolean;\n    isMultiLine?: boolean;\n    regex?: RegExp | (RegExp[] & { offset?: number });\n}\n\nexport class Search {\n    options: SearchOptions;\n    forEach: (callback: any) => void;\n    forEachInLine: (row: number, offset: number, callback: any) => boolean;\n\n    constructor() {\n        this.options = {};\n    }\n\n    set(options: SearchOptions): void {\n        this.options = Object.assign({}, options);\n    }\n\n    find(session: EditSession): Range {\n        const options = this.options;\n        this.setMatchIterator(session, options);\n        const iterator = this.forEach;\n        if (!iterator) {\n            return null;\n        }\n\n        let firstRange = null;\n        iterator((startRow: number, startColumn: number, endRow: number, endColumn: number) => {\n            firstRange = new Range(new Point(startRow, startColumn), new Point(endRow, endColumn));\n            if (\n                startColumn === endColumn &&\n                options.start instanceof Range &&\n                options.start.start &&\n                options.skipCurrent !== false &&\n                firstRange.isEqual(options.start)\n            ) {\n                firstRange = null;\n                return false;\n            }\n\n            return true;\n        });\n\n        return firstRange;\n    }\n\n    assembleRegExp(options: SearchOptions): RegExp | RegExp[] {\n        let needle = options.term;\n\n        if (!options.term) {\n            options.regex = null;\n            return options.regex;\n        }\n\n        let modifier = 'gmi';\n\n        options.isMultiLine = /[\\n\\r]/.test(needle);\n        if (options.isMultiLine) {\n            options.regex = this.assembleMultilineRegExp(needle, modifier);\n            return options.regex;\n        }\n\n        let regular: RegExp;\n        try {\n            regular = new RegExp(needle, modifier);\n        } catch (e) {\n            regular = null;\n        }\n        options.regex = regular;\n        return options.regex;\n    }\n\n    assembleMultilineRegExp(needle: string, modifier: string): RegExp[] {\n        const parts = needle.replace(/\\r\\n|\\r|\\n/g, '$\\n^').split('\\n');\n        const regex: RegExp[] = [];\n        for (const element of parts) {\n            try {\n                regex.push(new RegExp(element, modifier));\n            } catch (e) {\n                return [];\n            }\n        }\n        return regex;\n    }\n\n    setMatchIterator(session: EditSession, options: SearchOptions): void {\n        const regex = this.assembleRegExp(options);\n        if (!regex) {\n            return null;\n        }\n        const backwards = options.backwards ?? false;\n        const skipCurrent = options.skipCurrent ?? false;\n\n        let start = options.start;\n        if (!start) {\n            start = session.selection.range;\n        }\n\n        let startPoint: Point;\n        if (start instanceof Range && start.start) {\n            startPoint = start[skipCurrent !== backwards ? 'end' : 'start'];\n        }\n\n        let firstRow = 0;\n        let lastRow = session.document.getLinesCount() - 1;\n\n        this.setForEach(backwards, startPoint, options, firstRow, lastRow);\n\n        const singleRe = regex as RegExp;\n        this.setForEachInLine(regex, options, backwards, session, singleRe);\n    }\n\n    private setForEach(backwards: boolean, startPoint: Point, options: SearchOptions, firstRow: number, lastRow: number): void {\n        if (backwards) {\n            this.setForEachForBackwards(startPoint, options, firstRow, lastRow);\n\n            return;\n        }\n\n        this.setDefaultForEach(startPoint, options, firstRow, lastRow);\n    }\n\n    private setDefaultForEach(startPoint: Point, options: SearchOptions, firstRow: number, lastRow: number): void {\n        this.forEach = callback => {\n            let row = startPoint.row;\n            if (this.forEachInLine(row, startPoint.column, callback)) {\n                return;\n            }\n            for (row = row + 1; row <= lastRow; row++) {\n                if (this.forEachInLine(row, 0, callback)) {\n                    return;\n                }\n            }\n            if (options.wrap === false) {\n                return;\n            }\n            for (row = firstRow, lastRow = startPoint.row; row <= lastRow; row++) {\n                if (this.forEachInLine(row, 0, callback)) {\n                    return;\n                }\n            }\n        };\n    }\n\n    private setForEachForBackwards(startPoint: Point, options: SearchOptions, firstRow: number, lastRow: number): void {\n        this.forEach = callback => {\n            let row = startPoint.row;\n            if (this.forEachInLine(row, startPoint.column, callback)) {\n                return;\n            }\n            for (row--; row >= firstRow; row--) {\n                if (this.forEachInLine(row, Number.MAX_VALUE, callback)) {\n                    return;\n                }\n            }\n            if (options.wrap === false) {\n                return;\n            }\n            for (row = lastRow, firstRow = startPoint.row; row >= firstRow; row--) {\n                if (this.forEachInLine(row, Number.MAX_VALUE, callback)) {\n                    return;\n                }\n            }\n        };\n    }\n\n    private setForEachInLine(\n        re: RegExp | RegExp[],\n        options: SearchOptions,\n        backwards: boolean,\n        session: EditSession,\n        singleRe: RegExp\n    ): void {\n        if (Array.isArray(re) && options.isMultiLine) {\n            this.setForEachInLineForRegArray(re, backwards, session);\n        } else if (backwards) {\n            this.setForEachInLineForBackwards(session, singleRe);\n        } else {\n            this.setDefaultForEachInLine(session, singleRe);\n        }\n    }\n\n    private setForEachInLineForRegArray(regex: RegExp[], backwards: boolean, session: EditSession) {\n        let regularLength = regex.length;\n        this.forEachInLine = (row, offset, callback) => {\n            let startRow = backwards ? row - regularLength + 1 : row;\n            if (startRow < 0) {\n                return false;\n            }\n            let line = session.document.getLine(session.document.lines, startRow);\n            let startIndex = line.search(regex[0]);\n            if ((!backwards && startIndex < offset) || startIndex === -1) {\n                return false;\n            }\n            for (let i = 1; i < regularLength; i++) {\n                line = session.document.getLine(session.document.lines, startRow + i);\n                if (line.search(regex[i]) === -1) {\n                    return false;\n                }\n            }\n            let endIndex = line.match(regex[regularLength - 1])[0].length;\n            if (backwards && endIndex > offset) {\n                return false;\n            }\n            if (callback(startRow, startIndex, startRow + regularLength - 1, endIndex)) {\n                return true;\n            }\n            return false;\n        };\n    }\n\n    private setForEachInLineForBackwards(session: EditSession, singleRe: RegExp) {\n        this.forEachInLine = (row, endIndex, callback) => {\n            let line = session.document.getLine(session.document.lines, row);\n            let matches = [];\n            let regexResult: RegExpExecArray,\n                last = 0;\n            singleRe.lastIndex = 0;\n            while ((regexResult = singleRe.exec(line))) {\n                let length = regexResult[0].length;\n                last = regexResult.index;\n                if (!length) {\n                    if (last >= line.length) {\n                        break;\n                    }\n                    singleRe.lastIndex = last + 1;\n                }\n                if (regexResult.index + length > endIndex) {\n                    break;\n                }\n                matches.push(regexResult.index, length);\n            }\n            for (let i = matches.length - 1; i >= 0; i -= 2) {\n                let column = matches[i - 1];\n                let length = matches[i];\n                if (callback(row, column, row, column + length)) {\n                    return true;\n                }\n            }\n            return false;\n        };\n    }\n\n    private setDefaultForEachInLine(session: EditSession, singleRe: RegExp) {\n        this.forEachInLine = (row, startIndex, callback) => {\n            let line = session.document.getLine(session.document.lines, row);\n            let last: number;\n            let regexResult: RegExpExecArray;\n            singleRe.lastIndex = startIndex;\n            while ((regexResult = singleRe.exec(line))) {\n                let length = regexResult[0].length;\n                last = regexResult.index;\n                if (callback(row, last, row, last + length)) {\n                    return true;\n                }\n                if (!length) {\n                    singleRe.lastIndex = last += 1;\n                    if (last >= line.length) {\n                        return false;\n                    }\n                }\n            }\n            return false;\n        };\n    }\n}\n"]}