@progress/kendo-angular-grid 7.0.0-dev.202201261657 → 7.0.0-next.202203311511

package/esm2015/grouping/group-scroll-binding.directive.js

@@ -0,0 +1,271 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, Input, isDevMode } from '@angular/core';
+import { DataBindingDirective } from "../databinding.directive";
+import { filterBy, process } from "@progress/kendo-data-query";
+import { isPresent, isArray } from "../utils";
+import { diffFilters, cloneFilters } from "../common/filter-descriptor-differ";
+import * as i0 from "@angular/core";
+import * as i1 from "../grid.component";
+import * as i2 from "../editing/local-data-changes.service";
+const hasGroups = (items) => items && items.length && items[0].field && items[0].items;
+const groupDescriptorsPresent = (descriptors) => isPresent(descriptors) && descriptors.length > 0;
+const processGroups = (data, state) => process(data, state).data;
+const removeParentDescriptors = (parents, owner) => g => g.field !== owner.field && !parents.some(y => y.field === g.field);
+const findGroup = (groupIndex, groups) => {
+    const parents = [];
+    return {
+        group: groupIndex.split("_").reduce((acc, x) => {
+            const idx = parseInt(x, 10);
+            if (acc.items) {
+                parents.push(acc);
+                return acc.items[idx];
+            }
+            return isArray(acc) ? acc[idx] : acc;
+        }, groups),
+        parents
+    };
+};
+const findChildren = (data, parents) => {
+    const filters = parents.map(p => ({ field: p.field, operator: "eq", value: p.value }));
+    return filterBy(data, {
+        filters: filters,
+        logic: "and"
+    });
+};
+/**
+ * @hidden
+ */
+export const count = (groups, includeFooters = false) => (groups.reduce((acc, group) => {
+    if (!group.skipHeader) {
+        acc++;
+    }
+    if (group.items) {
+        const children = count(group.items, includeFooters);
+        if (includeFooters && children && !group.hideFooter) {
+            acc++;
+        }
+        acc += children;
+    }
+    return acc;
+}, 0));
+/**
+ * @hidden
+ */
+export const slice = (groups, skip, take, includeFooters = false) => {
+    if (!isPresent(take)) {
+        return groups;
+    }
+    const result = [];
+    for (let idx = 0, length = groups.length; idx < length; idx++) {
+        if (take <= 0) {
+            break;
+        }
+        const group = groups[idx];
+        const groupItems = group.items;
+        let itemCount = count(groupItems, includeFooters);
+        if (includeFooters && groupItems.length) {
+            itemCount++;
+        }
+        const skipHeader = skip > 0;
+        if (skip) {
+            skip--;
+            if (itemCount && skip >= itemCount) {
+                skip -= itemCount;
+                continue;
+            }
+        }
+        if (!skipHeader || itemCount) {
+            const items = [];
+            let hideFooter = true;
+            if (!skipHeader) {
+                take--;
+            }
+            if (take) {
+                if (hasGroups(groupItems)) {
+                    const children = slice(groupItems, skip, take, includeFooters);
+                    items.push(...children);
+                    take -= count(children, includeFooters);
+                }
+                else {
+                    items.push(...groupItems.slice(skip, Math.min(skip + take, groupItems.length)));
+                    take -= items.length;
+                }
+                if (take && includeFooters) {
+                    hideFooter = false;
+                    take--;
+                }
+                skip = 0;
+            }
+            result.push({
+                aggregates: group.aggregates,
+                field: group.field,
+                hideFooter,
+                items,
+                offset: idx,
+                skipHeader,
+                value: group.value
+            });
+        }
+    }
+    return result;
+};
+const skippedHeaders = (groupItem) => {
+    let total = 0;
+    while (groupItem) {
+        if (groupItem.skipHeader) {
+            total++;
+        }
+        groupItem = groupItem.items && groupItem.items[0] || null;
+    }
+    return total;
+};
+/**
+ * A directive which encapsulates the in-memory handling of grouping with virtual scrolling.
+ */
+export class GroupBindingDirective extends DataBindingDirective {
+    constructor(grid, changeDetector, localDataChangesService) {
+        super(grid, changeDetector, localDataChangesService);
+    }
+    /**
+     * The array of data which will be used to populate the Grid.
+     */
+    set kendoGridGroupBinding(value) {
+        this.groups = null;
+        this.grid.resetGroupsState();
+        this.data = value;
+    }
+    /**
+     * @hidden
+     */
+    set data(value) {
+        this.originalData = value || [];
+        this.dataChanged = true;
+    }
+    /**
+     * Defines the descriptors by which the data will be sorted.
+     */
+    set sort(value) {
+        const clear = this.state.sort !== value;
+        this.grid.sort = this.state.sort = value;
+        if (clear) {
+            this.groups = null;
+            this.grid.resetGroupsState();
+        }
+    }
+    /**
+     * Defines the descriptor by which the data will be filtered.
+     */
+    set filter(value) {
+        const clear = diffFilters(this.state.filter, value);
+        if (clear) {
+            this.state.filter = value;
+            this.grid.filter = cloneFilters(value);
+            this.groups = null;
+            this.grid.resetGroupsState();
+        }
+    }
+    /**
+     * Defines the descriptors by which the data will be grouped.
+     */
+    set group(value) {
+        // don't clear if no groups are present in previous and current value
+        const groupsPresent = groupDescriptorsPresent(this.state.group) || groupDescriptorsPresent(value);
+        const clear = this.state.group !== value && groupsPresent;
+        this.grid.group = this.state.group = value;
+        if (clear) {
+            this.groups = null;
+            this.grid.resetGroupsState();
+            this.skip = 0;
+        }
+    }
+    /**
+     * @hidden
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        this.grid.groupExpand.subscribe(this.groupExpand.bind(this));
+        this.grid.groupCollapse.subscribe(this.groupCollapse.bind(this));
+    }
+    ngAfterContentInit() {
+        if (isDevMode() && this.grid.isGroupExpanded) {
+            throw new Error('Using the `kendoGridGroupBinding` directive in combination with the `kendoGridExpandGroupBy` directive ' +
+                'or the `isGroupExpanded` callback is not supported. To use grouping with the `kendoGridGroupBinding` directive, ' +
+                'set the Grid `groupable` property to `true`.');
+        }
+    }
+    groupExpand({ groupIndex }) {
+        this.grid.expandGroupChildren(groupIndex);
+        const { group, parents } = findGroup(groupIndex, this.groups);
+        if (!group.items.length) {
+            const descriptors = this.state.group.filter(removeParentDescriptors(parents, group));
+            const children = findChildren(this.originalData, parents.concat(group));
+            group.items = processGroups(children, {
+                filter: this.state.filter,
+                group: descriptors,
+                sort: this.state.sort
+            });
+        }
+        this.grid.data = this.dataResult(this.state.skip, this.state.take);
+    }
+    groupCollapse({ groupIndex }) {
+        const { group } = findGroup(groupIndex, this.groups);
+        if (group) {
+            group.items = [];
+        }
+        this.grid.data = this.dataResult(this.state.skip, this.state.take);
+    }
+    process(state) {
+        if (state.group && state.group.length) {
+            const groups = this.processGroups(state);
+            this.grid.skip -= skippedHeaders(groups.data[0]);
+            return groups;
+        }
+        else {
+            this.groups = null;
+        }
+        return super.process(state);
+    }
+    processGroups(state) {
+        if (!this.groups || !this.groups.length) {
+            this.groups = processGroups(this.originalData, {
+                filter: state.filter,
+                group: state.group,
+                sort: state.sort
+            });
+        }
+        return this.dataResult(state.skip, state.take);
+    }
+    dataResult(skip, take) {
+        const includeFooters = this.grid.showGroupFooters;
+        return {
+            data: slice(this.groups, skip, take, includeFooters),
+            total: count(this.groups, includeFooters)
+        };
+    }
+    applyState({ skip, take, sort, group, filter }) {
+        this.skip = skip;
+        this.state.take = take;
+        // this.pageSize = take; // do need to update take as the process with slice correctly
+        this.sort = sort;
+        this.group = group;
+        this.filter = filter;
+    }
+}
+GroupBindingDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupBindingDirective, deps: [{ token: i1.GridComponent }, { token: i0.ChangeDetectorRef }, { token: i2.LocalDataChangesService }], target: i0.ɵɵFactoryTarget.Directive });
+GroupBindingDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: GroupBindingDirective, selector: "[kendoGridGroupBinding]", inputs: { kendoGridGroupBinding: "kendoGridGroupBinding", sort: "sort", filter: "filter", group: "group" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupBindingDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[kendoGridGroupBinding]' }]
+        }], ctorParameters: function () { return [{ type: i1.GridComponent }, { type: i0.ChangeDetectorRef }, { type: i2.LocalDataChangesService }]; }, propDecorators: { kendoGridGroupBinding: [{
+                type: Input,
+                args: ["kendoGridGroupBinding"]
+            }], sort: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }] } });

package/esm2015/grouping/group-settings.js

@@ -0,0 +1,5 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export {};

package/esm2015/grouping/group.module.js

@@ -0,0 +1,56 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { GroupHeaderTemplateDirective } from './group-header-template.directive';
+import { GroupHeaderColumnTemplateDirective } from './group-header-column-template.directive';
+import { GroupHeaderComponent } from './group-header.component';
+import { GroupFooterTemplateDirective } from './group-footer-template.directive';
+import { GroupPanelComponent } from './group-panel.component';
+import { GroupIndicatorComponent } from './group-indicator.component';
+import { SharedModule } from "../shared.module";
+import { DragAndDropModule } from '../dragdrop/drag-and-drop.module';
+import * as i0 from "@angular/core";
+const exportedModules = [
+    GroupHeaderTemplateDirective,
+    GroupHeaderColumnTemplateDirective,
+    GroupFooterTemplateDirective,
+    GroupHeaderComponent,
+    GroupPanelComponent,
+    GroupIndicatorComponent
+];
+/**
+ * @hidden
+ */
+export class GroupModule {
+    static exports() {
+        return [
+            GroupHeaderTemplateDirective,
+            GroupHeaderColumnTemplateDirective,
+            GroupFooterTemplateDirective
+        ];
+    }
+}
+GroupModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+GroupModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupModule, declarations: [GroupHeaderTemplateDirective,
+        GroupHeaderColumnTemplateDirective,
+        GroupFooterTemplateDirective,
+        GroupHeaderComponent,
+        GroupPanelComponent,
+        GroupIndicatorComponent], imports: [CommonModule, SharedModule, DragAndDropModule], exports: [GroupHeaderTemplateDirective,
+        GroupHeaderColumnTemplateDirective,
+        GroupFooterTemplateDirective,
+        GroupHeaderComponent,
+        GroupPanelComponent,
+        GroupIndicatorComponent] });
+GroupModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupModule, imports: [[CommonModule, SharedModule, DragAndDropModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [exportedModules],
+                    exports: [exportedModules],
+                    imports: [CommonModule, SharedModule, DragAndDropModule]
+                }]
+        }] });

