@plait/angular-board 0.62.0-next.0

package/README.md

@@ -0,0 +1 @@
+## @plait/angular

package/board/board.component.d.ts

@@ -0,0 +1,57 @@
+import { AfterContentInit, AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges, ViewContainerRef } from '@angular/core';
+import { RoughSVG } from 'roughjs/bin/svg';
+import { Subject } from 'rxjs';
+import { BoardComponentInterface } from './board.component.interface';
+import { ListRender, PlaitBoard, PlaitBoardOptions, PlaitElement, PlaitPlugin, PlaitTheme, Viewport } from '@plait/core';
+import { PlaitIslandBaseComponent } from '../island/island-base.component';
+import { OnChangeData } from '../plugins/angular-board';
+import * as i0 from "@angular/core";
+export declare class PlaitBoardComponent implements BoardComponentInterface, OnInit, OnChanges, AfterViewInit, AfterContentInit, OnDestroy {
+    cdr: ChangeDetectorRef;
+    viewContainerRef: ViewContainerRef;
+    private elementRef;
+    private ngZone;
+    hasInitialized: boolean;
+    board: PlaitBoard;
+    roughSVG: RoughSVG;
+    destroy$: Subject<void>;
+    private resizeObserver;
+    plaitValue: PlaitElement[];
+    plaitViewport: Viewport;
+    plaitPlugins: PlaitPlugin[];
+    plaitOptions?: PlaitBoardOptions;
+    plaitTheme?: PlaitTheme;
+    onChange: EventEmitter<OnChangeData>;
+    plaitBoardInitialized: EventEmitter<PlaitBoard>;
+    get host(): SVGSVGElement;
+    get hostClass(): string;
+    getBrowserClassName(): "safari" | "chrome" | "firefox" | "";
+    get readonly(): boolean | undefined;
+    get isFocused(): boolean;
+    get disabledScrollOnNonFocus(): boolean | undefined;
+    get nativeElement(): HTMLElement;
+    svg: ElementRef;
+    viewportContainer: ElementRef;
+    islands?: QueryList<PlaitIslandBaseComponent>;
+    listRender: ListRender;
+    constructor(cdr: ChangeDetectorRef, viewContainerRef: ViewContainerRef, elementRef: ElementRef<HTMLElement>, ngZone: NgZone);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    private initializePlugins;
+    private initializeHookListener;
+    private initializeListRender;
+    private updateListRender;
+    private initializeChildrenContext;
+    private viewportScrollListener;
+    private elementResizeListener;
+    private initializeIslands;
+    private updateIslands;
+    private wheelZoomListener;
+    trackBy: (index: number, element: PlaitElement) => string;
+    ngOnDestroy(): void;
+    markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlaitBoardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlaitBoardComponent, "plait-board", never, { "plaitValue": { "alias": "plaitValue"; "required": false; }; "plaitViewport": { "alias": "plaitViewport"; "required": false; }; "plaitPlugins": { "alias": "plaitPlugins"; "required": false; }; "plaitOptions": { "alias": "plaitOptions"; "required": false; }; "plaitTheme": { "alias": "plaitTheme"; "required": false; }; }, { "onChange": "onChange"; "plaitBoardInitialized": "plaitBoardInitialized"; }, ["islands"], ["*"], true, never>;
+}

package/board/board.component.interface.d.ts

@@ -0,0 +1,9 @@
+import { ChangeDetectorRef, EventEmitter, ViewContainerRef } from '@angular/core';
+import { OnChangeData } from '../plugins/angular-board';
+export interface BoardComponentInterface {
+    markForCheck: () => void;
+    cdr: ChangeDetectorRef;
+    nativeElement: HTMLElement;
+    viewContainerRef: ViewContainerRef;
+    onChange: EventEmitter<OnChangeData>;
+}

package/esm2022/board/board.component.interface.mjs

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

package/esm2022/board/board.component.mjs

