@dugararchit/flex-layout 13.0.0-dugararchit

package/esm2020/grid/rows/rows.mjs

@@ -0,0 +1,96 @@
+/**
+ * @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 { Directive, Input, Injectable } from '@angular/core';
+import { BaseDirective2, StyleBuilder, } from '@angular/flex-layout/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/flex-layout/core";
+const DEFAULT_VALUE = 'none';
+const AUTO_SPECIFIER = '!';
+export class GridRowsStyleBuilder extends StyleBuilder {
+    buildStyles(input, parent) {
+        input = input || DEFAULT_VALUE;
+        let auto = false;
+        if (input.endsWith(AUTO_SPECIFIER)) {
+            input = input.substring(0, input.indexOf(AUTO_SPECIFIER));
+            auto = true;
+        }
+        const css = {
+            'display': parent.inline ? 'inline-grid' : 'grid',
+            'grid-auto-rows': '',
+            'grid-template-rows': '',
+        };
+        const key = (auto ? 'grid-auto-rows' : 'grid-template-rows');
+        css[key] = input;
+        return css;
+    }
+}
+GridRowsStyleBuilder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: GridRowsStyleBuilder, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+GridRowsStyleBuilder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: GridRowsStyleBuilder, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: GridRowsStyleBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+export class GridRowsDirective extends BaseDirective2 {
+    constructor(elementRef, styleBuilder, styler, marshal) {
+        super(elementRef, styleBuilder, styler, marshal);
+        this.DIRECTIVE_KEY = 'grid-rows';
+        this._inline = false;
+        this.init();
+    }
+    get inline() { return this._inline; }
+    set inline(val) { this._inline = coerceBooleanProperty(val); }
+    // *********************************************
+    // Protected methods
+    // *********************************************
+    updateWithValue(value) {
+        this.styleCache = this.inline ? rowsInlineCache : rowsCache;
+        this.addStyles(value, { inline: this.inline });
+    }
+}
+GridRowsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: GridRowsDirective, deps: [{ token: i0.ElementRef }, { token: GridRowsStyleBuilder }, { token: i1.StyleUtils }, { token: i1.MediaMarshaller }], target: i0.ɵɵFactoryTarget.Directive });
+GridRowsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: GridRowsDirective, inputs: { inline: ["gdInline", "inline"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: GridRowsDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: GridRowsStyleBuilder }, { type: i1.StyleUtils }, { type: i1.MediaMarshaller }]; }, propDecorators: { inline: [{
+                type: Input,
+                args: ['gdInline']
+            }] } });
+const rowsCache = new Map();
+const rowsInlineCache = new Map();
+const inputs = [
+    'gdRows',
+    'gdRows.xs', 'gdRows.sm', 'gdRows.md', 'gdRows.lg', 'gdRows.xl',
+    'gdRows.lt-sm', 'gdRows.lt-md', 'gdRows.lt-lg', 'gdRows.lt-xl',
+    'gdRows.gt-xs', 'gdRows.gt-sm', 'gdRows.gt-md', 'gdRows.gt-lg'
+];
+const selector = `
+  [gdRows],
+  [gdRows.xs], [gdRows.sm], [gdRows.md], [gdRows.lg], [gdRows.xl],
+  [gdRows.lt-sm], [gdRows.lt-md], [gdRows.lt-lg], [gdRows.lt-xl],
+  [gdRows.gt-xs], [gdRows.gt-sm], [gdRows.gt-md], [gdRows.gt-lg]
+`;
+/**
+ * 'grid-template-rows' CSS Grid styling directive
+ * Configures the sizing for the rows in the grid
+ * Syntax: <column value> [auto]
+ * @see https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-13
+ */
+export class DefaultGridRowsDirective extends GridRowsDirective {
+    constructor() {
+        super(...arguments);
+        this.inputs = inputs;
+    }
+}
+DefaultGridRowsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: DefaultGridRowsDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DefaultGridRowsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: DefaultGridRowsDirective, selector: "\n  [gdRows],\n  [gdRows.xs], [gdRows.sm], [gdRows.md], [gdRows.lg], [gdRows.xl],\n  [gdRows.lt-sm], [gdRows.lt-md], [gdRows.lt-lg], [gdRows.lt-xl],\n  [gdRows.gt-xs], [gdRows.gt-sm], [gdRows.gt-md], [gdRows.gt-lg]\n", inputs: { gdRows: "gdRows", "gdRows.xs": "gdRows.xs", "gdRows.sm": "gdRows.sm", "gdRows.md": "gdRows.md", "gdRows.lg": "gdRows.lg", "gdRows.xl": "gdRows.xl", "gdRows.lt-sm": "gdRows.lt-sm", "gdRows.lt-md": "gdRows.lt-md", "gdRows.lt-lg": "gdRows.lt-lg", "gdRows.lt-xl": "gdRows.lt-xl", "gdRows.gt-xs": "gdRows.gt-xs", "gdRows.gt-sm": "gdRows.gt-sm", "gdRows.gt-md": "gdRows.gt-md", "gdRows.gt-lg": "gdRows.gt-lg" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: DefaultGridRowsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector, inputs }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/module.mjs