package/esm2015/grouping/groups.service.js

@@ -0,0 +1,65 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { getGroupRowArgs } from './utils';
+import * as i0 from "@angular/core";
+const isChildIndex = (targetIndex, parentIndex) => parentIndex !== targetIndex && targetIndex.startsWith(parentIndex);
+/**
+ * @hidden
+ */
+export class GroupsService {
+    constructor() {
+        this.changes = new Subject();
+        this.rowState = new Set();
+    }
+    reset() {
+        this.rowState.clear();
+    }
+    ngOnDestroy() {
+        this.reset();
+    }
+    isExpanded(groupArgs) {
+        if (this.userCallback) {
+            return this.userCallback(groupArgs);
+        }
+        return !this.rowState.has(groupArgs.groupIndex);
+    }
+    isInExpandedGroup(groupItem) {
+        let expanded = true;
+        while (groupItem && expanded) {
+            expanded = this.isExpanded({
+                group: groupItem.data,
+                groupIndex: groupItem.index,
+                parentGroup: getGroupRowArgs(groupItem.parentGroup)
+            });
+            groupItem = groupItem.parentGroup;
+        }
+        return expanded;
+    }
+    toggleRow(groupItem) {
+        const parentGroup = getGroupRowArgs(groupItem.parentGroup);
+        const expand = !this.isExpanded({ group: groupItem.data, groupIndex: groupItem.index, parentGroup });
+        this.changes.next({ group: groupItem.data, expand, groupIndex: groupItem.index, parentGroup });
+        // if usercallback is given, the rowState should be ignored
+        if (this.userCallback) {
+            return;
+        }
+        if (expand) {
+            this.rowState.delete(groupItem.index);
+        }
+        else {
+            this.rowState.add(groupItem.index);
+        }
+    }
+    expandChildren(parentIndex) {
+        this.rowState.forEach(index => isChildIndex(index, parentIndex) && this.rowState.delete(index));
+    }
+}
+GroupsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+GroupsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: GroupsService, decorators: [{
+            type: Injectable
+        }] });