@@ -0,0 +1,433 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, ElementRef, EventEmitter, HostBinding, Input, Output, ViewChild } from '@angular/core';
+import rough from 'roughjs/bin/rough';
+import { fromEvent, Subject } from 'rxjs';
+import { filter, takeUntil, tap } from 'rxjs/operators';
+import { BOARD_TO_AFTER_CHANGE, BOARD_TO_CONTEXT, BOARD_TO_ELEMENT_HOST, BOARD_TO_HOST, BOARD_TO_MOVING_POINT, BOARD_TO_MOVING_POINT_IN_BOARD, BOARD_TO_ON_CHANGE, BOARD_TO_ROUGH_SVG, BoardTransforms, HOST_CLASS_NAME, IS_BOARD_ALIVE, IS_CHROME, IS_FIREFOX, IS_SAFARI, ListRender, PlaitBoard, PlaitBoardContext, WritableClipboardOperationType, ZOOM_STEP, createBoard, deleteFragment, getClipboardData, hasInputOrTextareaTarget, initializeViewBox, initializeViewportContainer, initializeViewportOffset, isFromViewportChange, isPreventTouchMove, setFragment, setIsFromViewportChange, toHostPoint, toViewBoxPoint, updateViewportByScrolling, updateViewportOffset, withBoard, withHandPointer, withHistory, withHotkey, withMoving, withOptions, withRelatedFragment, withSelection, withViewport } from '@plait/core';
+import { PlaitIslandBaseComponent, hasOnBoardChange } from '../island/island-base.component';
+import { BOARD_TO_COMPONENT } from '../utils/weak-maps';
+import { withAngular } from '../plugins/with-angular';
+import { withImage, withText } from '@plait/common';
+import * as i0 from "@angular/core";
+const ElementLowerHostClass = 'element-lower-host';
+const ElementHostClass = 'element-host';
+const ElementUpperHostClass = 'element-upper-host';
+const ElementActiveHostClass = 'element-active-host';
+export class PlaitBoardComponent {
+    get host() {
+        return this.svg.nativeElement;
+    }
+    get hostClass() {
+        return `${HOST_CLASS_NAME} theme-${this.board.theme.themeColorMode} ${this.getBrowserClassName()}`;
+    }
+    getBrowserClassName() {
+        if (IS_SAFARI) {
+            return 'safari';
+        }
+        if (IS_CHROME) {
+            return 'chrome';
+        }
+        if (IS_FIREFOX) {
+            return 'firefox';
+        }
+        return '';
+    }
+    get readonly() {
+        return this.board.options.readonly;
+    }
+    get isFocused() {
+        return PlaitBoard.isFocus(this.board);
+    }
+    get disabledScrollOnNonFocus() {
+        return this.board.options.disabledScrollOnNonFocus && !PlaitBoard.isFocus(this.board);
+    }
+    get nativeElement() {
+        return this.elementRef.nativeElement;
+    }
+    constructor(cdr, viewContainerRef, elementRef, ngZone) {
+        this.cdr = cdr;
+        this.viewContainerRef = viewContainerRef;
+        this.elementRef = elementRef;
+        this.ngZone = ngZone;
+        this.hasInitialized = false;
+        this.destroy$ = new Subject();
+        this.plaitValue = [];
+        this.plaitPlugins = [];
+        this.onChange = new EventEmitter();
+        this.plaitBoardInitialized = new EventEmitter();
+        this.trackBy = (index, element) => {
+            return element.id;
+        };
+    }
+    ngOnInit() {
+        const elementLowerHost = this.host.querySelector(`.${ElementLowerHostClass}`);
+        const elementHost = this.host.querySelector(`.${ElementHostClass}`);
+        const elementUpperHost = this.host.querySelector(`.${ElementUpperHostClass}`);
+        const elementActiveHost = this.host.querySelector(`.${ElementActiveHostClass}`);
+        const roughSVG = rough.svg(this.host, {
+            options: { roughness: 0, strokeWidth: 1 }
+        });
+        this.roughSVG = roughSVG;
+        this.initializePlugins();
+        this.ngZone.runOutsideAngular(() => {
+            this.initializeHookListener();
+            this.viewportScrollListener();
+            this.wheelZoomListener();
+            this.elementResizeListener();
+            fromEvent(document, 'mouseleave')
+                .pipe(takeUntil(this.destroy$))
+                .subscribe((event) => {
+                BOARD_TO_MOVING_POINT.delete(this.board);
+            });
+        });
+        BOARD_TO_COMPONENT.set(this.board, this);
+        BOARD_TO_ROUGH_SVG.set(this.board, roughSVG);
+        BOARD_TO_HOST.set(this.board, this.host);
+        IS_BOARD_ALIVE.set(this.board, true);
+        BOARD_TO_ELEMENT_HOST.set(this.board, {
+            lowerHost: elementLowerHost,
+            host: elementHost,
+            upperHost: elementUpperHost,
+            activeHost: elementActiveHost,
+            container: this.elementRef.nativeElement,
+            viewportContainer: this.viewportContainer.nativeElement
+        });
+        BOARD_TO_ON_CHANGE.set(this.board, () => {
+            this.ngZone.run(() => {
+                this.updateListRender();
+            });
+        });
+        BOARD_TO_AFTER_CHANGE.set(this.board, () => {
+            this.ngZone.run(() => {
+                const data = {
+                    children: this.board.children,
+                    operations: this.board.operations,
+                    viewport: this.board.viewport,
+                    selection: this.board.selection,
+                    theme: this.board.theme
+                };
+                this.updateIslands();
+                this.onChange.emit(data);
+            });
+        });
+        const context = new PlaitBoardContext();
+        BOARD_TO_CONTEXT.set(this.board, context);
+        this.initializeListRender();
+        this.elementRef.nativeElement.classList.add(`pointer-${this.board.pointer}`);
+        this.hasInitialized = true;
+    }
+    ngAfterContentInit() {
+        this.initializeIslands();
+    }
+    ngOnChanges(changes) {
+        if (this.hasInitialized) {
+            const valueChange = changes['plaitValue'];
+            const options = changes['plaitOptions'];
+            if (valueChange) {
+                this.board.children = valueChange.currentValue;
+                this.updateListRender();
+            }
+            if (options) {
+                this.board.options = options.currentValue;
+            }
+            this.cdr.markForCheck();
+        }
+    }
+    ngAfterViewInit() {
+        this.plaitBoardInitialized.emit(this.board);
+        initializeViewportContainer(this.board);
+        initializeViewBox(this.board);
+        initializeViewportOffset(this.board);
+    }
+    initializePlugins() {
+        let board = withRelatedFragment(withHotkey(withHandPointer(withHistory(withSelection(withMoving(withBoard(withViewport(withOptions(withAngular(withImage(withText(createBoard(this.plaitValue, this.plaitOptions)))))))))))));
+        this.plaitPlugins.forEach(plugin => {
+            board = plugin(board);
+        });
+        this.board = board;
+        if (this.plaitViewport) {
+            this.board.viewport = this.plaitViewport;
+        }
+        if (this.plaitTheme) {
+            this.board.theme = this.plaitTheme;
+        }
+    }
+    initializeHookListener() {
+        fromEvent(this.host, 'mousedown')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.mousedown(event);
+        });
+        fromEvent(this.host, 'pointerdown')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.pointerDown(event);
+        });
+        fromEvent(this.host, 'mousemove')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            BOARD_TO_MOVING_POINT_IN_BOARD.set(this.board, [event.x, event.y]);
+            this.board.mousemove(event);
+        });
+        fromEvent(this.host, 'pointermove')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            BOARD_TO_MOVING_POINT_IN_BOARD.set(this.board, [event.x, event.y]);
+            this.board.pointerMove(event);
+        });
+        fromEvent(this.host, 'mouseleave')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            BOARD_TO_MOVING_POINT_IN_BOARD.delete(this.board);
+            this.board.mouseleave(event);
+        });
+        fromEvent(this.host, 'pointerleave')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            BOARD_TO_MOVING_POINT_IN_BOARD.delete(this.board);
+            this.board.pointerLeave(event);
+        });
+        fromEvent(document, 'mousemove')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            BOARD_TO_MOVING_POINT.set(this.board, [event.x, event.y]);
+            this.board.globalMousemove(event);
+        });
+        fromEvent(document, 'pointermove')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            BOARD_TO_MOVING_POINT.set(this.board, [event.x, event.y]);
+            this.board.globalPointerMove(event);
+        });
+        fromEvent(this.host, 'mouseup')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.mouseup(event);
+        });
+        fromEvent(this.host, 'pointerup')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.pointerUp(event);
+        });
+        fromEvent(document, 'mouseup')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.globalMouseup(event);
+        });
+        fromEvent(document, 'pointerup')
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.board.globalPointerUp(event);
+        });
+        fromEvent(this.host, 'dblclick')
+            .pipe(takeUntil(this.destroy$), filter(() => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board)))
+            .subscribe((event) => {
+            this.board.dblClick(event);
+        });
+        fromEvent(document, 'keydown')
+            .pipe(takeUntil(this.destroy$), tap(event => {
+            this.board.globalKeyDown(event);
+        }), filter(event => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board) && !hasInputOrTextareaTarget(event.target)))
+            .subscribe((event) => {
+            this.board.keyDown(event);
+        });
+        fromEvent(document, 'keyup')
+            .pipe(takeUntil(this.destroy$), filter(() => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board)))
+            .subscribe((event) => {
+            this.board?.keyUp(event);
+        });
+        fromEvent(document, 'copy')
+            .pipe(takeUntil(this.destroy$), filter(() => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board)))
+            .subscribe((event) => {
+            event.preventDefault();
+            setFragment(this.board, WritableClipboardOperationType.copy, event.clipboardData);
+        });
+        fromEvent(document, 'paste')
+            .pipe(takeUntil(this.destroy$), filter(() => this.isFocused && !PlaitBoard.isReadonly(this.board) && !PlaitBoard.hasBeenTextEditing(this.board)))
+            .subscribe(async (clipboardEvent) => {
+            const mousePoint = PlaitBoard.getMovingPointInBoard(this.board);
+            if (mousePoint) {
+                const targetPoint = toViewBoxPoint(this.board, toHostPoint(this.board, mousePoint[0], mousePoint[1]));
+                const clipboardData = await getClipboardData(clipboardEvent.clipboardData);
+                this.board.insertFragment(clipboardData, targetPoint, WritableClipboardOperationType.paste);
+            }
+        });
+        fromEvent(document, 'cut')
+            .pipe(takeUntil(this.destroy$), filter(() => this.isFocused && !PlaitBoard.isReadonly(this.board) && !PlaitBoard.hasBeenTextEditing(this.board)))
+            .subscribe((event) => {
+            event.preventDefault();
+            setFragment(this.board, WritableClipboardOperationType.cut, event.clipboardData);
+            deleteFragment(this.board);
+        });
+    }
+    initializeListRender() {
+        this.listRender = new ListRender(this.board);
+        this.listRender.initialize(this.board.children, this.initializeChildrenContext());
+    }
+    updateListRender() {
+        this.listRender.update(this.board.children, this.initializeChildrenContext());
+        PlaitBoard.getBoardContext(this.board).nextStable();
+    }
+    initializeChildrenContext() {
+        return {
+            board: this.board,
+            parent: this.board,
+            parentG: PlaitBoard.getElementHost(this.board)
+        };
+    }
+    viewportScrollListener() {
+        fromEvent(this.viewportContainer.nativeElement, 'scroll')
+            .pipe(takeUntil(this.destroy$), filter(() => {
+            if (isFromViewportChange(this.board)) {
+                setIsFromViewportChange(this.board, false);
+                return false;
+            }
+            return true;
+        }))
+            .subscribe((event) => {
+            const { scrollLeft, scrollTop } = event.target;
+            updateViewportByScrolling(this.board, scrollLeft, scrollTop);
+        });
+        fromEvent(this.viewportContainer.nativeElement, 'touchmove', { passive: false })
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            if (isPreventTouchMove(this.board)) {
+                event.preventDefault();
+            }
+        });
+    }
+    elementResizeListener() {
+        this.resizeObserver = new ResizeObserver(() => {
+            initializeViewportContainer(this.board);
+            initializeViewBox(this.board);
+            updateViewportOffset(this.board);
+        });
+        this.resizeObserver.observe(this.nativeElement);
+    }
+    initializeIslands() {
+        this.islands?.forEach(island => {
+            island.initialize(this.board);
+        });
+    }
+    updateIslands() {
+        this.islands?.forEach(island => {
+            if (hasOnBoardChange(island)) {
+                island.onBoardChange();
+            }
+            island.markForCheck();
+        });
+    }
+    wheelZoomListener() {
+        fromEvent(this.host, 'wheel', { passive: false })
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((event) => {
+            // Credits to excalidraw
+            // https://github.com/excalidraw/excalidraw/blob/b7d7ccc929696cc17b4cc34452e4afd846d59f4f/src/components/App.tsx#L9060
+            if (event.metaKey || event.ctrlKey) {
+                event.preventDefault();
+                const { deltaX, deltaY } = event;
+                const zoom = this.board.viewport.zoom;
+                const sign = Math.sign(deltaY);
+                const MAX_STEP = ZOOM_STEP * 100;
+                const absDelta = Math.abs(deltaY);
+                let delta = deltaY;
+                if (absDelta > MAX_STEP) {
+                    delta = MAX_STEP * sign;
+                }
+                let newZoom = zoom - delta / 100;
+                // increase zoom steps the more zoomed-in we are (applies to >100% only)
+                newZoom +=
+                    Math.log10(Math.max(1, zoom)) *
+                        -sign *
+                        // reduced amplification for small deltas (small movements on a trackpad)
+                        Math.min(1, absDelta / 20);
+                BoardTransforms.updateZoom(this.board, newZoom, false);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.resizeObserver && this.resizeObserver?.disconnect();
+        BOARD_TO_ROUGH_SVG.delete(this.board);
+        BOARD_TO_COMPONENT.delete(this.board);
+        BOARD_TO_ROUGH_SVG.delete(this.board);
+        BOARD_TO_HOST.delete(this.board);
+        BOARD_TO_ELEMENT_HOST.delete(this.board);
+        IS_BOARD_ALIVE.set(this.board, false);
+        BOARD_TO_ON_CHANGE.delete(this.board);
+        BOARD_TO_AFTER_CHANGE.set(this.board, () => { });
+    }
+    markForCheck() {
+        this.cdr.markForCheck();
+        this.ngZone.run(() => {
+            this.updateIslands();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: PlaitBoardComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ViewContainerRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.4", type: PlaitBoardComponent, isStandalone: true, selector: "plait-board", inputs: { plaitValue: "plaitValue", plaitViewport: "plaitViewport", plaitPlugins: "plaitPlugins", plaitOptions: "plaitOptions", plaitTheme: "plaitTheme" }, outputs: { onChange: "onChange", plaitBoardInitialized: "plaitBoardInitialized" }, host: { properties: { "class": "this.hostClass", "class.readonly": "this.readonly", "class.focused": "this.isFocused", "class.disabled-scroll": "this.disabledScrollOnNonFocus" } }, queries: [{ propertyName: "islands", predicate: PlaitIslandBaseComponent, descendants: true }], viewQueries: [{ propertyName: "svg", first: true, predicate: ["svg"], descendants: true, static: true }, { propertyName: "viewportContainer", first: true, predicate: ["viewportContainer"], descendants: true, read: ElementRef, static: true }], usesOnChanges: true, ngImport: i0, template: `
+        <div class="viewport-container" #viewportContainer>
+            <svg #svg width="100%" height="100%" style="position: relative;" class="board-host-svg">
+                <g class="element-lower-host"></g>
+                <g class="element-host"></g>
+                <g class="element-upper-host"></g>
+                <g class="element-active-host"></g>
+            </svg>
+        </div>
+        <ng-content></ng-content>
+    `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: PlaitBoardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'plait-board',
+                    template: `
+        <div class="viewport-container" #viewportContainer>
+            <svg #svg width="100%" height="100%" style="position: relative;" class="board-host-svg">
+                <g class="element-lower-host"></g>
+                <g class="element-host"></g>
+                <g class="element-upper-host"></g>
+                <g class="element-active-host"></g>
+            </svg>
+        </div>
+        <ng-content></ng-content>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ViewContainerRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { plaitValue: [{
+                type: Input
+            }], plaitViewport: [{
+                type: Input
+            }], plaitPlugins: [{
+                type: Input
+            }], plaitOptions: [{
+                type: Input
+            }], plaitTheme: [{
+                type: Input
+            }], onChange: [{
+                type: Output
+            }], plaitBoardInitialized: [{
+                type: Output
+            }], hostClass: [{
+                type: HostBinding,
+                args: ['class']
+            }], readonly: [{
+                type: HostBinding,
+                args: ['class.readonly']
+            }], isFocused: [{
+                type: HostBinding,
+                args: ['class.focused']
+            }], disabledScrollOnNonFocus: [{
+                type: HostBinding,
+                args: ['class.disabled-scroll']
+            }], svg: [{
+                type: ViewChild,
+                args: ['svg', { static: true }]
+            }], viewportContainer: [{
+                type: ViewChild,
+                args: ['viewportContainer', { read: ElementRef, static: true }]
+            }], islands: [{
+                type: ContentChildren,
+                args: [PlaitIslandBaseComponent, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"board.component.js","sourceRoot":"","sources":["../../../../packages/angular-board/src/board/board.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChildren,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    Input,\n    NgZone,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    QueryList,\n    SimpleChanges,\n    ViewChild,\n    ViewContainerRef\n} from '@angular/core';\nimport rough from 'roughjs/bin/rough';\nimport { RoughSVG } from 'roughjs/bin/svg';\nimport { fromEvent, Subject } from 'rxjs';\nimport { filter, takeUntil, tap } from 'rxjs/operators';\nimport { BoardComponentInterface } from './board.component.interface';\nimport {\n    BOARD_TO_AFTER_CHANGE,\n    BOARD_TO_CONTEXT,\n    BOARD_TO_ELEMENT_HOST,\n    BOARD_TO_HOST,\n    BOARD_TO_MOVING_POINT,\n    BOARD_TO_MOVING_POINT_IN_BOARD,\n    BOARD_TO_ON_CHANGE,\n    BOARD_TO_ROUGH_SVG,\n    BoardTransforms,\n    HOST_CLASS_NAME,\n    IS_BOARD_ALIVE,\n    IS_CHROME,\n    IS_FIREFOX,\n    IS_SAFARI,\n    ListRender,\n    PlaitBoard,\n    PlaitBoardContext,\n    PlaitBoardOptions,\n    PlaitChildrenContext,\n    PlaitElement,\n    PlaitPlugin,\n    PlaitTheme,\n    Viewport,\n    WritableClipboardOperationType,\n    ZOOM_STEP,\n    createBoard,\n    deleteFragment,\n    getClipboardData,\n    hasInputOrTextareaTarget,\n    initializeViewBox,\n    initializeViewportContainer,\n    initializeViewportOffset,\n    isFromViewportChange,\n    isPreventTouchMove,\n    setFragment,\n    setIsFromViewportChange,\n    toHostPoint,\n    toViewBoxPoint,\n    updateViewportByScrolling,\n    updateViewportOffset,\n    withBoard,\n    withHandPointer,\n    withHistory,\n    withHotkey,\n    withMoving,\n    withOptions,\n    withRelatedFragment,\n    withSelection,\n    withViewport\n} from '@plait/core';\nimport { PlaitIslandBaseComponent, hasOnBoardChange } from '../island/island-base.component';\nimport { BOARD_TO_COMPONENT } from '../utils/weak-maps';\nimport { withAngular } from '../plugins/with-angular';\nimport { withImage, withText } from '@plait/common';\nimport { OnChangeData } from '../plugins/angular-board';\n\nconst ElementLowerHostClass = 'element-lower-host';\nconst ElementHostClass = 'element-host';\nconst ElementUpperHostClass = 'element-upper-host';\nconst ElementActiveHostClass = 'element-active-host';\n\n@Component({\n    selector: 'plait-board',\n    template: `\n        <div class=\"viewport-container\" #viewportContainer>\n            <svg #svg width=\"100%\" height=\"100%\" style=\"position: relative;\" class=\"board-host-svg\">\n                <g class=\"element-lower-host\"></g>\n                <g class=\"element-host\"></g>\n                <g class=\"element-upper-host\"></g>\n                <g class=\"element-active-host\"></g>\n            </svg>\n        </div>\n        <ng-content></ng-content>\n    `,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    standalone: true\n})\nexport class PlaitBoardComponent implements BoardComponentInterface, OnInit, OnChanges, AfterViewInit, AfterContentInit, OnDestroy {\n    hasInitialized = false;\n\n    board!: PlaitBoard;\n\n    roughSVG!: RoughSVG;\n\n    destroy$ = new Subject<void>();\n\n    private resizeObserver!: ResizeObserver;\n\n    @Input() plaitValue: PlaitElement[] = [];\n\n    @Input() plaitViewport!: Viewport;\n\n    @Input() plaitPlugins: PlaitPlugin[] = [];\n\n    @Input() plaitOptions?: PlaitBoardOptions;\n\n    @Input() plaitTheme?: PlaitTheme;\n\n    @Output() onChange: EventEmitter<OnChangeData> = new EventEmitter();\n\n    @Output() plaitBoardInitialized: EventEmitter<PlaitBoard> = new EventEmitter();\n\n    get host(): SVGSVGElement {\n        return this.svg.nativeElement;\n    }\n\n    @HostBinding('class')\n    get hostClass() {\n        return `${HOST_CLASS_NAME} theme-${this.board.theme.themeColorMode} ${this.getBrowserClassName()}`;\n    }\n\n    getBrowserClassName() {\n        if (IS_SAFARI) {\n            return 'safari';\n        }\n        if (IS_CHROME) {\n            return 'chrome';\n        }\n        if (IS_FIREFOX) {\n            return 'firefox';\n        }\n        return '';\n    }\n\n    @HostBinding('class.readonly')\n    get readonly() {\n        return this.board.options.readonly;\n    }\n\n    @HostBinding('class.focused')\n    get isFocused() {\n        return PlaitBoard.isFocus(this.board);\n    }\n\n    @HostBinding('class.disabled-scroll')\n    get disabledScrollOnNonFocus() {\n        return this.board.options.disabledScrollOnNonFocus && !PlaitBoard.isFocus(this.board);\n    }\n\n    get nativeElement(): HTMLElement {\n        return this.elementRef.nativeElement;\n    }\n\n    @ViewChild('svg', { static: true })\n    svg!: ElementRef;\n\n    @ViewChild('viewportContainer', { read: ElementRef, static: true })\n    viewportContainer!: ElementRef;\n\n    @ContentChildren(PlaitIslandBaseComponent, { descendants: true }) islands?: QueryList<PlaitIslandBaseComponent>;\n\n    listRender!: ListRender;\n\n    constructor(\n        public cdr: ChangeDetectorRef,\n        public viewContainerRef: ViewContainerRef,\n        private elementRef: ElementRef<HTMLElement>,\n        private ngZone: NgZone\n    ) {}\n\n    ngOnInit(): void {\n        const elementLowerHost = this.host.querySelector(`.${ElementLowerHostClass}`) as SVGGElement;\n        const elementHost = this.host.querySelector(`.${ElementHostClass}`) as SVGGElement;\n        const elementUpperHost = this.host.querySelector(`.${ElementUpperHostClass}`) as SVGGElement;\n        const elementActiveHost = this.host.querySelector(`.${ElementActiveHostClass}`) as SVGGElement;\n        const roughSVG = rough.svg(this.host as SVGSVGElement, {\n            options: { roughness: 0, strokeWidth: 1 }\n        });\n        this.roughSVG = roughSVG;\n        this.initializePlugins();\n        this.ngZone.runOutsideAngular(() => {\n            this.initializeHookListener();\n            this.viewportScrollListener();\n            this.wheelZoomListener();\n            this.elementResizeListener();\n            fromEvent<MouseEvent>(document, 'mouseleave')\n                .pipe(takeUntil(this.destroy$))\n                .subscribe((event: MouseEvent) => {\n                    BOARD_TO_MOVING_POINT.delete(this.board);\n                });\n        });\n        BOARD_TO_COMPONENT.set(this.board, this);\n        BOARD_TO_ROUGH_SVG.set(this.board, roughSVG);\n        BOARD_TO_HOST.set(this.board, this.host);\n        IS_BOARD_ALIVE.set(this.board, true);\n        BOARD_TO_ELEMENT_HOST.set(this.board, {\n            lowerHost: elementLowerHost,\n            host: elementHost,\n            upperHost: elementUpperHost,\n            activeHost: elementActiveHost,\n            container: this.elementRef.nativeElement,\n            viewportContainer: this.viewportContainer.nativeElement\n        });\n        BOARD_TO_ON_CHANGE.set(this.board, () => {\n            this.ngZone.run(() => {\n                this.updateListRender();\n            });\n        });\n        BOARD_TO_AFTER_CHANGE.set(this.board, () => {\n            this.ngZone.run(() => {\n                const data: OnChangeData = {\n                    children: this.board.children,\n                    operations: this.board.operations,\n                    viewport: this.board.viewport,\n                    selection: this.board.selection,\n                    theme: this.board.theme\n                };\n                this.updateIslands();\n                this.onChange.emit(data);\n            });\n        });\n        const context = new PlaitBoardContext();\n        BOARD_TO_CONTEXT.set(this.board, context);\n        this.initializeListRender();\n        this.elementRef.nativeElement.classList.add(`pointer-${this.board.pointer}`);\n        this.hasInitialized = true;\n    }\n\n    ngAfterContentInit(): void {\n        this.initializeIslands();\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (this.hasInitialized) {\n            const valueChange = changes['plaitValue'];\n            const options = changes['plaitOptions'];\n\n            if (valueChange) {\n                this.board.children = valueChange.currentValue;\n                this.updateListRender();\n            }\n            if (options) {\n                this.board.options = options.currentValue;\n            }\n            this.cdr.markForCheck();\n        }\n    }\n\n    ngAfterViewInit(): void {\n        this.plaitBoardInitialized.emit(this.board);\n        initializeViewportContainer(this.board);\n        initializeViewBox(this.board);\n        initializeViewportOffset(this.board);\n    }\n\n    private initializePlugins() {\n        let board = withRelatedFragment(\n            withHotkey(\n                withHandPointer(\n                    withHistory(\n                        withSelection(\n                            withMoving(\n                                withBoard(\n                                    withViewport(\n                                        withOptions(withAngular(withImage(withText(createBoard(this.plaitValue, this.plaitOptions)))))\n                                    )\n                                )\n                            )\n                        )\n                    )\n                )\n            )\n        );\n        this.plaitPlugins.forEach(plugin => {\n            board = plugin(board);\n        });\n        this.board = board;\n\n        if (this.plaitViewport) {\n            this.board.viewport = this.plaitViewport;\n        }\n\n        if (this.plaitTheme) {\n            this.board.theme = this.plaitTheme;\n        }\n    }\n\n    private initializeHookListener() {\n        fromEvent<MouseEvent>(this.host, 'mousedown')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                this.board.mousedown(event);\n            });\n\n        fromEvent<PointerEvent>(this.host, 'pointerdown')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: PointerEvent) => {\n                this.board.pointerDown(event);\n            });\n\n        fromEvent<MouseEvent>(this.host, 'mousemove')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                BOARD_TO_MOVING_POINT_IN_BOARD.set(this.board, [event.x, event.y]);\n                this.board.mousemove(event);\n            });\n\n        fromEvent<PointerEvent>(this.host, 'pointermove')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: PointerEvent) => {\n                BOARD_TO_MOVING_POINT_IN_BOARD.set(this.board, [event.x, event.y]);\n                this.board.pointerMove(event);\n            });\n\n        fromEvent<MouseEvent>(this.host, 'mouseleave')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                BOARD_TO_MOVING_POINT_IN_BOARD.delete(this.board);\n                this.board.mouseleave(event);\n            });\n\n        fromEvent<PointerEvent>(this.host, 'pointerleave')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: PointerEvent) => {\n                BOARD_TO_MOVING_POINT_IN_BOARD.delete(this.board);\n                this.board.pointerLeave(event);\n            });\n\n        fromEvent<MouseEvent>(document, 'mousemove')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                BOARD_TO_MOVING_POINT.set(this.board, [event.x, event.y]);\n                this.board.globalMousemove(event);\n            });\n\n        fromEvent<PointerEvent>(document, 'pointermove')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: PointerEvent) => {\n                BOARD_TO_MOVING_POINT.set(this.board, [event.x, event.y]);\n                this.board.globalPointerMove(event);\n            });\n\n        fromEvent<MouseEvent>(this.host, 'mouseup')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                this.board.mouseup(event);\n            });\n\n        fromEvent<PointerEvent>(this.host, 'pointerup')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: PointerEvent) => {\n                this.board.pointerUp(event);\n            });\n\n        fromEvent<MouseEvent>(document, 'mouseup')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: MouseEvent) => {\n                this.board.globalMouseup(event);\n            });\n\n        fromEvent<PointerEvent>(document, 'pointerup')\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: PointerEvent) => {\n                this.board.globalPointerUp(event);\n            });\n\n        fromEvent<MouseEvent>(this.host, 'dblclick')\n            .pipe(\n                takeUntil(this.destroy$),\n                filter(() => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board))\n            )\n            .subscribe((event: MouseEvent) => {\n                this.board.dblClick(event);\n            });\n\n        fromEvent<KeyboardEvent>(document, 'keydown')\n            .pipe(\n                takeUntil(this.destroy$),\n                tap(event => {\n                    this.board.globalKeyDown(event);\n                }),\n                filter(event => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board) && !hasInputOrTextareaTarget(event.target))\n            )\n            .subscribe((event: KeyboardEvent) => {\n                this.board.keyDown(event);\n            });\n\n        fromEvent<KeyboardEvent>(document, 'keyup')\n            .pipe(\n                takeUntil(this.destroy$),\n                filter(() => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board))\n            )\n            .subscribe((event: KeyboardEvent) => {\n                this.board?.keyUp(event);\n            });\n\n        fromEvent<ClipboardEvent>(document, 'copy')\n            .pipe(\n                takeUntil(this.destroy$),\n                filter(() => this.isFocused && !PlaitBoard.hasBeenTextEditing(this.board))\n            )\n            .subscribe((event: ClipboardEvent) => {\n                event.preventDefault();\n                setFragment(this.board, WritableClipboardOperationType.copy, event.clipboardData);\n            });\n\n        fromEvent<ClipboardEvent>(document, 'paste')\n            .pipe(\n                takeUntil(this.destroy$),\n                filter(() => this.isFocused && !PlaitBoard.isReadonly(this.board) && !PlaitBoard.hasBeenTextEditing(this.board))\n            )\n            .subscribe(async (clipboardEvent: ClipboardEvent) => {\n                const mousePoint = PlaitBoard.getMovingPointInBoard(this.board);\n                if (mousePoint) {\n                    const targetPoint = toViewBoxPoint(this.board, toHostPoint(this.board, mousePoint[0], mousePoint[1]));\n                    const clipboardData = await getClipboardData(clipboardEvent.clipboardData);\n                    this.board.insertFragment(clipboardData, targetPoint, WritableClipboardOperationType.paste);\n                }\n            });\n\n        fromEvent<ClipboardEvent>(document, 'cut')\n            .pipe(\n                takeUntil(this.destroy$),\n                filter(() => this.isFocused && !PlaitBoard.isReadonly(this.board) && !PlaitBoard.hasBeenTextEditing(this.board))\n            )\n            .subscribe((event: ClipboardEvent) => {\n                event.preventDefault();\n                setFragment(this.board, WritableClipboardOperationType.cut, event.clipboardData);\n                deleteFragment(this.board);\n            });\n    }\n\n    private initializeListRender() {\n        this.listRender = new ListRender(this.board);\n        this.listRender.initialize(this.board.children, this.initializeChildrenContext());\n    }\n\n    private updateListRender() {\n        this.listRender.update(this.board.children, this.initializeChildrenContext());\n        PlaitBoard.getBoardContext(this.board).nextStable();\n    }\n\n    private initializeChildrenContext(): PlaitChildrenContext {\n        return {\n            board: this.board,\n            parent: this.board,\n            parentG: PlaitBoard.getElementHost(this.board)\n        };\n    }\n\n    private viewportScrollListener() {\n        fromEvent<MouseEvent>(this.viewportContainer.nativeElement, 'scroll')\n            .pipe(\n                takeUntil(this.destroy$),\n                filter(() => {\n                    if (isFromViewportChange(this.board)) {\n                        setIsFromViewportChange(this.board, false);\n                        return false;\n                    }\n                    return true;\n                })\n            )\n            .subscribe((event: Event) => {\n                const { scrollLeft, scrollTop } = event.target as HTMLElement;\n                updateViewportByScrolling(this.board, scrollLeft, scrollTop);\n            });\n        fromEvent<MouseEvent>(this.viewportContainer.nativeElement, 'touchmove', { passive: false })\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: Event) => {\n                if (isPreventTouchMove(this.board)) {\n                    event.preventDefault();\n                }\n            });\n    }\n\n    private elementResizeListener() {\n        this.resizeObserver = new ResizeObserver(() => {\n            initializeViewportContainer(this.board);\n            initializeViewBox(this.board);\n            updateViewportOffset(this.board);\n        });\n        this.resizeObserver.observe(this.nativeElement);\n    }\n\n    private initializeIslands() {\n        this.islands?.forEach(island => {\n            island.initialize(this.board);\n        });\n    }\n\n    private updateIslands() {\n        this.islands?.forEach(island => {\n            if (hasOnBoardChange(island)) {\n                island.onBoardChange();\n            }\n            island.markForCheck();\n        });\n    }\n\n    private wheelZoomListener() {\n        fromEvent<WheelEvent>(this.host, 'wheel', { passive: false })\n            .pipe(takeUntil(this.destroy$))\n            .subscribe((event: WheelEvent) => {\n                // Credits to excalidraw\n                // https://github.com/excalidraw/excalidraw/blob/b7d7ccc929696cc17b4cc34452e4afd846d59f4f/src/components/App.tsx#L9060\n                if (event.metaKey || event.ctrlKey) {\n                    event.preventDefault();\n                    const { deltaX, deltaY } = event;\n                    const zoom = this.board.viewport.zoom;\n                    const sign = Math.sign(deltaY);\n                    const MAX_STEP = ZOOM_STEP * 100;\n                    const absDelta = Math.abs(deltaY);\n                    let delta = deltaY;\n                    if (absDelta > MAX_STEP) {\n                        delta = MAX_STEP * sign;\n                    }\n                    let newZoom = zoom - delta / 100;\n                    // increase zoom steps the more zoomed-in we are (applies to >100% only)\n                    newZoom +=\n                        Math.log10(Math.max(1, zoom)) *\n                        -sign *\n                        // reduced amplification for small deltas (small movements on a trackpad)\n                        Math.min(1, absDelta / 20);\n                    BoardTransforms.updateZoom(this.board, newZoom, false);\n                }\n            });\n    }\n\n    trackBy = (index: number, element: PlaitElement) => {\n        return element.id;\n    };\n\n    ngOnDestroy(): void {\n        this.destroy$.next();\n        this.destroy$.complete();\n        this.resizeObserver && this.resizeObserver?.disconnect();\n        BOARD_TO_ROUGH_SVG.delete(this.board);\n        BOARD_TO_COMPONENT.delete(this.board);\n        BOARD_TO_ROUGH_SVG.delete(this.board);\n        BOARD_TO_HOST.delete(this.board);\n        BOARD_TO_ELEMENT_HOST.delete(this.board);\n        IS_BOARD_ALIVE.set(this.board, false);\n        BOARD_TO_ON_CHANGE.delete(this.board);\n        BOARD_TO_AFTER_CHANGE.set(this.board, () => {});\n    }\n\n    markForCheck() {\n        this.cdr.markForCheck();\n        this.ngZone.run(() => {\n            this.updateIslands();\n        });\n    }\n}\n"]}