@koobiq/components 16.0.0-beta.1

package/esm2022/sidepanel/sidepanel-directives.mjs

@@ -0,0 +1,167 @@
+import { Component, Directive, ElementRef, Input, Optional } from '@angular/core';
+import { ThemePalette } from '@koobiq/components/core';
+import { KbqSidepanelRef } from './sidepanel-ref';
+import { KbqSidepanelService } from './sidepanel.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./sidepanel-ref";
+import * as i2 from "./sidepanel.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@koobiq/components/button";
+import * as i5 from "@koobiq/components/icon";
+import * as i6 from "@koobiq/components/title";
+/**
+ * Button that will close the current sidepanel.
+ */
+export class KbqSidepanelClose {
+    constructor(sidepanelRef, elementRef, sidepanelService) {
+        this.sidepanelRef = sidepanelRef;
+        this.elementRef = elementRef;
+        this.sidepanelService = sidepanelService;
+    }
+    ngOnInit() {
+        if (!this.sidepanelRef) {
+            // When this directive is included in a sidepanel via TemplateRef (rather than being
+            // in a Component), the SidepanelRef isn't available via injection because embedded
+            // views cannot be given a custom injector. Instead, we look up the SidepanelRef by
+            // ID.
+            // This must occur in `onInit`, as the ID binding for the sidepanel container won't
+            // be resolved at constructor time. We use setTimeout by same reason.
+            setTimeout(() => {
+                this.sidepanelRef = getClosestSidepanel(this.elementRef, this.sidepanelService.openedSidepanels);
+            });
+        }
+    }
+    ngOnChanges(changes) {
+        const proxiedChange = changes.mcSidepanelClose || changes.sidepanelResult;
+        if (proxiedChange) {
+            this.sidepanelResult = proxiedChange.currentValue;
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelClose, deps: [{ token: i1.KbqSidepanelRef, optional: true }, { token: i0.ElementRef }, { token: i2.KbqSidepanelService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: KbqSidepanelClose, selector: "button[kbq-sidepanel-close], button[mcSidepanelClose]", inputs: { sidepanelResult: ["kbq-sidepanel-close", "sidepanelResult"], mcSidepanelClose: "mcSidepanelClose" }, host: { listeners: { "click": "sidepanelRef.close(sidepanelResult)" }, classAttribute: "kbq-sidepanel-close" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelClose, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[kbq-sidepanel-close], button[mcSidepanelClose]',
+                    host: {
+                        '(click)': 'sidepanelRef.close(sidepanelResult)',
+                        class: 'kbq-sidepanel-close'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.KbqSidepanelRef, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ElementRef }, { type: i2.KbqSidepanelService }]; }, propDecorators: { sidepanelResult: [{
+                type: Input,
+                args: ['kbq-sidepanel-close']
+            }], mcSidepanelClose: [{
+                type: Input,
+                args: ['mcSidepanelClose']
+            }] } });
+/**
+ * Header of a sidepanel.
+ */
+export class KbqSidepanelHeader {
+    constructor() {
+        this.themePalette = ThemePalette;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelHeader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.5", type: KbqSidepanelHeader, selector: "kbq-sidepanel-header", inputs: { closeable: "closeable" }, host: { classAttribute: "kbq-sidepanel-header" }, ngImport: i0, template: `
+        <div class="kbq-sidepanel-title" kbq-title>
+            <ng-content></ng-content>
+        </div>
+
+        <button *ngIf="closeable"
+                kbq-button
+                kbq-sidepanel-close
+                class="kbq-button_transparent">
+            <i kbq-icon="mc-close-L_16" class="kbq-icon kbq-icon_light" [color]="themePalette.Secondary"></i>
+        </button>
+    `, isInline: true, dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.KbqButton, selector: "[kbq-button]", inputs: ["color", "tabIndex", "kbqStyle", "disabled"] }, { kind: "directive", type: i4.KbqButtonCssStyler, selector: "[kbq-button]" }, { kind: "component", type: i5.KbqIcon, selector: "[kbq-icon]", inputs: ["color", "small", "autoColor"] }, { kind: "directive", type: i6.KbqTitleDirective, selector: "[kbq-title]", exportAs: ["mcTitle"] }, { kind: "directive", type: KbqSidepanelClose, selector: "button[kbq-sidepanel-close], button[mcSidepanelClose]", inputs: ["kbq-sidepanel-close", "mcSidepanelClose"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelHeader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kbq-sidepanel-header',
+                    template: `
+        <div class="kbq-sidepanel-title" kbq-title>
+            <ng-content></ng-content>
+        </div>
+
+        <button *ngIf="closeable"
+                kbq-button
+                kbq-sidepanel-close
+                class="kbq-button_transparent">
+            <i kbq-icon="mc-close-L_16" class="kbq-icon kbq-icon_light" [color]="themePalette.Secondary"></i>
+        </button>
+    `,
+                    host: {
+                        class: 'kbq-sidepanel-header'
+                    }
+                }]
+        }], propDecorators: { closeable: [{
+                type: Input
+            }] } });
+/**
+ * Scrollable content container of a sidepanel.
+ */
+export class KbqSidepanelBody {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelBody, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: KbqSidepanelBody, selector: "kbq-sidepanel-body, [kbq-sidepanel-body], mcSidepanelBody", host: { classAttribute: "kbq-sidepanel-body kbq-scrollbar" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelBody, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'kbq-sidepanel-body, [kbq-sidepanel-body], mcSidepanelBody',
+                    host: {
+                        class: 'kbq-sidepanel-body kbq-scrollbar'
+                    }
+                }]
+        }] });
+/**
+ * Footer of a sidepanel.
+ */
+export class KbqSidepanelFooter {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelFooter, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: KbqSidepanelFooter, selector: "kbq-sidepanel-footer, [kbq-sidepanel-footer], mcSidepanelFooter", host: { classAttribute: "kbq-sidepanel-footer" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelFooter, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'kbq-sidepanel-footer, [kbq-sidepanel-footer], mcSidepanelFooter',
+                    host: {
+                        class: 'kbq-sidepanel-footer'
+                    }
+                }]
+        }] });
+/**
+ * Actions block of a sidepanel footer.
+ */
+export class KbqSidepanelActions {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelActions, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: KbqSidepanelActions, selector: "kbq-sidepanel-actions, [kbq-sidepanel-actions], mcSidepanelActions", host: { classAttribute: "kbq-sidepanel-actions" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelActions, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'kbq-sidepanel-actions, [kbq-sidepanel-actions], mcSidepanelActions',
+                    host: {
+                        class: 'kbq-sidepanel-actions'
+                    }
+                }]
+        }] });
+/**
+ * Finds the closest KbqSidepanelRef to an element by looking at the DOM.
+ * @param element Element relative to which to look for a sidepanel.
+ * @param openSidepanels References to the currently-open sidepanels.
+ */
+function getClosestSidepanel(element, openSidepanels) {
+    let parent = element.nativeElement.parentElement;
+    while (parent && !parent.classList.contains('kbq-sidepanel-container')) {
+        parent = parent.parentElement;
+    }
+    return parent ?
+        openSidepanels.find((sidepanel) => sidepanel.id === parent.id) :
+        null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sidepanel-directives.js","sourceRoot":"","sources":["../../../../packages/components/sidepanel/sidepanel-directives.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    Directive,\n    ElementRef,\n    Input,\n    OnChanges,\n    OnInit,\n    Optional,\n    SimpleChanges\n} from '@angular/core';\nimport { ThemePalette } from '@koobiq/components/core';\n\nimport { KbqSidepanelRef } from './sidepanel-ref';\nimport { KbqSidepanelService } from './sidepanel.service';\n\n\n/**\n * Button that will close the current sidepanel.\n */\n@Directive({\n    selector: 'button[kbq-sidepanel-close], button[mcSidepanelClose]',\n    host: {\n        '(click)': 'sidepanelRef.close(sidepanelResult)',\n        class: 'kbq-sidepanel-close'\n    }\n})\nexport class KbqSidepanelClose implements OnInit, OnChanges {\n    @Input('kbq-sidepanel-close') sidepanelResult: any;\n\n    @Input('mcSidepanelClose') mcSidepanelClose: any;\n\n    constructor(\n        @Optional() public sidepanelRef: KbqSidepanelRef,\n        private elementRef: ElementRef<HTMLElement>,\n        private sidepanelService: KbqSidepanelService\n    ) {}\n\n    ngOnInit() {\n        if (!this.sidepanelRef) {\n            // When this directive is included in a sidepanel via TemplateRef (rather than being\n            // in a Component), the SidepanelRef isn't available via injection because embedded\n            // views cannot be given a custom injector. Instead, we look up the SidepanelRef by\n            // ID.\n            // This must occur in `onInit`, as the ID binding for the sidepanel container won't\n            // be resolved at constructor time. We use setTimeout by same reason.\n            setTimeout(() => {\n                this.sidepanelRef = getClosestSidepanel(this.elementRef, this.sidepanelService.openedSidepanels)!;\n            });\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        const proxiedChange = changes.mcSidepanelClose || changes.sidepanelResult;\n\n        if (proxiedChange) {\n            this.sidepanelResult = proxiedChange.currentValue;\n        }\n    }\n}\n\n/**\n * Header of a sidepanel.\n */\n@Component({\n    selector: 'kbq-sidepanel-header',\n    template: `\n        <div class=\"kbq-sidepanel-title\" kbq-title>\n            <ng-content></ng-content>\n        </div>\n\n        <button *ngIf=\"closeable\"\n                kbq-button\n                kbq-sidepanel-close\n                class=\"kbq-button_transparent\">\n            <i kbq-icon=\"mc-close-L_16\" class=\"kbq-icon kbq-icon_light\" [color]=\"themePalette.Secondary\"></i>\n        </button>\n    `,\n    host: {\n        class: 'kbq-sidepanel-header'\n    }\n})\nexport class KbqSidepanelHeader {\n    themePalette = ThemePalette;\n\n    @Input() closeable: boolean;\n}\n\n/**\n * Scrollable content container of a sidepanel.\n */\n@Directive({\n    selector: 'kbq-sidepanel-body, [kbq-sidepanel-body], mcSidepanelBody',\n    host: {\n        class: 'kbq-sidepanel-body kbq-scrollbar'\n    }\n})\nexport class KbqSidepanelBody {}\n\n/**\n * Footer of a sidepanel.\n */\n@Directive({\n    selector: 'kbq-sidepanel-footer, [kbq-sidepanel-footer], mcSidepanelFooter',\n    host: {\n        class: 'kbq-sidepanel-footer'\n    }\n})\nexport class KbqSidepanelFooter {}\n\n/**\n * Actions block of a sidepanel footer.\n */\n@Directive({\n    selector: 'kbq-sidepanel-actions, [kbq-sidepanel-actions], mcSidepanelActions',\n    host: {\n        class: 'kbq-sidepanel-actions'\n    }\n})\nexport class KbqSidepanelActions {}\n\n/**\n * Finds the closest KbqSidepanelRef to an element by looking at the DOM.\n * @param element Element relative to which to look for a sidepanel.\n * @param openSidepanels References to the currently-open sidepanels.\n */\nfunction getClosestSidepanel(element: ElementRef<HTMLElement>, openSidepanels: KbqSidepanelRef[]) {\n    let parent: HTMLElement | null = element.nativeElement.parentElement;\n\n    while (parent && !parent.classList.contains('kbq-sidepanel-container')) {\n        parent = parent.parentElement;\n    }\n\n    return parent ?\n        openSidepanels.find((sidepanel) => sidepanel.id === parent!.id) :\n        null;\n}\n"]}

package/esm2022/sidepanel/sidepanel-ref.mjs

@@ -0,0 +1,53 @@
+import { ESCAPE } from '@koobiq/cdk/keycodes';
+import { merge, Subject } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { KbqSidepanelAnimationState } from './sidepanel-animations';
+// Counter for unique sidepanel ids.
+let uniqueId = 0;
+export class KbqSidepanelRef {
+    constructor(containerInstance, overlayRef, config) {
+        this.containerInstance = containerInstance;
+        this.overlayRef = overlayRef;
+        this.config = config;
+        /** Subject for notifying the user that the sidepanel has been closed and dismissed. */
+        this.afterClosed$ = new Subject();
+        /** Subject for notifying the user that the sidepanel has opened and appeared. */
+        this.afterOpened$ = new Subject();
+        this.id = this.config.id || `kbq-sidepanel-${uniqueId++}`;
+        this.containerInstance.id = this.id;
+        // Emit when opening animation completes
+        containerInstance.animationStateChanged.pipe(filter((event) => event.phaseName === 'done' && event.toState === KbqSidepanelAnimationState.Visible), take(1)).subscribe(() => {
+            this.afterOpened$.next();
+            this.afterOpened$.complete();
+        });
+        // Dispose overlay when closing animation is complete
+        containerInstance.animationStateChanged.pipe(filter((event) => event.phaseName === 'done' && event.toState === KbqSidepanelAnimationState.Hidden), take(1)).subscribe(() => {
+            overlayRef.dispose();
+            this.afterClosed$.next(this.result);
+            this.afterClosed$.complete();
+        });
+        if (!containerInstance.sidepanelConfig.disableClose) {
+            merge(overlayRef.backdropClick(), overlayRef.keydownEvents().pipe(
+            // tslint:disable:deprecation
+            // keyCode is deprecated, but IE11 and Edge don't support code property, which we need use instead
+            filter((event) => event.keyCode === ESCAPE))).subscribe(() => this.close());
+        }
+    }
+    close(result) {
+        if (!this.afterClosed$.closed) {
+            // Transition the backdrop in parallel to the sidepanel.
+            this.containerInstance.animationStateChanged.pipe(filter((event) => event.phaseName === 'done'), take(1)).subscribe(() => this.overlayRef.detachBackdrop());
+            this.result = result;
+            this.containerInstance.exit();
+        }
+    }
+    /** Gets an observable that is notified when the sidepanel is finished closing. */
+    afterClosed() {
+        return this.afterClosed$.asObservable();
+    }
+    /** Gets an observable that is notified when the sidepanel has opened and appeared. */
+    afterOpened() {
+        return this.afterOpened$.asObservable();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/sidepanel/sidepanel.module.mjs

@@ -0,0 +1,75 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { KbqButtonModule } from '@koobiq/components/button';
+import { KbqCommonModule } from '@koobiq/components/core';
+import { KbqIconModule } from '@koobiq/components/icon';
+import { KbqTitleModule } from '@koobiq/components/title';
+import { KbqSidepanelContainerComponent } from './sidepanel-container.component';
+import { KbqSidepanelActions, KbqSidepanelBody, KbqSidepanelClose, KbqSidepanelFooter, KbqSidepanelHeader } from './sidepanel-directives';
+import { KbqSidepanelService } from './sidepanel.service';
+import * as i0 from "@angular/core";
+export class KbqSidepanelModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelModule, declarations: [KbqSidepanelContainerComponent,
+            KbqSidepanelClose,
+            KbqSidepanelHeader,
+            KbqSidepanelBody,
+            KbqSidepanelFooter,
+            KbqSidepanelActions], imports: [CommonModule,
+            OverlayModule,
+            PortalModule,
+            KbqCommonModule,
+            KbqButtonModule,
+            KbqIconModule,
+            KbqTitleModule,
+            A11yModule], exports: [KbqSidepanelContainerComponent,
+            KbqSidepanelClose,
+            KbqSidepanelHeader,
+            KbqSidepanelBody,
+            KbqSidepanelFooter,
+            KbqSidepanelActions] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelModule, providers: [KbqSidepanelService], imports: [CommonModule,
+            OverlayModule,
+            PortalModule,
+            KbqCommonModule,
+            KbqButtonModule,
+            KbqIconModule,
+            KbqTitleModule,
+            A11yModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        OverlayModule,
+                        PortalModule,
+                        KbqCommonModule,
+                        KbqButtonModule,
+                        KbqIconModule,
+                        KbqTitleModule,
+                        A11yModule
+                    ],
+                    providers: [KbqSidepanelService],
+                    declarations: [
+                        KbqSidepanelContainerComponent,
+                        KbqSidepanelClose,
+                        KbqSidepanelHeader,
+                        KbqSidepanelBody,
+                        KbqSidepanelFooter,
+                        KbqSidepanelActions
+                    ],
+                    exports: [
+                        KbqSidepanelContainerComponent,
+                        KbqSidepanelClose,
+                        KbqSidepanelHeader,
+                        KbqSidepanelBody,
+                        KbqSidepanelFooter,
+                        KbqSidepanelActions
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/sidepanel/sidepanel.service.mjs

@@ -0,0 +1,171 @@
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, TemplateRef } from '@angular/core';
+import { KBQ_SIDEPANEL_DATA, KbqSidepanelConfig } from './sidepanel-config';
+import { KbqSidepanelContainerComponent, KBQ_SIDEPANEL_WITH_INDENT, KBQ_SIDEPANEL_WITH_SHADOW } from './sidepanel-container.component';
+import { KbqSidepanelRef } from './sidepanel-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "./sidepanel-config";
+/** Injection token that can be used to specify default sidepanel options. */
+export const KBQ_SIDEPANEL_DEFAULT_OPTIONS = new InjectionToken('kbq-sidepanel-default-options');
+export class KbqSidepanelService {
+    /** Keeps track of the currently-open sidepanels. */
+    get openedSidepanels() {
+        return this.parentSidepanelService ?
+            this.parentSidepanelService.openedSidepanels :
+            this.openedSidepanelsAtThisLevel;
+    }
+    constructor(overlay, injector, defaultOptions, parentSidepanelService) {
+        this.overlay = overlay;
+        this.injector = injector;
+        this.defaultOptions = defaultOptions;
+        this.parentSidepanelService = parentSidepanelService;
+        this.openedSidepanelsAtThisLevel = [];
+    }
+    ngOnDestroy() {
+        // Only close the sidepanels at this level on destroy
+        // since the parent service may still be active.
+        this.closeSidepanels(this.openedSidepanelsAtThisLevel);
+    }
+    open(componentOrTemplateRef, config) {
+        const fullConfig = {
+            ...(this.defaultOptions || new KbqSidepanelConfig()),
+            ...config
+        };
+        if (fullConfig.id && this.getSidepanelById(fullConfig.id)) {
+            throw Error(`Sidepanel with id "${fullConfig.id}" exists already. The sidepanel id must be unique.`);
+        }
+        const overlayRef = this.createOverlay(fullConfig);
+        overlayRef.hostElement.classList.add('kbq-sidepanel-overlay');
+        const container = this.attachContainer(overlayRef, fullConfig);
+        const ref = new KbqSidepanelRef(container, overlayRef, fullConfig);
+        if (componentOrTemplateRef instanceof TemplateRef) {
+            container.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, null, {
+                $implicit: fullConfig.data,
+                sidepanelRef: ref
+            }));
+        }
+        else {
+            const portal = new ComponentPortal(componentOrTemplateRef, undefined, this.createInjector(fullConfig, ref, container));
+            const contentRef = container.attachComponentPortal(portal);
+            ref.instance = contentRef.instance;
+        }
+        this.openedSidepanels.push(ref);
+        ref.afterClosed()
+            .subscribe(() => this.removeOpenSidepanel(ref));
+        container.enter();
+        return ref;
+    }
+    /**
+     * Closes all of the currently-open sidepanels.
+     */
+    closeAll() {
+        this.closeSidepanels(this.openedSidepanels);
+    }
+    /**
+     * Finds an open sidepanel by its id.
+     * @param id ID to use when looking up the sidepanel.
+     */
+    getSidepanelById(id) {
+        return this.openedSidepanels.find((sidepanel) => sidepanel.id === id);
+    }
+    /**
+     * Attaches the sidepanel container component to the overlay.
+     */
+    attachContainer(overlayRef, config) {
+        const openedSidepanelsWithSamePosition = this.getOpenedSidepanelsWithSamePosition(config);
+        const injector = Injector.create({
+            parent: this.injector,
+            providers: [
+                { provide: KbqSidepanelConfig, useValue: config },
+                { provide: KBQ_SIDEPANEL_WITH_INDENT, useValue: openedSidepanelsWithSamePosition.length >= 1 },
+                // tslint:disable-next-line:no-magic-numbers
+                { provide: KBQ_SIDEPANEL_WITH_SHADOW, useValue: openedSidepanelsWithSamePosition.length < 2 }
+            ]
+        });
+        const containerPortal = new ComponentPortal(KbqSidepanelContainerComponent, undefined, injector);
+        const containerRef = overlayRef.attach(containerPortal);
+        return containerRef.instance;
+    }
+    /**
+     * Creates a custom injector to be used inside the sidepanel. This allows a component loaded inside
+     * of a sidepanel to close itself and, optionally, to return a value.
+     * @param config Config object that is used to construct the sidepanel.
+     * @param sidepanelRef Reference to the sidepanel.
+     * @param sidepanelContainer Sidepanel container element that wraps all of the contents.
+     * @returns The custom injector that can be used inside the sidepanel.
+     */
+    createInjector(config, sidepanelRef, sidepanelContainer) {
+        // The KbqSidepanelContainerComponent is injected in the portal as the KbqSidepanelContainerComponent and
+        // the sidepanel's content are created out of the same ViewContainerRef and as such, are siblings for injector
+        // purposes. To allow the hierarchy that is expected, the KbqSidepanelContainerComponent is explicitly
+        // added to the injection tokens.
+        return Injector.create({
+            parent: this.injector,
+            providers: [
+                { provide: KbqSidepanelContainerComponent, useValue: sidepanelContainer },
+                { provide: KBQ_SIDEPANEL_DATA, useValue: config.data },
+                { provide: KbqSidepanelRef, useValue: sidepanelRef }
+            ]
+        });
+    }
+    /**
+     * Creates a new overlay and places it in the correct location.
+     * @param config The user-specified sidepanel config.
+     */
+    createOverlay(config) {
+        const overlayConfig = new OverlayConfig({
+            hasBackdrop: config.hasBackdrop,
+            backdropClass: this.getBackdropClass(config),
+            maxWidth: '100%',
+            panelClass: config.overlayPanelClass,
+            scrollStrategy: this.overlay.scrollStrategies.block(),
+            positionStrategy: this.overlay.position().global()
+        });
+        return this.overlay.create(overlayConfig);
+    }
+    closeSidepanels(sidepanels) {
+        const reversedOpenedSidepanels = [...sidepanels.reverse()];
+        reversedOpenedSidepanels
+            .forEach((sidepanelRef) => sidepanelRef.close());
+    }
+    getBackdropClass(config) {
+        if (config.hasBackdrop && config.backdropClass) {
+            return config.backdropClass;
+        }
+        const hasOpenedSidepanelWithBackdrop = this.openedSidepanels
+            .some((sidepanelRef) => sidepanelRef.config.hasBackdrop);
+        return config.requiredBackdrop || !hasOpenedSidepanelWithBackdrop ?
+            'cdk-overlay-dark-backdrop' :
+            'cdk-overlay-transparent-backdrop';
+    }
+    getOpenedSidepanelsWithSamePosition(config) {
+        return this.openedSidepanels.filter((sidepanelRef) => sidepanelRef.config.position === config.position);
+    }
+    /**
+     * Removes a sidepanel from the array of open sidepanels.
+     * @param sidepanelRef Sidepanel to be removed.
+     */
+    removeOpenSidepanel(sidepanelRef) {
+        const index = this.openedSidepanels.indexOf(sidepanelRef);
+        if (index > -1) {
+            this.openedSidepanels.splice(index, 1);
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelService, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: KBQ_SIDEPANEL_DEFAULT_OPTIONS, optional: true }, { token: KbqSidepanelService, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqSidepanelService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.KbqSidepanelConfig, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [KBQ_SIDEPANEL_DEFAULT_OPTIONS]
+                }] }, { type: KbqSidepanelService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sidepanel.service.js","sourceRoot":"","sources":["../../../../packages/components/sidepanel/sidepanel.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Overlay, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';\nimport { ComponentPortal, ComponentType, TemplatePortal } from '@angular/cdk/portal';\nimport {\n    ComponentRef,\n    Inject,\n    Injectable,\n    InjectionToken,\n    Injector,\n    OnDestroy,\n    Optional,\n    SkipSelf,\n    TemplateRef\n} from '@angular/core';\n\nimport { KBQ_SIDEPANEL_DATA, KbqSidepanelConfig } from './sidepanel-config';\nimport {\n    KbqSidepanelContainerComponent,\n    KBQ_SIDEPANEL_WITH_INDENT,\n    KBQ_SIDEPANEL_WITH_SHADOW\n} from './sidepanel-container.component';\nimport { KbqSidepanelRef } from './sidepanel-ref';\n\n\n/** Injection token that can be used to specify default sidepanel options. */\nexport const KBQ_SIDEPANEL_DEFAULT_OPTIONS = new InjectionToken<KbqSidepanelConfig>('kbq-sidepanel-default-options');\n\n@Injectable()\nexport class KbqSidepanelService implements OnDestroy {\n    private openedSidepanelsAtThisLevel: KbqSidepanelRef[] = [];\n\n    /** Keeps track of the currently-open sidepanels. */\n    get openedSidepanels(): KbqSidepanelRef[] {\n        return this.parentSidepanelService ?\n            this.parentSidepanelService.openedSidepanels :\n            this.openedSidepanelsAtThisLevel;\n    }\n\n    constructor(\n        private overlay: Overlay,\n        private injector: Injector,\n        @Optional() @Inject(KBQ_SIDEPANEL_DEFAULT_OPTIONS) private defaultOptions: KbqSidepanelConfig,\n        @Optional() @SkipSelf() private parentSidepanelService: KbqSidepanelService\n    ) {}\n\n    ngOnDestroy() {\n        // Only close the sidepanels at this level on destroy\n        // since the parent service may still be active.\n        this.closeSidepanels(this.openedSidepanelsAtThisLevel);\n    }\n\n    open<T, D = any>(\n        componentOrTemplateRef: ComponentType<T> | TemplateRef<T>, config?: KbqSidepanelConfig<D>\n    ): KbqSidepanelRef<T> {\n        const fullConfig = {\n            ...(this.defaultOptions || new KbqSidepanelConfig()),\n            ...config\n        };\n\n        if (fullConfig.id && this.getSidepanelById(fullConfig.id)) {\n            throw Error(`Sidepanel with id \"${fullConfig.id}\" exists already. The sidepanel id must be unique.`);\n        }\n\n        const overlayRef = this.createOverlay(fullConfig);\n        overlayRef.hostElement.classList.add('kbq-sidepanel-overlay');\n        const container = this.attachContainer(overlayRef, fullConfig);\n        const ref = new KbqSidepanelRef(container, overlayRef, fullConfig);\n\n        if (componentOrTemplateRef instanceof TemplateRef) {\n            container.attachTemplatePortal(\n                new TemplatePortal<T>(\n                    componentOrTemplateRef,\n                    null!,\n                    {\n                        $implicit: fullConfig.data,\n                        sidepanelRef: ref\n                    } as any\n                )\n            );\n        } else {\n            const portal = new ComponentPortal(\n                componentOrTemplateRef,\n                undefined,\n                this.createInjector(fullConfig, ref, container)\n            );\n            const contentRef = container.attachComponentPortal(portal);\n\n            ref.instance = contentRef.instance;\n        }\n\n        this.openedSidepanels.push(ref);\n        ref.afterClosed()\n            .subscribe(() => this.removeOpenSidepanel(ref));\n\n        container.enter();\n\n        return ref;\n    }\n\n    /**\n     * Closes all of the currently-open sidepanels.\n     */\n    closeAll(): void {\n        this.closeSidepanels(this.openedSidepanels);\n    }\n\n    /**\n     * Finds an open sidepanel by its id.\n     * @param id ID to use when looking up the sidepanel.\n     */\n    getSidepanelById(id: string): KbqSidepanelRef | undefined {\n        return this.openedSidepanels.find((sidepanel) => sidepanel.id === id);\n    }\n\n    /**\n     * Attaches the sidepanel container component to the overlay.\n     */\n    private attachContainer(overlayRef: OverlayRef, config: KbqSidepanelConfig): KbqSidepanelContainerComponent {\n        const openedSidepanelsWithSamePosition = this.getOpenedSidepanelsWithSamePosition(config);\n\n        const injector = Injector.create({\n            parent: this.injector,\n            providers: [\n                { provide: KbqSidepanelConfig, useValue: config },\n                { provide: KBQ_SIDEPANEL_WITH_INDENT, useValue: openedSidepanelsWithSamePosition.length >= 1 },\n                // tslint:disable-next-line:no-magic-numbers\n                { provide: KBQ_SIDEPANEL_WITH_SHADOW, useValue: openedSidepanelsWithSamePosition.length < 2 }\n            ]\n        });\n\n        const containerPortal = new ComponentPortal(KbqSidepanelContainerComponent, undefined, injector);\n        const containerRef: ComponentRef<KbqSidepanelContainerComponent> = overlayRef.attach(containerPortal);\n\n        return containerRef.instance;\n    }\n\n    /**\n     * Creates a custom injector to be used inside the sidepanel. This allows a component loaded inside\n     * of a sidepanel to close itself and, optionally, to return a value.\n     * @param config Config object that is used to construct the sidepanel.\n     * @param sidepanelRef Reference to the sidepanel.\n     * @param sidepanelContainer Sidepanel container element that wraps all of the contents.\n     * @returns The custom injector that can be used inside the sidepanel.\n     */\n    private createInjector<T>(\n        config: KbqSidepanelConfig,\n        sidepanelRef: KbqSidepanelRef<T>,\n        sidepanelContainer: KbqSidepanelContainerComponent\n    ): Injector {\n\n        // The KbqSidepanelContainerComponent is injected in the portal as the KbqSidepanelContainerComponent and\n        // the sidepanel's content are created out of the same ViewContainerRef and as such, are siblings for injector\n        // purposes. To allow the hierarchy that is expected, the KbqSidepanelContainerComponent is explicitly\n        // added to the injection tokens.\n\n        return Injector.create({\n            parent: this.injector,\n            providers: [\n                { provide: KbqSidepanelContainerComponent, useValue: sidepanelContainer },\n                { provide: KBQ_SIDEPANEL_DATA, useValue: config.data },\n                { provide: KbqSidepanelRef, useValue: sidepanelRef }\n            ]\n        });\n    }\n\n    /**\n     * Creates a new overlay and places it in the correct location.\n     * @param config The user-specified sidepanel config.\n     */\n    private createOverlay(config: KbqSidepanelConfig): OverlayRef {\n        const overlayConfig = new OverlayConfig({\n            hasBackdrop: config.hasBackdrop,\n            backdropClass: this.getBackdropClass(config),\n            maxWidth: '100%',\n            panelClass: config.overlayPanelClass,\n            scrollStrategy: this.overlay.scrollStrategies.block(),\n            positionStrategy: this.overlay.position().global()\n        });\n\n        return this.overlay.create(overlayConfig);\n    }\n\n    private closeSidepanels(sidepanels: KbqSidepanelRef[]) {\n        const reversedOpenedSidepanels = [...sidepanels.reverse()];\n\n        reversedOpenedSidepanels\n            .forEach((sidepanelRef: KbqSidepanelRef) => sidepanelRef.close());\n    }\n\n    private getBackdropClass(config: KbqSidepanelConfig): string {\n        if (config.hasBackdrop && config.backdropClass) {\n            return config.backdropClass;\n        }\n\n        const hasOpenedSidepanelWithBackdrop = this.openedSidepanels\n            .some((sidepanelRef) => sidepanelRef.config.hasBackdrop!);\n\n        return config.requiredBackdrop || !hasOpenedSidepanelWithBackdrop ?\n            'cdk-overlay-dark-backdrop' :\n            'cdk-overlay-transparent-backdrop';\n    }\n\n    private getOpenedSidepanelsWithSamePosition(config: KbqSidepanelConfig): KbqSidepanelRef[] {\n        return this.openedSidepanels.filter((sidepanelRef) => sidepanelRef.config.position === config.position);\n    }\n\n    /**\n     * Removes a sidepanel from the array of open sidepanels.\n     * @param sidepanelRef Sidepanel to be removed.\n     */\n    private removeOpenSidepanel(sidepanelRef: KbqSidepanelRef) {\n        const index = this.openedSidepanels.indexOf(sidepanelRef);\n\n        if (index > -1) {\n            this.openedSidepanels.splice(index, 1);\n        }\n    }\n}\n"]}

package/esm2022/splitter/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21wb25lbnRzL3NwbGl0dGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/splitter/koobiq-components-splitter.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29vYmlxLWNvbXBvbmVudHMtc3BsaXR0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21wb25lbnRzL3NwbGl0dGVyL2tvb2JpcS1jb21wb25lbnRzLXNwbGl0dGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/splitter/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './splitter.module';
+export * from './splitter.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBvbmVudHMvc3BsaXR0ZXIvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NwbGl0dGVyLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NwbGl0dGVyLmNvbXBvbmVudCc7XG4iXX0=