package/esm2015/grouping/virtual-group-result.interface.js

@@ -0,0 +1,5 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export {};

package/esm2015/kendo-angular-grid.js

@@ -0,0 +1,8 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './main';

package/esm2015/layout/browser-support.service.js

@@ -0,0 +1,80 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable, EventEmitter } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { auditTime } from 'rxjs/operators';
+import { isDocumentAvailable } from '@progress/kendo-angular-common';
+import * as i0 from "@angular/core";
+const canCreateElement = () => isDocumentAvailable() && document.createElement;
+let cachedScrollbarWidth = null;
+let cachedPixelRatio;
+let cachedRtlScrollLeft = null;
+function scrollbarWidth() {
+    if (cachedScrollbarWidth === null && canCreateElement()) {
+        cachedPixelRatio = window.devicePixelRatio || 1;
+        const div = document.createElement("div");
+        div.style.cssText = "overflow:scroll;overflow-x:hidden;zoom:1;clear:both;display:block";
+        div.innerHTML = " ";
+        document.body.appendChild(div);
+        cachedScrollbarWidth = div.offsetWidth - div.scrollWidth;
+        document.body.removeChild(div);
+    }
+    return cachedScrollbarWidth;
+}
+function rtlScrollLeft() {
+    if (cachedRtlScrollLeft === null && canCreateElement()) {
+        const div = document.createElement("div");
+        div.style.cssText = "overflow:scroll;zoom:1;clear:both;display:block;width:100px;visibility:hidden;position:absolute;left:-10000px;direction:rtl;";
+        div.innerHTML = "<div style='width:200px;height:1px;'</div>";
+        document.body.appendChild(div);
+        const initial = div.scrollLeft;
+        div.scrollLeft = -1;
+        cachedRtlScrollLeft = div.scrollLeft < 0 ? div.scrollLeft : initial;
+        document.body.removeChild(div);
+    }
+    return cachedRtlScrollLeft;
+}
+/**
+ * @hidden
+ * move to kendo-common
+ */
+export class BrowserSupportService {
+    constructor(zone, changeDetector) {
+        this.zone = zone;
+        this.changeDetector = changeDetector;
+        this.changes = new EventEmitter();
+        if (typeof window === 'undefined') {
+            return;
+        }
+        this.zone.runOutsideAngular(() => {
+            this.subscriptions = fromEvent(window, 'resize').pipe(auditTime(100)).subscribe(() => {
+                if (cachedPixelRatio !== window.devicePixelRatio) {
+                    zone.run(() => {
+                        cachedScrollbarWidth = null;
+                        this.changes.emit();
+                        this.changeDetector.markForCheck();
+                    });
+                }
+            });
+        });
+    }
+    ngOnDestroy() {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+            this.subscriptions = null;
+        }
+    }
+    get scrollbarWidth() {
+        return scrollbarWidth();
+    }
+    get rtlScrollLeft() {
+        return rtlScrollLeft();
+    }
+}
+BrowserSupportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BrowserSupportService, deps: [{ token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Injectable });
+BrowserSupportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BrowserSupportService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BrowserSupportService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; } });

