@plait/core 0.0.2

package/README.md

@@ -0,0 +1 @@
+# Core/Board

package/board/board.component.d.ts

@@ -0,0 +1,37 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { PlaitBoardChangeEvent, PlaitBoard } from '../interfaces/board';
+import { PlaitElement } from '../interfaces/element';
+import { Subject } from 'rxjs';
+import { PlaitPlugin } from '../interfaces/plugin';
+import { RoughSVG } from 'roughjs/bin/svg';
+import { Viewport } from '../interfaces/viewport';
+import * as i0 from "@angular/core";
+export declare class PlaitBoardComponent implements OnInit, AfterViewInit, OnDestroy {
+    private cdr;
+    private renderer2;
+    zoom: number;
+    hostClass: string;
+    board: PlaitBoard;
+    roughSVG: RoughSVG;
+    destroy$: Subject<any>;
+    svg: ElementRef;
+    get host(): SVGElement;
+    plaitValue: PlaitElement[];
+    plaitViewport: Viewport;
+    plaitPlugins: PlaitPlugin[];
+    plaitChange: EventEmitter<PlaitBoardChangeEvent>;
+    plaitBoardInitialized: EventEmitter<PlaitBoard>;
+    constructor(cdr: ChangeDetectorRef, renderer2: Renderer2);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    initializePlugins(): void;
+    initializeEvents(): void;
+    updateViewport(): void;
+    zoomIn(event: MouseEvent): void;
+    zoomOut(event: MouseEvent): void;
+    resetZoom(event: MouseEvent): void;
+    trackBy: (index: number, element: PlaitElement) => number;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlaitBoardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlaitBoardComponent, "plait-board", never, { "plaitValue": "plaitValue"; "plaitViewport": "plaitViewport"; "plaitPlugins": "plaitPlugins"; }, { "plaitChange": "plaitChange"; "plaitBoardInitialized": "plaitBoardInitialized"; }, never, ["*"]>;
+}

package/core/base/detector.d.ts

@@ -0,0 +1,7 @@
+import { Point } from '../../interfaces/point';
+import { PlaitElement } from '../../interfaces/element';
+import { Selection } from '../../interfaces/selection';
+export interface BaseDetector {
+    contian: (selection: Selection, element: PlaitElement) => boolean;
+    hit: (point: Point, element: PlaitElement) => boolean;
+}

package/core/element/element.component.d.ts

