@dugararchit/flex-layout 13.0.0-dugararchit

package/esm2020/core/media-marshaller/print-hook.mjs

@@ -0,0 +1,265 @@
+/**
+ * @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 } from '@angular/core';
+import { mergeAlias } from '../add-alias';
+import { MediaChange } from '../media-change';
+import { LAYOUT_CONFIG } from '../tokens/library-config';
+import { sortDescendingPriority } from '../utils/sort';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../breakpoints/break-point-registry";
+const PRINT = 'print';
+export const BREAKPOINT_PRINT = {
+    alias: PRINT,
+    mediaQuery: PRINT,
+    priority: 1000
+};
+/**
+ * PrintHook - Use to intercept print MediaQuery activations and force
+ *             layouts to render with the specified print alias/breakpoint
+ *
+ * Used in MediaMarshaller and MediaObserver
+ */
+export class PrintHook {
+    constructor(breakpoints, layoutConfig, _document) {
+        this.breakpoints = breakpoints;
+        this.layoutConfig = layoutConfig;
+        this._document = _document;
+        // registeredBeforeAfterPrintHooks tracks if we registered the `beforeprint`
+        //  and `afterprint` event listeners.
+        this.registeredBeforeAfterPrintHooks = false;
+        // isPrintingBeforeAfterEvent is used to track if we are printing from within
+        // a `beforeprint` event handler. This prevents the typical `stopPrinting`
+        // form `interceptEvents` so that printing is not stopped while the dialog
+        // is still open. This is an extension of the `isPrinting` property on
+        // browsers which support `beforeprint` and `afterprint` events.
+        this.isPrintingBeforeAfterEvent = false;
+        this.beforePrintEventListeners = [];
+        this.afterPrintEventListeners = [];
+        this.formerActivations = null;
+        // Is this service currently in print mode
+        this.isPrinting = false;
+        this.queue = new PrintQueue();
+        this.deactivations = [];
+    }
+    /** Add 'print' mediaQuery: to listen for matchMedia activations */
+    withPrintQuery(queries) {
+        return [...queries, PRINT];
+    }
+    /** Is the MediaChange event for any 'print' @media */
+    isPrintEvent(e) {
+        return e.mediaQuery.startsWith(PRINT);
+    }
+    /** What is the desired mqAlias to use while printing? */
+    get printAlias() {
+        return [...(this.layoutConfig.printWithBreakpoints ?? [])];
+    }
+    /** Lookup breakpoints associated with print aliases. */
+    get printBreakPoints() {
+        return this.printAlias
+            .map(alias => this.breakpoints.findByAlias(alias))
+            .filter(bp => bp !== null);
+    }
+    /** Lookup breakpoint associated with mediaQuery */
+    getEventBreakpoints({ mediaQuery }) {
+        const bp = this.breakpoints.findByQuery(mediaQuery);
+        const list = bp ? [...this.printBreakPoints, bp] : this.printBreakPoints;
+        return list.sort(sortDescendingPriority);
+    }
+    /** Update event with printAlias mediaQuery information */
+    updateEvent(event) {
+        let bp = this.breakpoints.findByQuery(event.mediaQuery);
+        if (this.isPrintEvent(event)) {
+            // Reset from 'print' to first (highest priority) print breakpoint
+            bp = this.getEventBreakpoints(event)[0];
+            event.mediaQuery = bp?.mediaQuery ?? '';
+        }
+        return mergeAlias(event, bp);
+    }
+    // registerBeforeAfterPrintHooks registers a `beforeprint` event hook so we can
+    // trigger print styles synchronously and apply proper layout styles.
+    // It is a noop if the hooks have already been registered or if the document's
+    // `defaultView` is not available.
+    registerBeforeAfterPrintHooks(target) {
+        // `defaultView` may be null when rendering on the server or in other contexts.
+        if (!this._document.defaultView || this.registeredBeforeAfterPrintHooks) {
+            return;
+        }
+        this.registeredBeforeAfterPrintHooks = true;
+        const beforePrintListener = () => {
+            // If we aren't already printing, start printing and update the styles as
+            // if there was a regular print `MediaChange`(from matchMedia).
+            if (!this.isPrinting) {
+                this.isPrintingBeforeAfterEvent = true;
+                this.startPrinting(target, this.getEventBreakpoints(new MediaChange(true, PRINT)));
+                target.updateStyles();
+            }
+        };
+        const afterPrintListener = () => {
+            // If we aren't already printing, start printing and update the styles as
+            // if there was a regular print `MediaChange`(from matchMedia).
+            this.isPrintingBeforeAfterEvent = false;
+            if (this.isPrinting) {
+                this.stopPrinting(target);
+                target.updateStyles();
+            }
+        };
+        // Could we have teardown logic to remove if there are no print listeners being used?
+        this._document.defaultView.addEventListener('beforeprint', beforePrintListener);
+        this._document.defaultView.addEventListener('afterprint', afterPrintListener);
+        this.beforePrintEventListeners.push(beforePrintListener);
+        this.afterPrintEventListeners.push(afterPrintListener);
+    }
+    /**
+     * Prepare RxJS tap operator with partial application
+     * @return pipeable tap predicate
+     */
+    interceptEvents(target) {
+        return (event) => {
+            if (this.isPrintEvent(event)) {
+                if (event.matches && !this.isPrinting) {
+                    this.startPrinting(target, this.getEventBreakpoints(event));
+                    target.updateStyles();
+                }
+                else if (!event.matches && this.isPrinting && !this.isPrintingBeforeAfterEvent) {
+                    this.stopPrinting(target);
+                    target.updateStyles();
+                }
+                return;
+            }
+            this.collectActivations(target, event);
+        };
+    }
+    /** Stop mediaChange event propagation in event streams */
+    blockPropagation() {
+        return (event) => {
+            return !(this.isPrinting || this.isPrintEvent(event));
+        };
+    }
+    /**
+     * Save current activateBreakpoints (for later restore)
+     * and substitute only the printAlias breakpoint
+     */
+    startPrinting(target, bpList) {
+        this.isPrinting = true;
+        this.formerActivations = target.activatedBreakpoints;
+        target.activatedBreakpoints = this.queue.addPrintBreakpoints(bpList);
+    }
+    /** For any print de-activations, reset the entire print queue */
+    stopPrinting(target) {
+        target.activatedBreakpoints = this.deactivations;
+        this.deactivations = [];
+        this.formerActivations = null;
+        this.queue.clear();
+        this.isPrinting = false;
+    }
+    /**
+     * To restore pre-Print Activations, we must capture the proper
+     * list of breakpoint activations BEFORE print starts. OnBeforePrint()
+     * is supported; so 'print' mediaQuery activations are used as a fallback
+     * in browsers without `beforeprint` support.
+     *
+     * >  But activated breakpoints are deactivated BEFORE 'print' activation.
+     *
+     * Let's capture all de-activations using the following logic:
+     *
+     *  When not printing:
+     *    - clear cache when activating non-print breakpoint
+     *    - update cache (and sort) when deactivating
+     *
+     *  When printing:
+     *    - sort and save when starting print
+     *    - restore as activatedTargets and clear when stop printing
+     */
+    collectActivations(target, event) {
+        if (!this.isPrinting || this.isPrintingBeforeAfterEvent) {
+            if (!this.isPrintingBeforeAfterEvent) {
+                // Only clear deactivations if we aren't printing from a `beforeprint` event.
+                // Otherwise, this will clear before `stopPrinting()` is called to restore
+                // the pre-Print Activations.
+                this.deactivations = [];
+                return;
+            }
+            if (!event.matches) {
+                const bp = this.breakpoints.findByQuery(event.mediaQuery);
+                // Deactivating a breakpoint
+                if (bp) {
+                    const hasFormerBp = this.formerActivations && this.formerActivations.includes(bp);
+                    const wasActivated = !this.formerActivations && target.activatedBreakpoints.includes(bp);
+                    const shouldDeactivate = hasFormerBp || wasActivated;
+                    if (shouldDeactivate) {
+                        this.deactivations.push(bp);
+                        this.deactivations.sort(sortDescendingPriority);
+                    }
+                }
+            }
+        }
+    }
+    /** Teardown logic for the service. */
+    ngOnDestroy() {
+        if (this._document.defaultView) {
+            this.beforePrintEventListeners.forEach(l => this._document.defaultView.removeEventListener('beforeprint', l));
+            this.afterPrintEventListeners.forEach(l => this._document.defaultView.removeEventListener('afterprint', l));
+        }
+    }
+}
+PrintHook.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: PrintHook, deps: [{ token: i1.BreakPointRegistry }, { token: LAYOUT_CONFIG }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+PrintHook.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: PrintHook, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: PrintHook, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.BreakPointRegistry }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LAYOUT_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+// ************************************************************************
+// Internal Utility class 'PrintQueue'
+// ************************************************************************
+/**
+ * Utility class to manage print breakpoints + activatedBreakpoints
+ * with correct sorting WHILE printing
+ */
+class PrintQueue {
+    constructor() {
+        /** Sorted queue with prioritized print breakpoints */
+        this.printBreakpoints = [];
+    }
+    addPrintBreakpoints(bpList) {
+        bpList.push(BREAKPOINT_PRINT);
+        bpList.sort(sortDescendingPriority);
+        bpList.forEach(bp => this.addBreakpoint(bp));
+        return this.printBreakpoints;
+    }
+    /** Add Print breakpoint to queue */
+    addBreakpoint(bp) {
+        if (!!bp) {
+            const bpInList = this.printBreakpoints.find(it => it.mediaQuery === bp.mediaQuery);
+            if (bpInList === undefined) {
+                // If this is a `printAlias` breakpoint, then append. If a true 'print' breakpoint,
+                // register as highest priority in the queue
+                this.printBreakpoints = isPrintBreakPoint(bp) ? [bp, ...this.printBreakpoints]
+                    : [...this.printBreakpoints, bp];
+            }
+        }
+    }
+    /** Restore original activated breakpoints and clear internal caches */
+    clear() {
+        this.printBreakpoints = [];
+    }
+}
+// ************************************************************************
+// Internal Utility methods
+// ************************************************************************
+/** Only support intercept queueing if the Breakpoint is a print @media query */
+function isPrintBreakPoint(bp) {
+    return bp?.mediaQuery.startsWith(PRINT) ?? false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"print-hook.js","sourceRoot":"","sources":["../../../../../../projects/libs/flex-layout/core/media-marshaller/print-hook.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, OnDestroy} from '@angular/core';\n\nimport {mergeAlias} from '../add-alias';\nimport {MediaChange} from '../media-change';\nimport {BreakPoint} from '../breakpoints/break-point';\nimport {LAYOUT_CONFIG, LayoutConfigOptions} from '../tokens/library-config';\nimport {BreakPointRegistry, OptionalBreakPoint} from '../breakpoints/break-point-registry';\nimport {sortDescendingPriority} from '../utils/sort';\nimport {DOCUMENT} from '@angular/common';\n\n/**\n * Interface to apply PrintHook to call anonymous `target.updateStyles()`\n */\nexport interface HookTarget {\n  activatedBreakpoints: BreakPoint[];\n  updateStyles(): void;\n}\n\nconst PRINT = 'print';\nexport const BREAKPOINT_PRINT = {\n  alias: PRINT,\n  mediaQuery: PRINT,\n  priority: 1000\n};\n\n/**\n * PrintHook - Use to intercept print MediaQuery activations and force\n *             layouts to render with the specified print alias/breakpoint\n *\n * Used in MediaMarshaller and MediaObserver\n */\n@Injectable({providedIn: 'root'})\nexport class PrintHook implements OnDestroy {\n  constructor(\n      protected breakpoints: BreakPointRegistry,\n      @Inject(LAYOUT_CONFIG) protected layoutConfig: LayoutConfigOptions,\n      @Inject(DOCUMENT) protected _document: any) {\n  }\n\n  /** Add 'print' mediaQuery: to listen for matchMedia activations */\n  withPrintQuery(queries: string[]): string[] {\n    return [...queries, PRINT];\n  }\n\n  /** Is the MediaChange event for any 'print' @media */\n  isPrintEvent(e: MediaChange): boolean {\n    return e.mediaQuery.startsWith(PRINT);\n  }\n\n  /** What is the desired mqAlias to use while printing? */\n  get printAlias(): string[] {\n    return [...(this.layoutConfig.printWithBreakpoints ?? [])];\n  }\n\n  /** Lookup breakpoints associated with print aliases. */\n  get printBreakPoints(): BreakPoint[] {\n    return this.printAlias\n        .map(alias => this.breakpoints.findByAlias(alias))\n        .filter(bp => bp !== null) as BreakPoint[];\n  }\n\n  /** Lookup breakpoint associated with mediaQuery */\n  getEventBreakpoints({mediaQuery}: MediaChange): BreakPoint[] {\n    const bp = this.breakpoints.findByQuery(mediaQuery);\n    const list = bp ? [...this.printBreakPoints, bp] : this.printBreakPoints;\n\n    return list.sort(sortDescendingPriority);\n  }\n\n  /** Update event with printAlias mediaQuery information */\n  updateEvent(event: MediaChange): MediaChange {\n    let bp: OptionalBreakPoint = this.breakpoints.findByQuery(event.mediaQuery);\n\n    if (this.isPrintEvent(event)) {\n      // Reset from 'print' to first (highest priority) print breakpoint\n      bp = this.getEventBreakpoints(event)[0];\n      event.mediaQuery = bp?.mediaQuery ?? '';\n    }\n\n    return mergeAlias(event, bp);\n  }\n\n\n  // registeredBeforeAfterPrintHooks tracks if we registered the `beforeprint`\n  //  and `afterprint` event listeners.\n  private registeredBeforeAfterPrintHooks = false;\n\n  // isPrintingBeforeAfterEvent is used to track if we are printing from within\n  // a `beforeprint` event handler. This prevents the typical `stopPrinting`\n  // form `interceptEvents` so that printing is not stopped while the dialog\n  // is still open. This is an extension of the `isPrinting` property on\n  // browsers which support `beforeprint` and `afterprint` events.\n  private isPrintingBeforeAfterEvent = false;\n\n  private beforePrintEventListeners: Function[] = [];\n  private afterPrintEventListeners: Function[] = [];\n\n  private formerActivations: Array<BreakPoint> | null = null;\n\n  // registerBeforeAfterPrintHooks registers a `beforeprint` event hook so we can\n  // trigger print styles synchronously and apply proper layout styles.\n  // It is a noop if the hooks have already been registered or if the document's\n  // `defaultView` is not available.\n  registerBeforeAfterPrintHooks(target: HookTarget) {\n    // `defaultView` may be null when rendering on the server or in other contexts.\n    if (!this._document.defaultView || this.registeredBeforeAfterPrintHooks) {\n      return;\n    }\n\n    this.registeredBeforeAfterPrintHooks = true;\n\n    const beforePrintListener = () => {\n      // If we aren't already printing, start printing and update the styles as\n      // if there was a regular print `MediaChange`(from matchMedia).\n      if (!this.isPrinting) {\n        this.isPrintingBeforeAfterEvent = true;\n        this.startPrinting(target, this.getEventBreakpoints(new MediaChange(true, PRINT)));\n        target.updateStyles();\n      }\n    };\n\n    const afterPrintListener = () => {\n      // If we aren't already printing, start printing and update the styles as\n      // if there was a regular print `MediaChange`(from matchMedia).\n      this.isPrintingBeforeAfterEvent = false;\n      if (this.isPrinting) {\n        this.stopPrinting(target);\n        target.updateStyles();\n      }\n    };\n\n    // Could we have teardown logic to remove if there are no print listeners being used?\n    this._document.defaultView.addEventListener('beforeprint', beforePrintListener);\n    this._document.defaultView.addEventListener('afterprint', afterPrintListener);\n\n    this.beforePrintEventListeners.push(beforePrintListener);\n    this.afterPrintEventListeners.push(afterPrintListener);\n  }\n\n  /**\n   * Prepare RxJS tap operator with partial application\n   * @return pipeable tap predicate\n   */\n  interceptEvents(target: HookTarget) {\n    return (event: MediaChange) => {\n      if (this.isPrintEvent(event)) {\n        if (event.matches && !this.isPrinting) {\n          this.startPrinting(target, this.getEventBreakpoints(event));\n          target.updateStyles();\n        } else if (!event.matches && this.isPrinting && !this.isPrintingBeforeAfterEvent) {\n          this.stopPrinting(target);\n          target.updateStyles();\n        }\n\n        return;\n      }\n\n      this.collectActivations(target, event);\n    };\n  }\n\n  /** Stop mediaChange event propagation in event streams */\n  blockPropagation() {\n    return (event: MediaChange): boolean => {\n      return !(this.isPrinting || this.isPrintEvent(event));\n    };\n  }\n\n  /**\n   * Save current activateBreakpoints (for later restore)\n   * and substitute only the printAlias breakpoint\n   */\n  protected startPrinting(target: HookTarget, bpList: OptionalBreakPoint[]) {\n    this.isPrinting = true;\n    this.formerActivations = target.activatedBreakpoints;\n    target.activatedBreakpoints = this.queue.addPrintBreakpoints(bpList);\n  }\n\n  /** For any print de-activations, reset the entire print queue */\n  protected stopPrinting(target: HookTarget) {\n    target.activatedBreakpoints = this.deactivations;\n    this.deactivations = [];\n    this.formerActivations = null;\n    this.queue.clear();\n    this.isPrinting = false;\n  }\n\n  /**\n   * To restore pre-Print Activations, we must capture the proper\n   * list of breakpoint activations BEFORE print starts. OnBeforePrint()\n   * is supported; so 'print' mediaQuery activations are used as a fallback\n   * in browsers without `beforeprint` support.\n   *\n   * >  But activated breakpoints are deactivated BEFORE 'print' activation.\n   *\n   * Let's capture all de-activations using the following logic:\n   *\n   *  When not printing:\n   *    - clear cache when activating non-print breakpoint\n   *    - update cache (and sort) when deactivating\n   *\n   *  When printing:\n   *    - sort and save when starting print\n   *    - restore as activatedTargets and clear when stop printing\n   */\n  collectActivations(target: HookTarget, event: MediaChange) {\n    if (!this.isPrinting || this.isPrintingBeforeAfterEvent) {\n      if (!this.isPrintingBeforeAfterEvent) {\n        // Only clear deactivations if we aren't printing from a `beforeprint` event.\n        // Otherwise, this will clear before `stopPrinting()` is called to restore\n        // the pre-Print Activations.\n        this.deactivations = [];\n\n        return;\n      }\n\n      if (!event.matches) {\n        const bp = this.breakpoints.findByQuery(event.mediaQuery);\n        // Deactivating a breakpoint\n        if (bp) {\n          const hasFormerBp = this.formerActivations && this.formerActivations.includes(bp);\n          const wasActivated = !this.formerActivations && target.activatedBreakpoints.includes(bp);\n          const shouldDeactivate = hasFormerBp || wasActivated;\n          if (shouldDeactivate) {\n            this.deactivations.push(bp);\n            this.deactivations.sort(sortDescendingPriority);\n          }\n        }\n      }\n    }\n  }\n\n  /** Teardown logic for the service. */\n  ngOnDestroy() {\n    if (this._document.defaultView) {\n      this.beforePrintEventListeners.forEach(l => this._document.defaultView.removeEventListener('beforeprint', l));\n      this.afterPrintEventListeners.forEach(l => this._document.defaultView.removeEventListener('afterprint', l));\n    }\n  }\n\n  // Is this service currently in print mode\n  private isPrinting = false;\n  private queue = new PrintQueue();\n  private deactivations: BreakPoint[] = [];\n}\n\n// ************************************************************************\n// Internal Utility class 'PrintQueue'\n// ************************************************************************\n\n/**\n * Utility class to manage print breakpoints + activatedBreakpoints\n * with correct sorting WHILE printing\n */\nclass PrintQueue {\n  /** Sorted queue with prioritized print breakpoints */\n  printBreakpoints: BreakPoint[] = [];\n\n  addPrintBreakpoints(bpList: OptionalBreakPoint[]): BreakPoint[] {\n    bpList.push(BREAKPOINT_PRINT);\n    bpList.sort(sortDescendingPriority);\n    bpList.forEach(bp => this.addBreakpoint(bp));\n\n    return this.printBreakpoints;\n  }\n\n  /** Add Print breakpoint to queue */\n  addBreakpoint(bp: OptionalBreakPoint) {\n    if (!!bp) {\n      const bpInList = this.printBreakpoints.find(it => it.mediaQuery === bp.mediaQuery);\n\n      if (bpInList === undefined) {\n        // If this is a `printAlias` breakpoint, then append. If a true 'print' breakpoint,\n        // register as highest priority in the queue\n        this.printBreakpoints = isPrintBreakPoint(bp) ? [bp, ...this.printBreakpoints]\n            : [...this.printBreakpoints, bp];\n      }\n    }\n  }\n\n  /** Restore original activated breakpoints and clear internal caches */\n  clear() {\n    this.printBreakpoints = [];\n  }\n}\n\n// ************************************************************************\n// Internal Utility methods\n// ************************************************************************\n\n/** Only support intercept queueing if the Breakpoint is a print @media query */\nfunction isPrintBreakPoint(bp: OptionalBreakPoint): boolean {\n  return bp?.mediaQuery.startsWith(PRINT) ?? false;\n}\n"]}

