@talrace/ngx-noder 0.0.6 → 0.0.8

package/esm2022/lib/editor/display/virtual.renderer.mjs

@@ -0,0 +1,317 @@
+import { DistanceModel } from '../execution/distance.model';
+import { DomHelper } from '../execution/helpers/dom.helper';
+import { PagesLayer } from './layers/pages.layer';
+import { RenderChangesModel } from './render-changes.model';
+import { Renderer } from './renderer';
+import { RenderLoop } from './renderloop';
+export class VirtualRenderer {
+    get isMousePressed() {
+        return this.renderer.isMousePressed;
+    }
+    set isMousePressed(val) {
+        this.renderer.isMousePressed = val;
+    }
+    get cursorLayer() {
+        return this.renderer.cursorLayer;
+    }
+    get loop() {
+        return this.renderer.loop;
+    }
+    set loop(val) {
+        this.renderer.loop = val;
+    }
+    get textarea() {
+        return this.renderer.textarea;
+    }
+    set textarea(val) {
+        this.renderer.textarea = val;
+    }
+    get layerConfig() {
+        return this.renderer.layerConfig;
+    }
+    set layerConfig(val) {
+        this.renderer.layerConfig = val;
+    }
+    constructor(parentContainer, editorService, mainSession, scrollBar) {
+        this.scrollBar = scrollBar;
+        this.changes = new RenderChangesModel();
+        this.size = {
+            width: 0,
+            height: 0,
+            scrollerHeight: 0,
+            scrollerWidth: 0,
+            dirty: true
+        };
+        this.container = parentContainer;
+        this.createScroller();
+        this.renderer = new Renderer(parentContainer, editorService, mainSession);
+        this.renderer.layerConfig = this.getDefaultLayerConfig();
+        this.pagesLayer = new PagesLayer(this.renderer.content, mainSession);
+        this.scrollSubscription = this.scrollBar.scrolled$.subscribe(() => this.loop.schedule({ scroll: true }));
+        this.createRenderLoop();
+    }
+    renderChanges(changes, force) {
+        changes.apply(this.changes);
+        this.changes = new RenderChangesModel();
+        if (!this.container.offsetWidth || (!changes.any && !force)) {
+            this.changes.apply(changes);
+            return;
+        }
+        if (this.size.dirty) {
+            this.changes.apply(changes);
+            this.onResize(true);
+            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.renderer.content, 0, -this.layerConfig.offset);
+            DomHelper.setStyle(this.renderer.content.style, 'width', `${this.layerConfig.width}px`);
+            DomHelper.setStyle(this.renderer.content.style, 'height', `${this.layerConfig.height}px`);
+        }
+        // full
+        if (changes.full) {
+            this.renderFull();
+            return;
+        }
+        // scrolling
+        if (changes.scroll) {
+            this.renderScroll(changes);
+        }
+        if (changes.text) {
+            this.renderText();
+        }
+        if (changes.cursor) {
+            this.renderCursor();
+        }
+        if (changes.marker || changes.selection) {
+            this.renderSelection();
+        }
+    }
+    /**
+     * Triggers a resize of the editor
+     **/
+    onResize(force) {
+        const height = this.container.clientHeight || this.container.scrollHeight;
+        const width = this.container.clientWidth || this.container.scrollWidth;
+        const changes = this.updateCachedSize(force, width, height);
+        changes.apply(this.changes);
+        if (force) {
+            this.renderChanges(changes, true);
+        }
+        else {
+            this.loop.schedule(changes);
+        }
+        this.scrollBar.setScrollTop(0);
+    }
+    /**
+     * Triggers a partial update of the text, from the range given by the two parameters.
+     **/
+    updateLines(firstRow, lastRow) {
+        this.renderer.updateLines(firstRow, lastRow);
+    }
+    updateCachedSize(force, width, height) {
+        if (width && (force || this.size.width !== width)) {
+            DomHelper.setStyle(this.scroller.style, 'left', 0);
+            this.size.scrollerWidth = Math.max(0, this.container.parentElement.clientWidth - this.scrollBar.width);
+            DomHelper.setStyle(this.scroller.style, 'right', 0);
+        }
+        let changes = new RenderChangesModel();
+        if (height && (force || this.size.height !== height)) {
+            this.size.height = height;
+            changes.size = true;
+            this.size.scrollerHeight = this.size.height;
+            changes.scroll = true;
+        }
+        if (width && (force || this.size.width !== width)) {
+            this.size.width = width;
+            changes.size = true;
+        }
+        this.size.dirty = !width || !height;
+        return changes;
+    }
+    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.renderer.textareaSize.height) {
+            DomHelper.translate(this.textarea, 0, 0);
+            return;
+        }
+        DomHelper.setStyle(this.textarea.style, 'height', `${this.renderer.textareaSize.height}px`);
+        DomHelper.setStyle(this.textarea.style, 'width', `${this.renderer.textareaSize.width}px`);
+        DomHelper.translate(this.textarea, Math.min(cursorPosition.pageX, this.size.scrollerWidth - this.renderer.textareaSize.width), Math.min(posTop, this.size.height - this.renderer.textareaSize.height));
+    }
+    updateSelection(range) {
+        this.renderer.updateSelection(range);
+    }
+    /**
+     * Triggers a full update of the text, for all the rows.
+     **/
+    updateText() {
+        this.renderer.updateText();
+    }
+    /**
+     * Triggers a full update of all the layers, for all the rows.
+     **/
+    updateFull(force) {
+        this.renderer.updateFull(force);
+    }
+    updateCursor() {
+        this.renderer.updateCursor();
+    }
+    scrollSelectionIntoView(anchor, lead, offset) {
+        // first scroll anchor into view then scroll lead into view
+        this.scrollCursorIntoView(anchor, offset);
+        this.scrollCursorIntoView(lead, offset);
+    }
+    /**
+     * Scrolls the cursor into the first visibile area of the editor
+     **/
+    scrollCursorIntoView(cursor, offset) {
+        if (!this.size.scrollerHeight) {
+            return;
+        }
+        const position = this.cursorLayer.getPixelPosition(cursor);
+        let top = position.pageY + this.scrollBar.scrollTop;
+        if (this.scrollBar.scrollTop > top) {
+            if (offset) {
+                top -= offset * this.container.scrollHeight;
+            }
+            this.scrollBar.setScrollTop(top);
+            this.loop.schedule({ scroll: true });
+        }
+        else if (this.scrollBar.scrollTop + this.container.scrollHeight < top + position.lineHeight) {
+            if (offset) {
+                top += offset * this.container.scrollHeight;
+            }
+            top += position.lineHeight - this.container.scrollHeight;
+            this.scrollBar.setScrollTop(top);
+            this.loop.schedule({ scroll: true });
+        }
+    }
+    scrollBy(deltaY) {
+        if (!deltaY || !this.scrollBar.isVisible) {
+            return;
+        }
+        const scrollTop = this.scrollBar.scrollTop + deltaY;
+        this.scrollBar.setScrollTop(scrollTop);
+        this.loop.schedule({ scroll: true });
+    }
+    screenToTextCoordinates(x, y) {
+        return this.renderer.screenToTextCoordinates(x, y);
+    }
+    showCursor() {
+        this.renderer.showCursor();
+    }
+    hideCursor() {
+        this.renderer.hideCursor();
+    }
+    destroy() {
+        DomHelper.removeElement(this.scrollBar.element);
+        this.pagesLayer.destroy();
+        this.renderer.destroy();
+        this.scrollSubscription?.unsubscribe();
+    }
+    computeLayerConfig() {
+        const pagesWrap = this.renderer.session.pagesWrap;
+        const maxHeight = pagesWrap.allPagesHeight;
+        const minHeight = pagesWrap.minHeight;
+        const scrollHidden = maxHeight < this.size.scrollerHeight;
+        const newScrollTop = Math.max(Math.min(this.scrollBar.scrollTop, maxHeight - this.size.scrollerHeight), 0);
+        this.scrollBar.setScrollHeight(maxHeight);
+        this.scrollBar.setScrollTop(newScrollTop);
+        const canScroll = !scrollHidden && this.size.scrollerHeight - maxHeight < 0;
+        const scrollChanged = this.canScroll !== canScroll;
+        if (scrollChanged) {
+            this.canScroll = canScroll;
+            this.scrollBar.setVisible(canScroll);
+        }
+        const changes = scrollChanged
+            ? this.updateCachedSize(true, this.size.width, this.size.height)
+            : new RenderChangesModel({ scroll: true });
+        const visibleRange = pagesWrap.getVisibleRange(this.scrollBar.scrollTop, this.size.scrollerHeight);
+        this.layerConfig = {
+            width: this.renderer.textLayer.element.clientWidth,
+            height: this.size.scrollerHeight,
+            contentRange: new DistanceModel({ start: visibleRange.startParagraph, end: visibleRange.endParagraph }),
+            minHeight,
+            maxHeight,
+            offset: 0,
+            visibleRange,
+            scrollTop: this.scrollBar.scrollTop,
+            pages: visibleRange.pages
+        };
+        return changes;
+    }
+    createScroller() {
+        this.scroller = document.createElement('div');
+        this.scroller.className = 'noder-scroller';
+        this.container.appendChild(this.scroller);
+    }
+    createRenderLoop() {
+        this.loop = new RenderLoop(changes => this.renderChanges(changes));
+        this.renderer.loop = this.loop;
+        this.loop.schedule({ full: true });
+    }
+    renderScroll(changes) {
+        this.pagesLayer.update(this.layerConfig);
+        if (changes.text || changes.lines) {
+            this.renderer.textLayer.updateEdges(this.layerConfig);
+            this.renderer.textLayer.updateLines(this.layerConfig);
+        }
+        else {
+            this.renderer.textLayer.scrollPages(this.layerConfig);
+            this.renderer.textLayer.scrollLines(this.layerConfig);
+        }
+        this.renderer.selectionLayer.update(this.layerConfig);
+        if (!this.renderer.cursorLayer.isVisible) {
+            return;
+        }
+        this.cursorLayer.update(this.layerConfig);
+        this.moveTextAreaToCursor();
+    }
+    renderFull() {
+        this.pagesLayer.update(this.layerConfig);
+        this.renderer.textLayer.updateEdges(this.layerConfig);
+        this.renderer.renderFull();
+    }
+    renderText() {
+        this.pagesLayer.update(this.layerConfig);
+        this.renderer.renderText();
+    }
+    renderCursor() {
+        this.renderer.renderCursor();
+    }
+    renderSelection() {
+        this.renderer.renderSelection();
+    }
+    getDefaultLayerConfig() {
+        return {
+            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
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual.renderer.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/display/virtual.renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription } from 'rxjs';\n\nimport { CursorLayer } from './layers/cursor.layer';\nimport { CursorParagraph } from '../positioning/cursor-paragraph';\nimport { DistanceModel } from '../execution/distance.model';\nimport { DomHelper } from '../execution/helpers/dom.helper';\nimport { EditorService } from '../interaction/editor.service';\nimport { EditSession } from '../execution/edit.session';\nimport { ILayerConfig } from './layers/layer.config';\nimport { PagesLayer } from './layers/pages.layer';\nimport { Range } from '../positioning/range';\nimport { RenderChangesModel } from './render-changes.model';\nimport { Renderer } from './renderer';\nimport { RenderLoop } from './renderloop';\nimport { ScrollBar } from '../gadgets/scrollbar';\n\nexport class VirtualRenderer {\n    get isMousePressed(): boolean {\n        return this.renderer.isMousePressed;\n    }\n    set isMousePressed(val: boolean) {\n        this.renderer.isMousePressed = val;\n    }\n\n    get cursorLayer(): CursorLayer {\n        return this.renderer.cursorLayer;\n    }\n\n    get loop(): RenderLoop {\n        return this.renderer.loop;\n    }\n    set loop(val: RenderLoop) {\n        this.renderer.loop = val;\n    }\n\n    get textarea(): HTMLElement {\n        return this.renderer.textarea;\n    }\n    set textarea(val: HTMLElement) {\n        this.renderer.textarea = val;\n    }\n\n    get layerConfig(): ILayerConfig {\n        return this.renderer.layerConfig;\n    }\n    set layerConfig(val: ILayerConfig) {\n        this.renderer.layerConfig = val;\n    }\n\n    container: HTMLElement;\n\n    scroller: HTMLElement;\n\n    pagesLayer: PagesLayer;\n\n    canScroll: boolean;\n\n    renderer!: Renderer;\n\n    changes = new RenderChangesModel();\n\n    size = {\n        width: 0,\n        height: 0,\n        scrollerHeight: 0,\n        scrollerWidth: 0,\n        dirty: true\n    };\n\n    private scrollSubscription: Subscription;\n\n    constructor(parentContainer: HTMLElement, editorService: EditorService, mainSession: EditSession, public scrollBar: ScrollBar) {\n        this.container = parentContainer;\n        this.createScroller();\n        this.renderer = new Renderer(parentContainer, editorService, mainSession);\n        this.renderer.layerConfig = this.getDefaultLayerConfig();\n        this.pagesLayer = new PagesLayer(this.renderer.content, mainSession);\n        this.scrollSubscription = this.scrollBar.scrolled$.subscribe(() => this.loop.schedule({ scroll: true }));\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.container.offsetWidth || (!changes.any && !force)) {\n            this.changes.apply(changes);\n\n            return;\n        }\n\n        if (this.size.dirty) {\n            this.changes.apply(changes);\n            this.onResize(true);\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.renderer.content, 0, -this.layerConfig.offset);\n\n            DomHelper.setStyle(this.renderer.content.style, 'width', `${this.layerConfig.width}px`);\n            DomHelper.setStyle(this.renderer.content.style, 'height', `${this.layerConfig.height}px`);\n        }\n\n        // full\n        if (changes.full) {\n            this.renderFull();\n\n            return;\n        }\n\n        // scrolling\n        if (changes.scroll) {\n            this.renderScroll(changes);\n        }\n\n        if (changes.text) {\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\n    /**\n     * Triggers a resize of the editor\n     **/\n    onResize(force?: boolean): void {\n        const height = this.container.clientHeight || this.container.scrollHeight;\n        const width = this.container.clientWidth || this.container.scrollWidth;\n        const changes = this.updateCachedSize(force, width, height);\n        changes.apply(this.changes);\n\n        if (force) {\n            this.renderChanges(changes, true);\n        } else {\n            this.loop.schedule(changes);\n        }\n        this.scrollBar.setScrollTop(0);\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        this.renderer.updateLines(firstRow, lastRow);\n    }\n\n    updateCachedSize(force: boolean, width: number, height: number): RenderChangesModel {\n        if (width && (force || this.size.width !== width)) {\n            DomHelper.setStyle(this.scroller.style, 'left', 0);\n            this.size.scrollerWidth = Math.max(0, this.container.parentElement.clientWidth - this.scrollBar.width);\n            DomHelper.setStyle(this.scroller.style, 'right', 0);\n        }\n\n        let changes = new RenderChangesModel();\n        if (height && (force || this.size.height !== height)) {\n            this.size.height = height;\n            changes.size = true;\n\n            this.size.scrollerHeight = this.size.height;\n            changes.scroll = true;\n        }\n\n        if (width && (force || this.size.width !== width)) {\n            this.size.width = width;\n            changes.size = true;\n        }\n\n        this.size.dirty = !width || !height;\n\n        return changes;\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.renderer.textareaSize.height) {\n            DomHelper.translate(this.textarea, 0, 0);\n            return;\n        }\n\n        DomHelper.setStyle(this.textarea.style, 'height', `${this.renderer.textareaSize.height}px`);\n        DomHelper.setStyle(this.textarea.style, 'width', `${this.renderer.textareaSize.width}px`);\n        DomHelper.translate(\n            this.textarea,\n            Math.min(cursorPosition.pageX, this.size.scrollerWidth - this.renderer.textareaSize.width),\n            Math.min(posTop, this.size.height - this.renderer.textareaSize.height)\n        );\n    }\n\n    updateSelection(range: Range): void {\n        this.renderer.updateSelection(range);\n    }\n\n    /**\n     * Triggers a full update of the text, for all the rows.\n     **/\n    updateText(): void {\n        this.renderer.updateText();\n    }\n\n    /**\n     * Triggers a full update of all the layers, for all the rows.\n     **/\n    updateFull(force?: boolean): void {\n        this.renderer.updateFull(force);\n    }\n\n    updateCursor(): void {\n        this.renderer.updateCursor();\n    }\n\n    scrollSelectionIntoView(anchor: CursorParagraph, lead: CursorParagraph, offset?: number): void {\n        // first scroll anchor into view then scroll lead into view\n        this.scrollCursorIntoView(anchor, offset);\n        this.scrollCursorIntoView(lead, offset);\n    }\n\n    /**\n     * Scrolls the cursor into the first visibile area of the editor\n     **/\n    scrollCursorIntoView(cursor?: CursorParagraph, offset?: number): void {\n        if (!this.size.scrollerHeight) {\n            return;\n        }\n\n        const position = this.cursorLayer.getPixelPosition(cursor);\n        let top = position.pageY + this.scrollBar.scrollTop;\n\n        if (this.scrollBar.scrollTop > top) {\n            if (offset) {\n                top -= offset * this.container.scrollHeight;\n            }\n\n            this.scrollBar.setScrollTop(top);\n            this.loop.schedule({ scroll: true });\n        } else if (this.scrollBar.scrollTop + this.container.scrollHeight < top + position.lineHeight) {\n            if (offset) {\n                top += offset * this.container.scrollHeight;\n            }\n\n            top += position.lineHeight - this.container.scrollHeight;\n            this.scrollBar.setScrollTop(top);\n            this.loop.schedule({ scroll: true });\n        }\n    }\n\n    scrollBy(deltaY: number): void {\n        if (!deltaY || !this.scrollBar.isVisible) {\n            return;\n        }\n\n        const scrollTop = this.scrollBar.scrollTop + deltaY;\n        this.scrollBar.setScrollTop(scrollTop);\n        this.loop.schedule({ scroll: true });\n    }\n\n    screenToTextCoordinates(x: number, y: number): CursorParagraph {\n        return this.renderer.screenToTextCoordinates(x, y);\n    }\n\n    showCursor(): void {\n        this.renderer.showCursor();\n    }\n\n    hideCursor(): void {\n        this.renderer.hideCursor();\n    }\n\n    destroy(): void {\n        DomHelper.removeElement(this.scrollBar.element);\n        this.pagesLayer.destroy();\n        this.renderer.destroy();\n        this.scrollSubscription?.unsubscribe();\n    }\n\n    private computeLayerConfig(): RenderChangesModel {\n        const pagesWrap = this.renderer.session.pagesWrap;\n        const maxHeight = pagesWrap.allPagesHeight;\n        const minHeight = pagesWrap.minHeight;\n        const scrollHidden = maxHeight < this.size.scrollerHeight;\n\n        const newScrollTop = Math.max(Math.min(this.scrollBar.scrollTop, maxHeight - this.size.scrollerHeight), 0);\n        this.scrollBar.setScrollHeight(maxHeight);\n        this.scrollBar.setScrollTop(newScrollTop);\n\n        const canScroll = !scrollHidden && this.size.scrollerHeight - maxHeight < 0;\n        const scrollChanged = this.canScroll !== canScroll;\n        if (scrollChanged) {\n            this.canScroll = canScroll;\n            this.scrollBar.setVisible(canScroll);\n        }\n\n        const changes = scrollChanged\n            ? this.updateCachedSize(true, this.size.width, this.size.height)\n            : new RenderChangesModel({ scroll: true });\n        const visibleRange = pagesWrap.getVisibleRange(this.scrollBar.scrollTop, this.size.scrollerHeight);\n        this.layerConfig = {\n            width: this.renderer.textLayer.element.clientWidth,\n            height: this.size.scrollerHeight,\n            contentRange: new DistanceModel({ start: visibleRange.startParagraph, end: visibleRange.endParagraph }),\n            minHeight,\n            maxHeight,\n            offset: 0,\n            visibleRange,\n            scrollTop: this.scrollBar.scrollTop,\n            pages: visibleRange.pages\n        };\n\n        return changes;\n    }\n\n    private createScroller(): void {\n        this.scroller = document.createElement('div');\n        this.scroller.className = 'noder-scroller';\n        this.container.appendChild(this.scroller);\n    }\n\n    private createRenderLoop(): void {\n        this.loop = new RenderLoop(changes => this.renderChanges(changes));\n        this.renderer.loop = this.loop;\n        this.loop.schedule({ full: true });\n    }\n\n    private renderScroll(changes: RenderChangesModel): void {\n        this.pagesLayer.update(this.layerConfig);\n        if (changes.text || changes.lines) {\n            this.renderer.textLayer.updateEdges(this.layerConfig);\n            this.renderer.textLayer.updateLines(this.layerConfig);\n        } else {\n            this.renderer.textLayer.scrollPages(this.layerConfig);\n            this.renderer.textLayer.scrollLines(this.layerConfig);\n        }\n\n        this.renderer.selectionLayer.update(this.layerConfig);\n        if (!this.renderer.cursorLayer.isVisible) {\n            return;\n        }\n\n        this.cursorLayer.update(this.layerConfig);\n        this.moveTextAreaToCursor();\n    }\n\n    private renderFull(): void {\n        this.pagesLayer.update(this.layerConfig);\n        this.renderer.textLayer.updateEdges(this.layerConfig);\n        this.renderer.renderFull();\n    }\n\n    private renderText(): void {\n        this.pagesLayer.update(this.layerConfig);\n        this.renderer.renderText();\n    }\n\n    private renderCursor(): void {\n        this.renderer.renderCursor();\n    }\n\n    private renderSelection(): void {\n        this.renderer.renderSelection();\n    }\n\n    private getDefaultLayerConfig(): ILayerConfig {\n        return {\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}\n"]}

package/esm2022/lib/editor/display/visible-range.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlzaWJsZS1yYW5nZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi9lZGl0b3IvZGlzcGxheS92aXNpYmxlLXJhbmdlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBWaXNpYmxlUmFuZ2Uge1xuICAgIHN0YXJ0UGFyYWdyYXBoOiBudW1iZXI7XG4gICAgc3RhcnRMaW5lOiBudW1iZXI7XG4gICAgc3RhcnRTY3JlZW5MaW5lOiBudW1iZXI7XG4gICAgc3RhcnRTY3JlZW5GdWxsTGluZTogbnVtYmVyO1xuICAgIGVuZFBhcmFncmFwaDogbnVtYmVyO1xuICAgIGVuZExpbmU6IG51bWJlcjtcbiAgICBlbmRTY3JlZW5MaW5lOiBudW1iZXI7XG4gICAgZW5kU2NyZWVuRnVsbExpbmU6IG51bWJlcjtcbiAgICBwYWdlcz86IG51bWJlcltdO1xufVxuIl19

package/esm2022/lib/editor/editor.module.mjs

@@ -0,0 +1,67 @@
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatIconModule } from '@angular/material/icon';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { CommandsService } from './operations/commands.service';
+import { ComponentService } from './components/shared/services/component.service';
+import { CustomContentService } from './components/shared/services/custom-content.service';
+import { DefaultImageApiService, ImageApiService } from './components/image/image-api.service';
+import { EditorComponent } from './components/editor.component';
+import { EXTERNAL_ELEMENT_SERVICE, EXTERNAL_ELEMENT_SIDENAV } from '../editor/components/external-element/external-elements.const';
+import { ExternalElementService } from '../editor/components/external-element/external-element.service';
+import { ExternalSidenavModel } from './components/external-element/models/external-sidenav.model';
+import { NoderEdgeComponent } from './components/edges/edge.component';
+import { NoderImageComponent } from './components/image/components/image.component';
+import { NoderTabComponent } from './components/tab/tab.component';
+import { NoderTableCellComponent } from './components/table/components/table-cell.component';
+import { NoderTableComponent } from './components/table/components/table.component';
+import { OverlayService } from './components/shared/services/overlay.service';
+import { RegulatorService } from './execution/regulator.service';
+import { ResizerComponent } from './components/image/resizer/resizer.component';
+import { TableOverlayMenuComponent } from './components/table/overlay-menu/overlay-menu.component';
+import * as i0 from "@angular/core";
+export class EditorModule {
+    static forRoot(options) {
+        return {
+            ngModule: EditorModule,
+            providers: [
+                { provide: EXTERNAL_ELEMENT_SIDENAV, useValue: new ExternalSidenavModel(options?.sidenav) },
+                { provide: EXTERNAL_ELEMENT_SERVICE, useClass: options?.elementService ?? ExternalElementService },
+                { provide: ImageApiService, useClass: options?.imageApiService ?? DefaultImageApiService }
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: EditorModule, declarations: [EditorComponent,
+            NoderEdgeComponent,
+            NoderImageComponent,
+            NoderTabComponent,
+            NoderTableCellComponent,
+            NoderTableComponent,
+            ResizerComponent,
+            TableOverlayMenuComponent], imports: [CommonModule, MatButtonModule, MatDialogModule, MatIconModule, MatSidenavModule, MatTooltipModule, ReactiveFormsModule], exports: [EditorComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EditorModule, providers: [ComponentService, CustomContentService, OverlayService, RegulatorService, ExternalElementService, CommandsService], imports: [CommonModule, MatButtonModule, MatDialogModule, MatIconModule, MatSidenavModule, MatTooltipModule, ReactiveFormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        EditorComponent,
+                        NoderEdgeComponent,
+                        NoderImageComponent,
+                        NoderTabComponent,
+                        NoderTableCellComponent,
+                        NoderTableComponent,
+                        ResizerComponent,
+                        TableOverlayMenuComponent
+                    ],
+                    imports: [CommonModule, MatButtonModule, MatDialogModule, MatIconModule, MatSidenavModule, MatTooltipModule, ReactiveFormsModule],
+                    providers: [ComponentService, CustomContentService, OverlayService, RegulatorService, ExternalElementService, CommandsService],
+                    exports: [EditorComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/execution/distance.model.mjs

@@ -0,0 +1,10 @@
+export class DistanceModel {
+    constructor(fields) {
+        if (!fields) {
+            return;
+        }
+        Object.assign(this, fields);
+        this.selectionEnd = this.end > 0 ? this.end - 1 : 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzdGFuY2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi9lZGl0b3IvZXhlY3V0aW9uL2Rpc3RhbmNlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxhQUFhO0lBS3RCLFlBQVksTUFBK0I7UUFDdkMsSUFBSSxDQUFDLE1BQU0sRUFBRTtZQUNULE9BQU87U0FDVjtRQUVELE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQzVCLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDeEQsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIERpc3RhbmNlTW9kZWwge1xuICAgIGVuZDogbnVtYmVyO1xuICAgIHNlbGVjdGlvbkVuZDogbnVtYmVyO1xuICAgIHN0YXJ0OiBudW1iZXI7XG5cbiAgICBjb25zdHJ1Y3RvcihmaWVsZHM/OiBQYXJ0aWFsPERpc3RhbmNlTW9kZWw+KSB7XG4gICAgICAgIGlmICghZmllbGRzKSB7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBPYmplY3QuYXNzaWduKHRoaXMsIGZpZWxkcyk7XG4gICAgICAgIHRoaXMuc2VsZWN0aW9uRW5kID0gdGhpcy5lbmQgPiAwID8gdGhpcy5lbmQgLSAxIDogMDtcbiAgICB9XG59XG4iXX0=