@@ -0,0 +1,64 @@
+/**
+ * @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, NgModule, PLATFORM_ID } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { SERVER_TOKEN, LAYOUT_CONFIG, DEFAULT_CONFIG, BREAKPOINT, } from '@angular/flex-layout/core';
+import { ExtendedModule } from '@angular/flex-layout/extended';
+import { FlexModule } from '@angular/flex-layout/flex';
+import { GridModule } from '@angular/flex-layout/grid';
+import * as i0 from "@angular/core";
+/**
+ * FlexLayoutModule -- the main import for all utilities in the Angular Layout library
+ * * Will automatically provide Flex, Grid, and Extended modules for use in the application
+ * * Can be configured using the static withConfig method, options viewable on the Wiki's
+ *   Configuration page
+ */
+export class FlexLayoutModule {
+    constructor(serverModuleLoaded, platformId) {
+        if (isPlatformServer(platformId) && !serverModuleLoaded) {
+            console.warn('Warning: Flex Layout loaded on the server without FlexLayoutServerModule');
+        }
+    }
+    /**
+     * Initialize the FlexLayoutModule with a set of config options,
+     * which sets the corresponding tokens accordingly
+     */
+    static withConfig(configOptions, 
+    // tslint:disable-next-line:max-line-length
+    breakpoints = []) {
+        return {
+            ngModule: FlexLayoutModule,
+            providers: configOptions.serverLoaded ?
+                [
+                    { provide: LAYOUT_CONFIG, useValue: { ...DEFAULT_CONFIG, ...configOptions } },
+                    { provide: BREAKPOINT, useValue: breakpoints, multi: true },
+                    { provide: SERVER_TOKEN, useValue: true },
+                ] : [
+                { provide: LAYOUT_CONFIG, useValue: { ...DEFAULT_CONFIG, ...configOptions } },
+                { provide: BREAKPOINT, useValue: breakpoints, multi: true },
+            ]
+        };
+    }
+}
+FlexLayoutModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutModule, deps: [{ token: SERVER_TOKEN }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.NgModule });
+FlexLayoutModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutModule, imports: [FlexModule, ExtendedModule, GridModule], exports: [FlexModule, ExtendedModule, GridModule] });
+FlexLayoutModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutModule, imports: [[FlexModule, ExtendedModule, GridModule], FlexModule, ExtendedModule, GridModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [FlexModule, ExtendedModule, GridModule],
+                    exports: [FlexModule, ExtendedModule, GridModule]
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SERVER_TOKEN]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of Angular Flex-Layout.
+ */
+export * from './version';
+export * from '@angular/flex-layout/core';
+export * from '@angular/flex-layout/extended';
+export * from '@angular/flex-layout/flex';
+export * from '@angular/flex-layout/grid';
+// Flex-Layout Module
+export * from './module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2xpYnMvZmxleC1sYXlvdXQvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSDs7OztHQUlHO0FBQ0gsY0FBYyxXQUFXLENBQUM7QUFFMUIsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyxxQkFBcUI7QUFDckIsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBAbW9kdWxlXG4gKiBAZGVzY3JpcHRpb25cbiAqIEVudHJ5IHBvaW50IGZvciBhbGwgcHVibGljIEFQSXMgb2YgQW5ndWxhciBGbGV4LUxheW91dC5cbiAqL1xuZXhwb3J0ICogZnJvbSAnLi92ZXJzaW9uJztcblxuZXhwb3J0ICogZnJvbSAnQGFuZ3VsYXIvZmxleC1sYXlvdXQvY29yZSc7XG5leHBvcnQgKiBmcm9tICdAYW5ndWxhci9mbGV4LWxheW91dC9leHRlbmRlZCc7XG5leHBvcnQgKiBmcm9tICdAYW5ndWxhci9mbGV4LWxheW91dC9mbGV4JztcbmV4cG9ydCAqIGZyb20gJ0Bhbmd1bGFyL2ZsZXgtbGF5b3V0L2dyaWQnO1xuXG4vLyBGbGV4LUxheW91dCBNb2R1bGVcbmV4cG9ydCAqIGZyb20gJy4vbW9kdWxlJztcbiJdfQ==