package/esm2015/layout/resizable.directive.js

@@ -0,0 +1,74 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./resize.service";
+import * as i2 from "./../common/provider.service";
+/**
+ * @hidden
+ */
+export class ResizableContainerDirective {
+    constructor(el, renderer, resizeService, providerService) {
+        this.el = el;
+        this.renderer = renderer;
+        this.resizeService = resizeService;
+        this.providerService = providerService;
+        this.enabled = false;
+    }
+    set lockedWidth(value) {
+        this._lockedWidth = value;
+        if (this.enabled) {
+            this.attachResize();
+            this.resize();
+        }
+    }
+    set kendoGridResizableContainer(enabled) {
+        const refresh = enabled !== this.enabled;
+        this.enabled = enabled;
+        if (refresh) {
+            this.attachResize();
+            this.resize();
+        }
+    }
+    ngOnDestroy() {
+        if (this.resizeSubscription) {
+            this.resizeSubscription.unsubscribe();
+        }
+    }
+    attachResize() {
+        if (this.resizeSubscription && !this.enabled) {
+            this.resizeSubscription.unsubscribe();
+            this.resizeSubscription = null;
+        }
+        if (!this.resizeSubscription && this.enabled) {
+            this.resizeSubscription = this.resizeService.changes.subscribe(this.resize.bind(this));
+        }
+    }
+    resize() {
+        if (this.providerService.grid && this.providerService.grid.wrapper) {
+            const containerElement = this.providerService.grid.wrapper.nativeElement;
+            const width = Math.max(containerElement.clientWidth - this._lockedWidth, 0);
+            if (this.enabled && width > 0) {
+                this.renderer.setStyle(this.el.nativeElement, "width", width + "px");
+            }
+            else {
+                this.renderer.setStyle(this.el.nativeElement, "width", "");
+            }
+        }
+    }
+}
+ResizableContainerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResizableContainerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ResizeService }, { token: i2.ProviderService }], target: i0.ɵɵFactoryTarget.Directive });
+ResizableContainerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: ResizableContainerDirective, selector: "[kendoGridResizableContainer]", inputs: { lockedWidth: "lockedWidth", kendoGridResizableContainer: "kendoGridResizableContainer" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResizableContainerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoGridResizableContainer]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ResizeService }, { type: i2.ProviderService }]; }, propDecorators: { lockedWidth: [{
+                type: Input,
+                args: ['lockedWidth']
+            }], kendoGridResizableContainer: [{
+                type: Input
+            }] } });

