ahcdashboardui/node_modules/@angular/cdk/esm2015/layout/breakpoints-observer.js

/**
 * @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 { coerceArray } from '@angular/cdk/coercion';
import { Injectable, NgZone } from '@angular/core';
import { combineLatest, concat, Observable, Subject } from 'rxjs';
import { debounceTime, map, skip, startWith, take, takeUntil } from 'rxjs/operators';
import { MediaMatcher } from './media-matcher';
import * as i0 from "@angular/core";
import * as i1 from "./media-matcher";
/** Utility for checking the matching state of @media queries. */
import * as ɵngcc0 from '@angular/core';
import * as ɵngcc1 from './media-matcher';
export class BreakpointObserver {
    constructor(_mediaMatcher, _zone) {
        this._mediaMatcher = _mediaMatcher;
        this._zone = _zone;
        /**  A map of all media queries currently being listened for. */
        this._queries = new Map();
        /** A subject for all other observables to takeUntil based on. */
        this._destroySubject = new Subject();
    }
    /** Completes the active subject, signalling to all other observables to complete. */
    ngOnDestroy() {
        this._destroySubject.next();
        this._destroySubject.complete();
    }
    /**
     * Whether one or more media queries match the current viewport size.
     * @param value One or more media queries to check.
     * @returns Whether any of the media queries match.
     */
    isMatched(value) {
        const queries = splitQueries(coerceArray(value));
        return queries.some(mediaQuery => this._registerQuery(mediaQuery).mql.matches);
    }
    /**
     * Gets an observable of results for the given queries that will emit new results for any changes
     * in matching of the given queries.
     * @param value One or more media queries to check.
     * @returns A stream of matches for the given queries.
     */
    observe(value) {
        const queries = splitQueries(coerceArray(value));
        const observables = queries.map(query => this._registerQuery(query).observable);
        let stateObservable = combineLatest(observables);
        // Emit the first state immediately, and then debounce the subsequent emissions.
        stateObservable = concat(stateObservable.pipe(take(1)), stateObservable.pipe(skip(1), debounceTime(0)));
        return stateObservable.pipe(map(breakpointStates => {
            const response = {
                matches: false,
                breakpoints: {},
            };
            breakpointStates.forEach(({ matches, query }) => {
                response.matches = response.matches || matches;
                response.breakpoints[query] = matches;
            });
            return response;
        }));
    }
    /** Registers a specific query to be listened for. */
    _registerQuery(query) {
        // Only set up a new MediaQueryList if it is not already being listened for.
        if (this._queries.has(query)) {
            return this._queries.get(query);
        }
        const mql = this._mediaMatcher.matchMedia(query);
        // Create callback for match changes and add it is as a listener.
        const queryObservable = new Observable((observer) => {
            // Listener callback methods are wrapped to be placed back in ngZone. Callbacks must be placed
            // back into the zone because matchMedia is only included in Zone.js by loading the
            // webapis-media-query.js file alongside the zone.js file.  Additionally, some browsers do not
            // have MediaQueryList inherit from EventTarget, which causes inconsistencies in how Zone.js
            // patches it.
            const handler = (e) => this._zone.run(() => observer.next(e));
            mql.addListener(handler);
            return () => {
                mql.removeListener(handler);
            };
        }).pipe(startWith(mql), map(({ matches }) => ({ query, matches })), takeUntil(this._destroySubject));
        // Add the MediaQueryList to the set of queries.
        const output = { observable: queryObservable, mql };
        this._queries.set(query, output);
        return output;
    }
}
BreakpointObserver.ɵfac = function BreakpointObserver_Factory(t) { return new (t || BreakpointObserver)(ɵngcc0.ɵɵinject(ɵngcc1.MediaMatcher), ɵngcc0.ɵɵinject(ɵngcc0.NgZone)); };
BreakpointObserver.ɵprov = i0.ɵɵdefineInjectable({ factory: function BreakpointObserver_Factory() { return new BreakpointObserver(i0.ɵɵinject(i1.MediaMatcher), i0.ɵɵinject(i0.NgZone)); }, token: BreakpointObserver, providedIn: "root" });
BreakpointObserver.ctorParameters = () => [
    { type: MediaMatcher },
    { type: NgZone }
];
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(BreakpointObserver, [{
        type: Injectable,
        args: [{ providedIn: 'root' }]
    }], function () { return [{ type: ɵngcc1.MediaMatcher }, { type: ɵngcc0.NgZone }]; }, null); })();
/**
 * Split each query string into separate query strings if two queries are provided as comma
 * separated.
 */
