@dugararchit/flex-layout 13.0.0-dugararchit

package/esm2020/core/match-media/match-media.mjs

@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { BehaviorSubject, Observable, merge } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { MediaChange } from '../media-change';
+import * as i0 from "@angular/core";
+/**
+ * MediaMonitor configures listeners to mediaQuery changes and publishes an Observable facade to
+ * convert mediaQuery change callbacks to subscriber notifications. These notifications will be
+ * performed within the ng Zone to trigger change detections and component updates.
+ *
+ * NOTE: both mediaQuery activations and de-activations are announced in notifications
+ */
+export class MatchMedia {
+    constructor(_zone, _platformId, _document) {
+        this._zone = _zone;
+        this._platformId = _platformId;
+        this._document = _document;
+        /** Initialize source with 'all' so all non-responsive APIs trigger style updates */
+        this.source = new BehaviorSubject(new MediaChange(true));
+        this.registry = new Map();
+        this.pendingRemoveListenerFns = [];
+        this._observable$ = this.source.asObservable();
+    }
+    /**
+     * Publish list of all current activations
+     */
+    get activations() {
+        const results = [];
+        this.registry.forEach((mql, key) => {
+            if (mql.matches) {
+                results.push(key);
+            }
+        });
+        return results;
+    }
+    /**
+     * For the specified mediaQuery?
+     */
+    isActive(mediaQuery) {
+        const mql = this.registry.get(mediaQuery);
+        return mql?.matches ?? this.registerQuery(mediaQuery).some(m => m.matches);
+    }
+    /**
+     * External observers can watch for all (or a specific) mql changes.
+     * Typically used by the MediaQueryAdaptor; optionally available to components
+     * who wish to use the MediaMonitor as mediaMonitor$ observable service.
+     *
+     * Use deferred registration process to register breakpoints only on subscription
+     * This logic also enforces logic to register all mediaQueries BEFORE notify
+     * subscribers of notifications.
+     */
+    observe(mqList, filterOthers = false) {
+        if (mqList && mqList.length) {
+            const matchMedia$ = this._observable$.pipe(filter((change) => !filterOthers ? true : (mqList.indexOf(change.mediaQuery) > -1)));
+            const registration$ = new Observable((observer) => {
+                const matches = this.registerQuery(mqList);
+                if (matches.length) {
+                    const lastChange = matches.pop();
+                    matches.forEach((e) => {
+                        observer.next(e);
+                    });
+                    this.source.next(lastChange); // last match is cached
+                }
+                observer.complete();
+            });
+            return merge(registration$, matchMedia$);
+        }
+        return this._observable$;
+    }
+    /**
+     * Based on the BreakPointRegistry provider, register internal listeners for each unique
+     * mediaQuery. Each listener emits specific MediaChange data to observers
+     */
+    registerQuery(mediaQuery) {
+        const list = Array.isArray(mediaQuery) ? mediaQuery : [mediaQuery];
+        const matches = [];
+        buildQueryCss(list, this._document);
+        list.forEach((query) => {
+            const onMQLEvent = (e) => {
+                this._zone.run(() => this.source.next(new MediaChange(e.matches, query)));
+            };
+            let mql = this.registry.get(query);
+            if (!mql) {
+                mql = this.buildMQL(query);
+                mql.addListener(onMQLEvent);
+                this.pendingRemoveListenerFns.push(() => mql.removeListener(onMQLEvent));
+                this.registry.set(query, mql);
+            }
+            if (mql.matches) {
+                matches.push(new MediaChange(true, query));
+            }
+        });
+        return matches;
+    }
+    ngOnDestroy() {
+        let fn;
+        while (fn = this.pendingRemoveListenerFns.pop()) {
+            fn();
+        }
+    }
+    /**
+     * Call window.matchMedia() to build a MediaQueryList; which
+     * supports 0..n listeners for activation/deactivation
+     */
+    buildMQL(query) {
+        return constructMql(query, isPlatformBrowser(this._platformId));
+    }
+}
+MatchMedia.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MatchMedia, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+MatchMedia.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MatchMedia, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MatchMedia, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+/**
+ * Private global registry for all dynamically-created, injected style tags
+ * @see prepare(query)
+ */
+const ALL_STYLES = {};
+/**
+ * For Webkit engines that only trigger the MediaQueryList Listener
+ * when there is at least one CSS selector for the respective media query.
+ *
+ * @param mediaQueries
+ * @param _document
+ */
+function buildQueryCss(mediaQueries, _document) {
+    const list = mediaQueries.filter(it => !ALL_STYLES[it]);
+    if (list.length > 0) {
+        const query = list.join(', ');
+        try {
+            const styleEl = _document.createElement('style');
+            styleEl.setAttribute('type', 'text/css');
+            if (!styleEl.styleSheet) {
+                const cssText = `
+/*
+  @angular/flex-layout - workaround for possible browser quirk with mediaQuery listeners
+  see http://bit.ly/2sd4HMP
+*/
+@media ${query} {.fx-query-test{ }}
+`;
+                styleEl.appendChild(_document.createTextNode(cssText));
+            }
+            _document.head.appendChild(styleEl);
+            // Store in private global registry
+            list.forEach(mq => ALL_STYLES[mq] = styleEl);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+function constructMql(query, isBrowser) {
+    const canListen = isBrowser && !!window.matchMedia('all').addListener;
+    return canListen ? window.matchMedia(query) : {
+        matches: query === 'all' || query === '',
+        media: query,
+        addListener: () => {
+        },
+        removeListener: () => {
+        },
+        onchange: null,
+        addEventListener() {
+        },
+        removeEventListener() {
+        },
+        dispatchEvent() {
+            return false;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match-media.js","sourceRoot":"","sources":["../../../../../../projects/libs/flex-layout/core/match-media/match-media.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {Inject, Injectable, NgZone, OnDestroy, PLATFORM_ID} from '@angular/core';\nimport {DOCUMENT, isPlatformBrowser} from '@angular/common';\nimport {BehaviorSubject, Observable, merge, Observer} from 'rxjs';\nimport {filter} from 'rxjs/operators';\n\nimport {MediaChange} from '../media-change';\n\n/**\n * MediaMonitor configures listeners to mediaQuery changes and publishes an Observable facade to\n * convert mediaQuery change callbacks to subscriber notifications. These notifications will be\n * performed within the ng Zone to trigger change detections and component updates.\n *\n * NOTE: both mediaQuery activations and de-activations are announced in notifications\n */\n@Injectable({providedIn: 'root'})\nexport class MatchMedia implements OnDestroy {\n  /** Initialize source with 'all' so all non-responsive APIs trigger style updates */\n  readonly source = new BehaviorSubject<MediaChange>(new MediaChange(true));\n  registry = new Map<string, MediaQueryList>();\n  private readonly pendingRemoveListenerFns: Array<() => void> = [];\n\n  constructor(protected _zone: NgZone,\n              @Inject(PLATFORM_ID) protected _platformId: Object,\n              @Inject(DOCUMENT) protected _document: any) {\n  }\n\n  /**\n   * Publish list of all current activations\n   */\n  get activations(): string[] {\n    const results: string[] = [];\n    this.registry.forEach((mql: MediaQueryList, key: string) => {\n      if (mql.matches) {\n        results.push(key);\n      }\n    });\n    return results;\n  }\n\n  /**\n   * For the specified mediaQuery?\n   */\n  isActive(mediaQuery: string): boolean {\n    const mql = this.registry.get(mediaQuery);\n    return mql?.matches ?? this.registerQuery(mediaQuery).some(m => m.matches);\n  }\n\n  /**\n   * External observers can watch for all (or a specific) mql changes.\n   *\n   * If a mediaQuery is not specified, then ALL mediaQuery activations will\n   * be announced.\n   */\n  observe(): Observable<MediaChange>;\n  observe(mediaQueries: string[]): Observable<MediaChange>;\n  observe(mediaQueries: string[], filterOthers: boolean): Observable<MediaChange>;\n\n  /**\n   * External observers can watch for all (or a specific) mql changes.\n   * Typically used by the MediaQueryAdaptor; optionally available to components\n   * who wish to use the MediaMonitor as mediaMonitor$ observable service.\n   *\n   * Use deferred registration process to register breakpoints only on subscription\n   * This logic also enforces logic to register all mediaQueries BEFORE notify\n   * subscribers of notifications.\n   */\n  observe(mqList?: string[], filterOthers = false): Observable<MediaChange> {\n    if (mqList && mqList.length) {\n      const matchMedia$: Observable<MediaChange> = this._observable$.pipe(\n          filter((change: MediaChange) =>\n            !filterOthers ? true : (mqList.indexOf(change.mediaQuery) > -1))\n      );\n      const registration$: Observable<MediaChange> = new Observable((observer: Observer<MediaChange>) => {  // tslint:disable-line:max-line-length\n        const matches: Array<MediaChange> = this.registerQuery(mqList);\n        if (matches.length) {\n          const lastChange = matches.pop()!;\n          matches.forEach((e: MediaChange) => {\n            observer.next(e);\n          });\n          this.source.next(lastChange); // last match is cached\n        }\n        observer.complete();\n      });\n      return merge(registration$, matchMedia$);\n    }\n\n    return this._observable$;\n  }\n\n  /**\n   * Based on the BreakPointRegistry provider, register internal listeners for each unique\n   * mediaQuery. Each listener emits specific MediaChange data to observers\n   */\n  registerQuery(mediaQuery: string | string[]) {\n    const list = Array.isArray(mediaQuery) ? mediaQuery : [mediaQuery];\n    const matches: MediaChange[] = [];\n\n    buildQueryCss(list, this._document);\n\n    list.forEach((query: string) => {\n      const onMQLEvent = (e: MediaQueryListEvent) => {\n        this._zone.run(() => this.source.next(new MediaChange(e.matches, query)));\n      };\n\n      let mql = this.registry.get(query);\n      if (!mql) {\n        mql = this.buildMQL(query);\n        mql.addListener(onMQLEvent);\n        this.pendingRemoveListenerFns.push(() => mql!.removeListener(onMQLEvent));\n        this.registry.set(query, mql);\n      }\n\n      if (mql.matches) {\n        matches.push(new MediaChange(true, query));\n      }\n    });\n\n    return matches;\n  }\n\n  ngOnDestroy(): void {\n    let fn;\n    while (fn = this.pendingRemoveListenerFns.pop()) {\n      fn();\n    }\n  }\n\n  /**\n   * Call window.matchMedia() to build a MediaQueryList; which\n   * supports 0..n listeners for activation/deactivation\n   */\n  protected buildMQL(query: string): MediaQueryList {\n    return constructMql(query, isPlatformBrowser(this._platformId));\n  }\n\n  protected _observable$ = this.source.asObservable();\n}\n\n/**\n * Private global registry for all dynamically-created, injected style tags\n * @see prepare(query)\n */\nconst ALL_STYLES: { [key: string]: any } = {};\n\n/**\n * For Webkit engines that only trigger the MediaQueryList Listener\n * when there is at least one CSS selector for the respective media query.\n *\n * @param mediaQueries\n * @param _document\n */\nfunction buildQueryCss(mediaQueries: string[], _document: Document) {\n  const list = mediaQueries.filter(it => !ALL_STYLES[it]);\n  if (list.length > 0) {\n    const query = list.join(', ');\n\n    try {\n      const styleEl = _document.createElement('style');\n\n      styleEl.setAttribute('type', 'text/css');\n      if (!(styleEl as any).styleSheet) {\n        const cssText = `\n/*\n  @angular/flex-layout - workaround for possible browser quirk with mediaQuery listeners\n  see http://bit.ly/2sd4HMP\n*/\n@media ${query} {.fx-query-test{ }}\n`;\n        styleEl.appendChild(_document.createTextNode(cssText));\n      }\n\n      _document.head!.appendChild(styleEl);\n\n      // Store in private global registry\n      list.forEach(mq => ALL_STYLES[mq] = styleEl);\n\n    } catch (e) {\n      console.error(e);\n    }\n  }\n}\n\nfunction constructMql(query: string, isBrowser: boolean): MediaQueryList {\n  const canListen = isBrowser && !!(<Window>window).matchMedia('all').addListener;\n\n  return canListen ? (<Window>window).matchMedia(query) : {\n    matches: query === 'all' || query === '',\n    media: query,\n    addListener: () => {\n    },\n    removeListener: () => {\n    },\n    onchange: null,\n    addEventListener() {\n    },\n    removeEventListener() {\n    },\n    dispatchEvent() {\n      return false;\n    }\n  } as MediaQueryList;\n}\n"]}

package/esm2020/core/match-media/mock/mock-match-media.mjs

@@ -0,0 +1,224 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { MatchMedia } from '../match-media';
+import * as i0 from "@angular/core";
+import * as i1 from "../../breakpoints/break-point-registry";
+/**
+ * MockMatchMedia mocks calls to the Window API matchMedia with a build of a simulated
+ * MockMediaQueryListener. Methods are available to simulate an activation of a mediaQuery
+ * range and to clearAll mediaQuery listeners.
+ */
+export class MockMatchMedia extends MatchMedia {
+    constructor(_zone, _platformId, _document, _breakpoints) {
+        super(_zone, _platformId, _document);
+        this._breakpoints = _breakpoints;
+        this.autoRegisterQueries = true; // Used for testing BreakPoint registrations
+        this.useOverlaps = false; // Allow fallback to overlapping mediaQueries
+    }
+    /** Easy method to clear all listeners for all mediaQueries */
+    clearAll() {
+        this.registry.forEach((mql) => {
+            mql.destroy();
+        });
+        this.registry.clear();
+        this.useOverlaps = false;
+    }
+    /** Feature to support manual, simulated activation of a mediaQuery. */
+    activate(mediaQuery, useOverlaps = this.useOverlaps) {
+        mediaQuery = this._validateQuery(mediaQuery);
+        if (useOverlaps || !this.isActive(mediaQuery)) {
+            this._deactivateAll();
+            this._registerMediaQuery(mediaQuery);
+            this._activateWithOverlaps(mediaQuery, useOverlaps);
+        }
+        return this.hasActivated;
+    }
+    /** Converts an optional mediaQuery alias to a specific, valid mediaQuery */
+    _validateQuery(queryOrAlias) {
+        const bp = this._breakpoints.findByAlias(queryOrAlias);
+        return bp?.mediaQuery ?? queryOrAlias;
+    }
+    /**
+     * Manually onMediaChange any overlapping mediaQueries to simulate
+     * similar functionality in the window.matchMedia()
+     */
+    _activateWithOverlaps(mediaQuery, useOverlaps) {
+        if (useOverlaps) {
+            const bp = this._breakpoints.findByQuery(mediaQuery);
+            const alias = bp?.alias ?? 'unknown';
+            // Simulate activation of overlapping lt-<XXX> ranges
+            switch (alias) {
+                case 'lg':
+                    this._activateByAlias(['lt-xl']);
+                    break;
+                case 'md':
+                    this._activateByAlias(['lt-xl', 'lt-lg']);
+                    break;
+                case 'sm':
+                    this._activateByAlias(['lt-xl', 'lt-lg', 'lt-md']);
+                    break;
+                case 'xs':
+                    this._activateByAlias(['lt-xl', 'lt-lg', 'lt-md', 'lt-sm']);
+                    break;
+            }
+            // Simulate activation of overlapping gt-<xxxx> mediaQuery ranges
+            switch (alias) {
+                case 'xl':
+                    this._activateByAlias(['gt-lg', 'gt-md', 'gt-sm', 'gt-xs']);
+                    break;
+                case 'lg':
+                    this._activateByAlias(['gt-md', 'gt-sm', 'gt-xs']);
+                    break;
+                case 'md':
+                    this._activateByAlias(['gt-sm', 'gt-xs']);
+                    break;
+                case 'sm':
+                    this._activateByAlias(['gt-xs']);
+                    break;
+            }
+        }
+        // Activate last since the responsiveActivation is watching *this* mediaQuery
+        return this._activateByQuery(mediaQuery);
+    }
+    /**
+     *
+     */
+    _activateByAlias(aliases) {
+        const activate = (alias) => {
+            const bp = this._breakpoints.findByAlias(alias);
+            this._activateByQuery(bp?.mediaQuery ?? alias);
+        };
+        aliases.forEach(activate);
+    }
+    /**
+     *
+     */
+    _activateByQuery(mediaQuery) {
+        if (!this.registry.has(mediaQuery) && this.autoRegisterQueries) {
+            this._registerMediaQuery(mediaQuery);
+        }
+        const mql = this.registry.get(mediaQuery);
+        if (mql && !this.isActive(mediaQuery)) {
+            this.registry.set(mediaQuery, mql.activate());
+        }
+        return this.hasActivated;
+    }
+    /** Deactivate all current MQLs and reset the buffer */
+    _deactivateAll() {
+        this.registry.forEach((it) => {
+            it.deactivate();
+        });
+        return this;
+    }
+    /** Insure the mediaQuery is registered with MatchMedia */
+    _registerMediaQuery(mediaQuery) {
+        if (!this.registry.has(mediaQuery) && this.autoRegisterQueries) {
+            this.registerQuery(mediaQuery);
+        }
+    }
+    /**
+     * Call window.matchMedia() to build a MediaQueryList; which
+     * supports 0..n listeners for activation/deactivation
+     */
+    buildMQL(query) {
+        return new MockMediaQueryList(query);
+    }
+    get hasActivated() {
+        return this.activations.length > 0;
+    }
+}
+MockMatchMedia.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MockMatchMedia, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }, { token: DOCUMENT }, { token: i1.BreakPointRegistry }], target: i0.ɵɵFactoryTarget.Injectable });
+MockMatchMedia.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MockMatchMedia });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MockMatchMedia, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.BreakPointRegistry }]; } });
+/**
+ * Special internal class to simulate a MediaQueryList and
+ * - supports manual activation to simulate mediaQuery matching
+ * - manages listeners
+ */
+export class MockMediaQueryList {
+    constructor(_mediaQuery) {
+        this._mediaQuery = _mediaQuery;
+        this._isActive = false;
+        this._listeners = [];
+        this.onchange = null;
+    }
+    get matches() {
+        return this._isActive;
+    }
+    get media() {
+        return this._mediaQuery;
+    }
+    /**
+     * Destroy the current list by deactivating the
+     * listeners and clearing the internal list
+     */
+    destroy() {
+        this.deactivate();
+        this._listeners = [];
+    }
+    /** Notify all listeners that 'matches === TRUE' */
+    activate() {
+        if (!this._isActive) {
+            this._isActive = true;
+            this._listeners.forEach((callback) => {
+                const cb = callback;
+                cb.call(this, { matches: this.matches, media: this.media });
+            });
+        }
+        return this;
+    }
+    /** Notify all listeners that 'matches === false' */
+    deactivate() {
+        if (this._isActive) {
+            this._isActive = false;
+            this._listeners.forEach((callback) => {
+                const cb = callback;
+                cb.call(this, { matches: this.matches, media: this.media });
+            });
+        }
+        return this;
+    }
+    /** Add a listener to our internal list to activate later */
+    addListener(listener) {
+        if (this._listeners.indexOf(listener) === -1) {
+            this._listeners.push(listener);
+        }
+        if (this._isActive) {
+            const cb = listener;
+            cb.call(this, { matches: this.matches, media: this.media });
+        }
+    }
+    /** Don't need to remove listeners in the testing environment */
+    removeListener(_) {
+    }
+    addEventListener(_, __, ___) {
+    }
+    removeEventListener(_, __, ___) {
+    }
+    dispatchEvent(_) {
+        return false;
+    }
+}
+/**
+ * Pre-configured provider for MockMatchMedia
+ */
+export const MockMatchMediaProvider = {
+    provide: MatchMedia,
+    useClass: MockMatchMedia
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mock-match-media.js","sourceRoot":"","sources":["../../../../../../../projects/libs/flex-layout/core/match-media/mock/mock-match-media.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {Inject, Injectable, NgZone, PLATFORM_ID} from '@angular/core';\nimport {DOCUMENT} from '@angular/common';\n\nimport {MatchMedia} from '../match-media';\nimport {BreakPointRegistry} from '../../breakpoints/break-point-registry';\n\n/**\n * MockMatchMedia mocks calls to the Window API matchMedia with a build of a simulated\n * MockMediaQueryListener. Methods are available to simulate an activation of a mediaQuery\n * range and to clearAll mediaQuery listeners.\n */\n@Injectable()\nexport class MockMatchMedia extends MatchMedia {\n\n\n  autoRegisterQueries = true;   // Used for testing BreakPoint registrations\n  useOverlaps = false;          // Allow fallback to overlapping mediaQueries\n\n  constructor(_zone: NgZone,\n              @Inject(PLATFORM_ID) _platformId: Object,\n              @Inject(DOCUMENT) _document: any,\n              private _breakpoints: BreakPointRegistry) {\n    super(_zone, _platformId, _document);\n  }\n\n  /** Easy method to clear all listeners for all mediaQueries */\n  clearAll() {\n    this.registry.forEach((mql: MediaQueryList) => {\n      (mql as MockMediaQueryList).destroy();\n    });\n    this.registry.clear();\n    this.useOverlaps = false;\n  }\n\n  /** Feature to support manual, simulated activation of a mediaQuery. */\n  activate(mediaQuery: string, useOverlaps = this.useOverlaps): boolean {\n    mediaQuery = this._validateQuery(mediaQuery);\n\n    if (useOverlaps || !this.isActive(mediaQuery)) {\n      this._deactivateAll();\n\n      this._registerMediaQuery(mediaQuery);\n      this._activateWithOverlaps(mediaQuery, useOverlaps);\n    }\n\n    return this.hasActivated;\n  }\n\n  /** Converts an optional mediaQuery alias to a specific, valid mediaQuery */\n  _validateQuery(queryOrAlias: string): string {\n    const bp = this._breakpoints.findByAlias(queryOrAlias);\n    return bp?.mediaQuery ?? queryOrAlias;\n  }\n\n  /**\n   * Manually onMediaChange any overlapping mediaQueries to simulate\n   * similar functionality in the window.matchMedia()\n   */\n  private _activateWithOverlaps(mediaQuery: string, useOverlaps: boolean): boolean {\n    if (useOverlaps) {\n      const bp = this._breakpoints.findByQuery(mediaQuery);\n      const alias = bp?.alias ?? 'unknown';\n\n      // Simulate activation of overlapping lt-<XXX> ranges\n      switch (alias) {\n        case 'lg':\n          this._activateByAlias(['lt-xl']);\n          break;\n        case 'md':\n          this._activateByAlias(['lt-xl', 'lt-lg']);\n          break;\n        case 'sm':\n          this._activateByAlias(['lt-xl', 'lt-lg', 'lt-md']);\n          break;\n        case 'xs':\n          this._activateByAlias(['lt-xl', 'lt-lg', 'lt-md', 'lt-sm']);\n          break;\n      }\n\n      // Simulate activation of overlapping gt-<xxxx> mediaQuery ranges\n      switch (alias) {\n        case 'xl':\n          this._activateByAlias(['gt-lg', 'gt-md', 'gt-sm', 'gt-xs']);\n          break;\n        case 'lg':\n          this._activateByAlias(['gt-md', 'gt-sm', 'gt-xs']);\n          break;\n        case 'md':\n          this._activateByAlias(['gt-sm', 'gt-xs']);\n          break;\n        case 'sm':\n          this._activateByAlias(['gt-xs']);\n          break;\n      }\n    }\n\n    // Activate last since the responsiveActivation is watching *this* mediaQuery\n    return this._activateByQuery(mediaQuery);\n  }\n\n  /**\n   *\n   */\n  private _activateByAlias(aliases: string[]) {\n    const activate = (alias: string) => {\n      const bp = this._breakpoints.findByAlias(alias);\n      this._activateByQuery(bp?.mediaQuery ?? alias);\n    };\n    aliases.forEach(activate);\n  }\n\n  /**\n   *\n   */\n  private _activateByQuery(mediaQuery: string) {\n    if (!this.registry.has(mediaQuery) && this.autoRegisterQueries) {\n      this._registerMediaQuery(mediaQuery);\n    }\n    const mql: MockMediaQueryList = this.registry.get(mediaQuery) as MockMediaQueryList;\n\n    if (mql && !this.isActive(mediaQuery)) {\n      this.registry.set(mediaQuery, mql.activate());\n    }\n    return this.hasActivated;\n  }\n\n  /** Deactivate all current MQLs and reset the buffer */\n  private _deactivateAll() {\n    this.registry.forEach((it: MediaQueryList) => {\n      (it as MockMediaQueryList).deactivate();\n    });\n    return this;\n  }\n\n  /** Insure the mediaQuery is registered with MatchMedia */\n  private _registerMediaQuery(mediaQuery: string) {\n    if (!this.registry.has(mediaQuery) && this.autoRegisterQueries) {\n      this.registerQuery(mediaQuery);\n    }\n  }\n\n  /**\n   * Call window.matchMedia() to build a MediaQueryList; which\n   * supports 0..n listeners for activation/deactivation\n   */\n  protected buildMQL(query: string): MediaQueryList {\n    return new MockMediaQueryList(query);\n  }\n\n  protected get hasActivated() {\n    return this.activations.length > 0;\n  }\n\n}\n\n/**\n * Special internal class to simulate a MediaQueryList and\n * - supports manual activation to simulate mediaQuery matching\n * - manages listeners\n */\nexport class MockMediaQueryList implements MediaQueryList {\n  private _isActive = false;\n  private _listeners: MediaQueryListListener[] = [];\n\n  get matches(): boolean {\n    return this._isActive;\n  }\n\n  get media(): string {\n    return this._mediaQuery;\n  }\n\n  constructor(private _mediaQuery: string) {\n  }\n\n  /**\n   * Destroy the current list by deactivating the\n   * listeners and clearing the internal list\n   */\n  destroy() {\n    this.deactivate();\n    this._listeners = [];\n  }\n\n  /** Notify all listeners that 'matches === TRUE' */\n  activate(): MockMediaQueryList {\n    if (!this._isActive) {\n      this._isActive = true;\n      this._listeners.forEach((callback) => {\n        const cb: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) = callback!;\n        cb.call(this, {matches: this.matches, media: this.media} as MediaQueryListEvent);\n      });\n    }\n    return this;\n  }\n\n  /** Notify all listeners that 'matches === false' */\n  deactivate(): MockMediaQueryList {\n    if (this._isActive) {\n      this._isActive = false;\n      this._listeners.forEach((callback) => {\n        const cb: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) = callback!;\n        cb.call(this, {matches: this.matches, media: this.media} as MediaQueryListEvent);\n      });\n    }\n    return this;\n  }\n\n  /** Add a listener to our internal list to activate later */\n  addListener(listener: MediaQueryListListener) {\n    if (this._listeners.indexOf(listener) === -1) {\n      this._listeners.push(listener);\n    }\n    if (this._isActive) {\n      const cb: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) = listener!;\n      cb.call(this, {matches: this.matches, media: this.media} as MediaQueryListEvent);\n    }\n  }\n\n  /** Don't need to remove listeners in the testing environment */\n  removeListener(_: MediaQueryListListener | null) {\n  }\n\n  addEventListener<K extends keyof MediaQueryListEventMap>(\n      _: K,\n      __: (this: MediaQueryList,\n      ev: MediaQueryListEventMap[K]) => any,\n      ___?: boolean | AddEventListenerOptions): void;\n\n  addEventListener(\n      _: string,\n      __: EventListenerOrEventListenerObject,\n      ___?: boolean | AddEventListenerOptions) {\n  }\n\n  removeEventListener<K extends keyof MediaQueryListEventMap>(\n      _: K,\n      __: (this: MediaQueryList,\n      ev: MediaQueryListEventMap[K]) => any,\n      ___?: boolean | EventListenerOptions): void;\n\n  removeEventListener(\n      _: string,\n      __: EventListenerOrEventListenerObject,\n      ___?: boolean | EventListenerOptions) {\n  }\n\n  dispatchEvent(_: Event): boolean {\n    return false;\n  }\n\n  onchange: MediaQueryListListener = null;\n}\n\n/**\n * Pre-configured provider for MockMatchMedia\n */\nexport const MockMatchMediaProvider = {  // tslint:disable-line:variable-name\n  provide: MatchMedia,\n  useClass: MockMatchMedia\n};\n\ntype MediaQueryListListener = ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;\n"]}

package/esm2020/core/media-change.mjs

@@ -0,0 +1,25 @@
+/**
+ * Class instances emitted [to observers] for each mql notification
+ */
+export class MediaChange {
+    /**
+     * @param matches whether the mediaQuery is currently activated
+     * @param mediaQuery e.g. (min-width: 600px) and (max-width: 959px)
+     * @param mqAlias e.g. gt-sm, md, gt-lg
+     * @param suffix e.g. GtSM, Md, GtLg
+     * @param priority the priority of activation for the given breakpoint
+     */
+    constructor(matches = false, mediaQuery = 'all', mqAlias = '', suffix = '', priority = 0) {
+        this.matches = matches;
+        this.mediaQuery = mediaQuery;
+        this.mqAlias = mqAlias;
+        this.suffix = suffix;
+        this.priority = priority;
+        this.property = '';
+    }
+    /** Create an exact copy of the MediaChange */
+    clone() {
+        return new MediaChange(this.matches, this.mediaQuery, this.mqAlias, this.suffix);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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