@dugararchit/flex-layout 13.0.0-dugararchit

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

@@ -0,0 +1,317 @@
+/**
+ * @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 { merge, Subject } from 'rxjs';
+import { filter, tap } from 'rxjs/operators';
+import { sortDescendingPriority } from '../utils/sort';
+import { mergeAlias } from '../add-alias';
+import * as i0 from "@angular/core";
+import * as i1 from "../match-media/match-media";
+import * as i2 from "../breakpoints/break-point-registry";
+import * as i3 from "./print-hook";
+/**
+ * MediaMarshaller - register responsive values from directives and
+ *                   trigger them based on media query events
+ */
+export class MediaMarshaller {
+    constructor(matchMedia, breakpoints, hook) {
+        this.matchMedia = matchMedia;
+        this.breakpoints = breakpoints;
+        this.hook = hook;
+        this._useFallbacks = true;
+        this._activatedBreakpoints = [];
+        this.elementMap = new Map();
+        this.elementKeyMap = new WeakMap();
+        this.watcherMap = new WeakMap(); // special triggers to update elements
+        this.updateMap = new WeakMap(); // callback functions to update styles
+        this.clearMap = new WeakMap(); // callback functions to clear styles
+        this.subject = new Subject();
+        this.observeActivations();
+    }
+    get activatedAlias() {
+        return this.activatedBreakpoints[0]?.alias ?? '';
+    }
+    set activatedBreakpoints(bps) {
+        this._activatedBreakpoints = [...bps];
+    }
+    get activatedBreakpoints() {
+        return [...this._activatedBreakpoints];
+    }
+    set useFallbacks(value) {
+        this._useFallbacks = value;
+    }
+    /**
+     * Update styles on breakpoint activates or deactivates
+     * @param mc
+     */
+    onMediaChange(mc) {
+        const bp = this.findByQuery(mc.mediaQuery);
+        if (bp) {
+            mc = mergeAlias(mc, bp);
+            const bpIndex = this.activatedBreakpoints.indexOf(bp);
+            if (mc.matches && bpIndex === -1) {
+                this._activatedBreakpoints.push(bp);
+                this._activatedBreakpoints.sort(sortDescendingPriority);
+                this.updateStyles();
+            }
+            else if (!mc.matches && bpIndex !== -1) {
+                // Remove the breakpoint when it's deactivated
+                this._activatedBreakpoints.splice(bpIndex, 1);
+                this._activatedBreakpoints.sort(sortDescendingPriority);
+                this.updateStyles();
+            }
+        }
+    }
+    /**
+     * initialize the marshaller with necessary elements for delegation on an element
+     * @param element
+     * @param key
+     * @param updateFn optional callback so that custom bp directives don't have to re-provide this
+     * @param clearFn optional callback so that custom bp directives don't have to re-provide this
+     * @param extraTriggers other triggers to force style updates (e.g. layout, directionality, etc)
+     */
+    init(element, key, updateFn, clearFn, extraTriggers = []) {
+        initBuilderMap(this.updateMap, element, key, updateFn);
+        initBuilderMap(this.clearMap, element, key, clearFn);
+        this.buildElementKeyMap(element, key);
+        this.watchExtraTriggers(element, key, extraTriggers);
+    }
+    /**
+     * get the value for an element and key and optionally a given breakpoint
+     * @param element
+     * @param key
+     * @param bp
+     */
+    getValue(element, key, bp) {
+        const bpMap = this.elementMap.get(element);
+        if (bpMap) {
+            const values = bp !== undefined ? bpMap.get(bp) : this.getActivatedValues(bpMap, key);
+            if (values) {
+                return values.get(key);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * whether the element has values for a given key
+     * @param element
+     * @param key
+     */
+    hasValue(element, key) {
+        const bpMap = this.elementMap.get(element);
+        if (bpMap) {
+            const values = this.getActivatedValues(bpMap, key);
+            if (values) {
+                return values.get(key) !== undefined || false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Set the value for an input on a directive
+     * @param element the element in question
+     * @param key the type of the directive (e.g. flex, layout-gap, etc)
+     * @param bp the breakpoint suffix (empty string = default)
+     * @param val the value for the breakpoint
+     */
+    setValue(element, key, val, bp) {
+        let bpMap = this.elementMap.get(element);
+        if (!bpMap) {
+            bpMap = new Map().set(bp, new Map().set(key, val));
+            this.elementMap.set(element, bpMap);
+        }
+        else {
+            const values = (bpMap.get(bp) ?? new Map()).set(key, val);
+            bpMap.set(bp, values);
+            this.elementMap.set(element, bpMap);
+        }
+        const value = this.getValue(element, key);
+        if (value !== undefined) {
+            this.updateElement(element, key, value);
+        }
+    }
+    /** Track element value changes for a specific key */
+    trackValue(element, key) {
+        return this.subject
+            .asObservable()
+            .pipe(filter(v => v.element === element && v.key === key));
+    }
+    /** update all styles for all elements on the current breakpoint */
+    updateStyles() {
+        this.elementMap.forEach((bpMap, el) => {
+            const keyMap = new Set(this.elementKeyMap.get(el));
+            let valueMap = this.getActivatedValues(bpMap);
+            if (valueMap) {
+                valueMap.forEach((v, k) => {
+                    this.updateElement(el, k, v);
+                    keyMap.delete(k);
+                });
+            }
+            keyMap.forEach(k => {
+                valueMap = this.getActivatedValues(bpMap, k);
+                if (valueMap) {
+                    const value = valueMap.get(k);
+                    this.updateElement(el, k, value);
+                }
+                else {
+                    this.clearElement(el, k);
+                }
+            });
+        });
+    }
+    /**
+     * clear the styles for a given element
+     * @param element
+     * @param key
+     */
+    clearElement(element, key) {
+        const builders = this.clearMap.get(element);
+        if (builders) {
+            const clearFn = builders.get(key);
+            if (!!clearFn) {
+                clearFn();
+                this.subject.next({ element, key, value: '' });
+            }
+        }
+    }
+    /**
+     * update a given element with the activated values for a given key
+     * @param element
+     * @param key
+     * @param value
+     */
+    updateElement(element, key, value) {
+        const builders = this.updateMap.get(element);
+        if (builders) {
+            const updateFn = builders.get(key);
+            if (!!updateFn) {
+                updateFn(value);
+                this.subject.next({ element, key, value });
+            }
+        }
+    }
+    /**
+     * release all references to a given element
+     * @param element
+     */
+    releaseElement(element) {
+        const watcherMap = this.watcherMap.get(element);
+        if (watcherMap) {
+            watcherMap.forEach(s => s.unsubscribe());
+            this.watcherMap.delete(element);
+        }
+        const elementMap = this.elementMap.get(element);
+        if (elementMap) {
+            elementMap.forEach((_, s) => elementMap.delete(s));
+            this.elementMap.delete(element);
+        }
+    }
+    /**
+     * trigger an update for a given element and key (e.g. layout)
+     * @param element
+     * @param key
+     */
+    triggerUpdate(element, key) {
+        const bpMap = this.elementMap.get(element);
+        if (bpMap) {
+            const valueMap = this.getActivatedValues(bpMap, key);
+            if (valueMap) {
+                if (key) {
+                    this.updateElement(element, key, valueMap.get(key));
+                }
+                else {
+                    valueMap.forEach((v, k) => this.updateElement(element, k, v));
+                }
+            }
+        }
+    }
+    /** Cross-reference for HTMLElement with directive key */
+    buildElementKeyMap(element, key) {
+        let keyMap = this.elementKeyMap.get(element);
+        if (!keyMap) {
+            keyMap = new Set();
+            this.elementKeyMap.set(element, keyMap);
+        }
+        keyMap.add(key);
+    }
+    /**
+     * Other triggers that should force style updates:
+     * - directionality
+     * - layout changes
+     * - mutationobserver updates
+     */
+    watchExtraTriggers(element, key, triggers) {
+        if (triggers && triggers.length) {
+            let watchers = this.watcherMap.get(element);
+            if (!watchers) {
+                watchers = new Map();
+                this.watcherMap.set(element, watchers);
+            }
+            const subscription = watchers.get(key);
+            if (!subscription) {
+                const newSubscription = merge(...triggers).subscribe(() => {
+                    const currentValue = this.getValue(element, key);
+                    this.updateElement(element, key, currentValue);
+                });
+                watchers.set(key, newSubscription);
+            }
+        }
+    }
+    /** Breakpoint locator by mediaQuery */
+    findByQuery(query) {
+        return this.breakpoints.findByQuery(query);
+    }
+    /**
+     * get the fallback breakpoint for a given element, starting with the current breakpoint
+     * @param bpMap
+     * @param key
+     */
+    getActivatedValues(bpMap, key) {
+        for (let i = 0; i < this.activatedBreakpoints.length; i++) {
+            const activatedBp = this.activatedBreakpoints[i];
+            const valueMap = bpMap.get(activatedBp.alias);
+            if (valueMap) {
+                if (key === undefined || (valueMap.has(key) && valueMap.get(key) != null)) {
+                    return valueMap;
+                }
+            }
+        }
+        // On the server, we explicitly have an "all" section filled in to begin with.
+        // So we don't need to aggressively find a fallback if no explicit value exists.
+        if (!this._useFallbacks) {
+            return undefined;
+        }
+        const lastHope = bpMap.get('');
+        return (key === undefined || lastHope && lastHope.has(key)) ? lastHope : undefined;
+    }
+    /**
+     * Watch for mediaQuery breakpoint activations
+     */
+    observeActivations() {
+        const queries = this.breakpoints.items.map(bp => bp.mediaQuery);
+        this.hook.registerBeforeAfterPrintHooks(this);
+        this.matchMedia
+            .observe(this.hook.withPrintQuery(queries))
+            .pipe(tap(this.hook.interceptEvents(this)), filter(this.hook.blockPropagation()))
+            .subscribe(this.onMediaChange.bind(this));
+    }
+}
+MediaMarshaller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MediaMarshaller, deps: [{ token: i1.MatchMedia }, { token: i2.BreakPointRegistry }, { token: i3.PrintHook }], target: i0.ɵɵFactoryTarget.Injectable });
+MediaMarshaller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MediaMarshaller, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MediaMarshaller, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.MatchMedia }, { type: i2.BreakPointRegistry }, { type: i3.PrintHook }]; } });
+function initBuilderMap(map, element, key, input) {
+    if (input !== undefined) {
+        const oldMap = map.get(element) ?? new Map();
+        oldMap.set(key, input);
+        map.set(element, oldMap);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"media-marshaller.js","sourceRoot":"","sources":["../../../../../../projects/libs/flex-layout/core/media-marshaller/media-marshaller.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} from '@angular/core';\n\nimport {merge, Observable, Subject, Subscription} from 'rxjs';\nimport {filter, tap} from 'rxjs/operators';\n\nimport {BreakPoint} from '../breakpoints/break-point';\nimport {sortDescendingPriority} from '../utils/sort';\nimport {BreakPointRegistry} from '../breakpoints/break-point-registry';\nimport {MatchMedia} from '../match-media/match-media';\nimport {MediaChange} from '../media-change';\n\nimport {PrintHook, HookTarget} from './print-hook';\nimport {mergeAlias} from '../add-alias';\n\ntype ClearCallback = () => void;\ntype UpdateCallback = (val: any) => void;\ntype Builder = UpdateCallback | ClearCallback;\n\ntype ValueMap = Map<string, string>;\ntype BreakpointMap = Map<string, ValueMap>;\ntype ElementMap = Map<HTMLElement, BreakpointMap>;\ntype ElementKeyMap = WeakMap<HTMLElement, Set<string>>;\ntype SubscriptionMap = Map<string, Subscription>;\ntype WatcherMap = WeakMap<HTMLElement, SubscriptionMap>;\ntype BuilderMap = WeakMap<HTMLElement, Map<string, Builder>>;\n\nexport interface ElementMatcher {\n  element: HTMLElement;\n  key: string;\n  value: any;\n}\n\n/**\n * MediaMarshaller - register responsive values from directives and\n *                   trigger them based on media query events\n */\n@Injectable({providedIn: 'root'})\nexport class MediaMarshaller {\n  private _useFallbacks = true;\n  private _activatedBreakpoints: BreakPoint[] = [];\n  private elementMap: ElementMap = new Map();\n  private elementKeyMap: ElementKeyMap = new WeakMap();\n  private watcherMap: WatcherMap = new WeakMap();     // special triggers to update elements\n  private updateMap: BuilderMap = new WeakMap();      // callback functions to update styles\n  private clearMap: BuilderMap = new WeakMap();       // callback functions to clear styles\n\n  private subject: Subject<ElementMatcher> = new Subject();\n\n  get activatedAlias(): string {\n    return this.activatedBreakpoints[0]?.alias ?? '';\n  }\n\n  set activatedBreakpoints(bps: BreakPoint[]) {\n    this._activatedBreakpoints = [...bps];\n  }\n\n  get activatedBreakpoints(): BreakPoint[] {\n    return [...this._activatedBreakpoints];\n  }\n\n  set useFallbacks(value: boolean) {\n    this._useFallbacks = value;\n  }\n\n  constructor(protected matchMedia: MatchMedia,\n              protected breakpoints: BreakPointRegistry,\n              protected hook: PrintHook) {\n    this.observeActivations();\n  }\n\n  /**\n   * Update styles on breakpoint activates or deactivates\n   * @param mc\n   */\n  onMediaChange(mc: MediaChange) {\n    const bp: BreakPoint | null = this.findByQuery(mc.mediaQuery);\n\n    if (bp) {\n      mc = mergeAlias(mc, bp);\n\n      const bpIndex = this.activatedBreakpoints.indexOf(bp);\n\n      if (mc.matches && bpIndex === -1) {\n        this._activatedBreakpoints.push(bp);\n        this._activatedBreakpoints.sort(sortDescendingPriority);\n\n        this.updateStyles();\n      } else if (!mc.matches && bpIndex !== -1) {\n        // Remove the breakpoint when it's deactivated\n        this._activatedBreakpoints.splice(bpIndex, 1);\n        this._activatedBreakpoints.sort(sortDescendingPriority);\n\n        this.updateStyles();\n      }\n    }\n  }\n\n  /**\n   * initialize the marshaller with necessary elements for delegation on an element\n   * @param element\n   * @param key\n   * @param updateFn optional callback so that custom bp directives don't have to re-provide this\n   * @param clearFn optional callback so that custom bp directives don't have to re-provide this\n   * @param extraTriggers other triggers to force style updates (e.g. layout, directionality, etc)\n   */\n  init(element: HTMLElement,\n       key: string,\n       updateFn?: UpdateCallback,\n       clearFn?: ClearCallback,\n       extraTriggers: Observable<any>[] = []): void {\n\n    initBuilderMap(this.updateMap, element, key, updateFn);\n    initBuilderMap(this.clearMap, element, key, clearFn);\n\n    this.buildElementKeyMap(element, key);\n    this.watchExtraTriggers(element, key, extraTriggers);\n  }\n\n  /**\n   * get the value for an element and key and optionally a given breakpoint\n   * @param element\n   * @param key\n   * @param bp\n   */\n  getValue(element: HTMLElement, key: string, bp?: string): any {\n    const bpMap = this.elementMap.get(element);\n    if (bpMap) {\n      const values = bp !== undefined ? bpMap.get(bp) : this.getActivatedValues(bpMap, key);\n      if (values) {\n        return values.get(key);\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * whether the element has values for a given key\n   * @param element\n   * @param key\n   */\n  hasValue(element: HTMLElement, key: string): boolean {\n    const bpMap = this.elementMap.get(element);\n    if (bpMap) {\n      const values = this.getActivatedValues(bpMap, key);\n      if (values) {\n        return values.get(key) !== undefined || false;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Set the value for an input on a directive\n   * @param element the element in question\n   * @param key the type of the directive (e.g. flex, layout-gap, etc)\n   * @param bp the breakpoint suffix (empty string = default)\n   * @param val the value for the breakpoint\n   */\n  setValue(element: HTMLElement, key: string, val: any, bp: string): void {\n    let bpMap: BreakpointMap | undefined = this.elementMap.get(element);\n    if (!bpMap) {\n      bpMap = new Map().set(bp, new Map().set(key, val));\n      this.elementMap.set(element, bpMap);\n    } else {\n      const values = (bpMap.get(bp) ?? new Map()).set(key, val);\n      bpMap.set(bp, values);\n      this.elementMap.set(element, bpMap);\n    }\n    const value = this.getValue(element, key);\n    if (value !== undefined) {\n      this.updateElement(element, key, value);\n    }\n  }\n\n  /** Track element value changes for a specific key */\n  trackValue(element: HTMLElement, key: string): Observable<ElementMatcher> {\n    return this.subject\n        .asObservable()\n        .pipe(filter(v => v.element === element && v.key === key));\n  }\n\n  /** update all styles for all elements on the current breakpoint */\n  updateStyles(): void {\n    this.elementMap.forEach((bpMap, el) => {\n      const keyMap = new Set(this.elementKeyMap.get(el)!);\n      let valueMap = this.getActivatedValues(bpMap);\n\n      if (valueMap) {\n        valueMap.forEach((v, k) => {\n          this.updateElement(el, k, v);\n          keyMap.delete(k);\n        });\n      }\n\n      keyMap.forEach(k => {\n        valueMap = this.getActivatedValues(bpMap, k);\n        if (valueMap) {\n          const value = valueMap.get(k);\n          this.updateElement(el, k, value);\n        } else {\n          this.clearElement(el, k);\n        }\n      });\n    });\n  }\n\n  /**\n   * clear the styles for a given element\n   * @param element\n   * @param key\n   */\n  clearElement(element: HTMLElement, key: string): void {\n    const builders = this.clearMap.get(element);\n\n    if (builders) {\n      const clearFn: ClearCallback = builders.get(key) as ClearCallback;\n      if (!!clearFn) {\n        clearFn();\n        this.subject.next({element, key, value: ''});\n      }\n    }\n  }\n\n  /**\n   * update a given element with the activated values for a given key\n   * @param element\n   * @param key\n   * @param value\n   */\n  updateElement(element: HTMLElement, key: string, value: any): void {\n    const builders = this.updateMap.get(element);\n    if (builders) {\n      const updateFn: UpdateCallback = builders.get(key) as UpdateCallback;\n      if (!!updateFn) {\n        updateFn(value);\n        this.subject.next({element, key, value});\n      }\n    }\n  }\n\n  /**\n   * release all references to a given element\n   * @param element\n   */\n  releaseElement(element: HTMLElement): void {\n    const watcherMap = this.watcherMap.get(element);\n    if (watcherMap) {\n      watcherMap.forEach(s => s.unsubscribe());\n      this.watcherMap.delete(element);\n    }\n    const elementMap = this.elementMap.get(element);\n    if (elementMap) {\n      elementMap.forEach((_, s) => elementMap.delete(s));\n      this.elementMap.delete(element);\n    }\n  }\n\n  /**\n   * trigger an update for a given element and key (e.g. layout)\n   * @param element\n   * @param key\n   */\n  triggerUpdate(element: HTMLElement, key?: string): void {\n    const bpMap = this.elementMap.get(element);\n    if (bpMap) {\n      const valueMap = this.getActivatedValues(bpMap, key);\n      if (valueMap) {\n        if (key) {\n          this.updateElement(element, key, valueMap.get(key));\n        } else {\n          valueMap.forEach((v, k) => this.updateElement(element, k, v));\n        }\n      }\n    }\n  }\n\n  /** Cross-reference for HTMLElement with directive key */\n  private buildElementKeyMap(element: HTMLElement, key: string) {\n    let keyMap = this.elementKeyMap.get(element);\n    if (!keyMap) {\n      keyMap = new Set();\n      this.elementKeyMap.set(element, keyMap);\n    }\n    keyMap.add(key);\n  }\n\n  /**\n   * Other triggers that should force style updates:\n   * - directionality\n   * - layout changes\n   * - mutationobserver updates\n   */\n  private watchExtraTriggers(element: HTMLElement,\n                             key: string,\n                             triggers: Observable<any>[]) {\n    if (triggers && triggers.length) {\n      let watchers = this.watcherMap.get(element);\n      if (!watchers) {\n        watchers = new Map();\n        this.watcherMap.set(element, watchers);\n      }\n      const subscription = watchers.get(key);\n      if (!subscription) {\n        const newSubscription = merge(...triggers).subscribe(() => {\n          const currentValue = this.getValue(element, key);\n          this.updateElement(element, key, currentValue);\n        });\n        watchers.set(key, newSubscription);\n      }\n    }\n  }\n\n  /** Breakpoint locator by mediaQuery */\n  private findByQuery(query: string) {\n    return this.breakpoints.findByQuery(query);\n  }\n\n  /**\n   * get the fallback breakpoint for a given element, starting with the current breakpoint\n   * @param bpMap\n   * @param key\n   */\n  private getActivatedValues(bpMap: BreakpointMap, key?: string): ValueMap | undefined {\n    for (let i = 0; i < this.activatedBreakpoints.length; i++) {\n      const activatedBp = this.activatedBreakpoints[i];\n      const valueMap = bpMap.get(activatedBp.alias);\n\n      if (valueMap) {\n        if (key === undefined || (valueMap.has(key) && valueMap.get(key) != null)) {\n          return valueMap;\n        }\n      }\n    }\n\n    // On the server, we explicitly have an \"all\" section filled in to begin with.\n    // So we don't need to aggressively find a fallback if no explicit value exists.\n    if (!this._useFallbacks) {\n      return undefined;\n    }\n\n    const lastHope = bpMap.get('');\n    return (key === undefined || lastHope && lastHope.has(key)) ? lastHope : undefined;\n  }\n\n  /**\n   * Watch for mediaQuery breakpoint activations\n   */\n  private observeActivations() {\n    const queries = this.breakpoints.items.map(bp => bp.mediaQuery);\n\n    this.hook.registerBeforeAfterPrintHooks(this);\n    this.matchMedia\n        .observe(this.hook.withPrintQuery(queries))\n        .pipe(\n            tap(this.hook.interceptEvents(this)),\n            filter(this.hook.blockPropagation())\n        )\n        .subscribe(this.onMediaChange.bind(this));\n  }\n\n}\n\nfunction initBuilderMap(map: BuilderMap,\n                        element: HTMLElement,\n                        key: string,\n                        input?: Builder): void {\n  if (input !== undefined) {\n    const oldMap = map.get(element) ?? new Map();\n    oldMap.set(key, input);\n    map.set(element, oldMap);\n  }\n}\n\n"]}