package/esm2020/server/angular-flex-layout-server.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci1mbGV4LWxheW91dC1zZXJ2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saWJzL2ZsZXgtbGF5b3V0L3NlcnZlci9hbmd1bGFyLWZsZXgtbGF5b3V0LXNlcnZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/server/module.mjs

@@ -0,0 +1,22 @@
+/**
+ * @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 { NgModule } from '@angular/core';
+import { SERVER_PROVIDERS } from './server-provider';
+import * as i0 from "@angular/core";
+export class FlexLayoutServerModule {
+}
+FlexLayoutServerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutServerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FlexLayoutServerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutServerModule });
+FlexLayoutServerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutServerModule, providers: [SERVER_PROVIDERS] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexLayoutServerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [SERVER_PROVIDERS]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGlicy9mbGV4LWxheW91dC9zZXJ2ZXIvbW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUNILE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFdkMsT0FBTyxFQUFDLGdCQUFnQixFQUFDLE1BQU0sbUJBQW1CLENBQUM7O0FBS25ELE1BQU0sT0FBTyxzQkFBc0I7O21IQUF0QixzQkFBc0I7b0hBQXRCLHNCQUFzQjtvSEFBdEIsc0JBQXNCLGFBRnRCLENBQUMsZ0JBQWdCLENBQUM7MkZBRWxCLHNCQUFzQjtrQkFIbEMsUUFBUTttQkFBQztvQkFDUixTQUFTLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztpQkFDOUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQge1NFUlZFUl9QUk9WSURFUlN9IGZyb20gJy4vc2VydmVyLXByb3ZpZGVyJztcblxuQE5nTW9kdWxlKHtcbiAgcHJvdmlkZXJzOiBbU0VSVkVSX1BST1ZJREVSU11cbn0pXG5leHBvcnQgY2xhc3MgRmxleExheW91dFNlcnZlck1vZHVsZSB7fVxuIl19

package/esm2020/server/public-api.mjs

@@ -0,0 +1,10 @@
+/**
+ * @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 './module';
+export * from './server-provider';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpYnMvZmxleC1sYXlvdXQvc2VydmVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZlci1wcm92aWRlcic7XG4iXX0=

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

@@ -0,0 +1,151 @@
+/**
+ * @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 { DOCUMENT } from '@angular/common';
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { ɵMatchMedia as MatchMedia, BREAKPOINTS, LAYOUT_CONFIG } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+/**
+ * Special server-only class to simulate a MediaQueryList and
+ * - supports manual activation to simulate mediaQuery matching
+ * - manages listeners
+ */
+export class ServerMediaQueryList {
+    constructor(_mediaQuery, _isActive = false) {
+        this._mediaQuery = _mediaQuery;
+        this._isActive = _isActive;
+        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 server environment */
+    removeListener() {
+    }
+    addEventListener() {
+    }
+    removeEventListener() {
+    }
+    dispatchEvent(_) {
+        return false;
+    }
+}
+/**
+ * Special server-only implementation of MatchMedia that uses the above
+ * ServerMediaQueryList as its internal representation
+ *
+ * Also contains methods to activate and deactivate breakpoints
+ */
+export class ServerMatchMedia extends MatchMedia {
+    constructor(_zone, _platformId, _document, breakpoints, layoutConfig) {
+        super(_zone, _platformId, _document);
+        this._zone = _zone;
+        this._platformId = _platformId;
+        this._document = _document;
+        this.breakpoints = breakpoints;
+        this.layoutConfig = layoutConfig;
+        this._activeBreakpoints = [];
+        const serverBps = layoutConfig.ssrObserveBreakpoints;
+        if (serverBps) {
+            this._activeBreakpoints = serverBps
+                .reduce((acc, serverBp) => {
+                const foundBp = breakpoints.find(bp => serverBp === bp.alias);
+                if (!foundBp) {
+                    console.warn(`FlexLayoutServerModule: unknown breakpoint alias "${serverBp}"`);
+                }
+                else {
+                    acc.push(foundBp);
+                }
+                return acc;
+            }, []);
+        }
+    }
+    /** Activate the specified breakpoint if we're on the server, no-op otherwise */
+    activateBreakpoint(bp) {
+        const lookupBreakpoint = this.registry.get(bp.mediaQuery);
+        if (lookupBreakpoint) {
+            lookupBreakpoint.activate();
+        }
+    }
+    /** Deactivate the specified breakpoint if we're on the server, no-op otherwise */
+    deactivateBreakpoint(bp) {
+        const lookupBreakpoint = this.registry.get(bp.mediaQuery);
+        if (lookupBreakpoint) {
+            lookupBreakpoint.deactivate();
+        }
+    }
+    /**
+     * Call window.matchMedia() to build a MediaQueryList; which
+     * supports 0..n listeners for activation/deactivation
+     */
+    buildMQL(query) {
+        const isActive = this._activeBreakpoints.some(ab => ab.mediaQuery === query);
+        return new ServerMediaQueryList(query, isActive);
+    }
+}
+ServerMatchMedia.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ServerMatchMedia, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }, { token: DOCUMENT }, { token: BREAKPOINTS }, { token: LAYOUT_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+ServerMatchMedia.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ServerMatchMedia });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ServerMatchMedia, 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: undefined, decorators: [{
+                    type: Inject,
+                    args: [BREAKPOINTS]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LAYOUT_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-match-media.js","sourceRoot":"","sources":["../../../../../projects/libs/flex-layout/server/server-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 {DOCUMENT} from '@angular/common';\nimport {Inject, Injectable, NgZone, PLATFORM_ID} from '@angular/core';\nimport {\n  BreakPoint,\n  ɵMatchMedia as MatchMedia,\n  BREAKPOINTS,\n  LAYOUT_CONFIG,\n  LayoutConfigOptions\n} from '@angular/flex-layout/core';\n\n/**\n * Special server-only class to simulate a MediaQueryList and\n * - supports manual activation to simulate mediaQuery matching\n * - manages listeners\n */\nexport class ServerMediaQueryList implements MediaQueryList {\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, private _isActive = false) {}\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(): ServerMediaQueryList {\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(): ServerMediaQueryList {\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 server environment */\n  removeListener() {\n  }\n\n  addEventListener() {\n  }\n\n  removeEventListener() {\n  }\n\n  dispatchEvent(_: Event): boolean {\n    return false;\n  }\n\n  onchange: MediaQueryListListener = null;\n}\n\n/**\n * Special server-only implementation of MatchMedia that uses the above\n * ServerMediaQueryList as its internal representation\n *\n * Also contains methods to activate and deactivate breakpoints\n */\n@Injectable()\nexport class ServerMatchMedia extends MatchMedia {\n  private _activeBreakpoints: BreakPoint[] = [];\n\n  constructor(protected _zone: NgZone,\n              @Inject(PLATFORM_ID) protected _platformId: Object,\n              @Inject(DOCUMENT) protected _document: any,\n              @Inject(BREAKPOINTS) protected breakpoints: BreakPoint[],\n              @Inject(LAYOUT_CONFIG) protected layoutConfig: LayoutConfigOptions) {\n    super(_zone, _platformId, _document);\n\n    const serverBps = layoutConfig.ssrObserveBreakpoints;\n    if (serverBps) {\n      this._activeBreakpoints = serverBps\n        .reduce((acc: BreakPoint[], serverBp: string) => {\n          const foundBp = breakpoints.find(bp => serverBp === bp.alias);\n          if (!foundBp) {\n            console.warn(`FlexLayoutServerModule: unknown breakpoint alias \"${serverBp}\"`);\n          } else {\n            acc.push(foundBp);\n          }\n          return acc;\n        }, []);\n    }\n  }\n\n  /** Activate the specified breakpoint if we're on the server, no-op otherwise */\n  activateBreakpoint(bp: BreakPoint) {\n    const lookupBreakpoint = this.registry.get(bp.mediaQuery) as ServerMediaQueryList;\n    if (lookupBreakpoint) {\n      lookupBreakpoint.activate();\n    }\n  }\n\n  /** Deactivate the specified breakpoint if we're on the server, no-op otherwise */\n  deactivateBreakpoint(bp: BreakPoint) {\n    const lookupBreakpoint = this.registry.get(bp.mediaQuery) as ServerMediaQueryList;\n    if (lookupBreakpoint) {\n      lookupBreakpoint.deactivate();\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): ServerMediaQueryList {\n    const isActive = this._activeBreakpoints.some(ab => ab.mediaQuery === query);\n\n    return new ServerMediaQueryList(query, isActive);\n  }\n}\n\ntype MediaQueryListListener = ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;\n"]}

package/esm2020/server/server-provider.mjs

@@ -0,0 +1,140 @@
+/**
+ * @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 { DOCUMENT } from '@angular/common';
+import { BEFORE_APP_SERIALIZED } from '@angular/platform-server';
+import { BREAKPOINTS, CLASS_NAME, SERVER_TOKEN, ɵMatchMedia as MatchMedia, StylesheetMap, sortAscendingPriority, MediaMarshaller, } from '@angular/flex-layout/core';
+import { ServerMatchMedia } from './server-match-media';
+/**
+ * Activate all the registered breakpoints in sequence, and then
+ * retrieve the associated stylings from the virtual stylesheet
+ * @param serverSheet the virtual stylesheet that stores styles for each
+ *        element
+ * @param mediaController the MatchMedia service to activate/deactivate breakpoints
+ * @param breakpoints the registered breakpoints to activate/deactivate
+ * @param mediaMarshaller the MediaMarshaller service to disable fallback styles dynamically
+ */
+export function generateStaticFlexLayoutStyles(serverSheet, mediaController, breakpoints, mediaMarshaller) {
+    // Store the custom classes in the following map, that way only
+    // one class gets allocated per HTMLElement, and each class can
+    // be referenced in the static media queries
+    const classMap = new Map();
+    // Get the initial stylings for all the directives,
+    // and initialize the fallback block of stylings.
+    const defaultStyles = new Map(serverSheet.stylesheet);
+    // Reset the class counter, otherwise class numbers will
+    // increase with each server render.
+    nextId = 0;
+    let styleText = generateCss(defaultStyles, 'all', classMap);
+    mediaMarshaller.useFallbacks = false;
+    [...breakpoints].sort(sortAscendingPriority).forEach((bp) => {
+        serverSheet.clearStyles();
+        mediaController.activateBreakpoint(bp);
+        const stylesheet = new Map(serverSheet.stylesheet);
+        if (stylesheet.size > 0) {
+            styleText += generateCss(stylesheet, bp.mediaQuery, classMap);
+        }
+        mediaController.deactivateBreakpoint(bp);
+    });
+    return styleText;
+}
+/**
+ * Create a style tag populated with the dynamic stylings from Flex
+ * components and attach it to the head of the DOM
+ */
+export function FLEX_SSR_SERIALIZER_FACTORY(serverSheet, mediaController, _document, breakpoints, mediaMarshaller) {
+    return () => {
+        // This is the style tag that gets inserted into the head of the DOM,
+        // populated with the manual media queries
+        const styleTag = _document.createElement('style');
+        const styleText = generateStaticFlexLayoutStyles(serverSheet, mediaController, breakpoints, mediaMarshaller);
+        styleTag.classList.add(`${CLASS_NAME}ssr`);
+        styleTag.textContent = styleText;
+        _document.head.appendChild(styleTag);
+    };
+}
+/**
+ *  Provider to set static styles on the server
+ */
+export const SERVER_PROVIDERS = [
+    {
+        provide: BEFORE_APP_SERIALIZED,
+        useFactory: FLEX_SSR_SERIALIZER_FACTORY,
+        deps: [
+            StylesheetMap,
+            MatchMedia,
+            DOCUMENT,
+            BREAKPOINTS,
+            MediaMarshaller,
+        ],
+        multi: true,
+    },
+    {
+        provide: SERVER_TOKEN,
+        useValue: true
+    },
+    {
+        provide: MatchMedia,
+        useClass: ServerMatchMedia
+    }
+];
+let nextId = 0;
+const IS_DEBUG_MODE = false;
+/**
+ * create @media queries based on a virtual stylesheet
+ * * Adds a unique class to each element and stores it
+ *   in a shared classMap for later reuse
+ * @param stylesheet the virtual stylesheet that stores styles for each
+ *        element
+ * @param mediaQuery the given @media CSS selector for the current breakpoint
+ * @param classMap the map of HTML elements to class names to avoid duplications
+ */
+function generateCss(stylesheet, mediaQuery, classMap) {
+    let css = '';
+    stylesheet.forEach((styles, el) => {
+        let keyVals = '';
+        let className = getClassName(el, classMap);
+        styles.forEach((v, k) => {
+            keyVals += v ? format(`${k}:${v};`) : '';
+        });
+        if (keyVals) {
+            // Build list of CSS styles; each with a className
+            css += format(`.${className} {`, keyVals, '}');
+        }
+    });
+    // Group 1 or more styles (each with className) in a specific mediaQuery
+    return format(`@media ${mediaQuery} {`, css, '}');
+}
+/**
+ * For debugging purposes, prefix css segment with linefeed(s) for easy
+  * debugging purposes.
+ */
+function format(...list) {
+    let result = '';
+    list.forEach((css, i) => {
+        result += IS_DEBUG_MODE ? formatSegment(css, i !== 0) : css;
+    });
+    return result;
+}
+function formatSegment(css, asPrefix = true) {
+    return asPrefix ? `\n${css}` : `${css}\n`;
+}
+/**
+ * Get className associated with CSS styling
+ * If not found, generate global className and set
+ * association.
+ */
+function getClassName(element, classMap) {
+    let className = classMap.get(element);
+    if (!className) {
+        className = `${CLASS_NAME}${nextId++}`;
+        classMap.set(element, className);
+    }
+    element.classList.add(className);
+    return className;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-provider.js","sourceRoot":"","sources":["../../../../../projects/libs/flex-layout/server/server-provider.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 {DOCUMENT} from '@angular/common';\nimport {BEFORE_APP_SERIALIZED} from '@angular/platform-server';\nimport {\n  BREAKPOINTS,\n  CLASS_NAME,\n  SERVER_TOKEN,\n  BreakPoint,\n  ɵMatchMedia as MatchMedia,\n  StylesheetMap,\n  sortAscendingPriority,\n  MediaMarshaller,\n} from '@angular/flex-layout/core';\n\nimport {ServerMatchMedia} from './server-match-media';\n\n/**\n * Activate all the registered breakpoints in sequence, and then\n * retrieve the associated stylings from the virtual stylesheet\n * @param serverSheet the virtual stylesheet that stores styles for each\n *        element\n * @param mediaController the MatchMedia service to activate/deactivate breakpoints\n * @param breakpoints the registered breakpoints to activate/deactivate\n * @param mediaMarshaller the MediaMarshaller service to disable fallback styles dynamically\n */\nexport function generateStaticFlexLayoutStyles(serverSheet: StylesheetMap,\n                                               mediaController: ServerMatchMedia,\n                                               breakpoints: BreakPoint[],\n                                               mediaMarshaller: MediaMarshaller) {\n  // Store the custom classes in the following map, that way only\n  // one class gets allocated per HTMLElement, and each class can\n  // be referenced in the static media queries\n  const classMap = new Map<HTMLElement, string>();\n\n  // Get the initial stylings for all the directives,\n  // and initialize the fallback block of stylings.\n  const defaultStyles = new Map(serverSheet.stylesheet);\n  // Reset the class counter, otherwise class numbers will\n  // increase with each server render.\n  nextId = 0;\n  let styleText = generateCss(defaultStyles, 'all', classMap);\n  mediaMarshaller.useFallbacks = false;\n\n  [...breakpoints].sort(sortAscendingPriority).forEach((bp) => {\n    serverSheet.clearStyles();\n    mediaController.activateBreakpoint(bp);\n    const stylesheet = new Map(serverSheet.stylesheet);\n    if (stylesheet.size > 0) {\n      styleText += generateCss(stylesheet, bp.mediaQuery, classMap);\n    }\n    mediaController.deactivateBreakpoint(bp);\n  });\n\n  return styleText;\n}\n\n/**\n * Create a style tag populated with the dynamic stylings from Flex\n * components and attach it to the head of the DOM\n */\nexport function FLEX_SSR_SERIALIZER_FACTORY(serverSheet: StylesheetMap,\n                                            mediaController: ServerMatchMedia,\n                                            _document: Document,\n                                            breakpoints: BreakPoint[],\n                                            mediaMarshaller: MediaMarshaller) {\n  return () => {\n    // This is the style tag that gets inserted into the head of the DOM,\n    // populated with the manual media queries\n    const styleTag = _document.createElement('style');\n    const styleText = generateStaticFlexLayoutStyles(\n      serverSheet, mediaController, breakpoints, mediaMarshaller);\n    styleTag.classList.add(`${CLASS_NAME}ssr`);\n    styleTag.textContent = styleText;\n    _document.head!.appendChild(styleTag);\n  };\n}\n\n/**\n *  Provider to set static styles on the server\n */\nexport const SERVER_PROVIDERS = [\n  {\n    provide: BEFORE_APP_SERIALIZED,\n    useFactory: FLEX_SSR_SERIALIZER_FACTORY,\n    deps: [\n      StylesheetMap,\n      MatchMedia,\n      DOCUMENT,\n      BREAKPOINTS,\n      MediaMarshaller,\n    ],\n    multi: true,\n  },\n  {\n    provide: SERVER_TOKEN,\n    useValue: true\n  },\n  {\n    provide: MatchMedia,\n    useClass: ServerMatchMedia\n  }\n];\n\n\nlet nextId = 0;\nconst IS_DEBUG_MODE = false;\n\nexport type StyleSheet = Map<HTMLElement, Map<string, string|number>>;\nexport type ClassMap = Map<HTMLElement, string>;\n\n/**\n * create @media queries based on a virtual stylesheet\n * * Adds a unique class to each element and stores it\n *   in a shared classMap for later reuse\n * @param stylesheet the virtual stylesheet that stores styles for each\n *        element\n * @param mediaQuery the given @media CSS selector for the current breakpoint\n * @param classMap the map of HTML elements to class names to avoid duplications\n */\nfunction generateCss(stylesheet: StyleSheet, mediaQuery: string, classMap: ClassMap) {\n  let css = '';\n  stylesheet.forEach((styles, el) => {\n    let keyVals = '';\n    let className = getClassName(el, classMap);\n\n    styles.forEach((v, k) => {\n      keyVals += v ? format(`${k}:${v};`) : '';\n    });\n\n    if (keyVals) {\n      // Build list of CSS styles; each with a className\n      css += format(`.${className} {`, keyVals, '}');\n    }\n  });\n\n  // Group 1 or more styles (each with className) in a specific mediaQuery\n  return format(`@media ${mediaQuery} {`, css, '}');\n}\n\n/**\n * For debugging purposes, prefix css segment with linefeed(s) for easy\n  * debugging purposes.\n */\nfunction format(...list: string[]): string {\n  let result = '';\n  list.forEach((css, i) => {\n    result += IS_DEBUG_MODE ? formatSegment(css, i !== 0) : css;\n  });\n  return result;\n}\n\nfunction formatSegment(css: string, asPrefix: boolean = true): string {\n  return asPrefix ? `\\n${css}` : `${css}\\n`;\n}\n\n/**\n * Get className associated with CSS styling\n * If not found, generate global className and set\n * association.\n */\nfunction getClassName(element: HTMLElement, classMap: Map<HTMLElement, string>) {\n  let className = classMap.get(element);\n  if (!className) {\n    className = `${CLASS_NAME}${nextId++}`;\n    classMap.set(element, className);\n  }\n  element.classList.add(className);\n\n  return className;\n}\n"]}

package/esm2020/version.mjs

@@ -0,0 +1,11 @@
+/**
+ * @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 { Version } from '@angular/core';
+/** Current version of Angular Flex-Layout. */
+export const VERSION = new Version('13.0.0-beta.38');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2xpYnMvZmxleC1sYXlvdXQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRXRDLDhDQUE4QztBQUM5QyxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsSUFBSSxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge1ZlcnNpb259IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKiogQ3VycmVudCB2ZXJzaW9uIG9mIEFuZ3VsYXIgRmxleC1MYXlvdXQuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IG5ldyBWZXJzaW9uKCcwLjAuMC1QTEFDRUhPTERFUicpO1xuIl19

package/extended/README.md

@@ -0,0 +1,18 @@
+The `extended` entrypoint contains all of the extended APIs provided by the
+Layout library. This includes extensions for Angular directives like NgClass
+and NgStyle, and HTML elements like `<img>`. The main export from this
+entrypoint is the `ExtendedModule` that encapsulates these directives, and
+can be imported separately to take advantage of tree shaking.
+
+```typescript
+import {NgModule} from '@angular/core';
+import {ExtendedModule} from '@angular/flex-layout/extended';
+
+@NgModule(({
+  imports: [
+    ... other imports here
+    ExtendedModule,
+  ]
+}))
+export class AppModule {}
+```

package/extended/angular-flex-layout-extended.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@angular/flex-layout/extended" />
+export * from './public-api';