angular-toolbox 1.2.2 → 1.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 A library that provides useful tools for Angular apps development.
 
-[![Angular Toolbox version](https://img.shields.io/badge/Angular%20Toolbox:1.2.2-%231E90FF.svg)]()
+[![Angular Toolbox version](https://img.shields.io/badge/Angular%20Toolbox:1.3.0%231E90FF.svg)]()
 
 ## License
 

package/esm2022/lib/component/index.mjs

@@ -6,4 +6,5 @@
  * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
  */
 export * from './angular-toolbox-logo/angular-toolbox-logo.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9jb21wb25lbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyx1REFBdUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAbGljZW5zZVxyXG4gKiBDb3B5cmlnaHQgUGFzY2FsIEVDSEVNQU5OLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxyXG4gKlxyXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxyXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vcGFzY2FsZWNoZW1hbm4uY29tL2FuZ3VsYXItdG9vbGJveC9yZXNvdXJjZXMvbGljZW5zZVxyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vYW5ndWxhci10b29sYm94LWxvZ28vYW5ndWxhci10b29sYm94LWxvZ28uY29tcG9uZW50JztcclxuIl19
+export * from './layout';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9jb21wb25lbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAbGljZW5zZVxyXG4gKiBDb3B5cmlnaHQgUGFzY2FsIEVDSEVNQU5OLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxyXG4gKlxyXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxyXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vcGFzY2FsZWNoZW1hbm4uY29tL2FuZ3VsYXItdG9vbGJveC9yZXNvdXJjZXMvbGljZW5zZVxyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vYW5ndWxhci10b29sYm94LWxvZ28vYW5ndWxhci10b29sYm94LWxvZ28uY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9sYXlvdXQnO1xyXG4iXX0=

package/esm2022/lib/component/layout/border-layout/border-layout.component.mjs

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { Component, ContentChildren, ViewChild, HostListener, EventEmitter, Output } from '@angular/core';
+import { BorderLayoutContainer } from '../border-layout-container/border-layout-container.component';
+import { LayoutDragEventType } from '../../../model';
+import { BorderLayoutRenderer } from './util/border-layout-renderer';
+import { IdentifiableComponent } from '../../../core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../model";
+/**
+ * A border layout lays out a container, arranging and resizing its components to fit in five regions: north, south, east, west, and center.
+ * Each region is defined by a `BorderLayoutContainer` instance, and is identified by a corresponding constant: `NORTH`, `SOUTH`, `EAST`, `WEST`, and `CENTER`.
+ */
+export class BorderLayout extends IdentifiableComponent {
+    /**
+     * @private
+     */
+    onResize() {
+        this.paint();
+    }
+    /**
+     * @private
+     */
+    set __containers__(containers) {
+        this.renderer.addContainers(containers);
+    }
+    ;
+    /**
+     * @private
+     */
+    constructor(subscribeSvc) {
+        super();
+        this.subscribeSvc = subscribeSvc;
+        /**
+         * Emits events each time the user starts dragging a region handle.
+         */
+        this.dragStart = new EventEmitter(false);
+        /**
+         * Emits events each time the user stops dragging a region handle.
+         */
+        this.dragStop = new EventEmitter(false);
+        /**
+         * Emits events each time the user is dragging a region handle.
+         */
+        this.dragging = new EventEmitter(false);
+        this.renderer = new BorderLayoutRenderer(subscribeSvc);
+        subscribeSvc.register(this, this.renderer.userAction.subscribe((event) => {
+            event.layout = this;
+            if (event.type === LayoutDragEventType.DRAGGING) {
+                this.dragging.emit(event);
+                return;
+            }
+            if (event.type === LayoutDragEventType.DRAG_START) {
+                this.dragStart.emit(event);
+                return;
+            }
+            this.dragStop.emit(event);
+        }));
+    }
+    /**
+     * @private
+     * For test purpose only.
+     */
+    getRenderer() {
+        return this.renderer;
+    }
+    /**
+     * @private
+     */
+    ngOnDestroy() {
+        this.subscribeSvc.clearAll(this);
+        this.renderer.destroy();
+    }
+    /**
+     * @private
+     */
+    ngAfterViewInit() {
+        this.renderer.setLayoutContainer(this.layoutContainer.nativeElement);
+        this.paint();
+    }
+    /**
+     * Forces the container to be redrawn.
+     */
+    paint() {
+        this.renderer.paint();
+    }
+    /**
+     * Resizes the specified region.
+     *
+     * @param region The region to resize.
+     * @param size The new size of the region to resize.
+     *
+     * @returns `true` whether the specified region has been resized; `false` otherwise.
+     */
+    resizeRegion(region, size) {
+        this.renderer.resizeRegion(region, size);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: BorderLayout, deps: [{ token: i1.SubscriptionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.3", type: BorderLayout, isStandalone: true, selector: "atx-border-layout", outputs: { dragStart: "dragStart", dragStop: "dragStop", dragging: "dragging" }, host: { listeners: { "window:resize": "onResize()" } }, queries: [{ propertyName: "__containers__", predicate: BorderLayoutContainer }], viewQueries: [{ propertyName: "layoutContainer", first: true, predicate: ["atxLayoutContainer"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<!--\n * LICENSE\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n-->\n\n<div #atxLayoutContainer class=\"atx-border-layout\">\n    <ng-content></ng-content>\n</div>", styles: [".atx-border-layout{position:relative;height:100%;width:100%;-webkit-user-select:none;user-select:none;overflow:hidden}.atx-border-layout,.atx-border-layout *{box-sizing:border-box}.atx-border-layout .content{height:100%;width:100%;overflow:auto}.atx-border-layout .drag{position:absolute;border:2px solid black}:host ::ng-deep .atx-handle{position:absolute}:host ::ng-deep .atx-handle:hover,:host ::ng-deep .atx-handle.atx-handle-selected{background-color:var(--atx-handle-color, #469afa)}:host ::ng-deep .north{position:absolute;z-index:10;top:0;left:0;right:0}:host ::ng-deep .north .atx-handle{left:0;right:0;bottom:0;height:4px;cursor:ns-resize}:host ::ng-deep .west{position:absolute;z-index:5;left:0;height:unset!important}:host ::ng-deep .west .atx-handle{right:0;bottom:0;top:0;width:4px;cursor:ew-resize}:host ::ng-deep .east{position:absolute;z-index:5;right:0;height:unset!important}:host ::ng-deep .east .atx-handle{left:0;bottom:0;top:0;width:4px;cursor:ew-resize}:host ::ng-deep .south{position:absolute;z-index:10;bottom:0;left:0;right:0}:host ::ng-deep .south .atx-handle{left:0;right:0;top:0;height:4px;cursor:ns-resize}:host ::ng-deep .center{position:absolute}\n/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be found in\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: BorderLayout, decorators: [{
+            type: Component,
+            args: [{ selector: 'atx-border-layout', standalone: true, template: "<!--\n * LICENSE\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n-->\n\n<div #atxLayoutContainer class=\"atx-border-layout\">\n    <ng-content></ng-content>\n</div>", styles: [".atx-border-layout{position:relative;height:100%;width:100%;-webkit-user-select:none;user-select:none;overflow:hidden}.atx-border-layout,.atx-border-layout *{box-sizing:border-box}.atx-border-layout .content{height:100%;width:100%;overflow:auto}.atx-border-layout .drag{position:absolute;border:2px solid black}:host ::ng-deep .atx-handle{position:absolute}:host ::ng-deep .atx-handle:hover,:host ::ng-deep .atx-handle.atx-handle-selected{background-color:var(--atx-handle-color, #469afa)}:host ::ng-deep .north{position:absolute;z-index:10;top:0;left:0;right:0}:host ::ng-deep .north .atx-handle{left:0;right:0;bottom:0;height:4px;cursor:ns-resize}:host ::ng-deep .west{position:absolute;z-index:5;left:0;height:unset!important}:host ::ng-deep .west .atx-handle{right:0;bottom:0;top:0;width:4px;cursor:ew-resize}:host ::ng-deep .east{position:absolute;z-index:5;right:0;height:unset!important}:host ::ng-deep .east .atx-handle{left:0;bottom:0;top:0;width:4px;cursor:ew-resize}:host ::ng-deep .south{position:absolute;z-index:10;bottom:0;left:0;right:0}:host ::ng-deep .south .atx-handle{left:0;right:0;top:0;height:4px;cursor:ns-resize}:host ::ng-deep .center{position:absolute}\n/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be found in\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n"] }]
+        }], ctorParameters: () => [{ type: i1.SubscriptionService }], propDecorators: { dragStart: [{
+                type: Output
+            }], dragStop: [{
+                type: Output
+            }], dragging: [{
+                type: Output
+            }], onResize: [{
+                type: HostListener,
+                args: ["window:resize"]
+            }], layoutContainer: [{
+                type: ViewChild,
+                args: ["atxLayoutContainer"]
+            }], __containers__: [{
+                type: ContentChildren,
+                args: [BorderLayoutContainer]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"border-layout.component.js","sourceRoot":"","sources":["../../../../../../../projects/angular-toolbox/src/lib/component/layout/border-layout/border-layout.component.ts","../../../../../../../projects/angular-toolbox/src/lib/component/layout/border-layout/border-layout.component.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be found in\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n\nimport { AfterViewInit, Component, ContentChildren, OnDestroy, ElementRef, ViewChild, HostListener, QueryList, EventEmitter, output, Output } from '@angular/core';\nimport { BorderLayoutContainer } from '../border-layout-container/border-layout-container.component';\nimport { LayoutDragEvent, LayoutDragEventType, LayoutRegion, LayoutRegionType, SubscriptionService } from '../../../model';\nimport { BorderLayoutRenderer } from './util/border-layout-renderer';\nimport { IdentifiableComponent } from '../../../core';\n\n/**\n * A border layout lays out a container, arranging and resizing its components to fit in five regions: north, south, east, west, and center.\n * Each region is defined by a `BorderLayoutContainer` instance, and is identified by a corresponding constant: `NORTH`, `SOUTH`, `EAST`, `WEST`, and `CENTER`.\n */\n@Component({\n  selector: 'atx-border-layout',\n  templateUrl: './border-layout.component.html',\n  styleUrls: ['./border-layout.component.scss'],\n  standalone: true\n})\nexport class BorderLayout extends IdentifiableComponent implements AfterViewInit, OnDestroy {\n\n  /**\n   * Emits events each time the user starts dragging a region handle.\n   */\n  @Output()\n  public readonly dragStart: EventEmitter<LayoutDragEvent> = new EventEmitter(false);\n\n  /**\n   * Emits events each time the user stops dragging a region handle.\n   */\n  @Output()\n  public readonly dragStop: EventEmitter<LayoutDragEvent> = new EventEmitter(false);\n\n  /**\n   * Emits events each time the user is dragging a region handle.\n   */\n  @Output()\n  public readonly dragging: EventEmitter<LayoutDragEvent> = new EventEmitter(false);\n  \n  /**\n   * @private\n   */\n  @HostListener(\"window:resize\")\n  private onResize(): void {\n    this.paint();\n  }\n\n  /**\n   * @private\n   */\n  @ViewChild(\"atxLayoutContainer\")\n  private layoutContainer!: ElementRef<HTMLDivElement>;\n\n  /**\n   * @private\n   */\n  private renderer: BorderLayoutRenderer;\n\n  /**\n   * @private\n   */\n  @ContentChildren(BorderLayoutContainer)\n  private set __containers__(containers: QueryList<BorderLayoutContainer>) {\n    this.renderer.addContainers(containers);\n  };\n\n  /**\n   * @private\n   */\n  constructor(private subscribeSvc: SubscriptionService) {\n    super();\n    this.renderer = new BorderLayoutRenderer(subscribeSvc);\n    subscribeSvc.register(this,\n      this.renderer.userAction.subscribe((event: LayoutDragEvent)=> {\n        event.layout = this;\n        if (event.type === LayoutDragEventType.DRAGGING) {\n          this.dragging.emit(event);\n          return;\n        }\n        if (event.type === LayoutDragEventType.DRAG_START) {\n          this.dragStart.emit(event);\n          return;\n        }\n        this.dragStop.emit(event);\n      })\n    );\n  }\n\n  /**\n   * @private\n   * For test purpose only.\n   */\n  public getRenderer(): BorderLayoutRenderer {\n    return this.renderer;\n  }\n\n  /**\n   * @private\n   */\n  public ngOnDestroy(): void {\n    this.subscribeSvc.clearAll(this);\n    this.renderer.destroy();\n  }\n\n  /**\n   * @private\n   */\n  public ngAfterViewInit(): void {\n    this.renderer.setLayoutContainer(this.layoutContainer.nativeElement);\n    this.paint();\n  }\n\n  /**\n   * Forces the container to be redrawn.\n   */\n  public paint(): void {\n    this.renderer.paint();\n  }\n\n  /**\n   * Resizes the specified region.\n   * \n   * @param region The region to resize.\n   * @param size The new size of the region to resize.\n   * \n   * @returns `true` whether the specified region has been resized; `false` otherwise.\n   */\n  public resizeRegion(region: LayoutRegion | LayoutRegionType, size: number): void {\n    this.renderer.resizeRegion(region as LayoutRegion, size);\n  }\n}\n","<!--\n * LICENSE\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n-->\n\n<div #atxLayoutContainer class=\"atx-border-layout\">\n    <ng-content></ng-content>\n</div>"]}

package/esm2022/lib/component/layout/border-layout/util/border-layout-bounds-manager.mjs

@@ -0,0 +1,211 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { LayoutRegion, } from '../../../../model';
+/**
+ * @private
+ * A utility class that computes the size of all border layout containers.
+ */
+export class BorderLayoutBoundsManager {
+    constructor() {
+        /**
+         * @private
+         * The container top position when the user starts to drag the handle.
+         */
+        this.topPos = 0;
+        /**
+         * @private
+         * The container left position when the user starts to drag the handle.
+         */
+        this.leftPos = 0;
+        /**
+         * @private
+         * The bounds of the center container.
+         */
+        this.bounds = new DOMRect();
+    }
+    /**
+     * Makes this object elligible for garbage collection.
+     */
+    destroy() {
+        this.bounds = null;
+    }
+    /**
+     * Returns a rectangle that represents the bounds currently computed by this object.
+     *
+     * @returns The bounds currently computed by this object.
+     */
+    getBounds() {
+        return this.bounds;
+    }
+    /**
+     * Sets the top-left hand corner position before each bounds computaion.
+     *
+     * @param x The x position of the main container, in pixels, before computaion.
+     * @param y The y position of the main container, in pixels, before computaion.
+     */
+    setOrigin(x, y) {
+        this.leftPos = x;
+        this.topPos = y;
+    }
+    /**
+     * @private
+     * For test purpose only.
+     */
+    getOrigin() {
+        return { x: this.leftPos, y: this.topPos };
+    }
+    /**
+     * Computes the size of a "north" container.
+     *
+     * @param event The mouse event that triggered the computation of the container size.
+     * @param width The width of the main container.
+     * @param height The height of the main container.
+     * @param minSize The minimum size of the container for which to compute the size.
+     * @param maxSize The maximum size of the container for which to compute the size.
+     *
+     * @returns The size of a "north" container.
+     */
+    northResize(event, width, height, minSize, maxSize) {
+        const size = event.clientY - this.topPos;
+        if (maxSize && size > maxSize)
+            return this.setY(maxSize);
+        if (minSize && size < minSize)
+            return this.setY(minSize);
+        return this.setY(size);
+    }
+    /**
+     * @private
+     */
+    setY(y) {
+        this.bounds.y = y;
+        return y;
+    }
+    /**
+     * Computes the size of a "south" container.
+     *
+     * @param event The mouse event that triggered the computation of the container size.
+     * @param width The width of the main container.
+     * @param height The height of the main container.
+     * @param minSize The minimum size of the container for which to compute the size.
+     * @param maxSize The maximum size of the container for which to compute the size.
+     *
+     * @returns The size of a "south" container.
+     */
+    southResize(event, width, height, minSize, maxSize) {
+        const size = height - (event.clientY - this.topPos);
+        if (maxSize && size > maxSize)
+            return this.setHeight(maxSize);
+        if (minSize && size < minSize)
+            return this.setHeight(minSize);
+        return this.setHeight(size);
+    }
+    /**
+     * @private
+     */
+    setHeight(height) {
+        this.bounds.height = height;
+        return height;
+    }
+    /**
+     * Computes the size of a "west" container.
+     *
+     * @param event The mouse event that triggered the computation of the container size.
+     * @param width The width of the main container.
+     * @param height The height of the main container.
+     * @param minSize The minimum size of the container for which to compute the size.
+     * @param maxSize The maximum size of the container for which to compute the size.
+     *
+     * @returns The size of a "west" container.
+     */
+    westResize(event, width, height, minSize, maxSize) {
+        const size = event.clientX - this.leftPos;
+        if (maxSize && size > maxSize)
+            return this.setX(maxSize);
+        if (minSize && size < minSize)
+            return this.setX(minSize);
+        return this.setX(size);
+    }
+    /**
+     * @private
+     */
+    setX(x) {
+        this.bounds.x = x;
+        return x;
+    }
+    /**
+     * Computes the size of a "east" container.
+     *
+     * @param event The mouse event that triggered the computation of the container size.
+     * @param width The width of the main container.
+     * @param height The height of the main container.
+     * @param minSize The minimum size of the container for which to compute the size.
+     * @param maxSize The maximum size of the container for which to compute the size.
+     *
+     * @returns The size of a "east" container.
+     */
+    eastResize(event, width, height, minSize, maxSize) {
+        const size = width - (event.clientX - this.leftPos);
+        if (maxSize && size > maxSize)
+            return this.setWidth(maxSize);
+        if (minSize && size < minSize)
+            return this.setWidth(minSize);
+        return this.setWidth(size);
+    }
+    /**
+     * @private
+     */
+    setWidth(width) {
+        this.bounds.width = width;
+        return width;
+    }
+    /**
+     * Invoked after each `BorderLayoutContainer` registration to initialize the center container bounds.
+     *
+     * @param container A `BorderLayoutContainer` instance added to the main container.
+     */
+    initBounds(container) {
+        const r = container.constraints.region;
+        if (r === LayoutRegion.NORTH) {
+            this.bounds.y = container.getSize();
+            return;
+        }
+        if (r === LayoutRegion.SOUTH) {
+            this.bounds.height = container.getSize();
+            return;
+        }
+        if (r === LayoutRegion.WEST) {
+            this.bounds.x = container.getSize();
+            return;
+        }
+        if (r === LayoutRegion.EAST)
+            this.bounds.width = container.getSize();
+    }
+    /**
+     * Returns the method used to compute the size of a container, depending on the specified region.
+     *
+     * @param region The region associated with the container for which to compute the size.
+     *
+     * @returns The method used to compute the size of a container.
+     */
+    getResizeMethod(region) {
+        let method = this.southResize;
+        switch (region) {
+            case LayoutRegion.NORTH:
+                method = this.northResize;
+                break;
+            case LayoutRegion.WEST:
+                method = this.westResize;
+                break;
+            case LayoutRegion.EAST:
+                method = this.eastResize;
+                break;
+        }
+        return method.bind(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"border-layout-bounds-manager.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/component/layout/border-layout/util/border-layout-bounds-manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be found in\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n\nimport { BorderLayoutContainer } from '../../border-layout-container/border-layout-container.component';\nimport { Destroyable, LayoutRegion, } from '../../../../model';\nimport { ResizeMethod } from './resize-method';\n\n/**\n * @private\n * A utility class that computes the size of all border layout containers.\n */\nexport class BorderLayoutBoundsManager implements Destroyable {\n\n  /**\n   * @private\n   * The container top position when the user starts to drag the handle.\n   */\n  private topPos: number = 0;\n\n  /**\n   * @private\n   * The container left position when the user starts to drag the handle.\n   */\n  private leftPos: number = 0;\n\n  /**\n   * @private\n   * The bounds of the center container.\n   */\n  private bounds: DOMRect = new DOMRect();\n\n  /**\n   * Makes this object elligible for garbage collection.\n   */\n  public destroy(): void {\n    this.bounds = null as any;\n  }\n\n  /**\n   * Returns a rectangle that represents the bounds currently computed by this object.\n   * \n   * @returns The bounds currently computed by this object.\n   */\n  public getBounds(): DOMRect {\n    return this.bounds;\n  }\n\n  /**\n   * Sets the top-left hand corner position before each bounds computaion.\n   * \n   * @param x The x position of the main container, in pixels, before computaion.\n   * @param y The y position of the main container, in pixels, before computaion.\n   */\n  public setOrigin(x: number, y: number): void {\n    this.leftPos = x;\n    this.topPos = y;\n  }\n\n  /**\n   * @private\n   * For test purpose only.\n   */\n  public getOrigin(): any {\n    return { x: this.leftPos, y: this.topPos };\n  }\n\n  /**\n   * Computes the size of a \"north\" container.\n   * \n   * @param event The mouse event that triggered the computation of the container size.\n   * @param width The width of the main container.\n   * @param height The height of the main container.\n   * @param minSize The minimum size of the container for which to compute the size.\n   * @param maxSize The maximum size of the container for which to compute the size.\n   * \n   * @returns The size of a \"north\" container.\n   */\n  public northResize(event: MouseEvent, width: number, height: number, minSize: number | undefined, maxSize: number | undefined): number {\n    const size: number = event.clientY - this.topPos;\n    if (maxSize && size > maxSize) return this.setY(maxSize);\n    if (minSize && size < minSize) return this.setY(minSize);\n    return this.setY(size);\n  }\n\n  /**\n   * @private\n   */\n  private setY(y: number): number {\n    this.bounds.y = y;\n    return y;\n  }\n\n  /**\n   * Computes the size of a \"south\" container.\n   * \n   * @param event The mouse event that triggered the computation of the container size.\n   * @param width The width of the main container.\n   * @param height The height of the main container.\n   * @param minSize The minimum size of the container for which to compute the size.\n   * @param maxSize The maximum size of the container for which to compute the size.\n   * \n   * @returns The size of a \"south\" container.\n   */\n  public southResize(event: MouseEvent, width: number, height: number, minSize: number | undefined, maxSize: number | undefined): number {\n    const size: number = height - (event.clientY - this.topPos);\n    if (maxSize && size > maxSize) return this.setHeight(maxSize);\n    if (minSize && size < minSize) return this.setHeight(minSize);\n    return this.setHeight(size);\n  }\n\n  /**\n   * @private\n   */\n  private setHeight(height: number): number {\n    this.bounds.height = height;\n    return height;\n  }\n\n  /**\n   * Computes the size of a \"west\" container.\n   * \n   * @param event The mouse event that triggered the computation of the container size.\n   * @param width The width of the main container.\n   * @param height The height of the main container.\n   * @param minSize The minimum size of the container for which to compute the size.\n   * @param maxSize The maximum size of the container for which to compute the size.\n   * \n   * @returns The size of a \"west\" container.\n   */\n  public westResize(event: MouseEvent, width: number, height: number, minSize: number | undefined, maxSize: number | undefined): number {\n    const size: number = event.clientX - this.leftPos;\n    if (maxSize && size > maxSize) return this.setX(maxSize);\n    if (minSize && size < minSize) return this.setX(minSize);\n    return this.setX(size);\n  }\n\n  /**\n   * @private\n   */\n  private setX(x: number): number {\n    this.bounds.x = x;\n    return x;\n  }\n\n  /**\n   * Computes the size of a \"east\" container.\n   * \n   * @param event The mouse event that triggered the computation of the container size.\n   * @param width The width of the main container.\n   * @param height The height of the main container.\n   * @param minSize The minimum size of the container for which to compute the size.\n   * @param maxSize The maximum size of the container for which to compute the size.\n   * \n   * @returns The size of a \"east\" container.\n   */\n  public eastResize(event: MouseEvent, width: number, height: number, minSize: number | undefined, maxSize: number | undefined): number {\n    const size: number = width - (event.clientX - this.leftPos);\n    if (maxSize && size > maxSize) return this.setWidth(maxSize);\n    if (minSize && size < minSize) return this.setWidth(minSize);\n    return this.setWidth(size);\n  }\n\n  /**\n   * @private\n   */\n  private setWidth(width: number): number {\n    this.bounds.width = width;\n    return width;\n  }\n\n  /**\n   * Invoked after each `BorderLayoutContainer` registration to initialize the center container bounds.\n   * \n   * @param container A `BorderLayoutContainer` instance added to the main container. \n   */\n  public initBounds(container: BorderLayoutContainer): void {\n    const r: LayoutRegion = container.constraints.region as LayoutRegion;\n    if (r === LayoutRegion.NORTH) {\n      this.bounds.y = container.getSize();\n      return;\n    }\n    if (r === LayoutRegion.SOUTH) {\n      this.bounds.height = container.getSize();\n      return;\n    }\n    if (r === LayoutRegion.WEST) {\n      this.bounds.x = container.getSize();\n      return;\n    }\n    if (r === LayoutRegion.EAST) this.bounds.width = container.getSize();\n  }\n  \n  /**\n   * Returns the method used to compute the size of a container, depending on the specified region.\n   * \n   * @param region The region associated with the container for which to compute the size.\n   * \n   * @returns The method used to compute the size of a container.\n   */\n  public getResizeMethod(region: LayoutRegion): ResizeMethod {\n    let method: ResizeMethod = this.southResize;\n    switch (region) {\n      case LayoutRegion.NORTH: method = this.northResize; break;\n      case LayoutRegion.WEST: method = this.westResize; break;\n      case LayoutRegion.EAST: method = this.eastResize; break;\n    }\n    return method.bind(this) as any;\n  }\n}\n"]}

package/esm2022/lib/component/layout/border-layout/util/border-layout-renderer.mjs

@@ -0,0 +1,212 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { EventEmitter } from '@angular/core';
+import { EMPTY_STRING } from '../../../../util';
+import { LayoutDragEvent, LayoutDragEventType, LayoutRegion } from '../../../../model';
+import { IdentifiableComponent } from '../../../../core';
+import { BorderLayoutBoundsManager } from './border-layout-bounds-manager';
+/**
+ * @private
+ */
+const MOUSEMOVE = "mousemove";
+/**
+ * @private
+ */
+const MOUSEUP = "mouseup";
+/**
+ * @private
+ */
+const REGION_ERR_MSG = "A container with the same identifier has already been registered: ";
+/**
+ * @private
+ */
+const LAYOUT_ERR_MSG = "No layout container has been registered.";
+/**
+ * @private
+ * A controller object responsible for handling user actions on a `BorderLayout` container.
+ */
+export class BorderLayoutRenderer extends IdentifiableComponent {
+    /**
+     * @private
+     */
+    constructor(subscribeSvc) {
+        super();
+        this.subscribeSvc = subscribeSvc;
+        /**
+         * Emits events each time the user starts, or stops dragging handle.
+         */
+        this.userAction = new EventEmitter(false);
+        /**
+         * @private
+         */
+        this.containerList = [];
+        this.boundsManager = new BorderLayoutBoundsManager();
+    }
+    /**
+     * Add the list `BorderLayoutContainer` objects associated with the main container to this controller.
+     *
+     * @param containers the list `BorderLayoutContainer` objects associated with the main container.
+     */
+    addContainers(containers) {
+        let regionValidator = EMPTY_STRING;
+        containers.forEach(container => {
+            const constraints = container.constraints;
+            const r = constraints.region;
+            if (regionValidator.indexOf(r) !== -1)
+                throw new SyntaxError(REGION_ERR_MSG + r);
+            regionValidator += r;
+            if (constraints.resizable) {
+                this.subscribeSvc.register(this, container.resizeStart.subscribe(container => this.resizeEnter(container)));
+            }
+            this.boundsManager.initBounds(container);
+            if (r === LayoutRegion.NORTH || r === LayoutRegion.SOUTH)
+                return;
+            this.containerList.push(container);
+        });
+    }
+    ;
+    /**
+     * Sets the reference to the HTML container associated with the main container.
+     *
+     * @param lytContainer The reference to the HTML container associated with the main container.
+     */
+    setLayoutContainer(lytContainer) {
+        this.lytContainerElm = lytContainer;
+    }
+    ;
+    /**
+     * @private
+     * For test purpose only.
+     * Returns the reference to the internal `BorderLayoutBoundsManager` instance.
+     */
+    getBoundsManager() {
+        return this.boundsManager;
+    }
+    /**
+     * Makes this object elligible for garbage collection.
+     */
+    destroy() {
+        this.subscribeSvc.clearAll(this);
+        this.containerList.length = 0;
+        this.containerList = null;
+        this.lytContainerElm = null;
+        this.boundsManager.destroy();
+        this.boundsManager = null;
+    }
+    /**
+     * Forces the layout of all `BorderLayoutContainer` objects associated with the main container.
+     */
+    paint() {
+        this.checkLytContainer();
+        this.render(this.lytContainerElm.offsetWidth);
+    }
+    /**
+     * Resizes the specified region of the associated container.
+     *
+     * @param region The region to resize.
+     * @param size The new size of the region to resize.
+     *
+     * @returns `true` whether the specified region has been resized; `false` otherwise.
+     */
+    resizeRegion(region, size) {
+        if (region === LayoutRegion.CENTER)
+            return false;
+        const container = this.containerList.find((c) => {
+            return c.constraints.region === region;
+        });
+        if (!container)
+            return false;
+        container.setSize(size);
+        this.boundsManager.initBounds(container);
+        this.paint();
+        return true;
+    }
+    /**
+     * @private
+     */
+    resizeEnter(container) {
+        this.checkLytContainer();
+        const lytNativeElm = this.lytContainerElm;
+        const width = lytNativeElm.offsetWidth;
+        const height = lytNativeElm.offsetHeight;
+        const bounds = lytNativeElm.getBoundingClientRect();
+        const constraints = container.constraints;
+        const region = constraints.region;
+        const minSize = constraints.minSize;
+        const maxSize = constraints.maxSize;
+        let size = 0;
+        this.boundsManager.setOrigin(bounds.x, bounds.y);
+        let resizeMethod = this.boundsManager.getResizeMethod(region);
+        container.selected = true;
+        const onMoveHandler = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            size = resizeMethod(event, width, height, minSize, maxSize);
+            container.setSize(size);
+            this.render(width);
+            this.fireEvent(container, LayoutDragEventType.DRAGGING);
+        };
+        const onStopHandler = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            lytNativeElm.removeEventListener(MOUSEMOVE, onMoveHandler);
+            lytNativeElm.removeEventListener(MOUSEUP, onStopHandler);
+            container.selected = false;
+            size = resizeMethod(event, width, height, minSize, maxSize);
+            container.setSize(size);
+            this.render(width);
+            this.fireEvent(container, LayoutDragEventType.DRAG_STOP);
+        };
+        lytNativeElm.addEventListener(MOUSEMOVE, onMoveHandler);
+        lytNativeElm.addEventListener(MOUSEUP, onStopHandler);
+        this.fireEvent(container, LayoutDragEventType.DRAG_START);
+    }
+    /**
+     * @private
+     */
+    fireEvent(target, type) {
+        const evt = new LayoutDragEvent(target, type);
+        this.userAction.emit(evt);
+    }
+    /**
+     * @private
+     */
+    render(width) {
+        const bounds = this.boundsManager.getBounds();
+        const top = bounds.top;
+        const bottom = bounds.bottom;
+        const left = bounds.left;
+        const right = bounds.right;
+        this.containerList.forEach((cont) => {
+            const r = cont.constraints.region;
+            if (r === LayoutRegion.WEST) {
+                cont.setTopPos(top);
+                cont.setRightPos(width - left);
+                cont.setBottomPos(bottom - top);
+                return;
+            }
+            if (r === LayoutRegion.CENTER) {
+                cont.setTopPos(top);
+                cont.setLeftPos(left);
+                cont.setRightPos(right - left);
+                cont.setBottomPos(bottom - top);
+                return;
+            }
+            if (r === LayoutRegion.EAST) {
+                cont.setTopPos(top);
+                cont.setLeftPos(width - (right - left));
+                cont.setBottomPos(bottom - top);
+            }
+        });
+    }
+    checkLytContainer() {
+        if (!this.lytContainerElm)
+            throw new ReferenceError(LAYOUT_ERR_MSG);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"border-layout-renderer.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/component/layout/border-layout/util/border-layout-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be found in\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n\nimport { EventEmitter, QueryList } from '@angular/core';\nimport { BorderLayoutContainer } from '../../border-layout-container/border-layout-container.component';\nimport { EMPTY_STRING } from '../../../../util';\nimport { Destroyable, LayoutConstraints, LayoutDragEvent, LayoutDragEventType, LayoutRegion, SubscriptionService } from '../../../../model';\nimport { IdentifiableComponent } from '../../../../core';\nimport { BorderLayoutBoundsManager } from './border-layout-bounds-manager';\nimport { ResizeMethod } from './resize-method';\n\n/**\n * @private\n */\nconst MOUSEMOVE: any = \"mousemove\";\n\n/**\n * @private\n */\nconst MOUSEUP: any = \"mouseup\";\n\n/**\n * @private\n */\nconst REGION_ERR_MSG: string = \"A container with the same identifier has already been registered: \";\n\n/**\n * @private\n */\nconst LAYOUT_ERR_MSG: string = \"No layout container has been registered.\";\n\n/**\n * @private\n * A controller object responsible for handling user actions on a `BorderLayout` container.\n */\nexport class BorderLayoutRenderer extends IdentifiableComponent implements Destroyable {\n\n  /**\n   * Emits events each time the user starts, or stops dragging handle.\n   */\n  public readonly userAction: EventEmitter<LayoutDragEvent> = new EventEmitter(false);\n\n  /**\n   * @private\n   */\n  private lytContainerElm!: HTMLDivElement;\n  \n  /**\n   * @private\n   */\n  private containerList: BorderLayoutContainer[] = [];\n  \n  /**\n   * @private\n   */\n  private boundsManager: BorderLayoutBoundsManager; \n\n  /**\n   * @private\n   */\n  constructor(private subscribeSvc: SubscriptionService) {\n    super();\n    this.boundsManager = new BorderLayoutBoundsManager();\n  }\n\n  /**\n   * Add the list `BorderLayoutContainer` objects associated with the main container to this controller.\n   * \n   * @param containers the list `BorderLayoutContainer` objects associated with the main container.\n   */\n  public addContainers(containers: QueryList<BorderLayoutContainer>): void {\n    let regionValidator: string = EMPTY_STRING;\n    containers.forEach(container => {\n      const constraints: LayoutConstraints = container.constraints;\n      const r: string = constraints.region as string;\n      if (regionValidator.indexOf(r) !== -1) throw new SyntaxError(REGION_ERR_MSG + r);\n      regionValidator += r;\n      if (constraints.resizable) {\n        this.subscribeSvc.register(this,\n          container.resizeStart.subscribe(container=> this.resizeEnter(container))\n        );\n      }\n      this.boundsManager.initBounds(container);\n      if (r === LayoutRegion.NORTH || r === LayoutRegion.SOUTH) return;\n      this.containerList.push(container);\n    });\n  };\n\n  /**\n   * Sets the reference to the HTML container associated with the main container.\n   * \n   * @param lytContainer The reference to the HTML container associated with the main container.\n   */\n  public setLayoutContainer(lytContainer: HTMLDivElement): void {\n    this.lytContainerElm = lytContainer;\n  };\n\n  /**\n   * @private\n   * For test purpose only.\n   * Returns the reference to the internal `BorderLayoutBoundsManager` instance.\n   */\n  public getBoundsManager(): BorderLayoutBoundsManager {\n    return this.boundsManager; \n  }\n\n  /**\n   * Makes this object elligible for garbage collection.\n   */\n  public destroy(): void {\n    this.subscribeSvc.clearAll(this);\n    this.containerList.length = 0;\n    this.containerList = null as any;\n    this.lytContainerElm = null as any;\n    this.boundsManager.destroy();\n    this.boundsManager = null as any;\n  }\n\n  /**\n   * Forces the layout of all `BorderLayoutContainer` objects associated with the main container.\n   */\n  public paint(): void {\n    this.checkLytContainer();\n    this.render(this.lytContainerElm.offsetWidth);\n  }\n\n  /**\n   * Resizes the specified region of the associated container.\n   * \n   * @param region The region to resize.\n   * @param size The new size of the region to resize.\n   * \n   * @returns `true` whether the specified region has been resized; `false` otherwise.\n   */\n  public resizeRegion(region: LayoutRegion, size: number): boolean {\n    if (region === LayoutRegion.CENTER) return false;\n    const container: BorderLayoutContainer | undefined = this.containerList.find((c: BorderLayoutContainer)=> {\n      return c.constraints.region === region;\n    });\n    if (!container) return false;\n    container.setSize(size);\n    this.boundsManager.initBounds(container);\n    this.paint();\n    return true;\n  }\n\n  /**\n   * @private\n   */\n  private resizeEnter(container: BorderLayoutContainer): void {\n    this.checkLytContainer();\n    const lytNativeElm: HTMLDivElement = this.lytContainerElm;\n    const width: number = lytNativeElm.offsetWidth;\n    const height: number = lytNativeElm.offsetHeight;\n    const bounds: DOMRect = lytNativeElm.getBoundingClientRect();\n    const constraints: LayoutConstraints = container.constraints;\n    const region: LayoutRegion = constraints.region as LayoutRegion;\n    const minSize: number | undefined = constraints.minSize;\n    const maxSize: number | undefined = constraints.maxSize;\n    let size: number = 0;\n    this.boundsManager.setOrigin(bounds.x, bounds.y);\n    let resizeMethod: ResizeMethod = this.boundsManager.getResizeMethod(region);\n    container.selected = true;\n    const onMoveHandler = (event: MouseEvent)=> {\n      event.preventDefault();\n      event.stopPropagation();\n      size = resizeMethod(event, width, height, minSize, maxSize);\n      container.setSize(size);\n      this.render(width);\n      this.fireEvent(container, LayoutDragEventType.DRAGGING);\n    };\n    const onStopHandler = (event: MouseEvent)=> {\n      event.preventDefault();\n      event.stopPropagation();\n      lytNativeElm.removeEventListener(MOUSEMOVE, onMoveHandler);\n      lytNativeElm.removeEventListener(MOUSEUP, onStopHandler);\n      container.selected = false;\n      size = resizeMethod(event, width, height, minSize, maxSize);\n      container.setSize(size);\n      this.render(width);\n      this.fireEvent(container, LayoutDragEventType.DRAG_STOP);\n    };\n    lytNativeElm.addEventListener(MOUSEMOVE, onMoveHandler);\n    lytNativeElm.addEventListener(MOUSEUP, onStopHandler);\n    this.fireEvent(container, LayoutDragEventType.DRAG_START);\n  }\n\n  /**\n   * @private\n   */\n  private fireEvent(target: BorderLayoutContainer, type: LayoutDragEventType): void {\n    const evt: LayoutDragEvent = new LayoutDragEvent(target, type);\n    this.userAction.emit(evt);\n  }\n\n  /**\n   * @private\n   */\n  private render(width: number): void {\n    const bounds: DOMRect = this.boundsManager.getBounds();\n    const top: number = bounds.top;\n    const bottom: number = bounds.bottom;\n    const left: number = bounds.left;\n    const right: number = bounds.right;\n    this.containerList.forEach((cont: BorderLayoutContainer) => {\n      const r: LayoutRegion = cont.constraints.region as LayoutRegion;\n      if (r === LayoutRegion.WEST) {\n        cont.setTopPos(top);\n        cont.setRightPos(width - left);\n        cont.setBottomPos(bottom - top);\n        return;\n      }\n      if (r === LayoutRegion.CENTER) {\n        cont.setTopPos(top);\n        cont.setLeftPos(left);\n        cont.setRightPos(right - left);\n        cont.setBottomPos(bottom - top);\n        return;\n      }\n      if (r === LayoutRegion.EAST) {\n        cont.setTopPos(top);\n        cont.setLeftPos(width - (right - left));\n        cont.setBottomPos(bottom - top);\n      }\n    });\n  }\n\n  private checkLytContainer(): void {\n    if (!this.lytContainerElm) throw new ReferenceError(LAYOUT_ERR_MSG);\n  }\n}\n"]}