@talrace/ngx-noder 0.0.7 → 0.0.9

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

@@ -0,0 +1,206 @@
+import { CursorLayer } from './layers/cursor.layer';
+import { DistanceModel } from '../execution/distance.model';
+import { DomHelper } from '../execution/helpers/dom.helper';
+import { EventEmitting } from '../core/event-emitting';
+import { PositionHelper } from '../positioning/position.helper';
+import { RenderChangesModel } from './render-changes.model';
+import { RenderLoop } from './renderloop';
+import { SelectionLayer } from './layers/selection.layer';
+import { TextLayer } from './layers/text.layer';
+export class Renderer extends EventEmitting {
+    constructor(parentContainer, editorService, session) {
+        super();
+        this.editorService = editorService;
+        this.session = session;
+        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 += ' noder-editor';
+        this.createContentContainer();
+        this.textLayer = new TextLayer(this.content, this.session, this.editorService);
+        this.selectionLayer = new SelectionLayer(this.content, 'text-selection', this.session);
+        this.cursorLayer = new CursorLayer(this.content, this.session);
+        this.loop = new RenderLoop(changes => this.renderChanges(changes));
+        this.session.displayData.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+    }
+    renderChanges(changes, force) {
+        changes.apply(this.changes);
+        this.changes = new RenderChangesModel();
+        if (!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));
+    }
+    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.displayData.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+        this.textLayer.destroy();
+        DomHelper.removeChildren(this.container);
+    }
+    renderFull() {
+        this.textLayer.updateLines(this.layerConfig);
+        this.selectionLayer.update(this.layerConfig);
+        this.cursorLayer.update(this.layerConfig);
+        this.moveTextAreaToCursor();
+    }
+    renderText() {
+        this.textLayer.updateLines(this.layerConfig);
+        this.cursorLayer.detectVisibility();
+    }
+    renderCursor() {
+        this.cursorLayer.update(this.layerConfig);
+        this.moveTextAreaToCursor();
+    }
+    renderSelection() {
+        this.selectionLayer.update(this.layerConfig);
+        this.cursorLayer.detectVisibility();
+    }
+    computeLayerConfig() {
+        const displayData = this.session.displayData;
+        const maxHeight = displayData.allPagesHeight;
+        const minHeight = displayData.minHeight;
+        const changes = new RenderChangesModel({ scroll: true });
+        // todo check logic after move wrapdata to display data
+        this.layerConfig = {
+            width: this.session.displayData.contentWidth + displayData.pageMargin.left + displayData.pageMargin.right,
+            height: displayData.defaultVerticalData.contentHeight,
+            contentRange: new DistanceModel({ start: 0, end: displayData.paragraphs.filter(x => x.paragraphSettings).length - 1 }),
+            minHeight,
+            maxHeight,
+            offset: 0,
+            scrollTop: this.session.scrollTop
+        };
+        return changes;
+    }
+    createContentContainer() {
+        this.content = document.createElement('div');
+        this.content.className = 'noder-content';
+        if (this.container.firstChild) {
+            this.container.firstChild.appendChild(this.content);
+        }
+        else {
+            this.container.appendChild(this.content);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/display/renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { 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 { EventEmitting } from '../core/event-emitting';\nimport { ILayerConfig } from './layers/layer.config';\nimport { PositionHelper } from '../positioning/position.helper';\nimport { Range } from '../positioning/range';\nimport { RenderChangesModel } from './render-changes.model';\nimport { RenderLoop } from './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    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, public session: EditSession) {\n        super();\n        this.container = parentContainer;\n        this.container.className += ' noder-editor';\n        this.createContentContainer();\n        this.textLayer = new TextLayer(this.content, this.session, this.editorService);\n        this.selectionLayer = new SelectionLayer(this.content, 'text-selection', this.session);\n        this.cursorLayer = new CursorLayer(this.content, this.session);\n        this.loop = new RenderLoop(changes => this.renderChanges(changes));\n        this.session.displayData.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n    }\n\n    renderChanges(changes: RenderChangesModel, force?: boolean): void {\n        changes.apply(this.changes);\n        this.changes = new RenderChangesModel();\n\n        if (!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    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): CursorParagraph {\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.displayData.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n        this.textLayer.destroy();\n        DomHelper.removeChildren(this.container);\n    }\n\n    renderFull(): void {\n        this.textLayer.updateLines(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.updateLines(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 displayData = this.session.displayData;\n        const maxHeight = displayData.allPagesHeight;\n        const minHeight = displayData.minHeight;\n\n        const changes = new RenderChangesModel({ scroll: true });\n        // todo check logic after move wrapdata to display data\n        this.layerConfig = {\n            width: this.session.displayData.contentWidth + displayData.pageMargin.left + displayData.pageMargin.right,\n            height: displayData.defaultVerticalData.contentHeight,\n            contentRange: new DistanceModel({ start: 0, end: displayData.paragraphs.filter(x => x.paragraphSettings).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 = 'noder-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"]}

package/esm2022/lib/editor/display/rendering.helper.mjs

@@ -0,0 +1,185 @@
+import { BreakHelper } from '../gadgets/page-break/break.helper';
+import { ContentStyleHelper } from '../content/helpers/content-style.helper';
+import { DistanceModel } from '../execution/distance.model';
+import { DomHelper } from '../execution/helpers/dom.helper';
+import { FormatExtModel } from '../content/display-data/format-ext.model';
+import { HYPERLINK_HEADING_STYLE_ID, NEW_LINE_MARKUP } from '../content/constants/editor.const';
+import { ScalingHelper } from '../content/helpers/scaling.helper';
+import { TextStyleModel } from '../../models/generated/text-style.model';
+export class RenderingHelper {
+    static createLineElement(lineInfo, numberingOffsetLeft, scalingRatio) {
+        let lineEl = document.createElement('div');
+        lineEl.className = 'noder-line';
+        if (lineInfo) {
+            const paddingLeft = ScalingHelper.scale(lineInfo.paddingLeft - numberingOffsetLeft, scalingRatio);
+            const marginLeft = paddingLeft < 0 ? paddingLeft : 0;
+            lineEl.setAttribute('style', 
+            // eslint-disable-next-line prettier/prettier
+            `padding-left:${paddingLeft}px;height:${lineInfo.height + lineInfo.offsetAfter}px;margin-top:${lineInfo.offsetBefore}px;margin-bottom:${lineInfo.endPageOffset}px;margin-left:${marginLeft}px;background-color:${lineInfo.backgroundColor}`);
+            lineEl.setAttribute('screen-index', `${lineInfo.screenLine}`);
+        }
+        return lineEl;
+    }
+    static renderContentSimpleLine(domContent, formatsExt, rowDistance, customContentService, customComponents, breaks = []) {
+        const valueFragment = DomHelper.createFragment(domContent.currentElement);
+        for (const formatExt of formatsExt) {
+            const fragmentDocumentStartIndex = rowDistance.start > formatExt.startIndex ? rowDistance.start : formatExt.startIndex;
+            const fragmentDocumentEndIndex = formatExt.endIndex > rowDistance.end ? rowDistance.end : formatExt.endIndex;
+            const fragmentDocumentDistance = new DistanceModel({ start: fragmentDocumentStartIndex, end: fragmentDocumentEndIndex });
+            const fragmentStartIndex = rowDistance.start > formatExt.startIndex ? rowDistance.start - formatExt.startIndex : 0;
+            const fragmentEndIndex = formatExt.endIndex > rowDistance.end ? rowDistance.end - formatExt.startIndex : formatExt.endIndex - formatExt.startIndex;
+            const fragmentDistance = new DistanceModel({ start: fragmentStartIndex, end: fragmentEndIndex });
+            this.renderFormatContent(valueFragment, formatExt, fragmentDocumentDistance, fragmentDistance, customContentService, customComponents, breaks);
+        }
+        domContent.parentNode.appendChild(valueFragment);
+    }
+    static renderContentWrappedLine(domContent, splits, currentParagraph, formatsExt, distance, customContentService, customComponents, scalingRatio, breaks = []) {
+        let splitIndex = 0;
+        const numberingOffsetLeft = currentParagraph.numberingData.numberingId === null
+            ? 0
+            : currentParagraph.numberingData.width + currentParagraph.numberingData.paddingLeft;
+        let lineEl = RenderingHelper.createLineElement(currentParagraph.textLinesInfo[splitIndex], numberingOffsetLeft, scalingRatio);
+        domContent.parentNode.appendChild(lineEl);
+        const valueFragment = DomHelper.createFragment(domContent.currentElement);
+        let paragraphChars = 0;
+        let split = splits[splitIndex];
+        for (const formatExt of formatsExt) {
+            const beforeSplitIndex = split ? split - 1 : distance.end - distance.start;
+            const beforeSplitDocumentIndex = distance.start + beforeSplitIndex;
+            const fragmentDocumentStartIndex = distance.start + paragraphChars;
+            const fragmentDocumentEndIndex = formatExt.endIndex < beforeSplitDocumentIndex ? formatExt.endIndex : beforeSplitDocumentIndex;
+            const fragmentDocumentDistance = new DistanceModel({ start: fragmentDocumentStartIndex, end: fragmentDocumentEndIndex });
+            const fragmentStartIndex = distance.start > formatExt.startIndex ? distance.start - formatExt.startIndex : 0;
+            const fragmentEndIndex = formatExt.endIndex < beforeSplitDocumentIndex
+                ? fragmentStartIndex + formatExt.endIndex - formatExt.startIndex
+                : distance.start + beforeSplitIndex - formatExt.startIndex;
+            const fragmentDistance = new DistanceModel({ start: fragmentStartIndex, end: fragmentEndIndex });
+            paragraphChars += this.renderFormatContent(valueFragment, formatExt, fragmentDocumentDistance, fragmentDistance, customContentService, customComponents, breaks);
+            lineEl.appendChild(valueFragment);
+            let nextFragmentStartIndex = fragmentEndIndex + 1;
+            while (paragraphChars === split && nextFragmentStartIndex !== distance.end) {
+                split = splits[++splitIndex];
+                const nextFragmentDocumentStartIndex = fragmentDocumentStartIndex + nextFragmentStartIndex - fragmentStartIndex;
+                lineEl = RenderingHelper.createLineElement(currentParagraph.textLinesInfo[splitIndex], numberingOffsetLeft, scalingRatio);
+                if (split > formatExt.endIndex) {
+                    const nextFragmentEndIndex = formatExt.content.length - 1;
+                    const nextFragmentDistance = new DistanceModel({ start: nextFragmentStartIndex, end: nextFragmentEndIndex });
+                    const nextFragmentDocumentEndIndex = nextFragmentDocumentStartIndex + nextFragmentEndIndex - nextFragmentStartIndex;
+                    const nextFragmentDocumentDistance = new DistanceModel({
+                        start: nextFragmentDocumentStartIndex,
+                        end: nextFragmentDocumentEndIndex
+                    });
+                    paragraphChars += this.renderFormatContent(valueFragment, formatExt, nextFragmentDocumentDistance, nextFragmentDistance, customContentService, customComponents, breaks);
+                    lineEl.appendChild(valueFragment);
+                    domContent.parentNode.appendChild(lineEl);
+                    break;
+                }
+                const textIndexLength = RenderingHelper.getTextIndexLengthForInsert(formatExt, nextFragmentDocumentStartIndex, distance, split, paragraphChars);
+                const nextFragmentDocumentEndIndex = nextFragmentDocumentStartIndex + textIndexLength;
+                const nextFragmentEndIndex = nextFragmentStartIndex + textIndexLength;
+                const nextFragmentDistance = new DistanceModel({ start: nextFragmentStartIndex, end: nextFragmentEndIndex });
+                const nextFragmentDocumentDistance = new DistanceModel({
+                    start: nextFragmentDocumentStartIndex,
+                    end: nextFragmentDocumentEndIndex
+                });
+                const renderedChars = this.renderFormatContent(valueFragment, formatExt, nextFragmentDocumentDistance, nextFragmentDistance, customContentService, customComponents, breaks);
+                lineEl.appendChild(valueFragment);
+                domContent.parentNode.appendChild(lineEl);
+                nextFragmentStartIndex += renderedChars;
+                paragraphChars += renderedChars;
+            }
+        }
+    }
+    static renderNumberingMarker(paragraph, layerElement, scalingRatio) {
+        const markerHeight = paragraph.numberingData.height;
+        const markerLineInfo = {
+            paddingLeft: paragraph.numberingData.paddingLeft,
+            height: markerHeight,
+            offsetBefore: 0,
+            firstLinePageOffset: 0,
+            endPageOffset: 0,
+            offsetAfter: 0,
+            screenLine: 0
+        };
+        const numberingLineEl = this.createLineElement(markerLineInfo, 0, scalingRatio);
+        const markerFragment = DomHelper.createFragment(layerElement);
+        const marker = paragraph.numberingData.marker;
+        const markerExtModel = new FormatExtModel({
+            textStyle: paragraph.numberingData.markerTextStyle,
+            content: marker
+        });
+        this.renderText(markerFragment, markerExtModel, marker);
+        numberingLineEl.appendChild(markerFragment);
+        return numberingLineEl;
+    }
+    static createDivContainer(className) {
+        const containerElement = document.createElement('div');
+        containerElement.className = className;
+        return containerElement;
+    }
+    static renderFormatContent(fragment, formatExt, fragmentDocumentDistance, fragmentDistance, customContentService, customComponents, breaks) {
+        let textFragment = formatExt.content.substring(fragmentDistance.start, fragmentDistance.end + 1);
+        if (!textFragment) {
+            return 0;
+        }
+        const textFragmentWithoutBreaks = BreakHelper.removeBreakMarker(breaks, textFragment, fragmentDocumentDistance.start);
+        if (customContentService.isFragmentContainComponent(customComponents, textFragment, fragmentDocumentDistance)) {
+            this.renderTextWithCustomContent(fragment, formatExt, fragmentDocumentDistance, textFragmentWithoutBreaks, customContentService, customComponents);
+        }
+        else {
+            RenderingHelper.renderText(fragment, formatExt, textFragmentWithoutBreaks);
+        }
+        return textFragment.length;
+    }
+    static renderTextWithCustomContent(fragment, formatExt, fragmentDocumentDistance, textFragment, customContentService, customComponents) {
+        const components = customContentService.getComponents(customComponents, fragmentDocumentDistance);
+        if (!components.length) {
+            RenderingHelper.renderText(fragment, formatExt, textFragment);
+            return;
+        }
+        let newTextFragmentStartIndex = fragmentDocumentDistance.start;
+        let nextTextFragment = textFragment;
+        for (const component of components) {
+            const textBeforeElement = nextTextFragment.substring(0, component.instance.insertIndex - newTextFragmentStartIndex);
+            nextTextFragment = nextTextFragment.substring(textBeforeElement.length + 1, nextTextFragment.length);
+            newTextFragmentStartIndex = newTextFragmentStartIndex + (textBeforeElement.length ? textBeforeElement.length + 1 : 1);
+            if (textBeforeElement.length) {
+                RenderingHelper.renderText(fragment, formatExt, textBeforeElement);
+            }
+            this.attachComponent(fragment, component, customContentService);
+        }
+        if (nextTextFragment.length) {
+            RenderingHelper.renderText(fragment, formatExt, nextTextFragment);
+        }
+    }
+    static renderText(fragment, formatExt, textFragment) {
+        const span = document.createElement('span');
+        const textStyle = new TextStyleModel({ ...formatExt.textStyle });
+        if (textFragment === NEW_LINE_MARKUP) {
+            span.className = 'paragraph-symbol';
+        }
+        if (textStyle.headingStyleId === HYPERLINK_HEADING_STYLE_ID) {
+            span.classList.add('hyperlink');
+            span.onmousemove = event => {
+                if (event.ctrlKey) {
+                    span.classList.add('hyperlink-hover');
+                }
+                else {
+                    span.classList.remove('hyperlink-hover');
+                }
+            };
+            span.onmouseleave = () => span.classList.remove('hyperlink-hover');
+        }
+        span.textContent = textFragment;
+        span.setAttribute('style', ContentStyleHelper.getTextStylesString(textStyle));
+        fragment.appendChild(span);
+    }
+    static getTextIndexLengthForInsert(formatExt, fragmentDocumentStartIndex, paragraphDistance, split, paragraphChars) {
+        const maxLength = Math.max(paragraphDistance.end - paragraphChars - paragraphDistance.start, 0);
+        return (Math.min(split - paragraphChars || Number.MAX_VALUE, maxLength, formatExt.endIndex - fragmentDocumentStartIndex + 1, formatExt.content.length) - 1);
+    }
+    static attachComponent(fragment, component, customContentService) {
+        customContentService.componentService.attachComponent(fragment, component);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rendering.helper.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/display/rendering.helper.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAEjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAE7E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAC1E,OAAO,EAAE,0BAA0B,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGhG,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAEzE,MAAM,OAAO,eAAe;IACxB,MAAM,CAAC,iBAAiB,CAAC,QAAsB,EAAE,mBAA2B,EAAE,YAAoB;QAC9F,IAAI,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC3C,MAAM,CAAC,SAAS,GAAG,YAAY,CAAC;QAEhC,IAAI,QAAQ,EAAE;YACV,MAAM,WAAW,GAAG,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,GAAG,mBAAmB,EAAE,YAAY,CAAC,CAAC;YAClG,MAAM,UAAU,GAAG,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;YAErD,MAAM,CAAC,YAAY,CACf,OAAO;YACP,6CAA6C;YAC7C,gBAAgB,WAAW,aAAa,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,WAAW,iBAC1E,QAAQ,CAAC,YACb,oBAAoB,QAAQ,CAAC,aAAa,kBAAkB,UAAU,uBAAuB,QAAQ,CAAC,eAAe,EAAE,CAC1H,CAAC;YACF,MAAM,CAAC,YAAY,CAAC,cAAc,EAAE,GAAG,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC;SACjE;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,MAAM,CAAC,uBAAuB,CAC1B,UAA6D,EAC7D,UAA4B,EAC5B,WAA0B,EAC1B,oBAA0C,EAC1C,gBAAmC,EACnC,SAAuB,EAAE;QAEzB,MAAM,aAAa,GAAG,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QAC1E,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;YAChC,MAAM,0BAA0B,GAAG,WAAW,CAAC,KAAK,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC;YACvH,MAAM,wBAAwB,GAAG,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC;YAC7G,MAAM,wBAAwB,GAAG,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,0BAA0B,EAAE,GAAG,EAAE,wBAAwB,EAAE,CAAC,CAAC;YACzH,MAAM,kBAAkB,GAAG,WAAW,CAAC,KAAK,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YACnH,MAAM,gBAAgB,GAClB,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC;YAC9H,MAAM,gBAAgB,GAAG,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,gBAAgB,EAAE,CAAC,CAAC;YACjG,IAAI,CAAC,mBAAmB,CACpB,aAAa,EACb,SAAS,EACT,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,MAAM,CACT,CAAC;SACL;QAED,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACrD,CAAC;IAED,MAAM,CAAC,wBAAwB,CAC3B,UAA6D,EAC7D,MAAgB,EAChB,gBAA2B,EAC3B,UAA4B,EAC5B,QAAuB,EACvB,oBAA0C,EAC1C,gBAAmC,EACnC,YAAoB,EACpB,SAAuB,EAAE;QAEzB,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,MAAM,mBAAmB,GACrB,gBAAgB,CAAC,aAAa,CAAC,WAAW,KAAK,IAAI;YAC/C,CAAC,CAAC,CAAC;YACH,CAAC,CAAC,gBAAgB,CAAC,aAAa,CAAC,KAAK,GAAG,gBAAgB,CAAC,aAAa,CAAC,WAAW,CAAC;QAC5F,IAAI,MAAM,GAAG,eAAe,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,aAAa,CAAC,UAAU,CAAC,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAAC;QAC9H,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAE1C,MAAM,aAAa,GAAG,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QAC1E,IAAI,cAAc,GAAG,CAAC,CAAC;QACvB,IAAI,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC/B,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;YAChC,MAAM,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC;YAC3E,MAAM,wBAAwB,GAAG,QAAQ,CAAC,KAAK,GAAG,gBAAgB,CAAC;YACnE,MAAM,0BAA0B,GAAG,QAAQ,CAAC,KAAK,GAAG,cAAc,CAAC;YACnE,MAAM,wBAAwB,GAAG,SAAS,CAAC,QAAQ,GAAG,wBAAwB,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,wBAAwB,CAAC;YAC/H,MAAM,wBAAwB,GAAG,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,0BAA0B,EAAE,GAAG,EAAE,wBAAwB,EAAE,CAAC,CAAC;YACzH,MAAM,kBAAkB,GAAG,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7G,MAAM,gBAAgB,GAClB,SAAS,CAAC,QAAQ,GAAG,wBAAwB;gBACzC,CAAC,CAAC,kBAAkB,GAAG,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,UAAU;gBAChE,CAAC,CAAC,QAAQ,CAAC,KAAK,GAAG,gBAAgB,GAAG,SAAS,CAAC,UAAU,CAAC;YACnE,MAAM,gBAAgB,GAAG,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,gBAAgB,EAAE,CAAC,CAAC;YACjG,cAAc,IAAI,IAAI,CAAC,mBAAmB,CACtC,aAAa,EACb,SAAS,EACT,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,MAAM,CACT,CAAC;YACF,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;YAClC,IAAI,sBAAsB,GAAG,gBAAgB,GAAG,CAAC,CAAC;YAClD,OAAO,cAAc,KAAK,KAAK,IAAI,sBAAsB,KAAK,QAAQ,CAAC,GAAG,EAAE;gBACxE,KAAK,GAAG,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC;gBAC7B,MAAM,8BAA8B,GAAG,0BAA0B,GAAG,sBAAsB,GAAG,kBAAkB,CAAC;gBAChH,MAAM,GAAG,eAAe,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,aAAa,CAAC,UAAU,CAAC,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAAC;gBAC1H,IAAI,KAAK,GAAG,SAAS,CAAC,QAAQ,EAAE;oBAC5B,MAAM,oBAAoB,GAAG,SAAS,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;oBAC1D,MAAM,oBAAoB,GAAG,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,oBAAoB,EAAE,CAAC,CAAC;oBAC7G,MAAM,4BAA4B,GAAG,8BAA8B,GAAG,oBAAoB,GAAG,sBAAsB,CAAC;oBACpH,MAAM,4BAA4B,GAAG,IAAI,aAAa,CAAC;wBACnD,KAAK,EAAE,8BAA8B;wBACrC,GAAG,EAAE,4BAA4B;qBACpC,CAAC,CAAC;oBACH,cAAc,IAAI,IAAI,CAAC,mBAAmB,CACtC,aAAa,EACb,SAAS,EACT,4BAA4B,EAC5B,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,MAAM,CACT,CAAC;oBACF,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;oBAClC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;oBAE1C,MAAM;iBACT;gBAED,MAAM,eAAe,GAAG,eAAe,CAAC,2BAA2B,CAC/D,SAAS,EACT,8BAA8B,EAC9B,QAAQ,EACR,KAAK,EACL,cAAc,CACjB,CAAC;gBACF,MAAM,4BAA4B,GAAG,8BAA8B,GAAG,eAAe,CAAC;gBACtF,MAAM,oBAAoB,GAAG,sBAAsB,GAAG,eAAe,CAAC;gBACtE,MAAM,oBAAoB,GAAG,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,oBAAoB,EAAE,CAAC,CAAC;gBAC7G,MAAM,4BAA4B,GAAG,IAAI,aAAa,CAAC;oBACnD,KAAK,EAAE,8BAA8B;oBACrC,GAAG,EAAE,4BAA4B;iBACpC,CAAC,CAAC;gBACH,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,CAC1C,aAAa,EACb,SAAS,EACT,4BAA4B,EAC5B,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,MAAM,CACT,CAAC;gBACF,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;gBAClC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gBAC1C,sBAAsB,IAAI,aAAa,CAAC;gBACxC,cAAc,IAAI,aAAa,CAAC;aACnC;SACJ;IACL,CAAC;IAED,MAAM,CAAC,qBAAqB,CAAC,SAAoB,EAAE,YAAyB,EAAE,YAAoB;QAC9F,MAAM,YAAY,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC;QAEpD,MAAM,cAAc,GAAG;YACnB,WAAW,EAAE,SAAS,CAAC,aAAa,CAAC,WAAW;YAChD,MAAM,EAAE,YAAY;YACpB,YAAY,EAAE,CAAC;YACf,mBAAmB,EAAE,CAAC;YACtB,aAAa,EAAE,CAAC;YAChB,WAAW,EAAE,CAAC;YACd,UAAU,EAAE,CAAC;SACA,CAAC;QAClB,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC;QAEhF,MAAM,cAAc,GAAG,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;QAC9D,MAAM,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC;QAC9C,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC;YACtC,SAAS,EAAE,SAAS,CAAC,aAAa,CAAC,eAAe;YAClD,OAAO,EAAE,MAAM;SAClB,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;QACxD,eAAe,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;QAE5C,OAAO,eAAe,CAAC;IAC3B,CAAC;IAED,MAAM,CAAC,kBAAkB,CAAC,SAAiB;QACvC,MAAM,gBAAgB,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACvD,gBAAgB,CAAC,SAAS,GAAG,SAAS,CAAC;QAEvC,OAAO,gBAAgB,CAAC;IAC5B,CAAC;IAEO,MAAM,CAAC,mBAAmB,CAC9B,QAA0B,EAC1B,SAAyB,EACzB,wBAAuC,EACvC,gBAA+B,EAC/B,oBAA0C,EAC1C,gBAAmC,EACnC,MAAoB;QAEpB,IAAI,YAAY,GAAG,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;QACjG,IAAI,CAAC,YAAY,EAAE;YACf,OAAO,CAAC,CAAC;SACZ;QAED,MAAM,yBAAyB,GAAG,WAAW,CAAC,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAEtH,IAAI,oBAAoB,CAAC,0BAA0B,CAAC,gBAAgB,EAAE,YAAY,EAAE,wBAAwB,CAAC,EAAE;YAC3G,IAAI,CAAC,2BAA2B,CAC5B,QAAQ,EACR,SAAS,EACT,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,gBAAgB,CACnB,CAAC;SACL;aAAM;YACH,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE,SAAS,EAAE,yBAAyB,CAAC,CAAC;SAC9E;QAED,OAAO,YAAY,CAAC,MAAM,CAAC;IAC/B,CAAC;IAEO,MAAM,CAAC,2BAA2B,CACtC,QAA0B,EAC1B,SAAyB,EACzB,wBAAuC,EACvC,YAAoB,EACpB,oBAA0C,EAC1C,gBAAmC;QAEnC,MAAM,UAAU,GAAG,oBAAoB,CAAC,aAAa,CAAC,gBAAgB,EAAE,wBAAwB,CAAC,CAAC;QAElG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;YACpB,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;YAC9D,OAAO;SACV;QAED,IAAI,yBAAyB,GAAG,wBAAwB,CAAC,KAAK,CAAC;QAC/D,IAAI,gBAAgB,GAAG,YAAY,CAAC;QAEpC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;YAChC,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,WAAW,GAAG,yBAAyB,CAAC,CAAC;YACpH,gBAAgB,GAAG,gBAAgB,CAAC,SAAS,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;YACrG,yBAAyB,GAAG,yBAAyB,GAAG,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAEtH,IAAI,iBAAiB,CAAC,MAAM,EAAE;gBAC1B,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC;aACtE;YAED,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,EAAE,oBAAoB,CAAC,CAAC;SACnE;QAED,IAAI,gBAAgB,CAAC,MAAM,EAAE;YACzB,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC;SACrE;IACL,CAAC;IAEO,MAAM,CAAC,UAAU,CAAC,QAA0B,EAAE,SAAyB,EAAE,YAAoB;QACjG,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,SAAS,GAAG,IAAI,cAAc,CAAC,EAAE,GAAG,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC;QAEjE,IAAI,YAAY,KAAK,eAAe,EAAE;YAClC,IAAI,CAAC,SAAS,GAAG,kBAAkB,CAAC;SACvC;QAED,IAAI,SAAS,CAAC,cAAc,KAAK,0BAA0B,EAAE;YACzD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YAChC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,EAAE;gBACvB,IAAI,KAAK,CAAC,OAAO,EAAE;oBACf,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;iBACzC;qBAAM;oBACH,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;iBAC5C;YACL,CAAC,CAAC;YACF,IAAI,CAAC,YAAY,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;SACtE;QAED,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC;QAChC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,CAAC;QAC9E,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEO,MAAM,CAAC,2BAA2B,CACtC,SAAyB,EACzB,0BAAkC,EAClC,iBAAgC,EAChC,KAAa,EACb,cAAsB;QAEtB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,GAAG,GAAG,cAAc,GAAG,iBAAiB,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAChG,OAAO,CACH,IAAI,CAAC,GAAG,CACJ,KAAK,GAAG,cAAc,IAAI,MAAM,CAAC,SAAS,EAC1C,SAAS,EACT,SAAS,CAAC,QAAQ,GAAG,0BAA0B,GAAG,CAAC,EACnD,SAAS,CAAC,OAAO,CAAC,MAAM,CAC3B,GAAG,CAAC,CACR,CAAC;IACN,CAAC;IAES,MAAM,CAAC,eAAe,CAC5B,QAA0B,EAC1B,SAAgC,EAChC,oBAA0C;QAE1C,oBAAoB,CAAC,gBAAgB,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC/E,CAAC;CACJ","sourcesContent":["import { ComponentRef } from '@angular/core';\n\nimport { BreakHelper } from '../gadgets/page-break/break.helper';\nimport { BreakModel } from '../../models/generated/break.model';\nimport { ContentStyleHelper } from '../content/helpers/content-style.helper';\nimport { CustomContentService } from '../components/shared/services/custom-content.service';\nimport { DistanceModel } from '../execution/distance.model';\nimport { DomHelper } from '../execution/helpers/dom.helper';\nimport { FormatExtModel } from '../content/display-data/format-ext.model';\nimport { HYPERLINK_HEADING_STYLE_ID, NEW_LINE_MARKUP } from '../content/constants/editor.const';\nimport { ICustomComponents } from '../components/shared/custom-components.interface';\nimport { Paragraph } from '../content/display-data/paragraph';\nimport { ScalingHelper } from '../content/helpers/scaling.helper';\nimport { TextLineInfo } from '../content/display-data/text-line-info';\nimport { TextStyleModel } from '../../models/generated/text-style.model';\n\nexport class RenderingHelper {\n    static createLineElement(lineInfo: TextLineInfo, numberingOffsetLeft: number, scalingRatio: number): HTMLElement {\n        let lineEl = document.createElement('div');\n        lineEl.className = 'noder-line';\n\n        if (lineInfo) {\n            const paddingLeft = ScalingHelper.scale(lineInfo.paddingLeft - numberingOffsetLeft, scalingRatio);\n            const marginLeft = paddingLeft < 0 ? paddingLeft : 0;\n\n            lineEl.setAttribute(\n                'style',\n                // eslint-disable-next-line prettier/prettier\n                `padding-left:${paddingLeft}px;height:${lineInfo.height + lineInfo.offsetAfter}px;margin-top:${\n                    lineInfo.offsetBefore\n                }px;margin-bottom:${lineInfo.endPageOffset}px;margin-left:${marginLeft}px;background-color:${lineInfo.backgroundColor}`\n            );\n            lineEl.setAttribute('screen-index', `${lineInfo.screenLine}`);\n        }\n\n        return lineEl;\n    }\n\n    static renderContentSimpleLine(\n        domContent: { currentElement: HTMLElement; parentNode: Node },\n        formatsExt: FormatExtModel[],\n        rowDistance: DistanceModel,\n        customContentService: CustomContentService,\n        customComponents: ICustomComponents,\n        breaks: BreakModel[] = []\n    ): void {\n        const valueFragment = DomHelper.createFragment(domContent.currentElement);\n        for (const formatExt of formatsExt) {\n            const fragmentDocumentStartIndex = rowDistance.start > formatExt.startIndex ? rowDistance.start : formatExt.startIndex;\n            const fragmentDocumentEndIndex = formatExt.endIndex > rowDistance.end ? rowDistance.end : formatExt.endIndex;\n            const fragmentDocumentDistance = new DistanceModel({ start: fragmentDocumentStartIndex, end: fragmentDocumentEndIndex });\n            const fragmentStartIndex = rowDistance.start > formatExt.startIndex ? rowDistance.start - formatExt.startIndex : 0;\n            const fragmentEndIndex =\n                formatExt.endIndex > rowDistance.end ? rowDistance.end - formatExt.startIndex : formatExt.endIndex - formatExt.startIndex;\n            const fragmentDistance = new DistanceModel({ start: fragmentStartIndex, end: fragmentEndIndex });\n            this.renderFormatContent(\n                valueFragment,\n                formatExt,\n                fragmentDocumentDistance,\n                fragmentDistance,\n                customContentService,\n                customComponents,\n                breaks\n            );\n        }\n\n        domContent.parentNode.appendChild(valueFragment);\n    }\n\n    static renderContentWrappedLine(\n        domContent: { currentElement: HTMLElement; parentNode: Node },\n        splits: number[],\n        currentParagraph: Paragraph,\n        formatsExt: FormatExtModel[],\n        distance: DistanceModel,\n        customContentService: CustomContentService,\n        customComponents: ICustomComponents,\n        scalingRatio: number,\n        breaks: BreakModel[] = []\n    ): void {\n        let splitIndex = 0;\n        const numberingOffsetLeft =\n            currentParagraph.numberingData.numberingId === null\n                ? 0\n                : currentParagraph.numberingData.width + currentParagraph.numberingData.paddingLeft;\n        let lineEl = RenderingHelper.createLineElement(currentParagraph.textLinesInfo[splitIndex], numberingOffsetLeft, scalingRatio);\n        domContent.parentNode.appendChild(lineEl);\n\n        const valueFragment = DomHelper.createFragment(domContent.currentElement);\n        let paragraphChars = 0;\n        let split = splits[splitIndex];\n        for (const formatExt of formatsExt) {\n            const beforeSplitIndex = split ? split - 1 : distance.end - distance.start;\n            const beforeSplitDocumentIndex = distance.start + beforeSplitIndex;\n            const fragmentDocumentStartIndex = distance.start + paragraphChars;\n            const fragmentDocumentEndIndex = formatExt.endIndex < beforeSplitDocumentIndex ? formatExt.endIndex : beforeSplitDocumentIndex;\n            const fragmentDocumentDistance = new DistanceModel({ start: fragmentDocumentStartIndex, end: fragmentDocumentEndIndex });\n            const fragmentStartIndex = distance.start > formatExt.startIndex ? distance.start - formatExt.startIndex : 0;\n            const fragmentEndIndex =\n                formatExt.endIndex < beforeSplitDocumentIndex\n                    ? fragmentStartIndex + formatExt.endIndex - formatExt.startIndex\n                    : distance.start + beforeSplitIndex - formatExt.startIndex;\n            const fragmentDistance = new DistanceModel({ start: fragmentStartIndex, end: fragmentEndIndex });\n            paragraphChars += this.renderFormatContent(\n                valueFragment,\n                formatExt,\n                fragmentDocumentDistance,\n                fragmentDistance,\n                customContentService,\n                customComponents,\n                breaks\n            );\n            lineEl.appendChild(valueFragment);\n            let nextFragmentStartIndex = fragmentEndIndex + 1;\n            while (paragraphChars === split && nextFragmentStartIndex !== distance.end) {\n                split = splits[++splitIndex];\n                const nextFragmentDocumentStartIndex = fragmentDocumentStartIndex + nextFragmentStartIndex - fragmentStartIndex;\n                lineEl = RenderingHelper.createLineElement(currentParagraph.textLinesInfo[splitIndex], numberingOffsetLeft, scalingRatio);\n                if (split > formatExt.endIndex) {\n                    const nextFragmentEndIndex = formatExt.content.length - 1;\n                    const nextFragmentDistance = new DistanceModel({ start: nextFragmentStartIndex, end: nextFragmentEndIndex });\n                    const nextFragmentDocumentEndIndex = nextFragmentDocumentStartIndex + nextFragmentEndIndex - nextFragmentStartIndex;\n                    const nextFragmentDocumentDistance = new DistanceModel({\n                        start: nextFragmentDocumentStartIndex,\n                        end: nextFragmentDocumentEndIndex\n                    });\n                    paragraphChars += this.renderFormatContent(\n                        valueFragment,\n                        formatExt,\n                        nextFragmentDocumentDistance,\n                        nextFragmentDistance,\n                        customContentService,\n                        customComponents,\n                        breaks\n                    );\n                    lineEl.appendChild(valueFragment);\n                    domContent.parentNode.appendChild(lineEl);\n\n                    break;\n                }\n\n                const textIndexLength = RenderingHelper.getTextIndexLengthForInsert(\n                    formatExt,\n                    nextFragmentDocumentStartIndex,\n                    distance,\n                    split,\n                    paragraphChars\n                );\n                const nextFragmentDocumentEndIndex = nextFragmentDocumentStartIndex + textIndexLength;\n                const nextFragmentEndIndex = nextFragmentStartIndex + textIndexLength;\n                const nextFragmentDistance = new DistanceModel({ start: nextFragmentStartIndex, end: nextFragmentEndIndex });\n                const nextFragmentDocumentDistance = new DistanceModel({\n                    start: nextFragmentDocumentStartIndex,\n                    end: nextFragmentDocumentEndIndex\n                });\n                const renderedChars = this.renderFormatContent(\n                    valueFragment,\n                    formatExt,\n                    nextFragmentDocumentDistance,\n                    nextFragmentDistance,\n                    customContentService,\n                    customComponents,\n                    breaks\n                );\n                lineEl.appendChild(valueFragment);\n                domContent.parentNode.appendChild(lineEl);\n                nextFragmentStartIndex += renderedChars;\n                paragraphChars += renderedChars;\n            }\n        }\n    }\n\n    static renderNumberingMarker(paragraph: Paragraph, layerElement: HTMLElement, scalingRatio: number): HTMLElement {\n        const markerHeight = paragraph.numberingData.height;\n\n        const markerLineInfo = {\n            paddingLeft: paragraph.numberingData.paddingLeft,\n            height: markerHeight,\n            offsetBefore: 0,\n            firstLinePageOffset: 0,\n            endPageOffset: 0,\n            offsetAfter: 0,\n            screenLine: 0\n        } as TextLineInfo;\n        const numberingLineEl = this.createLineElement(markerLineInfo, 0, scalingRatio);\n\n        const markerFragment = DomHelper.createFragment(layerElement);\n        const marker = paragraph.numberingData.marker;\n        const markerExtModel = new FormatExtModel({\n            textStyle: paragraph.numberingData.markerTextStyle,\n            content: marker\n        });\n        this.renderText(markerFragment, markerExtModel, marker);\n        numberingLineEl.appendChild(markerFragment);\n\n        return numberingLineEl;\n    }\n\n    static createDivContainer(className: string): HTMLDivElement {\n        const containerElement = document.createElement('div');\n        containerElement.className = className;\n\n        return containerElement;\n    }\n\n    private static renderFormatContent(\n        fragment: DocumentFragment,\n        formatExt: FormatExtModel,\n        fragmentDocumentDistance: DistanceModel,\n        fragmentDistance: DistanceModel,\n        customContentService: CustomContentService,\n        customComponents: ICustomComponents,\n        breaks: BreakModel[]\n    ): number {\n        let textFragment = formatExt.content.substring(fragmentDistance.start, fragmentDistance.end + 1);\n        if (!textFragment) {\n            return 0;\n        }\n\n        const textFragmentWithoutBreaks = BreakHelper.removeBreakMarker(breaks, textFragment, fragmentDocumentDistance.start);\n\n        if (customContentService.isFragmentContainComponent(customComponents, textFragment, fragmentDocumentDistance)) {\n            this.renderTextWithCustomContent(\n                fragment,\n                formatExt,\n                fragmentDocumentDistance,\n                textFragmentWithoutBreaks,\n                customContentService,\n                customComponents\n            );\n        } else {\n            RenderingHelper.renderText(fragment, formatExt, textFragmentWithoutBreaks);\n        }\n\n        return textFragment.length;\n    }\n\n    private static renderTextWithCustomContent(\n        fragment: DocumentFragment,\n        formatExt: FormatExtModel,\n        fragmentDocumentDistance: DistanceModel,\n        textFragment: string,\n        customContentService: CustomContentService,\n        customComponents: ICustomComponents\n    ): void {\n        const components = customContentService.getComponents(customComponents, fragmentDocumentDistance);\n\n        if (!components.length) {\n            RenderingHelper.renderText(fragment, formatExt, textFragment);\n            return;\n        }\n\n        let newTextFragmentStartIndex = fragmentDocumentDistance.start;\n        let nextTextFragment = textFragment;\n\n        for (const component of components) {\n            const textBeforeElement = nextTextFragment.substring(0, component.instance.insertIndex - newTextFragmentStartIndex);\n            nextTextFragment = nextTextFragment.substring(textBeforeElement.length + 1, nextTextFragment.length);\n            newTextFragmentStartIndex = newTextFragmentStartIndex + (textBeforeElement.length ? textBeforeElement.length + 1 : 1);\n\n            if (textBeforeElement.length) {\n                RenderingHelper.renderText(fragment, formatExt, textBeforeElement);\n            }\n\n            this.attachComponent(fragment, component, customContentService);\n        }\n\n        if (nextTextFragment.length) {\n            RenderingHelper.renderText(fragment, formatExt, nextTextFragment);\n        }\n    }\n\n    private static renderText(fragment: DocumentFragment, formatExt: FormatExtModel, textFragment: string): void {\n        const span = document.createElement('span');\n        const textStyle = new TextStyleModel({ ...formatExt.textStyle });\n\n        if (textFragment === NEW_LINE_MARKUP) {\n            span.className = 'paragraph-symbol';\n        }\n\n        if (textStyle.headingStyleId === HYPERLINK_HEADING_STYLE_ID) {\n            span.classList.add('hyperlink');\n            span.onmousemove = event => {\n                if (event.ctrlKey) {\n                    span.classList.add('hyperlink-hover');\n                } else {\n                    span.classList.remove('hyperlink-hover');\n                }\n            };\n            span.onmouseleave = () => span.classList.remove('hyperlink-hover');\n        }\n\n        span.textContent = textFragment;\n        span.setAttribute('style', ContentStyleHelper.getTextStylesString(textStyle));\n        fragment.appendChild(span);\n    }\n\n    private static getTextIndexLengthForInsert(\n        formatExt: FormatExtModel,\n        fragmentDocumentStartIndex: number,\n        paragraphDistance: DistanceModel,\n        split: number,\n        paragraphChars: number\n    ): number {\n        const maxLength = Math.max(paragraphDistance.end - paragraphChars - paragraphDistance.start, 0);\n        return (\n            Math.min(\n                split - paragraphChars || Number.MAX_VALUE,\n                maxLength,\n                formatExt.endIndex - fragmentDocumentStartIndex + 1,\n                formatExt.content.length\n            ) - 1\n        );\n    }\n\n    protected static attachComponent(\n        fragment: DocumentFragment,\n        component: ComponentRef<unknown>,\n        customContentService: CustomContentService\n    ): void {\n        customContentService.componentService.attachComponent(fragment, component);\n    }\n}\n"]}

package/esm2022/lib/editor/display/renderloop.mjs

@@ -0,0 +1,26 @@
+import { EventHelper } from './event.helper';
+import { RenderChangesModel } from './render-changes.model';
+export class RenderLoop {
+    constructor(onRender) {
+        this.changes = new RenderChangesModel();
+        this.flush = () => {
+            const changes = this.changes;
+            if (changes.any) {
+                this.changes = new RenderChangesModel();
+                onRender(changes);
+            }
+            if (this.changes.any) {
+                this.schedule();
+            }
+        };
+    }
+    schedule(changes) {
+        if (changes) {
+            this.changes.apply(changes);
+        }
+        if (this.changes) {
+            EventHelper.nextFrame(this.flush);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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