@talrace/ngx-noder 0.0.6 → 0.0.8

package/esm2022/lib/editor/components/image/components/image.component.mjs

@@ -0,0 +1,88 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { BaseNoderComponent } from '../../shared/abstract/base.component';
+import { ImageInputHandler } from '../../../components/image/input-handler/image-input.handler';
+import { ScalingHelper } from '../../../content/helpers/scaling.helper';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../components/image/image-api.service";
+import * as i2 from "../../../interaction/editor.service";
+import * as i3 from "@angular/common";
+import * as i4 from "../resizer/resizer.component";
+export class NoderImageComponent extends BaseNoderComponent {
+    get isViewOnly$() {
+        return this.editorService.isViewOnly$;
+    }
+    get image() {
+        return this.content;
+    }
+    set image(val) {
+        this.content = val;
+    }
+    get size() {
+        return { width: this._width, height: this._height };
+    }
+    constructor(elementRef, apiService, editorService) {
+        super();
+        this.elementRef = elementRef;
+        this.apiService = apiService;
+        this.editorService = editorService;
+        this.isCanvas = false;
+    }
+    initialize() {
+        const url = this.image.content?.replace('/api/', '') ?? '';
+        this._height = ScalingHelper.scale(this.image.height, this.generalProperties.scalingRatio);
+        this._width = ScalingHelper.scale(this.image.width, this.generalProperties.scalingRatio);
+        this.apiService.getFile(url).subscribe(x => {
+            const fileSource = URL.createObjectURL(x);
+            const image = this.createImage(fileSource);
+            this.elementRef.nativeElement.appendChild(image);
+            this.editorService.rendererUpdated(this.sessionId);
+        });
+    }
+    onResizeEnd(size) {
+        this.resize(size);
+        const resizedImage = { ...this.image, width: size.width, height: size.height };
+        this.editorService.changeImageStyle(resizedImage);
+    }
+    resize(size) {
+        this._width = size.width;
+        this._height = size.height;
+        this.isCanvas ? this.resizeCanvas(size) : this.resizeImage(size);
+        this.cdr.markForCheck();
+    }
+    focus() {
+        this.inputHandler = new ImageInputHandler(this.editorService, this);
+        super.focus();
+    }
+    blur() {
+        this.inputHandler?.destroy();
+        super.blur();
+    }
+    ngOnDestroy() {
+        this.inputHandler?.destroy();
+        super.ngOnDestroy();
+    }
+    createImage(fileSource) {
+        const imageEl = document.createElement('img');
+        imageEl.width = this._width;
+        imageEl.height = this._height;
+        imageEl.src = fileSource;
+        return imageEl;
+    }
+    resizeImage(size) {
+        const image = this.elementRef.nativeElement.querySelector('img');
+        image.width = size.width;
+        image.height = size.height;
+    }
+    resizeCanvas(size) {
+        const image = this.elementRef.nativeElement.querySelector('canvas');
+        image.style.width = `${size.width}px`;
+        image.style.height = `${size.height}px`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NoderImageComponent, deps: [{ token: i0.ElementRef }, { token: i1.ImageApiService }, { token: i2.EditorService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: NoderImageComponent, selector: "app-nod-image", usesInheritance: true, ngImport: i0, template: "<app-nod-resizer\n    *ngIf=\"isFocused\"\n    class=\"resizer\"\n    [isDisabled]=\"isViewOnly$ | async\"\n    [size]=\"size\"\n    (resizeEnd)=\"onResizeEnd($event)\" />\n", styles: [":host{position:relative;outline:none}.resizer{position:absolute;z-index:1}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.ResizerComponent, selector: "app-nod-resizer", inputs: ["isDisabled", "size"], outputs: ["resizeEnd"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NoderImageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-nod-image', changeDetection: ChangeDetectionStrategy.OnPush, template: "<app-nod-resizer\n    *ngIf=\"isFocused\"\n    class=\"resizer\"\n    [isDisabled]=\"isViewOnly$ | async\"\n    [size]=\"size\"\n    (resizeEnd)=\"onResizeEnd($event)\" />\n", styles: [":host{position:relative;outline:none}.resizer{position:absolute;z-index:1}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.ImageApiService }, { type: i2.EditorService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/editor/components/image/components/image.component.ts","../../../../../../../../projects/ngx-noder/src/lib/editor/components/image/components/image.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, ElementRef } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { BaseNoderComponent } from '../../shared/abstract/base.component';\nimport { EditorService } from '../../../interaction/editor.service';\nimport { ImageApiService } from '../../../components/image/image-api.service';\nimport { ImageInputHandler } from '../../../components/image/input-handler/image-input.handler';\nimport { ImageModel } from '../../../../models/generated/image.model';\nimport { ScalingHelper } from '../../../content/helpers/scaling.helper';\nimport { Size } from '../../../components/image/size';\n\n@Component({\n    selector: 'app-nod-image',\n    templateUrl: './image.component.html',\n    styleUrls: ['./image.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class NoderImageComponent extends BaseNoderComponent {\n    get isViewOnly$(): Observable<boolean> {\n        return this.editorService.isViewOnly$;\n    }\n\n    get image(): ImageModel {\n        return this.content as ImageModel;\n    }\n    set image(val: ImageModel) {\n        this.content = val;\n    }\n\n    get size(): Size {\n        return { width: this._width, height: this._height };\n    }\n\n    private isCanvas = false;\n\n    private inputHandler: ImageInputHandler;\n\n    constructor(protected elementRef: ElementRef<HTMLElement>, private apiService: ImageApiService, private editorService: EditorService) {\n        super();\n    }\n\n    initialize(): void {\n        const url = this.image.content?.replace('/api/', '') ?? '';\n        this._height = ScalingHelper.scale(this.image.height, this.generalProperties.scalingRatio);\n        this._width = ScalingHelper.scale(this.image.width, this.generalProperties.scalingRatio);\n        this.apiService.getFile(url).subscribe(x => {\n            const fileSource = URL.createObjectURL(x);\n            const image = this.createImage(fileSource);\n            this.elementRef.nativeElement.appendChild(image);\n            this.editorService.rendererUpdated(this.sessionId);\n        });\n    }\n\n    onResizeEnd(size: Size): void {\n        this.resize(size);\n        const resizedImage = { ...this.image, width: size.width, height: size.height };\n        this.editorService.changeImageStyle(resizedImage);\n    }\n\n    resize(size: Size): void {\n        this._width = size.width;\n        this._height = size.height;\n        this.isCanvas ? this.resizeCanvas(size) : this.resizeImage(size);\n        this.cdr.markForCheck();\n    }\n\n    override focus(): void {\n        this.inputHandler = new ImageInputHandler(this.editorService, this);\n        super.focus();\n    }\n\n    override blur(): void {\n        this.inputHandler?.destroy();\n        super.blur();\n    }\n\n    override ngOnDestroy(): void {\n        this.inputHandler?.destroy();\n        super.ngOnDestroy();\n    }\n\n    private createImage(fileSource: string): HTMLImageElement {\n        const imageEl = document.createElement('img');\n        imageEl.width = this._width;\n        imageEl.height = this._height;\n        imageEl.src = fileSource;\n        return imageEl;\n    }\n\n    private resizeImage(size: Size): void {\n        const image = this.elementRef.nativeElement.querySelector('img');\n        image.width = size.width;\n        image.height = size.height;\n    }\n\n    private resizeCanvas(size: Size): void {\n        const image = this.elementRef.nativeElement.querySelector('canvas');\n        image.style.width = `${size.width}px`;\n        image.style.height = `${size.height}px`;\n    }\n}\n","<app-nod-resizer\n    *ngIf=\"isFocused\"\n    class=\"resizer\"\n    [isDisabled]=\"isViewOnly$ | async\"\n    [size]=\"size\"\n    (resizeEnd)=\"onResizeEnd($event)\" />\n"]}

package/esm2022/lib/editor/components/image/image-api.service.mjs

@@ -0,0 +1,36 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ImageApiService {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageApiService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageApiService, decorators: [{
+            type: Injectable
+        }] });
+export class DefaultImageApiService {
+    constructor(http) {
+        this.http = http;
+        this.apiRelativePath = '/api/';
+        this._inFlight = {};
+    }
+    getFile(source) {
+        return this.httpGetBlob(source);
+    }
+    httpGetBlob(url) {
+        if (this._inFlight[url.toLowerCase()]) {
+            return this._inFlight[url.toLowerCase()];
+        }
+        return this.http.get(`${this.apiRelativePath}${url}`, {
+            responseType: 'blob',
+            headers: this.getHeaders()
+        });
+    }
+    getHeaders(headers = null) {
+        if (!headers) {
+            headers = new HttpHeaders();
+        }
+        return headers.set('require-user', 'true');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/components/image/input-handler/image-input.handler.mjs

@@ -0,0 +1,38 @@
+import { fromEvent } from 'rxjs';
+export class ImageInputHandler {
+    constructor(editorService, image) {
+        this.editorService = editorService;
+        this.image = image;
+        this.undoRedoActions = {};
+        this.imageKeyDownSubscription = fromEvent(document, 'keydown').subscribe(event => this.onKeyDown(event));
+        this.fillUndoRedoActions();
+    }
+    destroy() {
+        this.imageKeyDownSubscription?.unsubscribe();
+    }
+    onKeyDown(event) {
+        if (this.editorService.isViewOnly) {
+            return;
+        }
+        if (['Backspace', 'Delete'].includes(event.code)) {
+            this.editorService.removeImage(this.image.insertIndex);
+            return;
+        }
+        const keyCombination = this.getKeyCombination(event);
+        if (this.undoRedoActions[keyCombination] && !this.editorService.isViewOnly) {
+            this.undoRedoActions[keyCombination]();
+            event.preventDefault();
+        }
+    }
+    getKeyCombination(event) {
+        let result = event.metaKey ? 'Command-' : '';
+        return event.ctrlKey ? `${result}Ctrl-${event.code}` : '';
+    }
+    fillUndoRedoActions() {
+        this.undoRedoActions['Ctrl-KeyZ'] = () => this.editorService.undo();
+        this.undoRedoActions['Command-KeyZ'] = () => this.editorService.undo();
+        this.undoRedoActions['Ctrl-KeyY'] = () => this.editorService.redo();
+        this.undoRedoActions['Command-KeyY'] = () => this.editorService.redo();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/components/image/resizer/coordinate.mjs

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

package/esm2022/lib/editor/components/image/resizer/direction-wrapper.mjs

@@ -0,0 +1,19 @@
+import { Direction } from './direction.enum';
+export class DirectionWrapper {
+    constructor(direction) {
+        this.direction = direction;
+    }
+    isHorizontal() {
+        return [Direction.East, Direction.West].includes(this.direction);
+    }
+    isOrdinal() {
+        return [Direction.NorthWest, Direction.NorthEast, Direction.SouthEast, Direction.SouthWest].includes(this.direction);
+    }
+    includesWest() {
+        return [Direction.West, Direction.NorthWest, Direction.SouthWest].includes(this.direction);
+    }
+    includesNorth() {
+        return [Direction.North, Direction.NorthWest, Direction.NorthEast].includes(this.direction);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/components/image/resizer/direction.enum.mjs

@@ -0,0 +1,12 @@
+export var Direction;
+(function (Direction) {
+    Direction[Direction["NorthWest"] = 0] = "NorthWest";
+    Direction[Direction["North"] = 1] = "North";
+    Direction[Direction["NorthEast"] = 2] = "NorthEast";
+    Direction[Direction["East"] = 3] = "East";
+    Direction[Direction["SouthEast"] = 4] = "SouthEast";
+    Direction[Direction["South"] = 5] = "South";
+    Direction[Direction["SouthWest"] = 6] = "SouthWest";
+    Direction[Direction["West"] = 7] = "West";
+})(Direction || (Direction = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aW9uLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi9lZGl0b3IvY29tcG9uZW50cy9pbWFnZS9yZXNpemVyL2RpcmVjdGlvbi5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFNBU1g7QUFURCxXQUFZLFNBQVM7SUFDakIsbURBQVMsQ0FBQTtJQUNULDJDQUFLLENBQUE7SUFDTCxtREFBUyxDQUFBO0lBQ1QseUNBQUksQ0FBQTtJQUNKLG1EQUFTLENBQUE7SUFDVCwyQ0FBSyxDQUFBO0lBQ0wsbURBQVMsQ0FBQTtJQUNULHlDQUFJLENBQUE7QUFDUixDQUFDLEVBVFcsU0FBUyxLQUFULFNBQVMsUUFTcEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBEaXJlY3Rpb24ge1xuICAgIE5vcnRoV2VzdCxcbiAgICBOb3J0aCxcbiAgICBOb3J0aEVhc3QsXG4gICAgRWFzdCxcbiAgICBTb3V0aEVhc3QsXG4gICAgU291dGgsXG4gICAgU291dGhXZXN0LFxuICAgIFdlc3Rcbn1cbiJdfQ==

package/esm2022/lib/editor/components/image/resizer/resizer.component.mjs

@@ -0,0 +1,106 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, HostListener, Input, Output } from '@angular/core';
+import { Direction } from './direction.enum';
+import { DirectionWrapper } from './direction-wrapper';
+import { SizeWrapper } from './size-wrapper';
+import * as i0 from "@angular/core";
+export class ResizerComponent {
+    constructor() {
+        this.isDisabled = false;
+        this.resizeEnd = new EventEmitter();
+        this.Direction = Direction;
+    }
+    get width() {
+        return this._size.width;
+    }
+    get height() {
+        return this._size.height;
+    }
+    get right() {
+        return this.direction?.includesWest() ? 0 : null;
+    }
+    get bottom() {
+        const halfPointHeight = 4;
+        return this.direction?.includesNorth() ? halfPointHeight : null;
+    }
+    set size(value) {
+        if (!this.direction) {
+            this._size = new SizeWrapper(value, { width: 1, height: 1 });
+        }
+    }
+    ngOnInit() {
+        if (!this._size) {
+            throw new Error('Initial size is not set');
+        }
+    }
+    onMousemove(event) {
+        if (!this.direction || this.isDisabled) {
+            return;
+        }
+        const delta = this.getDelta(event);
+        this.setPreviousCoordinate(event);
+        if (this.direction.isOrdinal()) {
+            this.virtualRectSize.applyDelta(delta);
+            this._size.fitProportionallyTo(this.virtualRectSize);
+            return;
+        }
+        this.direction.isHorizontal() ? this.virtualRectSize.applyDeltaX(delta) : this.virtualRectSize.applyDeltaY(delta);
+        this._size.fitTo(this.virtualRectSize);
+    }
+    onMouseup() {
+        if (!this.direction || this.isDisabled) {
+            return;
+        }
+        this.direction = null;
+        this.resizeEnd.emit(this._size.toSize());
+    }
+    onStartResizing(event, direction) {
+        event.preventDefault();
+        if (event.button !== 0) {
+            return;
+        }
+        this.virtualRectSize = new SizeWrapper(this._size.toSize());
+        this.direction = new DirectionWrapper(direction);
+        this.setPreviousCoordinate(event);
+    }
+    getDelta(event) {
+        const rawDeltaX = event.screenX - this.prevCoordinate.x;
+        const deltaX = this.direction.includesWest() ? -rawDeltaX : rawDeltaX;
+        const rawDeltaY = event.screenY - this.prevCoordinate.y;
+        const deltaY = this.direction.includesNorth() ? -rawDeltaY : rawDeltaY;
+        return { deltaX, deltaY };
+    }
+    setPreviousCoordinate(event) {
+        this.prevCoordinate = { x: event.screenX, y: event.screenY };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResizerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ResizerComponent, selector: "app-nod-resizer", inputs: { isDisabled: "isDisabled", size: "size" }, outputs: { resizeEnd: "resizeEnd" }, host: { listeners: { "document:mousemove": "onMousemove($event)", "window:mouseup": "onMouseup()" }, properties: { "style.width.px": "this.width", "style.height.px": "this.height", "style.right.px": "this.right", "style.bottom.px": "this.bottom" } }, ngImport: i0, template: "<span\n    class=\"point north-west\"\n    (mousedown)=\"onStartResizing($event, Direction.NorthWest)\"></span>\n<span\n    class=\"point north\"\n    (mousedown)=\"onStartResizing($event, Direction.North)\"></span>\n<span\n    class=\"point north-east\"\n    (mousedown)=\"onStartResizing($event, Direction.NorthEast)\"></span>\n<span\n    class=\"point east\"\n    (mousedown)=\"onStartResizing($event, Direction.East)\"></span>\n<span\n    class=\"point south-east\"\n    (mousedown)=\"onStartResizing($event, Direction.SouthEast)\"></span>\n<span\n    class=\"point south\"\n    (mousedown)=\"onStartResizing($event, Direction.South)\"></span>\n<span\n    class=\"point south-west\"\n    (mousedown)=\"onStartResizing($event, Direction.SouthWest)\"></span>\n<span\n    class=\"point west\"\n    (mousedown)=\"onStartResizing($event, Direction.West)\"></span>\n", styles: [":host{display:block;border:1px solid #616161}.point{position:absolute;width:12px;height:12px;border:1px solid #616161;border-radius:50%;background-color:#fff}.point.north-west{top:-6px;left:-6px;cursor:nw-resize}.point.north{top:-6px;left:0;right:0;margin:auto;cursor:n-resize}.point.north-east{top:-6px;right:-6px;cursor:ne-resize}.point.east{top:0;bottom:0;right:-6px;margin:auto;cursor:e-resize}.point.south-east{bottom:-6px;right:-6px;cursor:se-resize}.point.south{bottom:-6px;left:0;right:0;margin:auto;cursor:s-resize}.point.south-west{bottom:-6px;left:-6px;cursor:sw-resize}.point.west{top:0;bottom:0;left:-6px;margin:auto;cursor:w-resize}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResizerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-nod-resizer', changeDetection: ChangeDetectionStrategy.OnPush, template: "<span\n    class=\"point north-west\"\n    (mousedown)=\"onStartResizing($event, Direction.NorthWest)\"></span>\n<span\n    class=\"point north\"\n    (mousedown)=\"onStartResizing($event, Direction.North)\"></span>\n<span\n    class=\"point north-east\"\n    (mousedown)=\"onStartResizing($event, Direction.NorthEast)\"></span>\n<span\n    class=\"point east\"\n    (mousedown)=\"onStartResizing($event, Direction.East)\"></span>\n<span\n    class=\"point south-east\"\n    (mousedown)=\"onStartResizing($event, Direction.SouthEast)\"></span>\n<span\n    class=\"point south\"\n    (mousedown)=\"onStartResizing($event, Direction.South)\"></span>\n<span\n    class=\"point south-west\"\n    (mousedown)=\"onStartResizing($event, Direction.SouthWest)\"></span>\n<span\n    class=\"point west\"\n    (mousedown)=\"onStartResizing($event, Direction.West)\"></span>\n", styles: [":host{display:block;border:1px solid #616161}.point{position:absolute;width:12px;height:12px;border:1px solid #616161;border-radius:50%;background-color:#fff}.point.north-west{top:-6px;left:-6px;cursor:nw-resize}.point.north{top:-6px;left:0;right:0;margin:auto;cursor:n-resize}.point.north-east{top:-6px;right:-6px;cursor:ne-resize}.point.east{top:0;bottom:0;right:-6px;margin:auto;cursor:e-resize}.point.south-east{bottom:-6px;right:-6px;cursor:se-resize}.point.south{bottom:-6px;left:0;right:0;margin:auto;cursor:s-resize}.point.south-west{bottom:-6px;left:-6px;cursor:sw-resize}.point.west{top:0;bottom:0;left:-6px;margin:auto;cursor:w-resize}\n"] }]
+        }], propDecorators: { width: [{
+                type: HostBinding,
+                args: ['style.width.px']
+            }], height: [{
+                type: HostBinding,
+                args: ['style.height.px']
+            }], right: [{
+                type: HostBinding,
+                args: ['style.right.px']
+            }], bottom: [{
+                type: HostBinding,
+                args: ['style.bottom.px']
+            }], isDisabled: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], resizeEnd: [{
+                type: Output
+            }], onMousemove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }], onMouseup: [{
+                type: HostListener,
+                args: ['window:mouseup']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizer.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-noder/src/lib/editor/components/image/resizer/resizer.component.ts","../../../../../../../../projects/ngx-noder/src/lib/editor/components/image/resizer/resizer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, HostListener, Input, OnInit, Output } from '@angular/core';\n\nimport { Coordinate } from './coordinate';\nimport { Direction } from './direction.enum';\nimport { DirectionWrapper } from './direction-wrapper';\nimport { Size } from '../size';\nimport { SizeDelta } from './size-delta';\nimport { SizeWrapper } from './size-wrapper';\n\n@Component({\n    selector: 'app-nod-resizer',\n    templateUrl: './resizer.component.html',\n    styleUrls: ['./resizer.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ResizerComponent implements OnInit {\n    @HostBinding('style.width.px')\n    get width(): number {\n        return this._size.width;\n    }\n\n    @HostBinding('style.height.px')\n    get height(): number {\n        return this._size.height;\n    }\n\n    @HostBinding('style.right.px')\n    get right(): number {\n        return this.direction?.includesWest() ? 0 : null;\n    }\n\n    @HostBinding('style.bottom.px')\n    get bottom(): number {\n        const halfPointHeight = 4;\n        return this.direction?.includesNorth() ? halfPointHeight : null;\n    }\n\n    @Input() isDisabled = false;\n\n    @Input()\n    set size(value: Size) {\n        if (!this.direction) {\n            this._size = new SizeWrapper(value, { width: 1, height: 1 });\n        }\n    }\n    private _size: SizeWrapper;\n\n    @Output() resizeEnd = new EventEmitter<Size>();\n\n    readonly Direction = Direction;\n\n    private virtualRectSize: SizeWrapper;\n\n    private prevCoordinate: Coordinate;\n\n    private direction: DirectionWrapper;\n\n    ngOnInit(): void {\n        if (!this._size) {\n            throw new Error('Initial size is not set');\n        }\n    }\n\n    @HostListener('document:mousemove', ['$event'])\n    onMousemove(event: MouseEvent): void {\n        if (!this.direction || this.isDisabled) {\n            return;\n        }\n\n        const delta = this.getDelta(event);\n        this.setPreviousCoordinate(event);\n        if (this.direction.isOrdinal()) {\n            this.virtualRectSize.applyDelta(delta);\n            this._size.fitProportionallyTo(this.virtualRectSize);\n            return;\n        }\n\n        this.direction.isHorizontal() ? this.virtualRectSize.applyDeltaX(delta) : this.virtualRectSize.applyDeltaY(delta);\n        this._size.fitTo(this.virtualRectSize);\n    }\n\n    @HostListener('window:mouseup')\n    onMouseup(): void {\n        if (!this.direction || this.isDisabled) {\n            return;\n        }\n\n        this.direction = null;\n        this.resizeEnd.emit(this._size.toSize());\n    }\n\n    onStartResizing(event: MouseEvent, direction: Direction): void {\n        event.preventDefault();\n        if (event.button !== 0) {\n            return;\n        }\n\n        this.virtualRectSize = new SizeWrapper(this._size.toSize());\n        this.direction = new DirectionWrapper(direction);\n        this.setPreviousCoordinate(event);\n    }\n\n    private getDelta(event: MouseEvent): SizeDelta {\n        const rawDeltaX = event.screenX - this.prevCoordinate.x;\n        const deltaX = this.direction.includesWest() ? -rawDeltaX : rawDeltaX;\n\n        const rawDeltaY = event.screenY - this.prevCoordinate.y;\n        const deltaY = this.direction.includesNorth() ? -rawDeltaY : rawDeltaY;\n\n        return { deltaX, deltaY };\n    }\n\n    private setPreviousCoordinate(event: MouseEvent): void {\n        this.prevCoordinate = { x: event.screenX, y: event.screenY };\n    }\n}\n","<span\n    class=\"point north-west\"\n    (mousedown)=\"onStartResizing($event, Direction.NorthWest)\"></span>\n<span\n    class=\"point north\"\n    (mousedown)=\"onStartResizing($event, Direction.North)\"></span>\n<span\n    class=\"point north-east\"\n    (mousedown)=\"onStartResizing($event, Direction.NorthEast)\"></span>\n<span\n    class=\"point east\"\n    (mousedown)=\"onStartResizing($event, Direction.East)\"></span>\n<span\n    class=\"point south-east\"\n    (mousedown)=\"onStartResizing($event, Direction.SouthEast)\"></span>\n<span\n    class=\"point south\"\n    (mousedown)=\"onStartResizing($event, Direction.South)\"></span>\n<span\n    class=\"point south-west\"\n    (mousedown)=\"onStartResizing($event, Direction.SouthWest)\"></span>\n<span\n    class=\"point west\"\n    (mousedown)=\"onStartResizing($event, Direction.West)\"></span>\n"]}

package/esm2022/lib/editor/components/image/resizer/size-delta.mjs

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

package/esm2022/lib/editor/components/image/resizer/size-wrapper.mjs

@@ -0,0 +1,52 @@
+export class SizeWrapper {
+    get width() {
+        return this._width;
+    }
+    get height() {
+        return this._height;
+    }
+    constructor(size, minSize) {
+        this.minSize = minSize;
+        if (minSize && (size.width < minSize.width || size.height < minSize.height)) {
+            throw new Error('Passed size is smaller than minimum size');
+        }
+        this._height = size.height;
+        this._width = size.width;
+        this.aspectRatio = this._width / this._height;
+    }
+    applyDelta(delta) {
+        this.applyDeltaX(delta);
+        this.applyDeltaY(delta);
+    }
+    applyDeltaX(delta) {
+        this._width = this.getAllowedWidth(this._width + delta.deltaX);
+    }
+    applyDeltaY(delta) {
+        this._height = this.getAllowedHeight(this._height + delta.deltaY);
+    }
+    fitProportionallyTo(size) {
+        const widthDiff = size._width - this._width;
+        const heightDiff = size._height - this._height;
+        if (widthDiff > heightDiff) {
+            this._width = this.getAllowedWidth(size.width);
+            this._height = Math.floor(this._width / this.aspectRatio);
+            return;
+        }
+        this._height = this.getAllowedHeight(size.height);
+        this._width = Math.floor(this._height * this.aspectRatio);
+    }
+    fitTo(size) {
+        this._width = this.getAllowedWidth(size.width);
+        this._height = this.getAllowedHeight(size.height);
+    }
+    toSize() {
+        return { width: this._width, height: this._height };
+    }
+    getAllowedWidth(value) {
+        return !this.minSize ? value : Math.max(value, this.minSize.width);
+    }
+    getAllowedHeight(value) {
+        return !this.minSize ? value : Math.max(value, this.minSize.height);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/components/image/size.mjs

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

package/esm2022/lib/editor/components/shared/abstract/base.component.mjs

@@ -0,0 +1,59 @@
+import { ChangeDetectorRef, Directive, HostBinding, inject, Input } from '@angular/core';
+import { DestroyComponent } from './destroy.component';
+import * as i0 from "@angular/core";
+export class BaseNoderComponent extends DestroyComponent {
+    constructor() {
+        super(...arguments);
+        this._isFocused = false;
+        this.cdr = inject(ChangeDetectorRef);
+    }
+    get focused() {
+        return this._isFocused;
+    }
+    get insertIndex() {
+        return this.content.insertIndex;
+    }
+    set insertIndex(val) {
+        this.content.insertIndex = val;
+    }
+    get height() {
+        return this._height;
+    }
+    get width() {
+        return this._width;
+    }
+    get isFocused() {
+        return this._isFocused;
+    }
+    focus() {
+        this._isFocused = true;
+        this.cdr.markForCheck();
+    }
+    blur() {
+        this._isFocused = false;
+        this.cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseNoderComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BaseNoderComponent, inputs: { content: "content", sessionId: "sessionId", contentWidth: "contentWidth", generalProperties: "generalProperties" }, host: { properties: { "class.focused": "this.focused", "attr.data-session-id": "this.sessionId", "attr.data-insert-index": "this.insertIndex" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseNoderComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { focused: [{
+                type: HostBinding,
+                args: ['class.focused']
+            }], content: [{
+                type: Input
+            }], sessionId: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.data-session-id']
+            }], insertIndex: [{
+                type: HostBinding,
+                args: ['attr.data-insert-index']
+            }], contentWidth: [{
+                type: Input
+            }], generalProperties: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/components/shared/abstract/destroy.component.mjs

@@ -0,0 +1,18 @@
+import { Directive } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DestroyComponent {
+    constructor() {
+        this.destroy$ = new Subject();
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DestroyComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: DestroyComponent, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DestroyComponent, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi9lZGl0b3IvY29tcG9uZW50cy9zaGFyZWQvYWJzdHJhY3QvZGVzdHJveS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBYSxNQUFNLGVBQWUsQ0FBQztBQUNyRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQUcvQixNQUFNLE9BQWdCLGdCQUFnQjtJQUR0QztRQUVJLGFBQVEsR0FBRyxJQUFJLE9BQU8sRUFBVyxDQUFDO0tBTXJDO0lBSkcsV0FBVztRQUNQLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3pCLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDN0IsQ0FBQzsrR0FOaUIsZ0JBQWdCO21HQUFoQixnQkFBZ0I7OzRGQUFoQixnQkFBZ0I7a0JBRHJDLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBEZXN0cm95Q29tcG9uZW50IGltcGxlbWVudHMgT25EZXN0cm95IHtcbiAgICBkZXN0cm95JCA9IG5ldyBTdWJqZWN0PGJvb2xlYW4+KCk7XG5cbiAgICBuZ09uRGVzdHJveSgpIHtcbiAgICAgICAgdGhpcy5kZXN0cm95JC5uZXh0KHRydWUpO1xuICAgICAgICB0aGlzLmRlc3Ryb3kkLmNvbXBsZXRlKCk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/editor/components/shared/custom-component.hepler.mjs

@@ -0,0 +1,43 @@
+export class CustomComponentHelper {
+    static applyRemovingComponents(components, startIndex, endIndex) {
+        let firstRemovingIndex = null;
+        let deleteCount = 0;
+        components.forEach((x, index) => {
+            if (x.instance.insertIndex >= startIndex && x.instance.insertIndex <= endIndex) {
+                if (firstRemovingIndex === null) {
+                    firstRemovingIndex = index;
+                }
+                deleteCount++;
+                x.destroy();
+            }
+        });
+        components.splice(firstRemovingIndex, deleteCount);
+    }
+    static applyRemovingOrReplacingToComponents(components, distance, symbolDifference, contents) {
+        if (!components.length) {
+            return;
+        }
+        const firstRemovingContentIndex = components.findIndex(x => x.instance.insertIndex >= distance.start);
+        if (firstRemovingContentIndex < 0) {
+            return;
+        }
+        let lastRemovingContentIndex = components.length - 1;
+        while (lastRemovingContentIndex >= 0) {
+            if (components[lastRemovingContentIndex].instance.insertIndex <= distance.selectionEnd) {
+                break;
+            }
+            components[lastRemovingContentIndex].instance.insertIndex += symbolDifference;
+            lastRemovingContentIndex--;
+        }
+        const deleteCount = lastRemovingContentIndex - firstRemovingContentIndex + 1;
+        const removedComponents = components.splice(firstRemovingContentIndex, deleteCount);
+        removedComponents.forEach(x => {
+            const index = contents.findIndex(y => y.insertIndex === x.instance.insertIndex);
+            if (index > -1) {
+                contents.splice(index, 1);
+            }
+            x.destroy();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/components/shared/custom-components.interface.mjs

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

package/esm2022/lib/editor/components/shared/custom-content-markers.const.mjs

@@ -0,0 +1,3 @@
+export const CUSTOM_ELEMENT_MARKER = '*';
+export const TABLE_MARKER = '#';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLWNvbnRlbnQtbWFya2Vycy5jb25zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliL2VkaXRvci9jb21wb25lbnRzL3NoYXJlZC9jdXN0b20tY29udGVudC1tYXJrZXJzLmNvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLEdBQUcsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsR0FBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IENVU1RPTV9FTEVNRU5UX01BUktFUiA9ICcqJztcbmV4cG9ydCBjb25zdCBUQUJMRV9NQVJLRVIgPSAnIyc7XG4iXX0=

package/esm2022/lib/editor/components/shared/custom-content.mjs

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