@scion/components 15.0.2 → 16.0.0

package/dimension/dimension.directive.d.ts

@@ -35,9 +35,9 @@ export declare class SciDimensionDirective implements OnInit, OnDestroy {
     get dimension(): SciDimension;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SciDimensionDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SciDimensionDirective, "[sciDimension]", ["sciDimension"], { "emitOutsideAngular": "emitOutsideAngular"; }, { "dimensionChange": "sciDimensionChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SciDimensionDirective, "[sciDimension]", ["sciDimension"], { "emitOutsideAngular": { "alias": "emitOutsideAngular"; "required": false; }; }, { "dimensionChange": "sciDimensionChange"; }, never, never, false, never>;
 }
 /**
  * Represents the dimension of an element.
  */
-export declare type SciDimension = Dimension;
+export type SciDimension = Dimension;

package/esm2022/dimension/dimension.directive.mjs

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2018-2019 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ */
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { captureElementDimension, fromDimension$ } from '@scion/toolkit/observable';
+import * as i0 from "@angular/core";
+/**
+ * Allows observing changes to host element's size.
+ *
+ * See {@link fromDimension$} Observable for more information.
+ *
+ * ---
+ * Usage:
+ *
+ * <div sciDimension (sciDimensionChange)="onDimensionChange($event)"></div>
+ */
+class SciDimensionDirective {
+    constructor(host, _ngZone) {
+        this._ngZone = _ngZone;
+        this._destroy$ = new Subject();
+        /**
+         * Upon subscription, it emits the host element's dimension, and then continuously emits when the dimension of the host element changes.
+         */
+        this.dimensionChange = new EventEmitter();
+        /**
+         * Controls if to emit a dimension change inside or outside of the Angular zone.
+         * If emitted outside of the Angular zone no change detection cycle is triggered.
+         *
+         * By default, if not specified, emits inside the Angular zone.
+         */
+        this.emitOutsideAngular = false;
+        this._host = host.nativeElement;
+    }
+    ngOnInit() {
+        this.installDimensionListener();
+    }
+    installDimensionListener() {
+        this._ngZone.runOutsideAngular(() => {
+            fromDimension$(this._host)
+                .pipe(takeUntil(this._destroy$))
+                .subscribe((dimension) => {
+                if (this.emitOutsideAngular) {
+                    this.dimensionChange.emit(dimension);
+                }
+                else {
+                    this._ngZone.run(() => this.dimensionChange.emit(dimension));
+                }
+            });
+        });
+    }
+    /**
+     * Returns the current dimension of its host element.
+     */
+    get dimension() {
+        return captureElementDimension(this._host);
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: SciDimensionDirective, selector: "[sciDimension]", inputs: { emitOutsideAngular: "emitOutsideAngular" }, outputs: { dimensionChange: "sciDimensionChange" }, exportAs: ["sciDimension"], ngImport: i0 }); }
+}
+export { SciDimensionDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sciDimension]',
+                    exportAs: 'sciDimension',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { dimensionChange: [{
+                type: Output,
+                args: ['sciDimensionChange']
+            }], emitOutsideAngular: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/dimension/dimension.module.mjs

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2018-2019 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SciDimensionDirective } from './dimension.directive';
+import * as i0 from "@angular/core";
+/**
+ * Provides a directive for observing changes to the size of the host element.
+ *
+ * @see fromDimension$
+ */
+class SciDimensionModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionModule, declarations: [SciDimensionDirective], imports: [CommonModule], exports: [SciDimensionDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionModule, imports: [CommonModule] }); }
+}
+export { SciDimensionModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                    ],
+                    declarations: [
+                        SciDimensionDirective,
+                    ],
+                    exports: [
+                        SciDimensionDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGltZW5zaW9uLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NjaW9uL2NvbXBvbmVudHMvZGltZW5zaW9uL3NyYy9kaW1lbnNpb24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sdUJBQXVCLENBQUM7O0FBRTVEOzs7O0dBSUc7QUFDSCxNQVdhLGtCQUFrQjs4R0FBbEIsa0JBQWtCOytHQUFsQixrQkFBa0IsaUJBTjNCLHFCQUFxQixhQUhyQixZQUFZLGFBTVoscUJBQXFCOytHQUdaLGtCQUFrQixZQVQzQixZQUFZOztTQVNILGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQVg5QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3FCQUNiO29CQUNELFlBQVksRUFBRTt3QkFDWixxQkFBcUI7cUJBQ3RCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxxQkFBcUI7cUJBQ3RCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxOC0yMDE5IFN3aXNzIEZlZGVyYWwgUmFpbHdheXNcbiAqXG4gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlXG4gKiBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIDIuMFxuICogd2hpY2ggaXMgYXZhaWxhYmxlIGF0IGh0dHBzOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC0yLjAvXG4gKlxuICogIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBFUEwtMi4wXG4gKi9cblxuaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7U2NpRGltZW5zaW9uRGlyZWN0aXZlfSBmcm9tICcuL2RpbWVuc2lvbi5kaXJlY3RpdmUnO1xuXG4vKipcbiAqIFByb3ZpZGVzIGEgZGlyZWN0aXZlIGZvciBvYnNlcnZpbmcgY2hhbmdlcyB0byB0aGUgc2l6ZSBvZiB0aGUgaG9zdCBlbGVtZW50LlxuICpcbiAqIEBzZWUgZnJvbURpbWVuc2lvbiRcbiAqL1xuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgU2NpRGltZW5zaW9uRGlyZWN0aXZlLFxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgU2NpRGltZW5zaW9uRGlyZWN0aXZlLFxuICBdLFxufSlcbmV4cG9ydCBjbGFzcyBTY2lEaW1lbnNpb25Nb2R1bGUge1xufVxuIl19

package/esm2022/sashbox/element-ref.directive.mjs

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2018-2019 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ */
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Provides access to the native {@link HTMLElement} of the host.
+ */
+class SciElementRefDirective {
+    constructor(host) {
+        this.host = host;
+        this.nativeElement = host.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciElementRefDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: SciElementRefDirective, selector: "[sciElementRef]", exportAs: ["sciElementRef"], ngImport: i0 }); }
+}
+export { SciElementRefDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciElementRefDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[sciElementRef]', exportAs: 'sciElementRef' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1yZWYuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2Npb24vY29tcG9uZW50cy9zYXNoYm94L3NyYy9lbGVtZW50LXJlZi5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFFSCxPQUFPLEVBQUMsU0FBUyxFQUFhLE1BQU0sZUFBZSxDQUFDOztBQUVwRDs7R0FFRztBQUNILE1BQ2Esc0JBQXNCO0lBSWpDLFlBQW1CLElBQTZCO1FBQTdCLFNBQUksR0FBSixJQUFJLENBQXlCO1FBQzlDLElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQztJQUMxQyxDQUFDOzhHQU5VLHNCQUFzQjtrR0FBdEIsc0JBQXNCOztTQUF0QixzQkFBc0I7MkZBQXRCLHNCQUFzQjtrQkFEbEMsU0FBUzttQkFBQyxFQUFDLFFBQVEsRUFBRSxpQkFBaUIsRUFBRSxRQUFRLEVBQUUsZUFBZSxFQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxOC0yMDE5IFN3aXNzIEZlZGVyYWwgUmFpbHdheXNcbiAqXG4gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlXG4gKiBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIDIuMFxuICogd2hpY2ggaXMgYXZhaWxhYmxlIGF0IGh0dHBzOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC0yLjAvXG4gKlxuICogIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBFUEwtMi4wXG4gKi9cblxuaW1wb3J0IHtEaXJlY3RpdmUsIEVsZW1lbnRSZWZ9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFByb3ZpZGVzIGFjY2VzcyB0byB0aGUgbmF0aXZlIHtAbGluayBIVE1MRWxlbWVudH0gb2YgdGhlIGhvc3QuXG4gKi9cbkBEaXJlY3RpdmUoe3NlbGVjdG9yOiAnW3NjaUVsZW1lbnRSZWZdJywgZXhwb3J0QXM6ICdzY2lFbGVtZW50UmVmJ30pXG5leHBvcnQgY2xhc3MgU2NpRWxlbWVudFJlZkRpcmVjdGl2ZSB7XG5cbiAgcHVibGljIHJlYWRvbmx5IG5hdGl2ZUVsZW1lbnQ6IEhUTUxFbGVtZW50O1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBob3N0OiBFbGVtZW50UmVmPEhUTUxFbGVtZW50Pikge1xuICAgIHRoaXMubmF0aXZlRWxlbWVudCA9IGhvc3QubmF0aXZlRWxlbWVudDtcbiAgfVxufVxuIl19

package/esm2022/sashbox/sash-initializer.directive.mjs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018-2019 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ */
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Initializes {SashDirective} with the target {HTMLDivElement}.
+ */
+class SciSashInitializerDirective {
+    constructor(_host) {
+        this._host = _host;
+    }
+    ngOnChanges(changes) {
+        this.sash.element = this._host.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciSashInitializerDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: SciSashInitializerDirective, selector: "div[sciSashInitializer].sash", inputs: { sash: ["sciSashInitializer", "sash"] }, usesOnChanges: true, ngImport: i0 }); }
+}
+export { SciSashInitializerDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciSashInitializerDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'div[sciSashInitializer].sash' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { sash: [{
+                type: Input,
+                args: ['sciSashInitializer']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/sashbox/sash.directive.mjs

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2018-2019 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ */
+import { Directive, Input } from '@angular/core';
+import { BehaviorSubject, merge } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./sashbox-accessor";
+/**
+ * Use this directive to model a sash for {@link SciSashboxComponent}.
+ * The host element of this modelling directive must be a <ng-template> which is used as sash template.
+ *
+ *
+ * ### Usage:
+ *
+ * <sci-sashbox direction="row">
+ *   <!-- fixed size sash -->
+ *   <ng-template sciSash size="200px">
+ *     ...
+ *   </ng-template>
+ *
+ *   <!-- sash which takes the remaining space -->
+ *   <ng-template sciSash>
+ *     ...
+ *   </ng-template>
+ * </sci-sashbox>
+ */
+class SciSashDirective {
+    /**
+     * Specifies the sash size, either as fixed size with an explicit unit,
+     * or as a unitless proportion to distibute remaining space. A proportional
+     * sash has the ability to grow or shrink if necessary, and must be >= 1.
+     *
+     * If not set, remaining space is distributed equally.
+     */
+    set size(size) {
+        this._size = size ?? '1';
+    }
+    get size() {
+        return this._size;
+    }
+    /**
+     * @internal
+     */
+    set flexGrow(flexGrow) {
+        this._flexGrow$.next(flexGrow);
+    }
+    /**
+     * @internal
+     */
+    get flexGrow() {
+        return this._flexGrow$.value;
+    }
+    constructor(sashTemplate, _sashBoxAccessor) {
+        this.sashTemplate = sashTemplate;
+        this._sashBoxAccessor = _sashBoxAccessor;
+        this._size = '1';
+        this._flexGrow$ = new BehaviorSubject(0);
+        this.flexGrowNormalized$ = this._sashBoxAccessor.sashes$
+            .pipe(switchMap(sashes => merge(...sashes.map(sash => sash._flexGrow$))), map(() => this.normalizeFlexGrow(this.flexGrow)));
+    }
+    ngOnInit() {
+        this.setFlexItemProperties();
+    }
+    ngOnChanges(changes) {
+        this.setFlexItemProperties();
+    }
+    /**
+     * Returns if this sash has a fixed size, meaning that it has not the ability to grow or shrink if necessary.
+     *
+     * @internal
+     */
+    get isFixedSize() {
+        return Number.isNaN(+this.size);
+    }
+    /**
+     * Returns the effective sash size as rendered in the DOM.
+     *
+     * @internal
+     */
+    get computedSize() {
+        // Note: Use `boundingClientRect` to get the fractional size.
+        // see https://developer.mozilla.org/en-US/docs/Web/API/Element/clientWidth
+        return this._sashBoxAccessor.direction === 'row' ? this.element.getBoundingClientRect().width : this.element.getBoundingClientRect().height;
+    }
+    /**
+     * Computes and sets the flex item properties based on the modelled size.
+     */
+    setFlexItemProperties() {
+        if (this.isFixedSize) {
+            // fixed-sized sash
+            this.flexGrow = 0;
+            this.flexShrink = 0;
+            this.flexBasis = `${this.size}`;
+        }
+        else {
+            // remaining space is distributed according to given proportion
+            const proportion = +this.size;
+            if (proportion < 1) {
+                throw Error(`[IllegalSashSizeError] The proportion for flexible sized sashes must be >=1 [size=${this.size}]`);
+            }
+            this.flexGrow = proportion;
+            this.flexShrink = 1;
+            this.flexBasis = '0';
+        }
+    }
+    /**
+     * Computes the normalized flex-grow proportion of the given sash, which is a value >= 1.
+     *
+     * If the sum of all flex-grow proportions would be less than 1, then, the sashes would not fill the entire sash-box space.
+     * Without normalization in place, e.g., this could happen when removing a sash.
+     */
+    normalizeFlexGrow(flexGrow) {
+        if (flexGrow === 0) {
+            return 0;
+        }
+        const sashes = this._sashBoxAccessor.sashes;
+        const flexGrowSum = sashes.reduce((sum, sash) => sum + sash.flexGrow, 0);
+        if (flexGrowSum === 0) {
+            return 0;
+        }
+        return flexGrow / flexGrowSum;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciSashDirective, deps: [{ token: i0.TemplateRef }, { token: i1.SciSashBoxAccessor }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: SciSashDirective, selector: "ng-template[sciSash]", inputs: { size: "size", minSize: "minSize" }, exportAs: ["sciSash"], usesOnChanges: true, ngImport: i0 }); }
+}
+export { SciSashDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciSashDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[sciSash]',
+                    exportAs: 'sciSash',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i1.SciSashBoxAccessor }]; }, propDecorators: { size: [{
+                type: Input
+            }], minSize: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sash.directive.js","sourceRoot":"","sources":["../../../../../projects/scion/components/sashbox/src/sash.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2019 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n *  SPDX-License-Identifier: EPL-2.0\n */\n\nimport {Directive, Input, OnChanges, OnInit, SimpleChanges, TemplateRef} from '@angular/core';\nimport {SciSashBoxAccessor} from './sashbox-accessor';\nimport {BehaviorSubject, merge, Observable} from 'rxjs';\nimport {map, switchMap} from 'rxjs/operators';\n\n/**\n * Use this directive to model a sash for {@link SciSashboxComponent}.\n * The host element of this modelling directive must be a <ng-template> which is used as sash template.\n *\n *\n * ### Usage:\n *\n * <sci-sashbox direction=\"row\">\n *   <!-- fixed size sash -->\n *   <ng-template sciSash size=\"200px\">\n *     ...\n *   </ng-template>\n *\n *   <!-- sash which takes the remaining space -->\n *   <ng-template sciSash>\n *     ...\n *   </ng-template>\n * </sci-sashbox>\n */\n@Directive({\n  selector: 'ng-template[sciSash]',\n  exportAs: 'sciSash',\n})\nexport class SciSashDirective implements OnInit, OnChanges {\n\n  private _size: string | number = '1';\n  private _flexGrow$ = new BehaviorSubject<number>(0);\n\n  /**\n   * Specifies the sash size, either as fixed size with an explicit unit,\n   * or as a unitless proportion to distibute remaining space. A proportional\n   * sash has the ability to grow or shrink if necessary, and must be >= 1.\n   *\n   * If not set, remaining space is distributed equally.\n   */\n  @Input()\n  public set size(size: string | number | null | undefined) {\n    this._size = size ?? '1';\n  }\n\n  public get size(): string | number {\n    return this._size;\n  }\n\n  /**\n   * Specifies the minimal sash size in pixel or percent.\n   * The min-size prevents the user from shrinking the sash below this minimal size.\n   *\n   * If the unit is omitted, the value is interpreted as a pixel value.\n   */\n  @Input()\n  public minSize?: string | number;\n\n  /**\n   * @internal\n   */\n  public element!: HTMLElement;\n\n  /**\n   * @internal\n   */\n  public set flexGrow(flexGrow: number) {\n    this._flexGrow$.next(flexGrow);\n  }\n\n  /**\n   * @internal\n   */\n  public get flexGrow(): number {\n    return this._flexGrow$.value;\n  }\n\n  /**\n   * @internal\n   */\n  public flexShrink!: number;\n\n  /**\n   * @internal\n   */\n  public flexBasis!: string;\n\n  /**\n   * Normalized flex-grow proportion of this sash, which is a value >= 1.\n   *\n   * @internal\n   */\n  public flexGrowNormalized$: Observable<number>;\n\n  constructor(public readonly sashTemplate: TemplateRef<void>, private _sashBoxAccessor: SciSashBoxAccessor) {\n    this.flexGrowNormalized$ = this._sashBoxAccessor.sashes$\n      .pipe(\n        switchMap(sashes => merge(...sashes.map(sash => sash._flexGrow$))),\n        map(() => this.normalizeFlexGrow(this.flexGrow)),\n      );\n  }\n\n  public ngOnInit(): void {\n    this.setFlexItemProperties();\n  }\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    this.setFlexItemProperties();\n  }\n\n  /**\n   * Returns if this sash has a fixed size, meaning that it has not the ability to grow or shrink if necessary.\n   *\n   * @internal\n   */\n  public get isFixedSize(): boolean {\n    return Number.isNaN(+this.size);\n  }\n\n  /**\n   * Returns the effective sash size as rendered in the DOM.\n   *\n   * @internal\n   */\n  public get computedSize(): number {\n    // Note: Use `boundingClientRect` to get the fractional size.\n    // see https://developer.mozilla.org/en-US/docs/Web/API/Element/clientWidth\n    return this._sashBoxAccessor.direction === 'row' ? this.element.getBoundingClientRect().width : this.element.getBoundingClientRect().height;\n  }\n\n  /**\n   * Computes and sets the flex item properties based on the modelled size.\n   */\n  private setFlexItemProperties(): void {\n    if (this.isFixedSize) {\n      // fixed-sized sash\n      this.flexGrow = 0;\n      this.flexShrink = 0;\n      this.flexBasis = `${this.size}`;\n    }\n    else {\n      // remaining space is distributed according to given proportion\n      const proportion = +this.size;\n      if (proportion < 1) {\n        throw Error(`[IllegalSashSizeError] The proportion for flexible sized sashes must be >=1 [size=${this.size}]`);\n      }\n\n      this.flexGrow = proportion;\n      this.flexShrink = 1;\n      this.flexBasis = '0';\n    }\n  }\n\n  /**\n   * Computes the normalized flex-grow proportion of the given sash, which is a value >= 1.\n   *\n   * If the sum of all flex-grow proportions would be less than 1, then, the sashes would not fill the entire sash-box space.\n   * Without normalization in place, e.g., this could happen when removing a sash.\n   */\n  private normalizeFlexGrow(flexGrow: number): number {\n    if (flexGrow === 0) {\n      return 0;\n    }\n\n    const sashes = this._sashBoxAccessor.sashes;\n    const flexGrowSum = sashes.reduce((sum, sash) => sum + sash.flexGrow, 0);\n    if (flexGrowSum === 0) {\n      return 0;\n    }\n    return flexGrow / flexGrowSum;\n  }\n}\n"]}