@talrace/ngx-noder 0.0.7

package/esm2022/lib/+shared/editor/core/layers/edges.layer.mjs

@@ -0,0 +1,99 @@
+import { DomHelper } from '../helpers/dom.helper';
+import { EdgeElementModel } from '../models/edge-element.model';
+import { EdgeType } from '../components/edges/edge-type.enum';
+import { EventEmitting } from '../base/event-emitting';
+import { RenderingHelper } from '../helpers/rendering.helper';
+export class EdgesLayer extends EventEmitting {
+    constructor(parentElement, editorService) {
+        super();
+        this.editorService = editorService;
+        this.edgeElements = [];
+        this.pagesCountChangedHandler = (event) => {
+            this.element.style.height = event.pagesCount * event.pageHeight + 'px';
+        };
+        this.element = document.createElement('div');
+        this.element.className = 'ace-layer ace-edges-layer';
+        parentElement.insertAdjacentElement('afterbegin', this.element);
+    }
+    destroy() {
+        this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+    }
+    setSession(newSession) {
+        this.session = newSession;
+        this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+        this.element.style.width = `${this.session.pagesWrap.pageWidth}px`;
+    }
+    update(config) {
+        DomHelper.translate(this.element, 0, -config.scrollTop);
+        this.config = config;
+        while (this.edgeElements.length) {
+            const removedEl = this.edgeElements.pop();
+            DomHelper.removeElement(removedEl.element);
+        }
+        this.renderPagesEdgeComponents(config.pages);
+    }
+    scrollPages(config) {
+        const oldConfig = this.config;
+        this.config = config;
+        DomHelper.translate(this.element, 0, -config.scrollTop);
+        const removedPages = oldConfig.pages.filter(x => !config.pages.includes(x));
+        this.removeRenderedComponents(removedPages);
+        const newPages = config.pages.filter(x => !oldConfig.pages.includes(x));
+        this.renderPagesEdgeComponents(newPages);
+    }
+    updateByLocation(updatedPageType) {
+        DomHelper.translate(this.element, 0, -this.config.scrollTop);
+        let pagesToRender = [];
+        for (let edgeElement of this.edgeElements) {
+            if (edgeElement.pageType !== updatedPageType || pagesToRender.includes(edgeElement.page)) {
+                continue;
+            }
+            pagesToRender.push(edgeElement.page);
+        }
+        this.removeRenderedComponents(pagesToRender);
+        this.renderPagesEdgeComponents(pagesToRender);
+    }
+    getParagraphTop(topOffset, page) {
+        const paragraphTop = this.session.pagesWrap.pagesSpace + topOffset;
+        return paragraphTop + (page - 1) * (this.session.pagesWrap.pageHeight + this.session.pagesWrap.pagesSpace);
+    }
+    renderPagesEdgeComponents(pages) {
+        const pagesWrap = this.session.pagesWrap;
+        for (let page of pages) {
+            const header = this.session.customComponents.edges.getComponentByPage(page, EdgeType.Header);
+            const headerHeight = this.session.customComponents.edges.getComponentHeight(page, EdgeType.Header);
+            if (header) {
+                this.renderEdgeComponent(header, headerHeight, page);
+            }
+            const footer = this.session.customComponents.edges.getComponentByPage(page, EdgeType.Footer);
+            const footerHeight = this.session.customComponents.edges.getComponentHeight(page, EdgeType.Footer);
+            if (footer) {
+                const topOffset = pagesWrap.pageHeight - footerHeight;
+                this.renderEdgeComponent(footer, footerHeight, page, topOffset);
+            }
+        }
+    }
+    renderEdgeComponent(edgeComponent, edgeHeight, page, topOffset = 0) {
+        const container = RenderingHelper.createDivContainer('ace-line-group');
+        let paragraphTop = this.getParagraphTop(topOffset, page);
+        DomHelper.setStyle(container.style, 'height', `${edgeHeight}px`);
+        DomHelper.setStyle(container.style, 'top', `${paragraphTop}px`);
+        const componentElement = edgeComponent.hostView.rootNodes[0];
+        const componentCopy = componentElement.cloneNode(true);
+        componentCopy.setAttribute('data-session-id', `${edgeComponent.instance.sessionId}`);
+        container.appendChild(componentCopy);
+        this.element.appendChild(container);
+        this.edgeElements.push(new EdgeElementModel({ page, element: container, pageType: edgeComponent.instance.model.pageType }));
+        this.editorService.edgeElementCopyUpdated(componentCopy, page);
+    }
+    removeRenderedComponents(removedPages) {
+        let removeIndex = this.edgeElements.findIndex(x => removedPages.includes(x.page));
+        while (removeIndex !== -1) {
+            const removedElement = this.edgeElements[removeIndex];
+            DomHelper.removeElement(removedElement.element);
+            this.edgeElements.splice(removeIndex, 1);
+            removeIndex = this.edgeElements.findIndex(x => removedPages.includes(x.page));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"edges.layer.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/layers/edges.layer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAIvD,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,MAAM,OAAO,UAAW,SAAQ,aAAa;IASzC,YAAmB,aAA0B,EAAU,aAA4B;QAC/E,KAAK,EAAE,CAAC;QAD2C,kBAAa,GAAb,aAAa,CAAe;QAFnF,iBAAY,GAAuB,EAAE,CAAC;QA0G9B,6BAAwB,GAAG,CAAC,KAAiD,EAAE,EAAE;YACrF,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC;QAC3E,CAAC,CAAC;QAvGE,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,2BAA2B,CAAC;QACrD,aAAa,CAAC,qBAAqB,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACpE,CAAC;IAED,OAAO;QACH,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,mBAAmB,CAAC,mBAAmB,EAAE,IAAI,CAAC,wBAAwB,CAAC,CAAC;IACnG,CAAC;IAED,UAAU,CAAC,UAAuB;QAC9B,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;QAC1B,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,mBAAmB,EAAE,IAAI,CAAC,wBAAwB,CAAC,CAAC;QAC5F,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,IAAI,CAAC;IACvE,CAAC;IAED,MAAM,CAAC,MAAoB;QACvB,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QAErB,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE;YAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;YAC1C,SAAS,CAAC,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;SAC9C;QAED,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;IAED,WAAW,CAAC,MAAoB;QAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAExD,MAAM,YAAY,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5E,IAAI,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;QAE5C,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACxE,IAAI,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAED,gBAAgB,CAAC,eAAyB;QACtC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC7D,IAAI,aAAa,GAAa,EAAE,CAAC;QACjC,KAAK,IAAI,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE;YACvC,IAAI,WAAW,CAAC,QAAQ,KAAK,eAAe,IAAI,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;gBACtF,SAAS;aACZ;YAED,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;SACxC;QACD,IAAI,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAC;QAC7C,IAAI,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC;IAClD,CAAC;IAES,eAAe,CAAC,SAAiB,EAAE,IAAY;QACrD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC;QACnE,OAAO,YAAY,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC/G,CAAC;IAEO,yBAAyB,CAAC,KAAe;QAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;QACzC,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE;YACpB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YAC7F,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YACnG,IAAI,MAAM,EAAE;gBACR,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;aACxD;YAED,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YAC7F,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YACnG,IAAI,MAAM,EAAE;gBACR,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU,GAAG,YAAY,CAAC;gBACtD,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;aACnE;SACJ;IACL,CAAC;IAEO,mBAAmB,CAAC,aAA+C,EAAE,UAAkB,EAAE,IAAY,EAAE,SAAS,GAAG,CAAC;QACxH,MAAM,SAAS,GAAG,eAAe,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;QACvE,IAAI,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACzD,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,UAAU,IAAI,CAAC,CAAC;QACjE,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,YAAY,IAAI,CAAC,CAAC;QAEhE,MAAM,gBAAgB,GAAI,aAAa,CAAC,QAAiC,CAAC,SAAS,CAAC,CAAC,CAAgB,CAAC;QACtG,MAAM,aAAa,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAgB,CAAC;QACtE,aAAa,CAAC,YAAY,CAAC,iBAAiB,EAAE,GAAG,aAAa,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;QACrF,SAAS,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QACpC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAC5H,IAAI,CAAC,aAAa,CAAC,sBAAsB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;IACnE,CAAC;IAEO,wBAAwB,CAAC,YAAsB;QACnD,IAAI,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAClF,OAAO,WAAW,KAAK,CAAC,CAAC,EAAE;YACvB,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;YACtD,SAAS,CAAC,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;YAChD,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;YACzC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;SACjF;IACL,CAAC;CAKJ","sourcesContent":["import { ComponentRef, EmbeddedViewRef } from '@angular/core';\n\nimport { DomHelper } from '../helpers/dom.helper';\nimport { EdgeElementModel } from '../models/edge-element.model';\nimport { EdgeType } from '../components/edges/edge-type.enum';\nimport { EditorService } from '../../interaction/editor.service';\nimport { EditSession } from '../edit.session';\nimport { EventEmitting } from '../base/event-emitting';\nimport { ILayerConfig } from '../interfaces/layer.config';\nimport { NoderEdgeComponent } from '../components/edges/edge.component';\nimport { PageType } from '../enums/page-type.enum';\nimport { RenderingHelper } from '../helpers/rendering.helper';\n\nexport class EdgesLayer extends EventEmitting {\n    element: HTMLElement;\n\n    session: EditSession;\n\n    config: ILayerConfig;\n\n    edgeElements: EdgeElementModel[] = [];\n\n    public constructor(parentElement: HTMLElement, private editorService: EditorService) {\n        super();\n\n        this.element = document.createElement('div');\n        this.element.className = 'ace-layer ace-edges-layer';\n        parentElement.insertAdjacentElement('afterbegin', this.element);\n    }\n\n    destroy(): void {\n        this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n    }\n\n    setSession(newSession: EditSession): void {\n        this.session = newSession;\n        this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n        this.element.style.width = `${this.session.pagesWrap.pageWidth}px`;\n    }\n\n    update(config: ILayerConfig): void {\n        DomHelper.translate(this.element, 0, -config.scrollTop);\n        this.config = config;\n\n        while (this.edgeElements.length) {\n            const removedEl = this.edgeElements.pop();\n            DomHelper.removeElement(removedEl.element);\n        }\n\n        this.renderPagesEdgeComponents(config.pages);\n    }\n\n    scrollPages(config: ILayerConfig): void {\n        const oldConfig = this.config;\n        this.config = config;\n        DomHelper.translate(this.element, 0, -config.scrollTop);\n\n        const removedPages = oldConfig.pages.filter(x => !config.pages.includes(x));\n        this.removeRenderedComponents(removedPages);\n\n        const newPages = config.pages.filter(x => !oldConfig.pages.includes(x));\n        this.renderPagesEdgeComponents(newPages);\n    }\n\n    updateByLocation(updatedPageType: PageType): void {\n        DomHelper.translate(this.element, 0, -this.config.scrollTop);\n        let pagesToRender: number[] = [];\n        for (let edgeElement of this.edgeElements) {\n            if (edgeElement.pageType !== updatedPageType || pagesToRender.includes(edgeElement.page)) {\n                continue;\n            }\n\n            pagesToRender.push(edgeElement.page);\n        }\n        this.removeRenderedComponents(pagesToRender);\n        this.renderPagesEdgeComponents(pagesToRender);\n    }\n\n    protected getParagraphTop(topOffset: number, page: number): number {\n        const paragraphTop = this.session.pagesWrap.pagesSpace + topOffset;\n        return paragraphTop + (page - 1) * (this.session.pagesWrap.pageHeight + this.session.pagesWrap.pagesSpace);\n    }\n\n    private renderPagesEdgeComponents(pages: number[]): void {\n        const pagesWrap = this.session.pagesWrap;\n        for (let page of pages) {\n            const header = this.session.customComponents.edges.getComponentByPage(page, EdgeType.Header);\n            const headerHeight = this.session.customComponents.edges.getComponentHeight(page, EdgeType.Header);\n            if (header) {\n                this.renderEdgeComponent(header, headerHeight, page);\n            }\n\n            const footer = this.session.customComponents.edges.getComponentByPage(page, EdgeType.Footer);\n            const footerHeight = this.session.customComponents.edges.getComponentHeight(page, EdgeType.Footer);\n            if (footer) {\n                const topOffset = pagesWrap.pageHeight - footerHeight;\n                this.renderEdgeComponent(footer, footerHeight, page, topOffset);\n            }\n        }\n    }\n\n    private renderEdgeComponent(edgeComponent: ComponentRef<NoderEdgeComponent>, edgeHeight: number, page: number, topOffset = 0): void {\n        const container = RenderingHelper.createDivContainer('ace-line-group');\n        let paragraphTop = this.getParagraphTop(topOffset, page);\n        DomHelper.setStyle(container.style, 'height', `${edgeHeight}px`);\n        DomHelper.setStyle(container.style, 'top', `${paragraphTop}px`);\n\n        const componentElement = (edgeComponent.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\n        const componentCopy = componentElement.cloneNode(true) as HTMLElement;\n        componentCopy.setAttribute('data-session-id', `${edgeComponent.instance.sessionId}`);\n        container.appendChild(componentCopy);\n        this.element.appendChild(container);\n        this.edgeElements.push(new EdgeElementModel({ page, element: container, pageType: edgeComponent.instance.model.pageType }));\n        this.editorService.edgeElementCopyUpdated(componentCopy, page);\n    }\n\n    private removeRenderedComponents(removedPages: number[]): void {\n        let removeIndex = this.edgeElements.findIndex(x => removedPages.includes(x.page));\n        while (removeIndex !== -1) {\n            const removedElement = this.edgeElements[removeIndex];\n            DomHelper.removeElement(removedElement.element);\n            this.edgeElements.splice(removeIndex, 1);\n            removeIndex = this.edgeElements.findIndex(x => removedPages.includes(x.page));\n        }\n    }\n\n    private pagesCountChangedHandler = (event: { pagesCount: number; pageHeight: number }) => {\n        this.element.style.height = event.pagesCount * event.pageHeight + 'px';\n    };\n}\n"]}

package/esm2022/lib/+shared/editor/core/layers/lines.mjs

@@ -0,0 +1,96 @@
+import { DocumentInfo } from '../constants/document-info.const';
+import { DomHelper } from '../helpers/dom.helper';
+export class Lines {
+    get length() {
+        return this.cells.length;
+    }
+    get last() {
+        return this.cells.length ? this.cells[this.cells.length - 1] : null;
+    }
+    get pageSize() {
+        return this._pageSize || DocumentInfo.height;
+    }
+    get pagesCount() {
+        return this._pagesCount || 1; // default page count
+    }
+    constructor(element) {
+        this.element = element;
+        this.cells = [];
+        this.cellCache = [];
+        this.setContainerSize();
+    }
+    shift() {
+        const cell = this.cells.shift();
+        DomHelper.removeElement(cell.element);
+        this.cacheCell(cell);
+    }
+    pop() {
+        const cell = this.cells.pop();
+        DomHelper.removeElement(cell.element);
+        this.cacheCell(cell);
+    }
+    push(data) {
+        if (Array.isArray(data)) {
+            this.cells.push(...data);
+            const fragment = DomHelper.createFragment(this.element);
+            for (const cell of data) {
+                fragment.appendChild(cell.element);
+            }
+            this.element.appendChild(fragment);
+            return;
+        }
+        this.cells.push(data);
+        this.element.appendChild(data.element);
+    }
+    unshift(data) {
+        if (Array.isArray(data)) {
+            this.cells.unshift(...data);
+            const fragment = DomHelper.createFragment(this.element);
+            for (const cell of data) {
+                fragment.appendChild(cell.element);
+            }
+            if (this.element.firstChild) {
+                this.element.insertBefore(fragment, this.element.firstChild);
+            }
+            else {
+                this.element.appendChild(fragment);
+            }
+            return;
+        }
+        this.cells.unshift(data);
+        this.element.insertAdjacentElement('afterbegin', data.element);
+    }
+    cacheCell(cell) {
+        if (!cell) {
+            return;
+        }
+        this.cellCache.push(cell);
+    }
+    createCell(row, page = 0) {
+        let cell = this.cellCache.pop();
+        if (!cell) {
+            const element = document.createElement('div');
+            this.element.appendChild(element);
+            cell = {
+                element,
+                row,
+                page
+            };
+        }
+        cell.row = row;
+        cell.page = page;
+        return cell;
+    }
+    setSizes(pagesCount, pageHeight) {
+        if (this._pageSize === pageHeight && this._pagesCount === pagesCount) {
+            return;
+        }
+        this._pageSize = pageHeight || DocumentInfo.height;
+        this._pagesCount = pagesCount;
+        this.setContainerSize();
+    }
+    setContainerSize() {
+        this.element.style.height = this.pagesCount * this.pageSize + 'px';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lines.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/layers/lines.ts"],"names":[],"mappings":"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","sourcesContent":["import { Cell } from '../interfaces/cell.interface';\nimport { DocumentInfo } from '../constants/document-info.const';\nimport { DomHelper } from '../helpers/dom.helper';\n\nexport class Lines {\n    cells: Cell[] = [];\n\n    cellCache: Cell[] = [];\n\n    get length(): number {\n        return this.cells.length;\n    }\n\n    get last(): Cell {\n        return this.cells.length ? this.cells[this.cells.length - 1] : null;\n    }\n\n    get pageSize(): number {\n        return this._pageSize || DocumentInfo.height;\n    }\n    private _pageSize: number;\n\n    get pagesCount(): number {\n        return this._pagesCount || 1; // default page count\n    }\n    private _pagesCount: number;\n\n    constructor(public element: HTMLElement) {\n        this.setContainerSize();\n    }\n\n    shift(): void {\n        const cell = this.cells.shift();\n        DomHelper.removeElement(cell.element);\n        this.cacheCell(cell);\n    }\n\n    pop(): void {\n        const cell = this.cells.pop();\n        DomHelper.removeElement(cell.element);\n        this.cacheCell(cell);\n    }\n\n    push(data: Cell | Cell[]): void {\n        if (Array.isArray(data)) {\n            this.cells.push(...data);\n            const fragment = DomHelper.createFragment(this.element);\n            for (const cell of data) {\n                fragment.appendChild(cell.element);\n            }\n\n            this.element.appendChild(fragment);\n\n            return;\n        }\n\n        this.cells.push(data);\n        this.element.appendChild(data.element);\n    }\n\n    unshift(data: Cell | Cell[]): void {\n        if (Array.isArray(data)) {\n            this.cells.unshift(...data);\n            const fragment = DomHelper.createFragment(this.element);\n            for (const cell of data) {\n                fragment.appendChild(cell.element);\n            }\n\n            if (this.element.firstChild) {\n                this.element.insertBefore(fragment, this.element.firstChild);\n            } else {\n                this.element.appendChild(fragment);\n            }\n\n            return;\n        }\n\n        this.cells.unshift(data);\n        this.element.insertAdjacentElement('afterbegin', data.element);\n    }\n\n    cacheCell(cell: Cell): void {\n        if (!cell) {\n            return;\n        }\n\n        this.cellCache.push(cell);\n    }\n\n    createCell(row: number, page = 0): Cell {\n        let cell = this.cellCache.pop();\n        if (!cell) {\n            const element = document.createElement('div');\n            this.element.appendChild(element);\n\n            cell = {\n                element,\n                row,\n                page\n            };\n        }\n\n        cell.row = row;\n        cell.page = page;\n\n        return cell;\n    }\n\n    setSizes(pagesCount: number, pageHeight: number): void {\n        if (this._pageSize === pageHeight && this._pagesCount === pagesCount) {\n            return;\n        }\n\n        this._pageSize = pageHeight || DocumentInfo.height;\n        this._pagesCount = pagesCount;\n        this.setContainerSize();\n    }\n\n    private setContainerSize(): void {\n        this.element.style.height = this.pagesCount * this.pageSize + 'px';\n    }\n}\n"]}

package/esm2022/lib/+shared/editor/core/layers/pages.layer.mjs

@@ -0,0 +1,106 @@
+import { DocumentInfo } from '../constants/document-info.const';
+import { DomHelper } from '../helpers/dom.helper';
+import { EventEmitting } from '../base/event-emitting';
+export class PagesLayer extends EventEmitting {
+    get pageSize() {
+        return this._pageSize || DocumentInfo.height;
+    }
+    get pagesCount() {
+        return this._pagesCount || 1;
+    }
+    constructor(parentElement) {
+        super();
+        this.parentElement = parentElement;
+        this.pageBreakElements = [];
+        this.pagesCountChangedHandler = (event) => {
+            if (this._pageSize === event.pageHeight && this._pagesCount === event.pagesCount) {
+                return;
+            }
+            this._pageSize = event.pageHeight || DocumentInfo.height;
+            this._pagesCount = event.pagesCount;
+            this.setContainerSize();
+        };
+        this.element = document.createElement('div');
+        this.element.className = 'ace-layer ace_pages-layer';
+        parentElement.insertAdjacentElement('afterbegin', this.element);
+        this.setContainerSize();
+        this.rulerLeft = document.createElement('div');
+        this.rulerLeft.className = 'ruler-line';
+        this.rulerRight = document.createElement('div');
+        this.rulerRight.className = 'ruler-line';
+        this.element.appendChild(this.rulerLeft);
+        this.element.appendChild(this.rulerRight);
+    }
+    update(config) {
+        if (!this.session) {
+            return;
+        }
+        DomHelper.translate(this.element, 0, -config.scrollTop);
+        const pageSpace = this.getPageSpace();
+        const pageHeight = this.session.pagesWrap.pageHeight;
+        const pages = config.pages || [];
+        let minPage = pages[0] || 1;
+        const maxPage = pages[pages.length - 1] || 1;
+        if (minPage > 1 && config.scrollTop <= (minPage - 1) * (pageHeight + pageSpace) + pageSpace) {
+            minPage--;
+        }
+        if (this.minPageNumber !== minPage || this.maxPageNumber !== maxPage || minPage === 1) {
+            this.minPageNumber = minPage;
+            this.maxPageNumber = maxPage;
+            this.removePages();
+            this.addPages(pageSpace, pageHeight);
+        }
+    }
+    setSession(session) {
+        if (this.session) {
+            this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+        }
+        this.session = session;
+        if (session) {
+            this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+        }
+    }
+    showRullerLines(positions) {
+        if (!positions || positions.length !== 2) {
+            DomHelper.removeCssClass(this.rulerLeft, 'visible');
+            DomHelper.removeCssClass(this.rulerRight, 'visible');
+            return;
+        }
+        DomHelper.setStyle(this.rulerLeft.style, 'left', `${positions[0]}px`);
+        DomHelper.addCssClass(this.rulerLeft, 'visible');
+        DomHelper.setStyle(this.rulerRight.style, 'left', `${positions[1]}px`);
+        DomHelper.addCssClass(this.rulerRight, 'visible');
+    }
+    destroy() {
+        this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);
+    }
+    getPageSpace() {
+        return this.session.pagesWrap.pagesSpace;
+    }
+    removePages() {
+        while (this.pageBreakElements?.length) {
+            const element = this.pageBreakElements.pop();
+            element.parentNode.removeChild(element);
+        }
+    }
+    addPages(pageSpace, pageHeight) {
+        for (let page = this.minPageNumber; page <= this.maxPageNumber; page++) {
+            const element = document.createElement('div');
+            element.className = 'page';
+            element.style.height = `${pageHeight}px`;
+            element.style.top = `${(page - 1) * (pageHeight + pageSpace) + pageSpace}px`;
+            if (page > 1) {
+                let pageLabel = document.createElement('span');
+                pageLabel.className = 'page-label';
+                pageLabel.innerText = `${page}.`;
+                element.appendChild(pageLabel);
+            }
+            this.element.appendChild(element);
+            this.pageBreakElements.push(element);
+        }
+    }
+    setContainerSize() {
+        this.element.style.height = `${(this.pagesCount + 1) * this.pageSize}px`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pages.layer.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/layers/pages.layer.ts"],"names":[],"mappings":"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","sourcesContent":["import { DocumentInfo } from '../constants/document-info.const';\nimport { DomHelper } from '../helpers/dom.helper';\nimport { EditSession } from '../edit.session';\nimport { EventEmitting } from '../base/event-emitting';\nimport { ILayerConfig } from '../interfaces/layer.config';\n\nexport class PagesLayer extends EventEmitting {\n    element: HTMLElement;\n\n    session: EditSession;\n\n    pageBreakElements: HTMLElement[] = [];\n\n    minPageNumber: number;\n\n    maxPageNumber: number;\n\n    rulerLeft: HTMLElement;\n\n    rulerRight: HTMLElement;\n\n    get pageSize(): number {\n        return this._pageSize || DocumentInfo.height;\n    }\n    private _pageSize: number;\n\n    get pagesCount(): number {\n        return this._pagesCount || 1;\n    }\n    private _pagesCount: number;\n\n    public constructor(public parentElement: HTMLElement) {\n        super();\n\n        this.element = document.createElement('div');\n        this.element.className = 'ace-layer ace_pages-layer';\n        parentElement.insertAdjacentElement('afterbegin', this.element);\n        this.setContainerSize();\n\n        this.rulerLeft = document.createElement('div');\n        this.rulerLeft.className = 'ruler-line';\n        this.rulerRight = document.createElement('div');\n        this.rulerRight.className = 'ruler-line';\n        this.element.appendChild(this.rulerLeft);\n        this.element.appendChild(this.rulerRight);\n    }\n\n    update(config: ILayerConfig): void {\n        if (!this.session) {\n            return;\n        }\n\n        DomHelper.translate(this.element, 0, -config.scrollTop);\n\n        const pageSpace = this.getPageSpace();\n        const pageHeight = this.session.pagesWrap.pageHeight;\n        const pages = config.pages || [];\n        let minPage = pages[0] || 1;\n        const maxPage = pages[pages.length - 1] || 1;\n        if (minPage > 1 && config.scrollTop <= (minPage - 1) * (pageHeight + pageSpace) + pageSpace) {\n            minPage--;\n        }\n\n        if (this.minPageNumber !== minPage || this.maxPageNumber !== maxPage || minPage === 1) {\n            this.minPageNumber = minPage;\n            this.maxPageNumber = maxPage;\n            this.removePages();\n            this.addPages(pageSpace, pageHeight);\n        }\n    }\n\n    setSession(session: EditSession): void {\n        if (this.session) {\n            this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n        }\n\n        this.session = session;\n        if (session) {\n            this.session.pagesWrap.addEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n        }\n    }\n\n    showRullerLines(positions: number[]): void {\n        if (!positions || positions.length !== 2) {\n            DomHelper.removeCssClass(this.rulerLeft, 'visible');\n            DomHelper.removeCssClass(this.rulerRight, 'visible');\n\n            return;\n        }\n\n        DomHelper.setStyle(this.rulerLeft.style, 'left', `${positions[0]}px`);\n        DomHelper.addCssClass(this.rulerLeft, 'visible');\n        DomHelper.setStyle(this.rulerRight.style, 'left', `${positions[1]}px`);\n        DomHelper.addCssClass(this.rulerRight, 'visible');\n    }\n\n    destroy(): void {\n        this.session.pagesWrap.removeEventListener('pagesCountChanged', this.pagesCountChangedHandler);\n    }\n\n    protected getPageSpace(): number {\n        return this.session.pagesWrap.pagesSpace;\n    }\n\n    private removePages(): void {\n        while (this.pageBreakElements?.length) {\n            const element = this.pageBreakElements.pop();\n            element.parentNode.removeChild(element);\n        }\n    }\n\n    private addPages(pageSpace: number, pageHeight: number): void {\n        for (let page = this.minPageNumber; page <= this.maxPageNumber; page++) {\n            const element = document.createElement('div');\n            element.className = 'page';\n            element.style.height = `${pageHeight}px`;\n            element.style.top = `${(page - 1) * (pageHeight + pageSpace) + pageSpace}px`;\n\n            if (page > 1) {\n                let pageLabel = document.createElement('span');\n                pageLabel.className = 'page-label';\n                pageLabel.innerText = `${page}.`;\n                element.appendChild(pageLabel);\n            }\n\n            this.element.appendChild(element);\n            this.pageBreakElements.push(element);\n        }\n    }\n\n    private setContainerSize(): void {\n        this.element.style.height = `${(this.pagesCount + 1) * this.pageSize}px`;\n    }\n\n    private pagesCountChangedHandler = (event: { pagesCount: number; pageHeight: number }): void => {\n        if (this._pageSize === event.pageHeight && this._pagesCount === event.pagesCount) {\n            return;\n        }\n\n        this._pageSize = event.pageHeight || DocumentInfo.height;\n        this._pagesCount = event.pagesCount;\n        this.setContainerSize();\n    };\n}\n"]}

package/esm2022/lib/+shared/editor/core/layers/print.edges.layer.mjs

@@ -0,0 +1,7 @@
+import { EdgesLayer } from './edges.layer';
+export class PrintEdgesLayer extends EdgesLayer {
+    getParagraphTop(topOffset, page) {
+        return topOffset + (page - 1) * this.session.pagesWrap.pageHeight;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbnQuZWRnZXMubGF5ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9jb3JlL2xheWVycy9wcmludC5lZGdlcy5sYXllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE1BQU0sT0FBTyxlQUFnQixTQUFRLFVBQVU7SUFDbEMsZUFBZSxDQUFDLFNBQWlCLEVBQUUsSUFBWTtRQUNwRCxPQUFPLFNBQVMsR0FBRyxDQUFDLElBQUksR0FBRyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUM7SUFDdEUsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRWRnZXNMYXllciB9IGZyb20gJy4vZWRnZXMubGF5ZXInO1xuXG5leHBvcnQgY2xhc3MgUHJpbnRFZGdlc0xheWVyIGV4dGVuZHMgRWRnZXNMYXllciB7XG4gICAgb3ZlcnJpZGUgZ2V0UGFyYWdyYXBoVG9wKHRvcE9mZnNldDogbnVtYmVyLCBwYWdlOiBudW1iZXIpOiBudW1iZXIge1xuICAgICAgICByZXR1cm4gdG9wT2Zmc2V0ICsgKHBhZ2UgLSAxKSAqIHRoaXMuc2Vzc2lvbi5wYWdlc1dyYXAucGFnZUhlaWdodDtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/+shared/editor/core/layers/print.pages.layer.mjs

@@ -0,0 +1,7 @@
+import { PagesLayer } from './pages.layer';
+export class PrintPagesLayer extends PagesLayer {
+    getPageSpace() {
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbnQucGFnZXMubGF5ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9jb3JlL2xheWVycy9wcmludC5wYWdlcy5sYXllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE1BQU0sT0FBTyxlQUFnQixTQUFRLFVBQVU7SUFDbEMsWUFBWTtRQUNqQixPQUFPLENBQUMsQ0FBQztJQUNiLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBhZ2VzTGF5ZXIgfSBmcm9tICcuL3BhZ2VzLmxheWVyJztcblxuZXhwb3J0IGNsYXNzIFByaW50UGFnZXNMYXllciBleHRlbmRzIFBhZ2VzTGF5ZXIge1xuICAgIG92ZXJyaWRlIGdldFBhZ2VTcGFjZSgpOiBudW1iZXIge1xuICAgICAgICByZXR1cm4gMDtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/+shared/editor/core/layers/print.text.layer.mjs

@@ -0,0 +1,7 @@
+import { TextLayer } from './text.layer';
+export class PrintTextLayer extends TextLayer {
+    getParagraphTop(paragraphs, row) {
+        return this.session.pagesWrap.getParagraphTopForPrint(paragraphs, row, this.session.pagesWrap.pagesSpace);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbnQudGV4dC5sYXllci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliLytzaGFyZWQvZWRpdG9yL2NvcmUvbGF5ZXJzL3ByaW50LnRleHQubGF5ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUV6QyxNQUFNLE9BQU8sY0FBZSxTQUFRLFNBQVM7SUFDaEMsZUFBZSxDQUFDLFVBQXVCLEVBQUUsR0FBVztRQUN6RCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLHVCQUF1QixDQUFDLFVBQVUsRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDOUcsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFyYWdyYXBoIH0gZnJvbSAnLi4vcGFnaW5nL3BhcmFncmFwaCc7XG5pbXBvcnQgeyBUZXh0TGF5ZXIgfSBmcm9tICcuL3RleHQubGF5ZXInO1xuXG5leHBvcnQgY2xhc3MgUHJpbnRUZXh0TGF5ZXIgZXh0ZW5kcyBUZXh0TGF5ZXIge1xuICAgIG92ZXJyaWRlIGdldFBhcmFncmFwaFRvcChwYXJhZ3JhcGhzOiBQYXJhZ3JhcGhbXSwgcm93OiBudW1iZXIpOiBudW1iZXIge1xuICAgICAgICByZXR1cm4gdGhpcy5zZXNzaW9uLnBhZ2VzV3JhcC5nZXRQYXJhZ3JhcGhUb3BGb3JQcmludChwYXJhZ3JhcGhzLCByb3csIHRoaXMuc2Vzc2lvbi5wYWdlc1dyYXAucGFnZXNTcGFjZSk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/+shared/editor/core/layers/renderloop.mjs

@@ -0,0 +1,26 @@
+import { EventHelper } from '../helpers/event.helper';
+import { RenderChangesModel } from '../models/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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

package/esm2022/lib/+shared/editor/core/layers/scrollbar.mjs

@@ -0,0 +1,100 @@
+import { EventEmitting } from '../base/event-emitting';
+/**
+ * Represents a vertical scroll bar.
+ * @class ScrollBar
+ **/
+export class ScrollBar extends EventEmitting {
+    /**
+     * Sets the scroll height of the scroll bar, in pixels.
+     **/
+    set scrollHeight(value) {
+        this._scrollHeight = value;
+        if (value > this.MAX_SCROLL_H) {
+            this.coeff = this.MAX_SCROLL_H / value;
+            value = this.MAX_SCROLL_H;
+        }
+        else if (this.coeff !== 1) {
+            this.coeff = 1;
+        }
+        this.inner.style.height = `${value}px`;
+    }
+    get scrollHeight() {
+        return this._scrollHeight;
+    }
+    /**
+     * Sets the height of the scroll bar, in pixels.
+     **/
+    set height(value) {
+        this.element.style.height = `${value}px`;
+    }
+    /**
+     * Returns the width of the scroll bar.
+     **/
+    get width() {
+        return Math.max(this.isVisible ? this._width : 0, this.element.offsetWidth, 0);
+    }
+    constructor(parent) {
+        super();
+        this.parent = parent;
+        // on ie maximal element height is smaller than what we get from 4-5K line document
+        // so scrollbar doesn't work, as a workaround we do not set height higher than MAX_SCROLL_H
+        // and rescale scrollTop
+        this.MAX_SCROLL_H = 0x8000;
+        this.scrollTop = 0;
+        this.skipEvent = false;
+        this.coeff = 1;
+        this._scrollHeight = 0;
+        this._width = 20;
+        /**
+         * Emitted when the scroll bar, well, scrolls.
+         **/
+        this.onScroll = () => {
+            if (!this.skipEvent) {
+                this.scrollTop = this.element.scrollTop;
+                if (this.coeff !== 1) {
+                    const height = this.element.clientHeight / this.scrollHeight;
+                    this.scrollTop = (this.scrollTop * (1 - height)) / (this.coeff - height);
+                }
+                this.emit('scroll', { data: this.scrollTop });
+            }
+            this.skipEvent = false;
+        };
+        this.init();
+        // in OSX lion the scrollbars appear to have no width. In this case resize the
+        // element to show the scrollbar but still pretend that the scrollbar has a width
+        // of 0px
+        // in Firefox 6+ scrollbar is hidden if element has the same width as scrollbar
+        // make element a little bit wider to retain scrollbar when page is zoomed
+        const newWidth = `${this._width}px`;
+        this.inner.style.width = newWidth;
+        this.element.style.width = newWidth;
+    }
+    setVisible(isVisible) {
+        this.element.style.display = isVisible ? '' : 'none';
+        this.isVisible = isVisible;
+        this.coeff = 1;
+    }
+    /**
+     * Sets the scroll top of the scroll bar.
+     **/
+    setScrollTop(value) {
+        if (this.scrollTop === value) {
+            return;
+        }
+        this.skipEvent = true;
+        this.scrollTop = value;
+        this.element.scrollTop = value * this.coeff;
+    }
+    init() {
+        this.element = document.createElement('div');
+        this.element.className = 'ace-scrollbar';
+        this.inner = document.createElement('div');
+        this.inner.className = 'ace-scrollbar-inner';
+        this.element.appendChild(this.inner);
+        this.parent.appendChild(this.element);
+        this.setVisible(false);
+        this.element.addEventListener('scroll', this.onScroll);
+        this.element.addEventListener('mousedown', (event) => event.preventDefault());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scrollbar.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/layers/scrollbar.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitting } from '../base/event-emitting';\n\n/**\n * Represents a vertical scroll bar.\n * @class ScrollBar\n **/\nexport class ScrollBar extends EventEmitting {\n    // on ie maximal element height is smaller than what we get from 4-5K line document\n    // so scrollbar doesn't work, as a workaround we do not set height higher than MAX_SCROLL_H\n    // and rescale scrollTop\n    readonly MAX_SCROLL_H = 0x8000;\n\n    element: HTMLElement;\n\n    inner: HTMLElement;\n\n    isVisible: boolean;\n\n    scrollTop = 0;\n\n    private skipEvent = false;\n\n    private coeff = 1;\n\n    /**\n     * Sets the scroll height of the scroll bar, in pixels.\n     **/\n    set scrollHeight(value: number) {\n        this._scrollHeight = value;\n        if (value > this.MAX_SCROLL_H) {\n            this.coeff = this.MAX_SCROLL_H / value;\n            value = this.MAX_SCROLL_H;\n        } else if (this.coeff !== 1) {\n            this.coeff = 1;\n        }\n\n        this.inner.style.height = `${value}px`;\n    }\n    get scrollHeight(): number {\n        return this._scrollHeight;\n    }\n    private _scrollHeight = 0;\n\n    /**\n     * Sets the height of the scroll bar, in pixels.\n     **/\n    set height(value: number) {\n        this.element.style.height = `${value}px`;\n    }\n\n    /**\n     * Returns the width of the scroll bar.\n     **/\n    get width(): number {\n        return Math.max(this.isVisible ? this._width : 0, this.element.offsetWidth, 0);\n    }\n    private _width = 20;\n\n    constructor(private parent: HTMLElement) {\n        super();\n\n        this.init();\n\n        // in OSX lion the scrollbars appear to have no width. In this case resize the\n        // element to show the scrollbar but still pretend that the scrollbar has a width\n        // of 0px\n        // in Firefox 6+ scrollbar is hidden if element has the same width as scrollbar\n        // make element a little bit wider to retain scrollbar when page is zoomed\n        const newWidth = `${this._width}px`;\n        this.inner.style.width = newWidth;\n        this.element.style.width = newWidth;\n    }\n\n    /**\n     * Emitted when the scroll bar, well, scrolls.\n     **/\n    onScroll = () => {\n        if (!this.skipEvent) {\n            this.scrollTop = this.element.scrollTop;\n            if (this.coeff !== 1) {\n                const height = this.element.clientHeight / this.scrollHeight;\n                this.scrollTop = (this.scrollTop * (1 - height)) / (this.coeff - height);\n            }\n\n            this.emit('scroll', { data: this.scrollTop });\n        }\n\n        this.skipEvent = false;\n    };\n\n    setVisible(isVisible: boolean): void {\n        this.element.style.display = isVisible ? '' : 'none';\n        this.isVisible = isVisible;\n        this.coeff = 1;\n    }\n\n    /**\n     * Sets the scroll top of the scroll bar.\n     **/\n    setScrollTop(value: number): void {\n        if (this.scrollTop === value) {\n            return;\n        }\n\n        this.skipEvent = true;\n        this.scrollTop = value;\n        this.element.scrollTop = value * this.coeff;\n    }\n\n    private init(): void {\n        this.element = document.createElement('div');\n        this.element.className = 'ace-scrollbar';\n\n        this.inner = document.createElement('div');\n        this.inner.className = 'ace-scrollbar-inner';\n        this.element.appendChild(this.inner);\n\n        this.parent.appendChild(this.element);\n\n        this.setVisible(false);\n\n        this.element.addEventListener('scroll', this.onScroll);\n        this.element.addEventListener('mousedown', (event: MouseEvent) => event.preventDefault());\n    }\n}\n"]}