package/esm2020/core/media-observer/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @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
+ */
+export * from './media-observer';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saWJzL2ZsZXgtbGF5b3V0L2NvcmUvbWVkaWEtb2JzZXJ2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21lZGlhLW9ic2VydmVyJztcbiJdfQ==

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

@@ -0,0 +1,195 @@
+/**
+ * @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 { Injectable } from '@angular/core';
+import { Subject, asapScheduler, of } from 'rxjs';
+import { debounceTime, distinctUntilChanged, filter, map, switchMap, takeUntil, } from 'rxjs/operators';
+import { mergeAlias } from '../add-alias';
+import { MediaChange } from '../media-change';
+import { sortDescendingPriority } from '../utils/sort';
+import { coerceArray } from '../utils/array';
+import * as i0 from "@angular/core";
+import * as i1 from "../breakpoints/break-point-registry";
+import * as i2 from "../match-media/match-media";
+import * as i3 from "../media-marshaller/print-hook";
+/**
+ * MediaObserver enables applications to listen for 1..n mediaQuery activations and to determine
+ * if a mediaQuery is currently activated.
+ *
+ * Since a breakpoint change will first deactivate 1...n mediaQueries and then possibly activate
+ * 1..n mediaQueries, the MediaObserver will debounce notifications and report ALL *activations*
+ * in 1 event notification. The reported activations will be sorted in descending priority order.
+ *
+ * This class uses the BreakPoint Registry to inject alias information into the raw MediaChange
+ * notification. For custom mediaQuery notifications, alias information will not be injected and
+ * those fields will be ''.
+ *
+ * Note: Developers should note that only mediaChange activations (not de-activations)
+ *       are announced by the MediaObserver.
+ *
+ *  @usage
+ *
+ *  // RxJS
+ *  import { filter } from 'rxjs/operators';
+ *  import { MediaObserver } from '@angular/flex-layout';
+ *
+ *  @Component({ ... })
+ *  export class AppComponent {
+ *    status: string = '';
+ *
+ *    constructor(mediaObserver: MediaObserver) {
+ *      const media$ = mediaObserver.asObservable().pipe(
+ *        filter((changes: MediaChange[]) => true)   // silly noop filter
+ *      );
+ *
+ *      media$.subscribe((changes: MediaChange[]) => {
+ *        let status = '';
+ *        changes.forEach( change => {
+ *          status += `'${change.mqAlias}' = (${change.mediaQuery}) <br/>` ;
+ *        });
+ *        this.status = status;
+ *     });
+ *
+ *    }
+ *  }
+ */
+export class MediaObserver {
+    constructor(breakpoints, matchMedia, hook) {
+        this.breakpoints = breakpoints;
+        this.matchMedia = matchMedia;
+        this.hook = hook;
+        /** Filter MediaChange notifications for overlapping breakpoints */
+        this.filterOverlaps = false;
+        this.destroyed$ = new Subject();
+        this._media$ = this.watchActivations();
+        this.media$ = this._media$.pipe(filter((changes) => changes.length > 0), map((changes) => changes[0]));
+    }
+    /**
+     * Completes the active subject, signalling to all complete for all
+     * MediaObserver subscribers
+     */
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    // ************************************************
+    // Public Methods
+    // ************************************************
+    /**
+     * Observe changes to current activation 'list'
+     */
+    asObservable() {
+        return this._media$;
+    }
+    /**
+     * Allow programmatic query to determine if one or more media query/alias match
+     * the current viewport size.
+     * @param value One or more media queries (or aliases) to check.
+     * @returns Whether any of the media queries match.
+     */
+    isActive(value) {
+        const aliases = splitQueries(coerceArray(value));
+        return aliases.some(alias => {
+            const query = toMediaQuery(alias, this.breakpoints);
+            return query !== null && this.matchMedia.isActive(query);
+        });
+    }
+    // ************************************************
+    // Internal Methods
+    // ************************************************
+    /**
+     * Register all the mediaQueries registered in the BreakPointRegistry
+     * This is needed so subscribers can be auto-notified of all standard, registered
+     * mediaQuery activations
+     */
+    watchActivations() {
+        const queries = this.breakpoints.items.map(bp => bp.mediaQuery);
+        return this.buildObservable(queries);
+    }
+    /**
+     * Only pass/announce activations (not de-activations)
+     *
+     * Since multiple-mediaQueries can be activation in a cycle,
+     * gather all current activations into a single list of changes to observers
+     *
+     * Inject associated (if any) alias information into the MediaChange event
+     * - Exclude mediaQuery activations for overlapping mQs. List bounded mQ ranges only
+     * - Exclude print activations that do not have an associated mediaQuery
+     *
+     * NOTE: the raw MediaChange events [from MatchMedia] do not
+     *       contain important alias information; as such this info
+     *       must be injected into the MediaChange
+     */
+    buildObservable(mqList) {
+        const hasChanges = (changes) => {
+            const isValidQuery = (change) => (change.mediaQuery.length > 0);
+            return (changes.filter(isValidQuery).length > 0);
+        };
+        const excludeOverlaps = (changes) => {
+            return !this.filterOverlaps ? changes : changes.filter(change => {
+                const bp = this.breakpoints.findByQuery(change.mediaQuery);
+                return bp?.overlapping ?? true;
+            });
+        };
+        const ignoreDuplicates = (previous, current) => {
+            if (previous.length !== current.length) {
+                return false;
+            }
+            const previousMqs = previous.map(mc => mc.mediaQuery);
+            const currentMqs = new Set(current.map(mc => mc.mediaQuery));
+            const difference = new Set(previousMqs.filter(mq => !currentMqs.has(mq)));
+            return difference.size === 0;
+        };
+        /**
+         */
+        return this.matchMedia
+            .observe(this.hook.withPrintQuery(mqList))
+            .pipe(filter((change) => change.matches), debounceTime(0, asapScheduler), switchMap(_ => of(this.findAllActivations())), map(excludeOverlaps), filter(hasChanges), distinctUntilChanged(ignoreDuplicates), takeUntil(this.destroyed$));
+    }
+    /**
+     * Find all current activations and prepare single list of activations
+     * sorted by descending priority.
+     */
+    findAllActivations() {
+        const mergeMQAlias = (change) => {
+            const bp = this.breakpoints.findByQuery(change.mediaQuery);
+            return mergeAlias(change, bp);
+        };
+        const replaceWithPrintAlias = (change) => {
+            return this.hook.isPrintEvent(change) ? this.hook.updateEvent(change) : change;
+        };
+        return this.matchMedia
+            .activations
+            .map(query => new MediaChange(true, query))
+            .map(replaceWithPrintAlias)
+            .map(mergeMQAlias)
+            .sort(sortDescendingPriority);
+    }
+}
+MediaObserver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MediaObserver, deps: [{ token: i1.BreakPointRegistry }, { token: i2.MatchMedia }, { token: i3.PrintHook }], target: i0.ɵɵFactoryTarget.Injectable });
+MediaObserver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MediaObserver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MediaObserver, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.BreakPointRegistry }, { type: i2.MatchMedia }, { type: i3.PrintHook }]; } });
+/**
+ * Find associated breakpoint (if any)
+ */
+function toMediaQuery(query, locator) {
+    const bp = locator.findByAlias(query) ?? locator.findByQuery(query);
+    return bp?.mediaQuery ?? 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;base64,{"version":3,"file":"media-observer.js","sourceRoot":"","sources":["../../../../../../projects/libs/flex-layout/core/media-observer/media-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 */\nimport {Injectable, OnDestroy} from '@angular/core';\nimport {Subject, asapScheduler, Observable, of} from 'rxjs';\nimport {\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  map,\n  switchMap,\n  takeUntil,\n} from 'rxjs/operators';\n\nimport {mergeAlias} from '../add-alias';\nimport {MediaChange} from '../media-change';\nimport {MatchMedia} from '../match-media/match-media';\nimport {PrintHook} from '../media-marshaller/print-hook';\nimport {BreakPointRegistry, OptionalBreakPoint} from '../breakpoints/break-point-registry';\n\nimport {sortDescendingPriority} from '../utils/sort';\nimport {coerceArray} from '../utils/array';\n\n\n/**\n * MediaObserver enables applications to listen for 1..n mediaQuery activations and to determine\n * if a mediaQuery is currently activated.\n *\n * Since a breakpoint change will first deactivate 1...n mediaQueries and then possibly activate\n * 1..n mediaQueries, the MediaObserver will debounce notifications and report ALL *activations*\n * in 1 event notification. The reported activations will be sorted in descending priority order.\n *\n * This class uses the BreakPoint Registry to inject alias information into the raw MediaChange\n * notification. For custom mediaQuery notifications, alias information will not be injected and\n * those fields will be ''.\n *\n * Note: Developers should note that only mediaChange activations (not de-activations)\n *       are announced by the MediaObserver.\n *\n *  @usage\n *\n *  // RxJS\n *  import { filter } from 'rxjs/operators';\n *  import { MediaObserver } from '@angular/flex-layout';\n *\n *  @Component({ ... })\n *  export class AppComponent {\n *    status: string = '';\n *\n *    constructor(mediaObserver: MediaObserver) {\n *      const media$ = mediaObserver.asObservable().pipe(\n *        filter((changes: MediaChange[]) => true)   // silly noop filter\n *      );\n *\n *      media$.subscribe((changes: MediaChange[]) => {\n *        let status = '';\n *        changes.forEach( change => {\n *          status += `'${change.mqAlias}' = (${change.mediaQuery}) <br/>` ;\n *        });\n *        this.status = status;\n *     });\n *\n *    }\n *  }\n */\n@Injectable({providedIn: 'root'})\nexport class MediaObserver implements OnDestroy {\n\n  /**\n   * @deprecated Use `asObservable()` instead.\n   * @breaking-change 8.0.0-beta.25\n   * @deletion-target 10.0.0\n   */\n  readonly media$: Observable<MediaChange>;\n\n  /** Filter MediaChange notifications for overlapping breakpoints */\n  filterOverlaps = false;\n\n  constructor(protected breakpoints: BreakPointRegistry,\n              protected matchMedia: MatchMedia,\n              protected hook: PrintHook) {\n    this._media$ = this.watchActivations();\n    this.media$ = this._media$.pipe(\n      filter((changes: MediaChange[]) => changes.length > 0),\n      map((changes: MediaChange[]) => changes[0])\n    );\n  }\n\n  /**\n   * Completes the active subject, signalling to all complete for all\n   * MediaObserver subscribers\n   */\n  ngOnDestroy(): void {\n    this.destroyed$.next();\n    this.destroyed$.complete();\n  }\n\n  // ************************************************\n  // Public Methods\n  // ************************************************\n\n  /**\n   * Observe changes to current activation 'list'\n   */\n  asObservable(): Observable<MediaChange[]> {\n    return this._media$;\n  }\n\n  /**\n   * Allow programmatic query to determine if one or more media query/alias match\n   * the current viewport size.\n   * @param value One or more media queries (or aliases) to check.\n   * @returns Whether any of the media queries match.\n   */\n  isActive(value: string | string[]): boolean {\n    const aliases = splitQueries(coerceArray(value));\n    return aliases.some(alias => {\n      const query = toMediaQuery(alias, this.breakpoints);\n      return query !== null && this.matchMedia.isActive(query);\n    });\n  }\n\n  // ************************************************\n  // Internal Methods\n  // ************************************************\n\n  /**\n   * Register all the mediaQueries registered in the BreakPointRegistry\n   * This is needed so subscribers can be auto-notified of all standard, registered\n   * mediaQuery activations\n   */\n  private watchActivations() {\n    const queries = this.breakpoints.items.map(bp => bp.mediaQuery);\n    return this.buildObservable(queries);\n  }\n\n  /**\n   * Only pass/announce activations (not de-activations)\n   *\n   * Since multiple-mediaQueries can be activation in a cycle,\n   * gather all current activations into a single list of changes to observers\n   *\n   * Inject associated (if any) alias information into the MediaChange event\n   * - Exclude mediaQuery activations for overlapping mQs. List bounded mQ ranges only\n   * - Exclude print activations that do not have an associated mediaQuery\n   *\n   * NOTE: the raw MediaChange events [from MatchMedia] do not\n   *       contain important alias information; as such this info\n   *       must be injected into the MediaChange\n   */\n  private buildObservable(mqList: string[]): Observable<MediaChange[]> {\n    const hasChanges = (changes: MediaChange[]) => {\n      const isValidQuery = (change: MediaChange) => (change.mediaQuery.length > 0);\n      return (changes.filter(isValidQuery).length > 0);\n    };\n    const excludeOverlaps = (changes: MediaChange[]) => {\n      return !this.filterOverlaps ? changes : changes.filter(change => {\n        const bp = this.breakpoints.findByQuery(change.mediaQuery);\n        return bp?.overlapping ?? true;\n      });\n    };\n    const ignoreDuplicates = (previous: MediaChange[], current: MediaChange[]): boolean => {\n      if (previous.length !== current.length) {\n        return false;\n      }\n\n      const previousMqs = previous.map(mc => mc.mediaQuery);\n      const currentMqs = new Set(current.map(mc => mc.mediaQuery));\n      const difference = new Set(previousMqs.filter(mq => !currentMqs.has(mq)));\n\n      return difference.size === 0;\n    };\n\n    /**\n     */\n    return this.matchMedia\n        .observe(this.hook.withPrintQuery(mqList))\n        .pipe(\n            filter((change: MediaChange) => change.matches),\n            debounceTime(0, asapScheduler),\n            switchMap(_ => of(this.findAllActivations())),\n            map(excludeOverlaps),\n            filter(hasChanges),\n            distinctUntilChanged(ignoreDuplicates),\n            takeUntil(this.destroyed$)\n        );\n  }\n\n  /**\n   * Find all current activations and prepare single list of activations\n   * sorted by descending priority.\n   */\n  private findAllActivations(): MediaChange[] {\n    const mergeMQAlias = (change: MediaChange) => {\n      const bp: OptionalBreakPoint = this.breakpoints.findByQuery(change.mediaQuery);\n      return mergeAlias(change, bp);\n    };\n    const replaceWithPrintAlias = (change: MediaChange) => {\n      return this.hook.isPrintEvent(change) ? this.hook.updateEvent(change) : change;\n    };\n\n    return this.matchMedia\n        .activations\n        .map(query => new MediaChange(true, query))\n        .map(replaceWithPrintAlias)\n        .map(mergeMQAlias)\n        .sort(sortDescendingPriority);\n  }\n\n  private readonly _media$: Observable<MediaChange[]>;\n  private readonly destroyed$ = new Subject<void>();\n}\n\n/**\n * Find associated breakpoint (if any)\n */\nfunction toMediaQuery(query: string, locator: BreakPointRegistry): string | null {\n  const bp = locator.findByAlias(query) ?? locator.findByQuery(query);\n  return bp?.mediaQuery ?? null;\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: string[]): string[] {\n  return queries.map((query: string) => query.split(','))\n                .reduce((a1: string[], a2: string[]) => a1.concat(a2))\n                .map(query => query.trim());\n}\n"]}

package/esm2020/core/media-trigger/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @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
+ */
+export * from './media-trigger';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saWJzL2ZsZXgtbGF5b3V0L2NvcmUvbWVkaWEtdHJpZ2dlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbWVkaWEtdHJpZ2dlcic7XG4iXX0=