function splitQueries(queries) {
    return queries.map(query => query.split(','))
        .reduce((a1, a2) => a1.concat(a2))
        .map(query => query.trim());
}

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"breakpoints-observer.js","sources":["../../../../../../src/cdk/layout/breakpoints-observer.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 */\n\nimport {coerceArray} from '@angular/cdk/coercion';\nimport {Injectable, NgZone, OnDestroy} from '@angular/core';\nimport {combineLatest, concat, Observable, Observer, Subject} from 'rxjs';\nimport {debounceTime, map, skip, startWith, take, takeUntil} from 'rxjs/operators';\nimport {MediaMatcher} from './media-matcher';\n\n\n/** The current state of a layout breakpoint. */\nexport interface BreakpointState {\n  /** Whether the breakpoint is currently matching. */\n  matches: boolean;\n  /**\n   * A key boolean pair for each query provided to the observe method,\n   * with its current matched state.\n   */\n  breakpoints: {\n    [key: string]: boolean;\n  };\n}\n\n/** The current state of a layout breakpoint. */\ninterface InternalBreakpointState {\n  /** Whether the breakpoint is currently matching. */\n  matches: boolean;\n  /** The media query being to be matched */\n  query: string;\n}\n\ninterface Query {\n  observable: Observable<InternalBreakpointState>;\n  mql: MediaQueryList;\n}\n\n/** Utility for checking the matching state of @media queries. */\n@Injectable({providedIn: 'root'})\nexport class BreakpointObserver implements OnDestroy {\n  /**  A map of all media queries currently being listened for. */\n  private _queries = new Map<string, Query>();\n  /** A subject for all other observables to takeUntil based on. */\n  private readonly _destroySubject = new Subject<void>();\n\n  constructor(private _mediaMatcher: MediaMatcher, private _zone: NgZone) {}\n\n  /** Completes the active subject, signalling to all other observables to complete. */\n  ngOnDestroy() {\n    this._destroySubject.next();\n    this._destroySubject.complete();\n  }\n\n  /**\n   * Whether one or more media queries match the current viewport size.\n   * @param value One or more media queries to check.\n   * @returns Whether any of the media queries match.\n   */\n  isMatched(value: string | readonly string[]): boolean {\n    const queries = splitQueries(coerceArray(value));\n    return queries.some(mediaQuery => this._registerQuery(mediaQuery).mql.matches);\n  }\n\n  /**\n   * Gets an observable of results for the given queries that will emit new results for any changes\n   * in matching of the given queries.\n   * @param value One or more media queries to check.\n   * @returns A stream of matches for the given queries.\n   */\n  observe(value: string | readonly string[]): Observable<BreakpointState> {\n    const queries = splitQueries(coerceArray(value));\n    const observables = queries.map(query => this._registerQuery(query).observable);\n\n    let stateObservable = combineLatest(observables);\n    // Emit the first state immediately, and then debounce the subsequent emissions.\n    stateObservable = concat(\n      stateObservable.pipe(take(1)),\n      stateObservable.pipe(skip(1), debounceTime(0)));\n    return stateObservable.pipe(map(breakpointStates => {\n      const response: BreakpointState = {\n        matches: false,\n        breakpoints: {},\n      };\n      breakpointStates.forEach(({matches, query}) => {\n        response.matches = response.matches || matches;\n        response.breakpoints[query] = matches;\n      });\n      return response;\n    }));\n  }\n\n  /** Registers a specific query to be listened for. */\n  private _registerQuery(query: string): Query {\n    // Only set up a new MediaQueryList if it is not already being listened for.\n    if (this._queries.has(query)) {\n      return this._queries.get(query)!;\n    }\n\n    const mql = this._mediaMatcher.matchMedia(query);\n\n    // Create callback for match changes and add it is as a listener.\n    const queryObservable = new Observable((observer: Observer<MediaQueryList>) => {\n      // Listener callback methods are wrapped to be placed back in ngZone. Callbacks must be placed\n      // back into the zone because matchMedia is only included in Zone.js by loading the\n      // webapis-media-query.js file alongside the zone.js file.  Additionally, some browsers do not\n      // have MediaQueryList inherit from EventTarget, which causes inconsistencies in how Zone.js\n      // patches it.\n      const handler = (e: any) => this._zone.run(() => observer.next(e));\n      mql.addListener(handler);\n\n      return () => {\n        mql.removeListener(handler);\n      };\n    }).pipe(\n      startWith(mql),\n      map(({matches}) => ({query, matches})),\n      takeUntil(this._destroySubject)\n    );\n\n    // Add the MediaQueryList to the set of queries.\n    const output = {observable: queryObservable, mql};\n    this._queries.set(query, output);\n    return output;\n  }\n}\n\n/**\n * Split each query string into separate query strings if two queries are provided as comma\n * separated.\n */\nfunction splitQueries(queries: readonly string[]): readonly string[] {\n  return queries.map(query => query.split(','))\n                .reduce((a1, a2) => a1.concat(a2))\n                .map(query => query.trim());\n}\n"]}