@scion/components 15.0.2 → 16.1.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, true, never>;
 }
 /**
  * Represents the dimension of an element.
  */
-export declare type SciDimension = Dimension;
+export type SciDimension = Dimension;

package/dimension/dimension.module.d.ts

@@ -1,6 +1,5 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./dimension.directive";
-import * as i2 from "@angular/common";
 /**
  * Provides a directive for observing changes to the size of the host element.
  *
@@ -8,6 +7,6 @@ import * as i2 from "@angular/common";
  */
 export declare class SciDimensionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<SciDimensionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<SciDimensionModule, [typeof i1.SciDimensionDirective], [typeof i2.CommonModule], [typeof i1.SciDimensionDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SciDimensionModule, never, [typeof i1.SciDimensionDirective], [typeof i1.SciDimensionDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<SciDimensionModule>;
 }

package/esm2022/dimension/dimension.directive.mjs

@@ -0,0 +1,85 @@
+/*
+ * 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, isStandalone: true, 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',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { dimensionChange: [{
+                type: Output,
+                args: ['sciDimensionChange']
+            }], emitOutsideAngular: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGltZW5zaW9uLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NjaW9uL2NvbXBvbmVudHMvZGltZW5zaW9uL3NyYy9kaW1lbnNpb24uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsT0FBTyxFQUFDLFNBQVMsRUFBYyxZQUFZLEVBQUUsS0FBSyxFQUE2QixNQUFNLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDNUcsT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUM3QixPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDekMsT0FBTyxFQUFDLHVCQUF1QixFQUFhLGNBQWMsRUFBQyxNQUFNLDJCQUEyQixDQUFDOztBQUU3Rjs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUthLHFCQUFxQjtJQW9CaEMsWUFBWSxJQUE2QixFQUFVLE9BQWU7UUFBZixZQUFPLEdBQVAsT0FBTyxDQUFRO1FBakIxRCxjQUFTLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztRQUV4Qzs7V0FFRztRQUVJLG9CQUFlLEdBQUcsSUFBSSxZQUFZLEVBQWdCLENBQUM7UUFFMUQ7Ozs7O1dBS0c7UUFFSSx1QkFBa0IsR0FBRyxLQUFLLENBQUM7UUFHaEMsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDO0lBQ2xDLENBQUM7SUFFTSxRQUFRO1FBQ2IsSUFBSSxDQUFDLHdCQUF3QixFQUFFLENBQUM7SUFDbEMsQ0FBQztJQUVPLHdCQUF3QjtRQUM5QixJQUFJLENBQUMsT0FBTyxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRTtZQUNsQyxjQUFjLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztpQkFDdkIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7aUJBQy9CLFNBQVMsQ0FBQyxDQUFDLFNBQXVCLEVBQUUsRUFBRTtnQkFDckMsSUFBSSxJQUFJLENBQUMsa0JBQWtCLEVBQUU7b0JBQzNCLElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO2lCQUN0QztxQkFDSTtvQkFDSCxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO2lCQUM5RDtZQUNILENBQUMsQ0FBQyxDQUFDO1FBQ1AsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFXLFNBQVM7UUFDbEIsT0FBTyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDN0MsQ0FBQztJQUVNLFdBQVc7UUFDaEIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN4QixDQUFDOzhHQXBEVSxxQkFBcUI7a0dBQXJCLHFCQUFxQjs7U0FBckIscUJBQXFCOzJGQUFyQixxQkFBcUI7a0JBTGpDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsUUFBUSxFQUFFLGNBQWM7b0JBQ3hCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQjtzSEFVUSxlQUFlO3NCQURyQixNQUFNO3VCQUFDLG9CQUFvQjtnQkFVckIsa0JBQWtCO3NCQUR4QixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxOC0yMDE5IFN3aXNzIEZlZGVyYWwgUmFpbHdheXNcbiAqXG4gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlXG4gKiBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIDIuMFxuICogd2hpY2ggaXMgYXZhaWxhYmxlIGF0IGh0dHBzOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC0yLjAvXG4gKlxuICogIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBFUEwtMi4wXG4gKi9cblxuaW1wb3J0IHtEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEV2ZW50RW1pdHRlciwgSW5wdXQsIE5nWm9uZSwgT25EZXN0cm95LCBPbkluaXQsIE91dHB1dH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1N1YmplY3R9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHt0YWtlVW50aWx9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7Y2FwdHVyZUVsZW1lbnREaW1lbnNpb24sIERpbWVuc2lvbiwgZnJvbURpbWVuc2lvbiR9IGZyb20gJ0BzY2lvbi90b29sa2l0L29ic2VydmFibGUnO1xuXG4vKipcbiAqIEFsbG93cyBvYnNlcnZpbmcgY2hhbmdlcyB0byBob3N0IGVsZW1lbnQncyBzaXplLlxuICpcbiAqIFNlZSB7QGxpbmsgZnJvbURpbWVuc2lvbiR9IE9ic2VydmFibGUgZm9yIG1vcmUgaW5mb3JtYXRpb24uXG4gKlxuICogLS0tXG4gKiBVc2FnZTpcbiAqXG4gKiA8ZGl2IHNjaURpbWVuc2lvbiAoc2NpRGltZW5zaW9uQ2hhbmdlKT1cIm9uRGltZW5zaW9uQ2hhbmdlKCRldmVudClcIj48L2Rpdj5cbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3NjaURpbWVuc2lvbl0nLFxuICBleHBvcnRBczogJ3NjaURpbWVuc2lvbicsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIFNjaURpbWVuc2lvbkRpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcblxuICBwcml2YXRlIHJlYWRvbmx5IF9ob3N0OiBIVE1MRWxlbWVudDtcbiAgcHJpdmF0ZSBfZGVzdHJveSQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuXG4gIC8qKlxuICAgKiBVcG9uIHN1YnNjcmlwdGlvbiwgaXQgZW1pdHMgdGhlIGhvc3QgZWxlbWVudCdzIGRpbWVuc2lvbiwgYW5kIHRoZW4gY29udGludW91c2x5IGVtaXRzIHdoZW4gdGhlIGRpbWVuc2lvbiBvZiB0aGUgaG9zdCBlbGVtZW50IGNoYW5nZXMuXG4gICAqL1xuICBAT3V0cHV0KCdzY2lEaW1lbnNpb25DaGFuZ2UnKSAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIEBhbmd1bGFyLWVzbGludC9uby1vdXRwdXQtcmVuYW1lXG4gIHB1YmxpYyBkaW1lbnNpb25DaGFuZ2UgPSBuZXcgRXZlbnRFbWl0dGVyPFNjaURpbWVuc2lvbj4oKTtcblxuICAvKipcbiAgICogQ29udHJvbHMgaWYgdG8gZW1pdCBhIGRpbWVuc2lvbiBjaGFuZ2UgaW5zaWRlIG9yIG91dHNpZGUgb2YgdGhlIEFuZ3VsYXIgem9uZS5cbiAgICogSWYgZW1pdHRlZCBvdXRzaWRlIG9mIHRoZSBBbmd1bGFyIHpvbmUgbm8gY2hhbmdlIGRldGVjdGlvbiBjeWNsZSBpcyB0cmlnZ2VyZWQuXG4gICAqXG4gICAqIEJ5IGRlZmF1bHQsIGlmIG5vdCBzcGVjaWZpZWQsIGVtaXRzIGluc2lkZSB0aGUgQW5ndWxhciB6b25lLlxuICAgKi9cbiAgQElucHV0KClcbiAgcHVibGljIGVtaXRPdXRzaWRlQW5ndWxhciA9IGZhbHNlO1xuXG4gIGNvbnN0cnVjdG9yKGhvc3Q6IEVsZW1lbnRSZWY8SFRNTEVsZW1lbnQ+LCBwcml2YXRlIF9uZ1pvbmU6IE5nWm9uZSkge1xuICAgIHRoaXMuX2hvc3QgPSBob3N0Lm5hdGl2ZUVsZW1lbnQ7XG4gIH1cblxuICBwdWJsaWMgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgdGhpcy5pbnN0YWxsRGltZW5zaW9uTGlzdGVuZXIoKTtcbiAgfVxuXG4gIHByaXZhdGUgaW5zdGFsbERpbWVuc2lvbkxpc3RlbmVyKCk6IHZvaWQge1xuICAgIHRoaXMuX25nWm9uZS5ydW5PdXRzaWRlQW5ndWxhcigoKSA9PiB7XG4gICAgICBmcm9tRGltZW5zaW9uJCh0aGlzLl9ob3N0KVxuICAgICAgICAucGlwZSh0YWtlVW50aWwodGhpcy5fZGVzdHJveSQpKVxuICAgICAgICAuc3Vic2NyaWJlKChkaW1lbnNpb246IFNjaURpbWVuc2lvbikgPT4ge1xuICAgICAgICAgIGlmICh0aGlzLmVtaXRPdXRzaWRlQW5ndWxhcikge1xuICAgICAgICAgICAgdGhpcy5kaW1lbnNpb25DaGFuZ2UuZW1pdChkaW1lbnNpb24pO1xuICAgICAgICAgIH1cbiAgICAgICAgICBlbHNlIHtcbiAgICAgICAgICAgIHRoaXMuX25nWm9uZS5ydW4oKCkgPT4gdGhpcy5kaW1lbnNpb25DaGFuZ2UuZW1pdChkaW1lbnNpb24pKTtcbiAgICAgICAgICB9XG4gICAgICAgIH0pO1xuICAgIH0pO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgdGhlIGN1cnJlbnQgZGltZW5zaW9uIG9mIGl0cyBob3N0IGVsZW1lbnQuXG4gICAqL1xuICBwdWJsaWMgZ2V0IGRpbWVuc2lvbigpOiBTY2lEaW1lbnNpb24ge1xuICAgIHJldHVybiBjYXB0dXJlRWxlbWVudERpbWVuc2lvbih0aGlzLl9ob3N0KTtcbiAgfVxuXG4gIHB1YmxpYyBuZ09uRGVzdHJveSgpOiB2b2lkIHtcbiAgICB0aGlzLl9kZXN0cm95JC5uZXh0KCk7XG4gIH1cbn1cblxuLyoqXG4gKiBSZXByZXNlbnRzIHRoZSBkaW1lbnNpb24gb2YgYW4gZWxlbWVudC5cbiAqL1xuZXhwb3J0IHR5cGUgU2NpRGltZW5zaW9uID0gRGltZW5zaW9uO1xuIl19

package/esm2022/dimension/dimension.module.mjs

@@ -0,0 +1,35 @@
+/*
+ * 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 { 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, imports: [SciDimensionDirective], exports: [SciDimensionDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionModule }); }
+}
+export { SciDimensionModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SciDimensionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        SciDimensionDirective,
+                    ],
+                    exports: [
+                        SciDimensionDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGltZW5zaW9uLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NjaW9uL2NvbXBvbmVudHMvZGltZW5zaW9uL3NyYy9kaW1lbnNpb24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMscUJBQXFCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQzs7QUFFNUQ7Ozs7R0FJRztBQUNILE1BUWEsa0JBQWtCOzhHQUFsQixrQkFBa0I7K0dBQWxCLGtCQUFrQixZQU4zQixxQkFBcUIsYUFHckIscUJBQXFCOytHQUdaLGtCQUFrQjs7U0FBbEIsa0JBQWtCOzJGQUFsQixrQkFBa0I7a0JBUjlCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLHFCQUFxQjtxQkFDdEI7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLHFCQUFxQjtxQkFDdEI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDE4LTIwMTkgU3dpc3MgRmVkZXJhbCBSYWlsd2F5c1xuICpcbiAqIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgYXJlIG1hZGVcbiAqIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgMi4wXG4gKiB3aGljaCBpcyBhdmFpbGFibGUgYXQgaHR0cHM6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLTIuMC9cbiAqXG4gKiAgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEVQTC0yLjBcbiAqL1xuXG5pbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7U2NpRGltZW5zaW9uRGlyZWN0aXZlfSBmcm9tICcuL2RpbWVuc2lvbi5kaXJlY3RpdmUnO1xuXG4vKipcbiAqIFByb3ZpZGVzIGEgZGlyZWN0aXZlIGZvciBvYnNlcnZpbmcgY2hhbmdlcyB0byB0aGUgc2l6ZSBvZiB0aGUgaG9zdCBlbGVtZW50LlxuICpcbiAqIEBzZWUgZnJvbURpbWVuc2lvbiRcbiAqL1xuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIFNjaURpbWVuc2lvbkRpcmVjdGl2ZSxcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFNjaURpbWVuc2lvbkRpcmVjdGl2ZSxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgU2NpRGltZW5zaW9uTW9kdWxlIHtcbn1cbiJdfQ==

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

@@ -0,0 +1,32 @@
+/*
+ * 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, isStandalone: true, 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',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1yZWYuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2Npb24vY29tcG9uZW50cy9zYXNoYm94L3NyYy9lbGVtZW50LXJlZi5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFFSCxPQUFPLEVBQUMsU0FBUyxFQUFhLE1BQU0sZUFBZSxDQUFDOztBQUVwRDs7R0FFRztBQUNILE1BS2Esc0JBQXNCO0lBSWpDLFlBQW1CLElBQTZCO1FBQTdCLFNBQUksR0FBSixJQUFJLENBQXlCO1FBQzlDLElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQztJQUMxQyxDQUFDOzhHQU5VLHNCQUFzQjtrR0FBdEIsc0JBQXNCOztTQUF0QixzQkFBc0I7MkZBQXRCLHNCQUFzQjtrQkFMbEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsaUJBQWlCO29CQUMzQixRQUFRLEVBQUUsZUFBZTtvQkFDekIsVUFBVSxFQUFFLElBQUk7aUJBQ2pCIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxOC0yMDE5IFN3aXNzIEZlZGVyYWwgUmFpbHdheXNcbiAqXG4gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlXG4gKiBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIDIuMFxuICogd2hpY2ggaXMgYXZhaWxhYmxlIGF0IGh0dHBzOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC0yLjAvXG4gKlxuICogIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBFUEwtMi4wXG4gKi9cblxuaW1wb3J0IHtEaXJlY3RpdmUsIEVsZW1lbnRSZWZ9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFByb3ZpZGVzIGFjY2VzcyB0byB0aGUgbmF0aXZlIHtAbGluayBIVE1MRWxlbWVudH0gb2YgdGhlIGhvc3QuXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tzY2lFbGVtZW50UmVmXScsXG4gIGV4cG9ydEFzOiAnc2NpRWxlbWVudFJlZicsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIFNjaUVsZW1lbnRSZWZEaXJlY3RpdmUge1xuXG4gIHB1YmxpYyByZWFkb25seSBuYXRpdmVFbGVtZW50OiBIVE1MRWxlbWVudDtcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgaG9zdDogRWxlbWVudFJlZjxIVE1MRWxlbWVudD4pIHtcbiAgICB0aGlzLm5hdGl2ZUVsZW1lbnQgPSBob3N0Lm5hdGl2ZUVsZW1lbnQ7XG4gIH1cbn1cbiJdfQ==

package/esm2022/sashbox/public_api.mjs

@@ -0,0 +1,18 @@
+/*
+ * 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
+ */
+/*
+ * Secondary entrypoint: '@scion/components/sashbox'
+ *
+ * @see https://github.com/ng-packagr/ng-packagr/blob/master/docs/secondary-entrypoints.md
+ */
+export { SciSashboxModule } from './sashbox.module';
+export { SciSashboxComponent } from './sashbox.component';
+export { SciSashDirective } from './sash.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NjaW9uL2NvbXBvbmVudHMvc2FzaGJveC9zcmMvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRztBQUVIOzs7O0dBSUc7QUFDSCxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQztBQUNsRCxPQUFPLEVBQUMsbUJBQW1CLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUN4RCxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtMjAxOSBTd2lzcyBGZWRlcmFsIFJhaWx3YXlzXG4gKlxuICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZVxuICogYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSAyLjBcbiAqIHdoaWNoIGlzIGF2YWlsYWJsZSBhdCBodHRwczovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtMi4wL1xuICpcbiAqICBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogRVBMLTIuMFxuICovXG5cbi8qXG4gKiBTZWNvbmRhcnkgZW50cnlwb2ludDogJ0BzY2lvbi9jb21wb25lbnRzL3Nhc2hib3gnXG4gKlxuICogQHNlZSBodHRwczovL2dpdGh1Yi5jb20vbmctcGFja2Fnci9uZy1wYWNrYWdyL2Jsb2IvbWFzdGVyL2RvY3Mvc2Vjb25kYXJ5LWVudHJ5cG9pbnRzLm1kXG4gKi9cbmV4cG9ydCB7U2NpU2FzaGJveE1vZHVsZX0gZnJvbSAnLi9zYXNoYm94Lm1vZHVsZSc7XG5leHBvcnQge1NjaVNhc2hib3hDb21wb25lbnR9IGZyb20gJy4vc2FzaGJveC5jb21wb25lbnQnO1xuZXhwb3J0IHtTY2lTYXNoRGlyZWN0aXZlfSBmcm9tICcuL3Nhc2guZGlyZWN0aXZlJztcbiJdfQ==

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

@@ -0,0 +1,36 @@
+/*
+ * 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, isStandalone: true, 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',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { sash: [{
+                type: Input,
+                args: [{ alias: 'sciSashInitializer', required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FzaC1pbml0aWFsaXplci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zY2lvbi9jb21wb25lbnRzL3Nhc2hib3gvc3JjL3Nhc2gtaW5pdGlhbGl6ZXIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsT0FBTyxFQUFDLFNBQVMsRUFBYyxLQUFLLEVBQTJCLE1BQU0sZUFBZSxDQUFDOztBQUdyRjs7R0FFRztBQUNILE1BSWEsMkJBQTJCO0lBS3RDLFlBQW9CLEtBQWlDO1FBQWpDLFVBQUssR0FBTCxLQUFLLENBQTRCO0lBQ3JELENBQUM7SUFFTSxXQUFXLENBQUMsT0FBc0I7UUFDdkMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUM7SUFDL0MsQ0FBQzs4R0FWVSwyQkFBMkI7a0dBQTNCLDJCQUEyQjs7U0FBM0IsMkJBQTJCOzJGQUEzQiwyQkFBMkI7a0JBSnZDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLDhCQUE4QjtvQkFDeEMsVUFBVSxFQUFFLElBQUk7aUJBQ2pCO2lHQUlRLElBQUk7c0JBRFYsS0FBSzt1QkFBQyxFQUFDLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxOC0yMDE5IFN3aXNzIEZlZGVyYWwgUmFpbHdheXNcbiAqXG4gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlXG4gKiBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIDIuMFxuICogd2hpY2ggaXMgYXZhaWxhYmxlIGF0IGh0dHBzOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC0yLjAvXG4gKlxuICogIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBFUEwtMi4wXG4gKi9cblxuaW1wb3J0IHtEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIElucHV0LCBPbkNoYW5nZXMsIFNpbXBsZUNoYW5nZXN9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtTY2lTYXNoRGlyZWN0aXZlfSBmcm9tICcuL3Nhc2guZGlyZWN0aXZlJztcblxuLyoqXG4gKiBJbml0aWFsaXplcyB7U2FzaERpcmVjdGl2ZX0gd2l0aCB0aGUgdGFyZ2V0IHtIVE1MRGl2RWxlbWVudH0uXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ2RpdltzY2lTYXNoSW5pdGlhbGl6ZXJdLnNhc2gnLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBTY2lTYXNoSW5pdGlhbGl6ZXJEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkNoYW5nZXMge1xuXG4gIEBJbnB1dCh7YWxpYXM6ICdzY2lTYXNoSW5pdGlhbGl6ZXInLCByZXF1aXJlZDogdHJ1ZX0pXG4gIHB1YmxpYyBzYXNoITogU2NpU2FzaERpcmVjdGl2ZTtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIF9ob3N0OiBFbGVtZW50UmVmPEhUTUxEaXZFbGVtZW50Pikge1xuICB9XG5cbiAgcHVibGljIG5nT25DaGFuZ2VzKGNoYW5nZXM6IFNpbXBsZUNoYW5nZXMpOiB2b2lkIHtcbiAgICB0aGlzLnNhc2guZWxlbWVudCA9IHRoaXMuX2hvc3QubmF0aXZlRWxlbWVudDtcbiAgfVxufVxuIl19

package/esm2022/sashbox/sash.directive.mjs

@@ -0,0 +1,146 @@
+/*
+ * 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, isStandalone: true, 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',
+                    standalone: true,
+                }]
+        }], 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  standalone: true,\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 | undefined;\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"]}