package/esm2015/layout/resize.service.js

@@ -0,0 +1,31 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import { Subject, Subscription } from "rxjs";
+import { throttleTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class ResizeService {
+    constructor() {
+        this.resizeSubscription = new Subscription(() => { });
+        this.dispatcher = new Subject();
+        this.changes = this.dispatcher.asObservable().pipe(throttleTime(100));
+    }
+    connect(resizes) {
+        this.resizeSubscription.add(resizes.subscribe(this.dispatcher));
+    }
+    destroy() {
+        if (this.resizeSubscription) {
+            this.resizeSubscription.unsubscribe();
+        }
+    }
+}
+ResizeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResizeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResizeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResizeService, decorators: [{
+            type: Injectable
+        }] });

package/esm2015/layout/responsive.service.js

@@ -0,0 +1,36 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+const bootstrapToMedia = (media) => (({
+    "xs": "(max-width: 576px)",
+    "sm": "(min-width: 576px)",
+    "md": "(min-width: 768px)",
+    "lg": "(min-width: 992px)",
+    "xl": "(min-width: 1200px)"
+})[media] || media);
+const browserMatchMedia = (media) => window.matchMedia(media).matches;
+/**
+ * @hidden
+ */
+export class ResponsiveService {
+    constructor() {
+        /**
+         * @hidden
+         */
+        this.matchMedia = browserMatchMedia;
+    }
+    /**
+     * @hidden
+     */
+    matchesMedia(media) {
+        return !media || this.matchMedia(bootstrapToMedia(media));
+    }
+}
+ResponsiveService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResponsiveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResponsiveService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResponsiveService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ResponsiveService, decorators: [{
+            type: Injectable
+        }] });