@@ -0,0 +1,27 @@
+import { OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges, ViewContainerRef } from '@angular/core';
+import { PlaitElement } from '../../interfaces/element';
+import { PlaitBoard } from '../../interfaces/board';
+import { Selection } from '../../interfaces/selection';
+import { Viewport } from '../../interfaces/viewport';
+import * as i0 from "@angular/core";
+export declare class PlaitElementComponent implements OnInit, OnChanges, OnDestroy {
+    renderer2: Renderer2;
+    viewContainerRef: ViewContainerRef;
+    initialized: boolean;
+    groupG: SVGGElement;
+    index: number;
+    element: PlaitElement;
+    board: PlaitBoard;
+    viewport: Viewport;
+    selection: Selection | null;
+    host: SVGElement;
+    constructor(renderer2: Renderer2, viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    initialize(): void;
+    transform(first?: boolean): void;
+    drawElement(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlaitElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlaitElementComponent, "plait-element", never, { "index": "index"; "element": "element"; "board": "board"; "viewport": "viewport"; "selection": "selection"; "host": "host"; }, {}, never, never>;
+}

package/esm2020/board/board.component.mjs

@@ -0,0 +1,211 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, Input, Output, ViewChild } from '@angular/core';
+import { BOARD_TO_ON_CHANGE, HOST_TO_ROUGH_SVG, IS_TEXT_EDITABLE } from '../utils/weak-maps';
+import { createBoard } from '../plugins/create-board';
+import { withBoard } from '../plugins/with-board';
+import { fromEvent, Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import rough from 'roughjs/bin/rough';
+import { Transforms } from '../transfroms';
+import { withSelection } from '../plugins/with-selection';
+import { PlaitOperation } from '../interfaces/operation';
+import { getViewBox } from '../utils/board';
+import * as i0 from "@angular/core";
+import * as i1 from "../core/element/element.component";
+import * as i2 from "@angular/common";
+export class PlaitBoardComponent {
+    constructor(cdr, renderer2) {
+        this.cdr = cdr;
+        this.renderer2 = renderer2;
+        this.zoom = 100;
+        this.hostClass = `plait-board-container`;
+        this.destroy$ = new Subject();
+        this.plaitValue = [];
+        this.plaitPlugins = [];
+        this.plaitChange = new EventEmitter();
+        this.plaitBoardInitialized = new EventEmitter();
+        this.trackBy = (index, element) => {
+            return index;
+        };
+    }
+    get host() {
+        return this.svg.nativeElement;
+    }
+    ngOnInit() {
+        const roughSVG = rough.svg(this.host, { options: { roughness: 0, strokeWidth: 1 } });
+        HOST_TO_ROUGH_SVG.set(this.host, roughSVG);
+        this.initializePlugins();
+        this.initializeEvents();
+        this.updateViewport();
+        BOARD_TO_ON_CHANGE.set(this.board, () => {
+            this.cdr.detectChanges();
+            const changeEvent = {
+                children: this.board.children,
+                operations: this.board.operations,
+                viewport: this.board.viewport,
+                selection: this.board.selection
+            };
+            this.plaitChange.emit(changeEvent);
+            // update viewBox
+            if (this.board.operations.some(op => PlaitOperation.isSetViewportOperation(op))) {
+                this.updateViewport();
+            }
+        });
+    }
+    ngAfterViewInit() {
+        this.plaitBoardInitialized.emit(this.board);
+    }
+    initializePlugins() {
+        let board = withSelection(withBoard(createBoard(this.host, this.plaitValue)));
+        this.plaitPlugins.forEach(plugin => {
+            board = plugin(board);
+        });
+        this.board = board;
+        if (this.plaitViewport) {
+            this.board.viewport = this.plaitViewport;
+        }
+    }
+    initializeEvents() {
+        fromEvent(this.host, 'mousedown')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.mousedown(event);
+        });
+        fromEvent(this.host, 'mousemove')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.mousemove(event);
+        });
+        fromEvent(document, 'mouseup')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.mouseup(event);
+        });
+        fromEvent(this.host, 'dblclick')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.dblclick(event);
+        });
+        fromEvent(this.host, 'wheel')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            event.preventDefault();
+            const viewport = this.board.viewport;
+            Transforms.setViewport(this.board, {
+                ...viewport,
+                offsetX: viewport?.offsetX - event.deltaX,
+                offsetY: viewport?.offsetY - event.deltaY
+            });
+        });
+        fromEvent(document, 'keydown')
+            .pipe(takeUntil(this.destroy$), filter(() => {
+            return !IS_TEXT_EDITABLE.get(this.board);
+        }))
+            .subscribe((event) => {
+            this.board?.keydown(event);
+        });
+        fromEvent(document, 'keyup')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board?.keyup(event);
+        });
+        window.onresize = () => {
+            const viewBoxModel = getViewBox(this.board);
+            const viewBoxValues = this.host.getAttribute('viewBox')?.split(',');
+            this.renderer2.setAttribute(this.host, 'viewBox', `${viewBoxValues[0].trim()}, ${viewBoxValues[1].trim()}, ${viewBoxModel.width}, ${viewBoxModel.height}`);
+        };
+    }
+    updateViewport() {
+        this.zoom = Math.floor(this.board.viewport.zoom * 100);
+        const viewBox = getViewBox(this.board);
+        this.renderer2.setAttribute(this.host, 'viewBox', `${viewBox.minX}, ${viewBox.minY}, ${viewBox.width}, ${viewBox.height}`);
+    }
+    // 放大
+    zoomIn(event) {
+        const viewport = this.board?.viewport;
+        Transforms.setViewport(this.board, {
+            ...viewport,
+            zoom: viewport.zoom + 0.1
+        });
+    }
+    // 缩小
+    zoomOut(event) {
+        const viewport = this.board?.viewport;
+        Transforms.setViewport(this.board, {
+            ...viewport,
+            zoom: viewport.zoom - 0.1
+        });
+    }
+    resetZoom(event) {
+        const viewport = this.board?.viewport;
+        Transforms.setViewport(this.board, {
+            ...viewport,
+            zoom: 1
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        HOST_TO_ROUGH_SVG.delete(this.host);
+    }
+}
+PlaitBoardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: PlaitBoardComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+PlaitBoardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: PlaitBoardComponent, selector: "plait-board", inputs: { plaitValue: "plaitValue", plaitViewport: "plaitViewport", plaitPlugins: "plaitPlugins" }, outputs: { plaitChange: "plaitChange", plaitBoardInitialized: "plaitBoardInitialized" }, host: { properties: { "class": "this.hostClass" } }, viewQueries: [{ propertyName: "svg", first: true, predicate: ["svg"], descendants: true, static: true }], ngImport: i0, template: `
+        <svg #svg width="100%" height="100%"></svg>
+        <div class="plait-toolbar island zoom-toolbar">
+            <button class="item" (mousedown)="zoomOut($event)">-</button>
+            <button class="item zoom-value" (mousedown)="resetZoom($event)">{{ zoom }}%</button>
+            <button class="item" (mousedown)="zoomIn($event)">+</button>
+        </div>
+        <plait-element
+            *ngFor="let item of board.children; let index = index; trackBy: trackBy"
+            [index]="index"
+            [element]="item"
+            [board]="board"
+            [viewport]="board.viewport"
+            [selection]="board.selection"
+            [host]="host"
+        ></plait-element>
+        <ng-content></ng-content>
+    `, isInline: true, components: [{ type: i1.PlaitElementComponent, selector: "plait-element", inputs: ["index", "element", "board", "viewport", "selection", "host"] }], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: PlaitBoardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'plait-board',
+                    template: `
+        <svg #svg width="100%" height="100%"></svg>
+        <div class="plait-toolbar island zoom-toolbar">
+            <button class="item" (mousedown)="zoomOut($event)">-</button>
+            <button class="item zoom-value" (mousedown)="resetZoom($event)">{{ zoom }}%</button>
+            <button class="item" (mousedown)="zoomIn($event)">+</button>
+        </div>
+        <plait-element
+            *ngFor="let item of board.children; let index = index; trackBy: trackBy"
+            [index]="index"
+            [element]="item"
+            [board]="board"
+            [viewport]="board.viewport"
+            [selection]="board.selection"
+            [host]="host"
+        ></plait-element>
+        <ng-content></ng-content>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }]; }, propDecorators: { hostClass: [{
+                type: HostBinding,
+                args: ['class']
+            }], svg: [{
+                type: ViewChild,
+                args: ['svg', { static: true }]
+            }], plaitValue: [{
+                type: Input
+            }], plaitViewport: [{
+                type: Input
+            }], plaitPlugins: [{
+                type: Input
+            }], plaitChange: [{
+                type: Output
+            }], plaitBoardInitialized: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"board.component.js","sourceRoot":"","sources":["../../../../packages/plait/src/board/board.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    Renderer2,\n    ViewChild\n} from '@angular/core';\nimport { BOARD_TO_ON_CHANGE, HOST_TO_ROUGH_SVG, IS_TEXT_EDITABLE } from '../utils/weak-maps';\nimport { PlaitBoardChangeEvent, PlaitBoard } from '../interfaces/board';\nimport { PlaitElement } from '../interfaces/element';\nimport { createBoard } from '../plugins/create-board';\nimport { withBoard } from '../plugins/with-board';\nimport { fromEvent, Subject } from 'rxjs';\nimport { filter, takeUntil } from 'rxjs/operators';\nimport { PlaitPlugin } from '../interfaces/plugin';\nimport { RoughSVG } from 'roughjs/bin/svg';\nimport rough from 'roughjs/bin/rough';\nimport { Transforms } from '../transfroms';\nimport { withSelection } from '../plugins/with-selection';\nimport { PlaitOperation } from '../interfaces/operation';\nimport { getViewBox } from '../utils/board';\nimport { Viewport } from '../interfaces/viewport';\n\n@Component({\n    selector: 'plait-board',\n    template: `\n        <svg #svg width=\"100%\" height=\"100%\"></svg>\n        <div class=\"plait-toolbar island zoom-toolbar\">\n            <button class=\"item\" (mousedown)=\"zoomOut($event)\">-</button>\n            <button class=\"item zoom-value\" (mousedown)=\"resetZoom($event)\">{{ zoom }}%</button>\n            <button class=\"item\" (mousedown)=\"zoomIn($event)\">+</button>\n        </div>\n        <plait-element\n            *ngFor=\"let item of board.children; let index = index; trackBy: trackBy\"\n            [index]=\"index\"\n            [element]=\"item\"\n            [board]=\"board\"\n            [viewport]=\"board.viewport\"\n            [selection]=\"board.selection\"\n            [host]=\"host\"\n        ></plait-element>\n        <ng-content></ng-content>\n    `,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PlaitBoardComponent implements OnInit, AfterViewInit, OnDestroy {\n    zoom = 100;\n\n    @HostBinding('class') hostClass = `plait-board-container`;\n\n    board!: PlaitBoard;\n\n    roughSVG!: RoughSVG;\n\n    destroy$: Subject<any> = new Subject();\n\n    @ViewChild('svg', { static: true })\n    svg!: ElementRef;\n\n    get host(): SVGElement {\n        return this.svg.nativeElement;\n    }\n\n    @Input() plaitValue: PlaitElement[] = [];\n\n    @Input() plaitViewport!: Viewport;\n\n    @Input() plaitPlugins: PlaitPlugin[] = [];\n\n    @Output() plaitChange: EventEmitter<PlaitBoardChangeEvent> = new EventEmitter();\n\n    @Output() plaitBoardInitialized: EventEmitter<PlaitBoard> = new EventEmitter();\n\n    constructor(private cdr: ChangeDetectorRef, private renderer2: Renderer2) {}\n\n    ngOnInit(): void {\n        const roughSVG = rough.svg(this.host as SVGSVGElement, { options: { roughness: 0, strokeWidth: 1 } });\n        HOST_TO_ROUGH_SVG.set(this.host, roughSVG);\n        this.initializePlugins();\n        this.initializeEvents();\n        this.updateViewport();\n        BOARD_TO_ON_CHANGE.set(this.board, () => {\n            this.cdr.detectChanges();\n            const changeEvent: PlaitBoardChangeEvent = {\n                children: this.board.children,\n                operations: this.board.operations,\n                viewport: this.board.viewport,\n                selection: this.board.selection\n            };\n            this.plaitChange.emit(changeEvent);\n            // update viewBox\n            if (this.board.operations.some(op => PlaitOperation.isSetViewportOperation(op))) {\n                this.updateViewport();\n            }\n        });\n    }\n\n    ngAfterViewInit(): void {\n        this.plaitBoardInitialized.emit(this.board);\n    }\n\n    initializePlugins() {\n        let board = withSelection(withBoard(createBoard(this.host, this.plaitValue)));\n        this.plaitPlugins.forEach(plugin => {\n            board = plugin(board);\n        });\n        this.board = board;\n        if (this.plaitViewport) {\n            this.board.viewport = this.plaitViewport;\n        }\n    }\n\n    initializeEvents() {\n        fromEvent<MouseEvent>(this.host, 'mousedown')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                this.board.mousedown(event);\n            });\n        fromEvent<MouseEvent>(this.host, 'mousemove')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                this.board.mousemove(event);\n            });\n        fromEvent<MouseEvent>(document, 'mouseup')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                this.board.mouseup(event);\n            });\n        fromEvent<MouseEvent>(this.host, 'dblclick')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                this.board.dblclick(event);\n            });\n        fromEvent<WheelEvent>(this.host, 'wheel')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: WheelEvent) => {\n                event.preventDefault();\n                const viewport = this.board.viewport;\n                Transforms.setViewport(this.board, {\n                    ...viewport,\n                    offsetX: viewport?.offsetX - event.deltaX,\n                    offsetY: viewport?.offsetY - event.deltaY\n                });\n            });\n        fromEvent<KeyboardEvent>(document, 'keydown')\n            .pipe(\n                takeUntil(this.destroy$),\n                filter(() => {\n                    return !IS_TEXT_EDITABLE.get(this.board as PlaitBoard);\n                })\n            )\n            .subscribe((event: KeyboardEvent) => {\n                this.board?.keydown(event);\n            });\n        fromEvent<KeyboardEvent>(document, 'keyup')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: KeyboardEvent) => {\n                this.board?.keyup(event);\n            });\n\n        window.onresize = () => {\n            const viewBoxModel = getViewBox(this.board);\n            const viewBoxValues = this.host.getAttribute('viewBox')?.split(',') as string[];\n            this.renderer2.setAttribute(\n                this.host,\n                'viewBox',\n                `${viewBoxValues[0].trim()}, ${viewBoxValues[1].trim()}, ${viewBoxModel.width}, ${viewBoxModel.height}`\n            );\n        };\n    }\n\n    updateViewport() {\n        this.zoom = Math.floor(this.board.viewport.zoom * 100);\n        const viewBox = getViewBox(this.board);\n        this.renderer2.setAttribute(this.host, 'viewBox', `${viewBox.minX}, ${viewBox.minY}, ${viewBox.width}, ${viewBox.height}`);\n    }\n\n    // 放大\n    zoomIn(event: MouseEvent) {\n        const viewport = this.board?.viewport as Viewport;\n        Transforms.setViewport(this.board, {\n            ...viewport,\n            zoom: viewport.zoom + 0.1\n        });\n    }\n\n    // 缩小\n    zoomOut(event: MouseEvent) {\n        const viewport = this.board?.viewport as Viewport;\n        Transforms.setViewport(this.board, {\n            ...viewport,\n            zoom: viewport.zoom - 0.1\n        });\n    }\n\n    resetZoom(event: MouseEvent) {\n        const viewport = this.board?.viewport as Viewport;\n        Transforms.setViewport(this.board, {\n            ...viewport,\n            zoom: 1\n        });\n    }\n\n    trackBy = (index: number, element: PlaitElement) => {\n        return index;\n    };\n\n    ngOnDestroy(): void {\n        this.destroy$.next();\n        this.destroy$.complete();\n        HOST_TO_ROUGH_SVG.delete(this.host);\n    }\n}\n"]}

package/esm2020/core/base/detector.mjs

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

package/esm2020/core/element/element.component.mjs

@@ -0,0 +1,70 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { createG } from '../../utils/dom';
+import * as i0 from "@angular/core";
+export class PlaitElementComponent {
+    constructor(renderer2, viewContainerRef) {
+        this.renderer2 = renderer2;
+        this.viewContainerRef = viewContainerRef;
+        this.initialized = false;
+        this.selection = null;
+    }
+    ngOnInit() {
+        this.initialize();
+        this.transform(true);
+        this.drawElement();
+    }
+    initialize() {
+        this.initialized = true;
+        this.groupG = createG();
+        this.renderer2.setAttribute(this.groupG, 'plait-element-group', this.index.toString());
+        this.host.append(this.groupG);
+    }
+    transform(first = false) {
+        if (first && this.viewport.offsetX === 0 && this.viewport.offsetY === 0) {
+            return;
+        }
+        this.renderer2.setAttribute(this.groupG, 'transform', `translate(${this.viewport.offsetX} ${this.viewport.offsetY})`);
+    }
+    drawElement() {
+        const gArray = this.board.drawElement({ elementInstance: this });
+        gArray.forEach(g => {
+            this.groupG.appendChild(g);
+        });
+    }
+    ngOnChanges(changes) {
+        const viewport = changes['viewport'];
+        if (this.initialized && viewport) {
+            this.transform();
+        }
+        if (this.initialized) {
+            this.board.redrawElement({ elementInstance: this }, changes);
+        }
+    }
+    ngOnDestroy() {
+        this.board.destroyElement();
+        this.groupG.remove();
+    }
+}
+PlaitElementComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: PlaitElementComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component });
+PlaitElementComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: PlaitElementComponent, selector: "plait-element", inputs: { index: "index", element: "element", board: "board", viewport: "viewport", selection: "selection", host: "host" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: PlaitElementComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'plait-element',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ViewContainerRef }]; }, propDecorators: { index: [{
+                type: Input
+            }], element: [{
+                type: Input
+            }], board: [{
+                type: Input
+            }], viewport: [{
+                type: Input
+            }], selection: [{
+                type: Input
+            }], host: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/interfaces/board.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9hcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wbGFpdC9zcmMvaW50ZXJmYWNlcy9ib2FyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2ltcGxlQ2hhbmdlcyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ3Vyc29yU3RhdHVzIH0gZnJvbSAnLi9jdXJzb3InO1xuaW1wb3J0IHsgUGxhaXRFbGVtZW50IH0gZnJvbSAnLi9lbGVtZW50JztcbmltcG9ydCB7IFBsYWl0RWxlbWVudENvbnRleHQgfSBmcm9tICcuL2VsZW1lbnQtY29udGV4dCc7XG5pbXBvcnQgeyBQbGFpdE9wZXJhdGlvbiB9IGZyb20gJy4vb3BlcmF0aW9uJztcbmltcG9ydCB7IFNlbGVjdGlvbiB9IGZyb20gJy4vc2VsZWN0aW9uJztcbmltcG9ydCB7IFZpZXdwb3J0IH0gZnJvbSAnLi92aWV3cG9ydCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGxhaXRCb2FyZCB7XG4gICAgaG9zdDogU1ZHRWxlbWVudDtcbiAgICB2aWV3cG9ydDogVmlld3BvcnQ7XG4gICAgY2hpbGRyZW46IFBsYWl0RWxlbWVudFtdO1xuICAgIG9wZXJhdGlvbnM6IFBsYWl0T3BlcmF0aW9uW107XG4gICAgc2VsZWN0aW9uOiBTZWxlY3Rpb24gfCBudWxsO1xuICAgIGN1cnNvcjogQ3Vyc29yU3RhdHVzO1xuICAgIGFwcGx5OiAob3BlcmF0aW9uOiBQbGFpdE9wZXJhdGlvbikgPT4gdm9pZDtcbiAgICBvbkNoYW5nZTogKCkgPT4gdm9pZDtcbiAgICBtb3VzZWRvd246IChldmVudDogTW91c2VFdmVudCkgPT4gdm9pZDtcbiAgICBtb3VzZXVwOiAoZXZlbnQ6IE1vdXNlRXZlbnQpID0+IHZvaWQ7XG4gICAgbW91c2Vtb3ZlOiAoZXZlbnQ6IE1vdXNlRXZlbnQpID0+IHZvaWQ7XG4gICAga2V5ZG93bjogKGV2ZW50OiBLZXlib2FyZEV2ZW50KSA9PiB2b2lkO1xuICAgIGtleXVwOiAoZXZlbnQ6IEtleWJvYXJkRXZlbnQpID0+IHZvaWQ7XG4gICAgZGJsY2xpY2s6IChldmVudDogTW91c2VFdmVudCkgPT4gdm9pZDtcbiAgICBkcmF3RWxlbWVudDogKGNvbnRleHQ6IFBsYWl0RWxlbWVudENvbnRleHQpID0+IFNWR0dFbGVtZW50W107XG4gICAgcmVkcmF3RWxlbWVudDogKGNvbnRleHQ6IFBsYWl0RWxlbWVudENvbnRleHQsIGNoYW5nZXM6IFNpbXBsZUNoYW5nZXMpID0+IFNWR0dFbGVtZW50W107XG4gICAgZGVzdHJveUVsZW1lbnQ6ICgpID0+IHZvaWQ7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGxhaXRCb2FyZENoYW5nZUV2ZW50IHtcbiAgICBjaGlsZHJlbjogUGxhaXRFbGVtZW50W107XG4gICAgb3BlcmF0aW9uczogUGxhaXRPcGVyYXRpb25bXTtcbiAgICB2aWV3cG9ydDogVmlld3BvcnQ7XG4gICAgc2VsZWN0aW9uOiBTZWxlY3Rpb24gfCBudWxsO1xufSJdfQ==

package/esm2020/interfaces/cursor.mjs

@@ -0,0 +1,6 @@
+export var BaseCursorStatus;
+(function (BaseCursorStatus) {
+    BaseCursorStatus["move"] = "move";
+    BaseCursorStatus["select"] = "select";
+})(BaseCursorStatus || (BaseCursorStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3Vyc29yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvcGxhaXQvc3JjL2ludGVyZmFjZXMvY3Vyc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE1BQU0sQ0FBTixJQUFZLGdCQUdYO0FBSEQsV0FBWSxnQkFBZ0I7SUFDeEIsaUNBQWUsQ0FBQTtJQUNmLHFDQUFtQixDQUFBO0FBQ3ZCLENBQUMsRUFIVyxnQkFBZ0IsS0FBaEIsZ0JBQWdCLFFBRzNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgQ3Vyc29yU3RhdHVzID0gQmFzZUN1cnNvclN0YXR1cyB8IHN0cmluZztcbmV4cG9ydCBlbnVtIEJhc2VDdXJzb3JTdGF0dXMge1xuICAgICdtb3ZlJyA9ICdtb3ZlJyxcbiAgICAnc2VsZWN0JyA9ICdzZWxlY3QnXG59XG4iXX0=

package/esm2020/interfaces/custom-types.mjs

@@ -0,0 +1,5 @@
+/**
+ * Extendable Custom Types Interface
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLXR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvcGxhaXQvc3JjL2ludGVyZmFjZXMvY3VzdG9tLXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlbmRhYmxlIEN1c3RvbSBUeXBlcyBJbnRlcmZhY2VcbiAqL1xuXG50eXBlIEV4dGVuZGFibGVUeXBlcyA9ICdWaWV3cG9ydCcgfCAnU2V0Vmlld3BvcnRPcGVyYXRpb24nIHwgJ1NldFNlbGVjdGlvbk9wZXJhdGlvbic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3VzdG9tVHlwZXMge1xuICAgIFtrZXk6IHN0cmluZ106IHVua25vd247XG59XG5cbmV4cG9ydCB0eXBlIEV4dGVuZGVkVHlwZTxLIGV4dGVuZHMgRXh0ZW5kYWJsZVR5cGVzLCBCPiA9IHVua25vd24gZXh0ZW5kcyBDdXN0b21UeXBlc1tLXSA/IEIgOiBDdXN0b21UeXBlc1tLXTtcbiJdfQ==

package/esm2020/interfaces/element-context.mjs

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

package/esm2020/interfaces/element.mjs

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

package/esm2020/interfaces/graph.mjs

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

package/esm2020/interfaces/index.mjs

@@ -0,0 +1,14 @@
+export * from './board';
+export * from './cursor';
+export * from './element-context';
+export * from './custom-types';
+export * from './element';
+export * from './graph';
+export * from './node';
+export * from './operation';
+export * from './path';
+export * from './plugin';
+export * from './point';
+export * from './selection';
+export * from './viewport';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wbGFpdC9zcmMvaW50ZXJmYWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2JvYXJkJztcbmV4cG9ydCAqIGZyb20gJy4vY3Vyc29yJztcbmV4cG9ydCAqIGZyb20gJy4vZWxlbWVudC1jb250ZXh0JztcbmV4cG9ydCAqIGZyb20gJy4vY3VzdG9tLXR5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vZWxlbWVudCc7XG5leHBvcnQgKiBmcm9tICcuL2dyYXBoJztcbmV4cG9ydCAqIGZyb20gJy4vbm9kZSc7XG5leHBvcnQgKiBmcm9tICcuL29wZXJhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3BhdGgnO1xuZXhwb3J0ICogZnJvbSAnLi9wbHVnaW4nO1xuZXhwb3J0ICogZnJvbSAnLi9wb2ludCc7XG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3ZpZXdwb3J0JzsiXX0=

package/esm2020/interfaces/node.mjs

@@ -0,0 +1,20 @@
+import { Path } from './path';
+export const PlaitNode = {
+    parent: (board, path) => {
+        const parentPath = Path.parent(path);
+        const p = PlaitNode.get(board, parentPath);
+        return p;
+    },
+    get(board, path) {
+        let node = board;
+        for (let i = 0; i < path.length; i++) {
+            const p = path[i];
+            if (!node || !node.children || !node.children[p]) {
+                throw new Error(`Cannot find a descendant at path [${path}]`);
+            }
+            node = node.children[p];
+        }
+        return node;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/interfaces/operation.mjs

@@ -0,0 +1,7 @@
+export const isSetViewportOperation = (value) => {
+    return value.type === 'set_viewport';
+};
+export const PlaitOperation = {
+    isSetViewportOperation
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlcmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvcGxhaXQvc3JjL2ludGVyZmFjZXMvb3BlcmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTJDQSxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLEtBQVUsRUFBaUMsRUFBRTtJQUNoRixPQUFPLEtBQUssQ0FBQyxJQUFJLEtBQUssY0FBYyxDQUFDO0FBQ3pDLENBQUMsQ0FBQztBQUdGLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRztJQUMxQixzQkFBc0I7Q0FDekIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBsYWl0Tm9kZSB9IGZyb20gJy4vbm9kZSc7XG5pbXBvcnQgeyBQYXRoIH0gZnJvbSAnLi9wYXRoJztcbmltcG9ydCB7IFNlbGVjdGlvbiB9IGZyb20gJy4vc2VsZWN0aW9uJztcbmltcG9ydCB7IFZpZXdwb3J0IH0gZnJvbSAnLi92aWV3cG9ydCc7XG5cbmV4cG9ydCB0eXBlIEluc2VydE5vZGVPcGVyYXRpb24gPSB7XG4gICAgdHlwZTogJ2luc2VydF9ub2RlJztcbiAgICBwYXRoOiBQYXRoO1xuICAgIG5vZGU6IFBsYWl0Tm9kZTtcbn07XG5cbmV4cG9ydCB0eXBlIFJlbW92ZU5vZGVPcGVyYXRpb24gPSB7XG4gICAgdHlwZTogJ3JlbW92ZV9ub2RlJztcbiAgICBwYXRoOiBQYXRoO1xufTtcblxuZXhwb3J0IHR5cGUgTW92ZU5vZGVPcGVyYXRpb24gPSB7XG4gICAgdHlwZTogJ21vdmVfbm9kZSc7XG4gICAgcGF0aDogUGF0aDtcbiAgICBuZXdQYXRoOiBQYXRoO1xufTtcblxuZXhwb3J0IHR5cGUgU2V0Vmlld3BvcnRPcGVyYXRpb24gPSB7XG4gICAgdHlwZTogJ3NldF92aWV3cG9ydCc7XG4gICAgcHJvcGVydGllczogUGFydGlhbDxWaWV3cG9ydD47XG4gICAgbmV3UHJvcGVydGllczogUGFydGlhbDxWaWV3cG9ydD47XG59O1xuXG5leHBvcnQgdHlwZSBTZXRTZWxlY3Rpb25PcGVyYXRpb24gPSB7XG4gICAgdHlwZTogJ3NldF9zZWxlY3Rpb24nO1xuICAgIHByb3BlcnRpZXM6IFNlbGVjdGlvbiB8IG51bGw7XG4gICAgbmV3UHJvcGVydGllczogU2VsZWN0aW9uIHwgbnVsbDtcbn07XG5cbmV4cG9ydCB0eXBlIFNldE5vZGVPcGVyYXRpb24gPSB7XG4gICAgdHlwZTogJ3NldF9ub2RlJztcbiAgICBwYXRoOiBQYXRoO1xuICAgIHByb3BlcnRpZXM6IFBhcnRpYWw8UGxhaXROb2RlPjtcbiAgICBuZXdQcm9wZXJ0aWVzOiBQYXJ0aWFsPFBsYWl0Tm9kZT47XG59O1xuXG5leHBvcnQgdHlwZSBQbGFpdE9wZXJhdGlvbiA9IEluc2VydE5vZGVPcGVyYXRpb24gfCBTZXRWaWV3cG9ydE9wZXJhdGlvbiB8IFNldFNlbGVjdGlvbk9wZXJhdGlvbiB8IFNldE5vZGVPcGVyYXRpb24gfCBSZW1vdmVOb2RlT3BlcmF0aW9uIHwgTW92ZU5vZGVPcGVyYXRpb247XG5cbmV4cG9ydCBjb25zdCBpc1NldFZpZXdwb3J0T3BlcmF0aW9uID0gKHZhbHVlOiBhbnkpOiB2YWx1ZSBpcyBTZXRWaWV3cG9ydE9wZXJhdGlvbiA9PiB7XG4gICAgcmV0dXJuIHZhbHVlLnR5cGUgPT09ICdzZXRfdmlld3BvcnQnO1xufTtcblxuXG5leHBvcnQgY29uc3QgUGxhaXRPcGVyYXRpb24gPSB7XG4gICAgaXNTZXRWaWV3cG9ydE9wZXJhdGlvblxufTsiXX0=