@talrace/ngx-noder 0.0.2

package/esm2022/lib/+shared/editor/core/paging/pages.wrap.mjs

@@ -0,0 +1,219 @@
+import { EdgeType } from '../components/edges/edge-type.enum';
+import { EventEmitting } from '../base/event-emitting';
+import { NumberingHelper } from '../helpers/numbering.helper';
+import { PageHelper } from '../helpers/page.helper';
+import { PageType } from '../enums/page-type.enum';
+import { PageVerticalDataModel } from './page-vertical-data.model';
+import { Paragraph } from './paragraph';
+import { ParagraphHelper } from '../helpers/paragraph.helper';
+export class PagesWrap extends EventEmitting {
+    get defaultVerticalData() {
+        return this.pagesVerticalData.find(x => x.pageType === PageType.Default);
+    }
+    constructor(pagesSpace, documentMargin, pageWidth, pageHeight = 0, edges = null) {
+        super();
+        this.pagesSpace = pagesSpace;
+        this.documentMargin = documentMargin;
+        this.pageWidth = pageWidth;
+        this.pageHeight = pageHeight;
+        this.edges = edges;
+        this.allPagesHeight = 0;
+        this.minHeight = 0;
+        this.paragraphs = [];
+        this.tabTokens = [];
+        this.minHeight = this.pageHeight + 2 * this.pagesSpace;
+        this.contentWidth = this.pageWidth - this.documentMargin.left - this.documentMargin.right;
+        this.initPagesVerticalData();
+        this.processTextLinesProperties = !this.pageHeight
+            ? ParagraphHelper.processTextLinesPropertiesForSinglePage
+            : ParagraphHelper.processTextLinesProperties;
+    }
+    getParagraphTop(paragraphs, index) {
+        return paragraphs[index] ? paragraphs[index].distanceFromTop : 0;
+    }
+    getParagraphTopForPrint(paragraphs, index, pagesSpace) {
+        if (!paragraphs[index]) {
+            return 0;
+        }
+        const paragraph = paragraphs[index];
+        const pageNumber = paragraph.pageNumbers[0];
+        let pageBreakHeight = 0;
+        paragraph.textLinesInfo.forEach(linesInfo => {
+            if (linesInfo.isAfterPageBreak) {
+                pageBreakHeight = linesInfo.height;
+            }
+        });
+        return paragraph.distanceFromTop - pageNumber * pagesSpace - pageBreakHeight;
+    }
+    getParagraphHeight(paragraphs, index) {
+        return paragraphs[index] ? paragraphs[index].height : 0;
+    }
+    remove(index, length) {
+        this.paragraphs.splice(index, length);
+    }
+    reset(paragraphsLength) {
+        this.paragraphs.length = paragraphsLength;
+    }
+    set(row, lineInfos, numberings, docParagraphs) {
+        if (!this.paragraphs[row]) {
+            const numberingData = NumberingHelper.createDataModel(numberings, docParagraphs, row);
+            this.paragraphs[row] = new Paragraph(numberingData, lineInfos[0].offsetBefore, this.processTextLinesProperties);
+        }
+        this.paragraphs[row].width = this.contentWidth;
+        this.paragraphs[row].setTextLinesInfo(lineInfos);
+    }
+    getVisibleRange(offsetTop, scrollerHeight) {
+        let start = this.paragraphs.findIndex(x => offsetTop <= x.distanceFromTop + x.height);
+        if (start < 0) {
+            start = 0;
+        }
+        let startLineInfo = null;
+        const startParagraph = this.paragraphs[start];
+        if (startParagraph) {
+            const startParagraphOffsetTop = offsetTop - startParagraph.distanceFromTop;
+            startLineInfo = ParagraphHelper.getVisibleLineInfo(startParagraph?.textLinesInfo, startParagraphOffsetTop, 1);
+        }
+        if (!startLineInfo) {
+            return {
+                startParagraph: 0,
+                startLine: 0,
+                startScreenLine: 0,
+                startScreenFullLine: 0,
+                endParagraph: 0,
+                endLine: 0,
+                endScreenLine: 0,
+                endScreenFullLine: 0,
+                pages: [1]
+            };
+        }
+        let end = this.paragraphs.findIndex(x => offsetTop + scrollerHeight <= x.distanceFromTop + x.height);
+        if (end < 0) {
+            end = this.paragraphs.length - 1;
+        }
+        let endLineInfo = null;
+        const endParagraph = this.paragraphs[end];
+        if (endParagraph) {
+            const endParagraphOffsetTop = offsetTop + scrollerHeight - endParagraph.distanceFromTop;
+            endLineInfo = ParagraphHelper.getVisibleLineInfo(endParagraph?.textLinesInfo, endParagraphOffsetTop, -1);
+        }
+        const visiblePages = this.getVisiblePages(offsetTop, scrollerHeight);
+        return {
+            startParagraph: start,
+            startLine: startLineInfo.index,
+            startScreenLine: startLineInfo.screenIndex,
+            startScreenFullLine: startLineInfo.visibleScreenIndex,
+            endParagraph: end,
+            endLine: endLineInfo.index,
+            endScreenLine: endLineInfo.screenIndex,
+            endScreenFullLine: endLineInfo.visibleScreenIndex,
+            pages: visiblePages
+        };
+    }
+    processParagraphsProperties(startParagraphIndex) {
+        const pagesInfo = { pagesVerticalData: this.pagesVerticalData, pagesSpace: this.pagesSpace };
+        let currentPage = startParagraphIndex === 0 ? 1 : this.paragraphs[startParagraphIndex - 1].lastPageNumber;
+        let pageVerticalData = PageHelper.getVerticalData(currentPage, this.pagesVerticalData);
+        for (let i = startParagraphIndex; i < this.paragraphs.length; i++) {
+            const prevParagraphInfo = this.getPreviousParagraphInfo(i);
+            const paragraph = this.paragraphs[i];
+            paragraph.processParagraphProperties(prevParagraphInfo, pagesInfo);
+            if (paragraph.firstPageNumber !== currentPage) {
+                currentPage = paragraph.firstPageNumber;
+                pageVerticalData = PageHelper.getVerticalData(paragraph.firstPageNumber, this.pagesVerticalData);
+            }
+            paragraph.distanceFromTop =
+                (paragraph.firstPageNumber - 1) * this.pageHeight +
+                    this.pagesSpace * paragraph.firstPageNumber +
+                    pageVerticalData.marginTop +
+                    paragraph.pagePreviousContentHeight;
+        }
+        let pageHeight = this.pageHeight;
+        if (!pageHeight) {
+            pageHeight = this.getAllParagraphsHeight() + this.documentMargin.top + this.documentMargin.bottom;
+            this.minHeight = pageHeight + 2 * this.pagesSpace;
+            this.defaultVerticalData.contentHeight = pageHeight;
+        }
+        const lastPageNumber = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;
+        this.allPagesHeight = lastPageNumber * (pageHeight + this.pagesSpace) + this.pagesSpace;
+        this.emit('pagesCountChanged', { pagesCount: lastPageNumber, pageHeight: pageHeight + 2 * this.pagesSpace });
+    }
+    getAllParagraphsHeight() {
+        return this.paragraphs.reduce((sum, x) => sum + x.height, 0);
+    }
+    destroy() {
+        this.removeAllListeners('pagesCountChanged');
+    }
+    updatePageVerticalData(edgeType, page) {
+        const pageVerticalData = PageHelper.getVerticalData(page, this.pagesVerticalData);
+        const componentHeight = this.edges.getComponentHeight(page, edgeType);
+        if (edgeType === EdgeType.Header) {
+            pageVerticalData.marginTop = componentHeight > this.documentMargin.top ? componentHeight : this.documentMargin.top;
+        }
+        else {
+            pageVerticalData.marginBottom = componentHeight > this.documentMargin.bottom ? componentHeight : this.documentMargin.bottom;
+        }
+        const newContentHeight = this.pageHeight - pageVerticalData.marginTop - pageVerticalData.marginBottom;
+        if (newContentHeight === pageVerticalData.contentHeight) {
+            return;
+        }
+        pageVerticalData.contentHeight = newContentHeight;
+        this.processParagraphsProperties(0);
+    }
+    getPreviousParagraphInfo(row) {
+        if (!row || !this.paragraphs.length) {
+            return { lastPage: 1, paragraphHeight: 0, paragraphLastLine: -1 };
+        }
+        const prevParagraph = this.paragraphs[row - 1];
+        return prevParagraph.getParagraphData();
+    }
+    getVisiblePages(offsetTop, containerHeight) {
+        const visiblePages = [];
+        let firstVisiblePage = offsetTop / (this.pageHeight + this.pagesSpace);
+        if (firstVisiblePage % 1 === 0) {
+            firstVisiblePage++;
+        }
+        let visiblePagesCount = containerHeight / (this.pageHeight + this.pagesSpace);
+        const partialPageOnScreenPercent = Math.trunc(((visiblePagesCount % 1) + (firstVisiblePage % 1)) * 100);
+        const pageSpaceHeightPercent = Math.trunc((this.pagesSpace / containerHeight) * 100);
+        if (partialPageOnScreenPercent - pageSpaceHeightPercent > 100) {
+            visiblePagesCount++;
+        }
+        visiblePagesCount = Math.ceil(visiblePagesCount);
+        firstVisiblePage = Math.ceil(firstVisiblePage);
+        const documentPagesCount = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;
+        if (firstVisiblePage + visiblePagesCount - 1 > documentPagesCount) {
+            visiblePagesCount = documentPagesCount - firstVisiblePage + 1;
+        }
+        for (let i = 0; i < visiblePagesCount; i++) {
+            visiblePages.push(firstVisiblePage + i);
+        }
+        return visiblePages;
+    }
+    initPagesVerticalData() {
+        if (!this.edges || (!this.edges.headersComponents.length && !this.edges.footersComponents.length)) {
+            this.pagesVerticalData = [
+                new PageVerticalDataModel({
+                    marginTop: this.documentMargin.top,
+                    marginBottom: this.documentMargin.bottom,
+                    contentHeight: this.pageHeight - this.documentMargin.top - this.documentMargin.bottom,
+                    pageType: PageType.Default
+                })
+            ];
+            return;
+        }
+        const pageTypes = this.edges.getUniquePageTypes();
+        this.pagesVerticalData = pageTypes.map(pageType => {
+            const headerHeight = this.edges.getComponentHeightByPageType(pageType, EdgeType.Header);
+            const footerHeight = this.edges.getComponentHeightByPageType(pageType, EdgeType.Footer);
+            const marginTop = Math.max(headerHeight, this.documentMargin.top);
+            const marginBottom = Math.max(footerHeight, this.documentMargin.bottom);
+            return new PageVerticalDataModel({
+                marginTop,
+                marginBottom,
+                contentHeight: this.pageHeight - marginTop - marginBottom,
+                pageType
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pages.wrap.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/paging/pages.wrap.ts"],"names":[],"mappings":"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","sourcesContent":["import { DisplayToken } from '../models/display-token.model';\nimport { Edges } from '../components/edges/edges';\nimport { EdgeType } from '../components/edges/edge-type.enum';\nimport { EventEmitting } from '../base/event-emitting';\nimport { LineInfoModel } from '../models/line-info.model';\nimport { MarginModel } from '../models/margin.model';\nimport { NumberingHelper } from '../helpers/numbering.helper';\nimport { NumberingModel } from '../../../../models/generated/numbering.model';\nimport { PageHelper } from '../helpers/page.helper';\nimport { PageType } from '../enums/page-type.enum';\nimport { PageVerticalDataModel } from './page-vertical-data.model';\nimport { Paragraph } from './paragraph';\nimport { ParagraphHelper } from '../helpers/paragraph.helper';\nimport { ParagraphModel } from '../../../../models/generated/paragraph.model';\nimport { VisibleRange } from '../interfaces/visible-range.interface';\n\nexport class PagesWrap extends EventEmitting {\n    contentWidth: number;\n\n    allPagesHeight = 0;\n\n    minHeight = 0;\n\n    paragraphs: Paragraph[] = [];\n\n    tabTokens: DisplayToken[] = [];\n\n    pagesVerticalData: PageVerticalDataModel[];\n\n    get defaultVerticalData(): PageVerticalDataModel {\n        return this.pagesVerticalData.find(x => x.pageType === PageType.Default);\n    }\n\n    private processTextLinesProperties: (\n        currentParagraph: Paragraph,\n        prevParagraphInfo: { lastPage: number; paragraphHeight: number; paragraphLastLine: number },\n        pagesInfo: { pagesVerticalData: PageVerticalDataModel[]; pagesSpace: number }\n    ) => void;\n\n    constructor(\n        public pagesSpace: number,\n        public documentMargin: MarginModel,\n        public pageWidth: number,\n        public pageHeight = 0,\n        public edges: Edges | null = null\n    ) {\n        super();\n        this.minHeight = this.pageHeight + 2 * this.pagesSpace;\n        this.contentWidth = this.pageWidth - this.documentMargin.left - this.documentMargin.right;\n        this.initPagesVerticalData();\n\n        this.processTextLinesProperties = !this.pageHeight\n            ? ParagraphHelper.processTextLinesPropertiesForSinglePage\n            : ParagraphHelper.processTextLinesProperties;\n    }\n\n    getParagraphTop(paragraphs: Paragraph[], index: number): number {\n        return paragraphs[index] ? paragraphs[index].distanceFromTop : 0;\n    }\n\n    getParagraphTopForPrint(paragraphs: Paragraph[], index: number, pagesSpace: number): number {\n        if (!paragraphs[index]) {\n            return 0;\n        }\n        const paragraph = paragraphs[index];\n        const pageNumber = paragraph.pageNumbers[0];\n        let pageBreakHeight = 0;\n        paragraph.textLinesInfo.forEach(linesInfo => {\n            if (linesInfo.isAfterPageBreak) {\n                pageBreakHeight = linesInfo.height;\n            }\n        });\n        return paragraph.distanceFromTop - pageNumber * pagesSpace - pageBreakHeight;\n    }\n\n    getParagraphHeight(paragraphs: Paragraph[], index: number): number {\n        return paragraphs[index] ? paragraphs[index].height : 0;\n    }\n\n    remove(index: number, length: number): void {\n        this.paragraphs.splice(index, length);\n    }\n\n    reset(paragraphsLength: number): void {\n        this.paragraphs.length = paragraphsLength;\n    }\n\n    set(row: number, lineInfos: LineInfoModel[], numberings: NumberingModel[], docParagraphs: ParagraphModel[]): void {\n        if (!this.paragraphs[row]) {\n            const numberingData = NumberingHelper.createDataModel(numberings, docParagraphs, row);\n            this.paragraphs[row] = new Paragraph(numberingData, lineInfos[0].offsetBefore, this.processTextLinesProperties);\n        }\n\n        this.paragraphs[row].width = this.contentWidth;\n        this.paragraphs[row].setTextLinesInfo(lineInfos);\n    }\n\n    getVisibleRange(offsetTop: number, scrollerHeight: number): VisibleRange {\n        let start = this.paragraphs.findIndex(x => offsetTop <= x.distanceFromTop + x.height);\n        if (start < 0) {\n            start = 0;\n        }\n\n        let startLineInfo = null;\n        const startParagraph = this.paragraphs[start];\n        if (startParagraph) {\n            const startParagraphOffsetTop = offsetTop - startParagraph.distanceFromTop;\n            startLineInfo = ParagraphHelper.getVisibleLineInfo(startParagraph?.textLinesInfo, startParagraphOffsetTop, 1);\n        }\n\n        if (!startLineInfo) {\n            return {\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                pages: [1]\n            };\n        }\n\n        let end = this.paragraphs.findIndex(x => offsetTop + scrollerHeight <= x.distanceFromTop + x.height);\n        if (end < 0) {\n            end = this.paragraphs.length - 1;\n        }\n\n        let endLineInfo = null;\n        const endParagraph = this.paragraphs[end];\n        if (endParagraph) {\n            const endParagraphOffsetTop = offsetTop + scrollerHeight - endParagraph.distanceFromTop;\n            endLineInfo = ParagraphHelper.getVisibleLineInfo(endParagraph?.textLinesInfo, endParagraphOffsetTop, -1);\n        }\n\n        const visiblePages = this.getVisiblePages(offsetTop, scrollerHeight);\n\n        return {\n            startParagraph: start,\n            startLine: startLineInfo.index,\n            startScreenLine: startLineInfo.screenIndex,\n            startScreenFullLine: startLineInfo.visibleScreenIndex,\n            endParagraph: end,\n            endLine: endLineInfo.index,\n            endScreenLine: endLineInfo.screenIndex,\n            endScreenFullLine: endLineInfo.visibleScreenIndex,\n            pages: visiblePages\n        };\n    }\n\n    processParagraphsProperties(startParagraphIndex: number): void {\n        const pagesInfo = { pagesVerticalData: this.pagesVerticalData, pagesSpace: this.pagesSpace };\n        let currentPage = startParagraphIndex === 0 ? 1 : this.paragraphs[startParagraphIndex - 1].lastPageNumber;\n        let pageVerticalData = PageHelper.getVerticalData(currentPage, this.pagesVerticalData);\n        for (let i = startParagraphIndex; i < this.paragraphs.length; i++) {\n            const prevParagraphInfo = this.getPreviousParagraphInfo(i);\n            const paragraph = this.paragraphs[i];\n            paragraph.processParagraphProperties(prevParagraphInfo, pagesInfo);\n            if (paragraph.firstPageNumber !== currentPage) {\n                currentPage = paragraph.firstPageNumber;\n                pageVerticalData = PageHelper.getVerticalData(paragraph.firstPageNumber, this.pagesVerticalData);\n            }\n\n            paragraph.distanceFromTop =\n                (paragraph.firstPageNumber - 1) * this.pageHeight +\n                this.pagesSpace * paragraph.firstPageNumber +\n                pageVerticalData.marginTop +\n                paragraph.pagePreviousContentHeight;\n        }\n\n        let pageHeight = this.pageHeight;\n        if (!pageHeight) {\n            pageHeight = this.getAllParagraphsHeight() + this.documentMargin.top + this.documentMargin.bottom;\n            this.minHeight = pageHeight + 2 * this.pagesSpace;\n            this.defaultVerticalData.contentHeight = pageHeight;\n        }\n\n        const lastPageNumber = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;\n        this.allPagesHeight = lastPageNumber * (pageHeight + this.pagesSpace) + this.pagesSpace;\n        this.emit('pagesCountChanged', { pagesCount: lastPageNumber, pageHeight: pageHeight + 2 * this.pagesSpace });\n    }\n\n    getAllParagraphsHeight(): number {\n        return this.paragraphs.reduce((sum, x) => sum + x.height, 0);\n    }\n\n    destroy(): void {\n        this.removeAllListeners('pagesCountChanged');\n    }\n\n    updatePageVerticalData(edgeType: EdgeType, page: number): void {\n        const pageVerticalData = PageHelper.getVerticalData(page, this.pagesVerticalData);\n        const componentHeight = this.edges.getComponentHeight(page, edgeType);\n        if (edgeType === EdgeType.Header) {\n            pageVerticalData.marginTop = componentHeight > this.documentMargin.top ? componentHeight : this.documentMargin.top;\n        } else {\n            pageVerticalData.marginBottom = componentHeight > this.documentMargin.bottom ? componentHeight : this.documentMargin.bottom;\n        }\n\n        const newContentHeight = this.pageHeight - pageVerticalData.marginTop - pageVerticalData.marginBottom;\n        if (newContentHeight === pageVerticalData.contentHeight) {\n            return;\n        }\n\n        pageVerticalData.contentHeight = newContentHeight;\n        this.processParagraphsProperties(0);\n    }\n\n    private getPreviousParagraphInfo(row: number): { lastPage: number; paragraphHeight: number; paragraphLastLine: number } {\n        if (!row || !this.paragraphs.length) {\n            return { lastPage: 1, paragraphHeight: 0, paragraphLastLine: -1 };\n        }\n\n        const prevParagraph = this.paragraphs[row - 1];\n        return prevParagraph.getParagraphData();\n    }\n\n    private getVisiblePages(offsetTop: number, containerHeight: number): number[] {\n        const visiblePages: number[] = [];\n\n        let firstVisiblePage = offsetTop / (this.pageHeight + this.pagesSpace);\n        if (firstVisiblePage % 1 === 0) {\n            firstVisiblePage++;\n        }\n\n        let visiblePagesCount = containerHeight / (this.pageHeight + this.pagesSpace);\n        const partialPageOnScreenPercent = Math.trunc(((visiblePagesCount % 1) + (firstVisiblePage % 1)) * 100);\n        const pageSpaceHeightPercent = Math.trunc((this.pagesSpace / containerHeight) * 100);\n        if (partialPageOnScreenPercent - pageSpaceHeightPercent > 100) {\n            visiblePagesCount++;\n        }\n\n        visiblePagesCount = Math.ceil(visiblePagesCount);\n        firstVisiblePage = Math.ceil(firstVisiblePage);\n        const documentPagesCount = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;\n        if (firstVisiblePage + visiblePagesCount - 1 > documentPagesCount) {\n            visiblePagesCount = documentPagesCount - firstVisiblePage + 1;\n        }\n\n        for (let i = 0; i < visiblePagesCount; i++) {\n            visiblePages.push(firstVisiblePage + i);\n        }\n\n        return visiblePages;\n    }\n\n    private initPagesVerticalData(): void {\n        if (!this.edges || (!this.edges.headersComponents.length && !this.edges.footersComponents.length)) {\n            this.pagesVerticalData = [\n                new PageVerticalDataModel({\n                    marginTop: this.documentMargin.top,\n                    marginBottom: this.documentMargin.bottom,\n                    contentHeight: this.pageHeight - this.documentMargin.top - this.documentMargin.bottom,\n                    pageType: PageType.Default\n                })\n            ];\n            return;\n        }\n\n        const pageTypes = this.edges.getUniquePageTypes();\n        this.pagesVerticalData = pageTypes.map(pageType => {\n            const headerHeight = this.edges.getComponentHeightByPageType(pageType, EdgeType.Header);\n            const footerHeight = this.edges.getComponentHeightByPageType(pageType, EdgeType.Footer);\n            const marginTop = Math.max(headerHeight, this.documentMargin.top);\n            const marginBottom = Math.max(footerHeight, this.documentMargin.bottom);\n\n            return new PageVerticalDataModel({\n                marginTop,\n                marginBottom,\n                contentHeight: this.pageHeight - marginTop - marginBottom,\n                pageType\n            });\n        });\n    }\n}\n"]}

package/esm2022/lib/+shared/editor/core/paging/paragraph.mjs

@@ -0,0 +1,52 @@
+import { ParagraphHelper } from '../helpers/paragraph.helper';
+import { TextLineInfo } from './text-line-info';
+export class Paragraph {
+    get firstPageNumber() {
+        return this.pageNumbers[0] || 1;
+    }
+    get lastPageNumber() {
+        return this.pageNumbers[this.pageNumbers.length - 1] || 1;
+    }
+    get firstScreenLine() {
+        return this.textLinesInfo[0].screenLine;
+    }
+    get lastScreenLine() {
+        return this.textLinesInfo[this.textLinesInfo.length - 1].screenLine;
+    }
+    get isEndedByPageBreak() {
+        return this.textLinesInfo[this.textLinesInfo.length - 1].isEndedByPageBreak;
+    }
+    get backgroundColor() {
+        return this.textLinesInfo[0].backgroundColor;
+    }
+    constructor(numberingData, offsetBefore, processTextLinesProperties) {
+        this.numberingData = numberingData;
+        this.offsetBefore = offsetBefore;
+        this.processTextLinesProperties = processTextLinesProperties;
+        this.textLinesInfo = [];
+        this.pagePreviousContentHeight = 0;
+        this.width = 0;
+        this.height = 0;
+        this.pageNumbers = [];
+    }
+    setTextLinesInfo(linesInfos) {
+        this.textLinesInfo = linesInfos.map(lineInfo => new TextLineInfo(this.width, lineInfo.align, lineInfo.indent, lineInfo));
+    }
+    setIsAfterPageBreak(value) {
+        this.textLinesInfo[0].isAfterPageBreak = value;
+    }
+    getParagraphData() {
+        const pageContentHeight = this.pageNumbers.length === 1
+            ? this.height + this.pagePreviousContentHeight
+            : ParagraphHelper.getPageLinesHeight(this.textLinesInfo, this.lastPageNumber);
+        return { lastPage: this.lastPageNumber, paragraphHeight: pageContentHeight, paragraphLastLine: this.lastScreenLine };
+    }
+    processParagraphProperties(prevParagraphInfo, pagesInfo) {
+        this.pagePreviousContentHeight = prevParagraphInfo.paragraphHeight;
+        this.processTextLinesProperties(this, prevParagraphInfo, pagesInfo);
+        ParagraphHelper.processOffsetLineWithNumberingMarker(this.textLinesInfo[0], this.numberingData.height, this.offsetBefore);
+        this.pageNumbers = ParagraphHelper.getParagraphPages(this.textLinesInfo);
+        this.height = ParagraphHelper.getParagraphHeight(this.textLinesInfo);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/+shared/editor/core/paging/text-line-info.mjs

@@ -0,0 +1,34 @@
+import { Alignment } from '../constants/alignments.const';
+export class TextLineInfo {
+    constructor(contentWidth, align, indent, fields) {
+        this.paddingLeft = 0;
+        this.offsetBefore = 0;
+        this.offsetAfter = 0;
+        this.firstLinePageOffset = 0;
+        this.endPageOffset = 0;
+        this.screenLine = 0;
+        this.isAfterPageBreak = false;
+        this.isEndedByPageBreak = false;
+        if (fields) {
+            Object.assign(this, fields);
+        }
+        const diff = contentWidth - this.width;
+        if (this.width === undefined || diff === 0) {
+            return;
+        }
+        switch (align) {
+            case Alignment.center:
+                this.paddingLeft = indent.left + (diff - indent.left - indent.right) / 2;
+                break;
+            case Alignment.right:
+                this.paddingLeft = diff - indent.right;
+                break;
+            default:
+                this.paddingLeft = indent.left;
+                break;
+        }
+        this.paddingLeft += indent.firstLine;
+        this.paddingLeft -= indent.hanging;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+export class Point {
+    constructor(row, column) {
+        this.row = row;
+        this.column = column;
+    }
+    static comparePoints(first, second) {
+        return first.row - second.row || first.column - second.column;
+    }
+    static clone(point) {
+        return new Point(point.row, point.column);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9jb3JlL3BvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxLQUFLO0lBS2QsWUFBWSxHQUFXLEVBQUUsTUFBYztRQUNuQyxJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQztRQUNmLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO0lBQ3pCLENBQUM7SUFFRCxNQUFNLENBQUMsYUFBYSxDQUFDLEtBQVksRUFBRSxNQUFhO1FBQzVDLE9BQU8sS0FBSyxDQUFDLEdBQUcsR0FBRyxNQUFNLENBQUMsR0FBRyxJQUFJLEtBQUssQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUNsRSxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFZO1FBQ3JCLE9BQU8sSUFBSSxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDOUMsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFBvaW50IHtcbiAgICByb3c6IG51bWJlcjtcblxuICAgIGNvbHVtbjogbnVtYmVyO1xuXG4gICAgY29uc3RydWN0b3Iocm93OiBudW1iZXIsIGNvbHVtbjogbnVtYmVyKSB7XG4gICAgICAgIHRoaXMucm93ID0gcm93O1xuICAgICAgICB0aGlzLmNvbHVtbiA9IGNvbHVtbjtcbiAgICB9XG5cbiAgICBzdGF0aWMgY29tcGFyZVBvaW50cyhmaXJzdDogUG9pbnQsIHNlY29uZDogUG9pbnQpOiBudW1iZXIge1xuICAgICAgICByZXR1cm4gZmlyc3Qucm93IC0gc2Vjb25kLnJvdyB8fCBmaXJzdC5jb2x1bW4gLSBzZWNvbmQuY29sdW1uO1xuICAgIH1cblxuICAgIHN0YXRpYyBjbG9uZShwb2ludDogUG9pbnQpOiBQb2ludCB7XG4gICAgICAgIHJldHVybiBuZXcgUG9pbnQocG9pbnQucm93LCBwb2ludC5jb2x1bW4pO1xuICAgIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,72 @@
+import { DistanceModel } from './models/distance.model';
+import { PrintEdgesLayer } from './layers/print.edges.layer';
+import { PrintPagesLayer } from './layers/print.pages.layer';
+import { PrintRenderingHelper } from './helpers/print.rendering.helper';
+import { PrintTextLayer } from './layers/print.text.layer';
+export class PrintRenderer {
+    constructor(session, editorService) {
+        this.session = session;
+        this.pagesCount = Math.round((session.pagesWrap.pagesSpace * 2 + session.pagesWrap.allPagesHeight) / session.pagesWrap.minHeight);
+        this.createContent();
+        this.createLayers(editorService);
+    }
+    renderPrintDocument() {
+        const layerConfig = this.computeLayerConfig();
+        this.pagesLayer.update(layerConfig);
+        this.textLayer.update(layerConfig);
+        this.edgesLayer.update(layerConfig);
+        this.createDocumentHtml(layerConfig);
+    }
+    computeLayerConfig() {
+        const pages = Array.from(Array(this.pagesCount).keys()).map(x => x + 1);
+        const pagesWrap = this.session.pagesWrap;
+        const maxHeight = pagesWrap.pageHeight * this.pagesCount;
+        const minHeight = pagesWrap.pageHeight;
+        return {
+            width: this.textLayer.element.clientWidth + pagesWrap.documentMargin.left + pagesWrap.documentMargin.right,
+            height: pagesWrap.defaultVerticalData.contentHeight,
+            contentRange: new DistanceModel({ start: 0, end: this.session.pagesWrap.paragraphs.length - 1 }),
+            minHeight,
+            maxHeight,
+            offset: 0,
+            pages,
+            scrollTop: 0
+        };
+    }
+    createContent() {
+        this.content = document.createElement('div');
+        this.content.className = 'ace-content print';
+    }
+    createLayers(editorService) {
+        this.textLayer = new PrintTextLayer(this.content, PrintRenderingHelper);
+        this.textLayer.setSession(this.session);
+        this.edgesLayer = new PrintEdgesLayer(this.content, editorService);
+        this.edgesLayer.setSession(this.session);
+        this.pagesLayer = new PrintPagesLayer(this.content);
+        this.pagesLayer.setSession(this.session);
+    }
+    createDocumentHtml(layerConfig) {
+        const head = this.createHeadWithStyles();
+        let body = `<div class="ace-scroller print" style="width: 100%;">${this.content.innerHTML}</div>`;
+        body = `<div class="edit-container ace-editor print">${body}</div>`;
+        body = `<div class="container print" style="height: ${layerConfig.maxHeight}px;">${body}</div>`;
+        body = `<div class="mat-drawer-content print">${body}</div>`;
+        body = `<div class="mat-drawer-container sidenav-container print">${body}</div>`;
+        body = `<div class="base-editor print">${body}</div>`;
+        this.documentHtml = `<!DOCTYPE html><html>${head}${body}</html>`;
+    }
+    createHeadWithStyles() {
+        let styles = '';
+        for (let i = 0; i < document.styleSheets.length; i++) {
+            const cssRules = Array.from(document.styleSheets[i].cssRules);
+            cssRules.forEach(rule => (styles += `<style>${rule.cssText}</style>`));
+        }
+        return `<head><title>Print</title>${styles}${this.getPrintPageStyle()}</head>`;
+    }
+    getPrintPageStyle() {
+        const pageStyle = '@page { margin: 0; }';
+        const contentStyle = `@media print { html, body { width: 100%; height: 100%; } }`;
+        return `<style>${pageStyle} ${contentStyle}</style>`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"print.renderer.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/print.renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { DistanceModel } from './models/distance.model';\nimport { EdgesLayer } from './layers/edges.layer';\nimport { EditorService } from '../interaction/editor.service';\nimport { EditSession } from './edit.session';\nimport { ILayerConfig } from './interfaces/layer.config';\nimport { PagesLayer } from './layers/pages.layer';\nimport { PagesWrap } from './paging/pages.wrap';\nimport { PrintEdgesLayer } from './layers/print.edges.layer';\nimport { PrintPagesLayer } from './layers/print.pages.layer';\nimport { PrintRenderingHelper } from './helpers/print.rendering.helper';\nimport { PrintTextLayer } from './layers/print.text.layer';\nimport { TextLayer } from './layers/text.layer';\n\nexport class PrintRenderer {\n    content: HTMLElement;\n\n    edgesLayer: EdgesLayer;\n\n    textLayer: TextLayer;\n\n    pagesLayer: PagesLayer;\n\n    originalPagesWrap: PagesWrap;\n\n    documentHtml: string;\n\n    headHtml: string;\n\n    pagesCount: number;\n\n    constructor(private session: EditSession, editorService: EditorService) {\n        this.pagesCount = Math.round((session.pagesWrap.pagesSpace * 2 + session.pagesWrap.allPagesHeight) / session.pagesWrap.minHeight);\n        this.createContent();\n        this.createLayers(editorService);\n    }\n\n    renderPrintDocument(): void {\n        const layerConfig = this.computeLayerConfig();\n\n        this.pagesLayer.update(layerConfig);\n        this.textLayer.update(layerConfig);\n        this.edgesLayer.update(layerConfig);\n\n        this.createDocumentHtml(layerConfig);\n    }\n\n    private computeLayerConfig(): ILayerConfig {\n        const pages = Array.from(Array(this.pagesCount).keys()).map(x => x + 1);\n        const pagesWrap = this.session.pagesWrap;\n        const maxHeight = pagesWrap.pageHeight * this.pagesCount;\n        const minHeight = pagesWrap.pageHeight;\n\n        return {\n            width: this.textLayer.element.clientWidth + pagesWrap.documentMargin.left + pagesWrap.documentMargin.right,\n            height: pagesWrap.defaultVerticalData.contentHeight,\n            contentRange: new DistanceModel({ start: 0, end: this.session.pagesWrap.paragraphs.length - 1 }),\n            minHeight,\n            maxHeight,\n            offset: 0,\n            pages,\n            scrollTop: 0\n        };\n    }\n\n    private createContent(): void {\n        this.content = document.createElement('div');\n        this.content.className = 'ace-content print';\n    }\n\n    private createLayers(editorService: EditorService): void {\n        this.textLayer = new PrintTextLayer(this.content, PrintRenderingHelper);\n        this.textLayer.setSession(this.session);\n        this.edgesLayer = new PrintEdgesLayer(this.content, editorService);\n        this.edgesLayer.setSession(this.session);\n        this.pagesLayer = new PrintPagesLayer(this.content);\n        this.pagesLayer.setSession(this.session);\n    }\n\n    private createDocumentHtml(layerConfig: ILayerConfig): void {\n        const head = this.createHeadWithStyles();\n        let body = `<div class=\"ace-scroller print\" style=\"width: 100%;\">${this.content.innerHTML}</div>`;\n        body = `<div class=\"edit-container ace-editor print\">${body}</div>`;\n        body = `<div class=\"container print\" style=\"height: ${layerConfig.maxHeight}px;\">${body}</div>`;\n        body = `<div class=\"mat-drawer-content print\">${body}</div>`;\n        body = `<div class=\"mat-drawer-container sidenav-container print\">${body}</div>`;\n        body = `<div class=\"base-editor print\">${body}</div>`;\n\n        this.documentHtml = `<!DOCTYPE html><html>${head}${body}</html>`;\n    }\n\n    private createHeadWithStyles(): string {\n        let styles = '';\n        for (let i = 0; i < document.styleSheets.length; i++) {\n            const cssRules = Array.from(document.styleSheets[i].cssRules);\n            cssRules.forEach(rule => (styles += `<style>${rule.cssText}</style>`));\n        }\n\n        return `<head><title>Print</title>${styles}${this.getPrintPageStyle()}</head>`;\n    }\n\n    private getPrintPageStyle(): string {\n        const pageStyle = '@page { margin: 0; }';\n        const contentStyle = `@media print { html, body { width: 100%; height: 100%; } }`;\n        return `<style>${pageStyle} ${contentStyle}</style>`;\n    }\n}\n"]}

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

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