@dugararchit/flex-layout 13.0.0-dugararchit

package/esm2020/extended/style/style-transforms.mjs

@@ -0,0 +1,76 @@
+/**
+ * @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
+ */
+/** NgStyle allowed inputs */
+export class NgStyleKeyValue {
+    constructor(key, value, noQuotes = true) {
+        this.key = key;
+        this.value = value;
+        this.key = noQuotes ? key.replace(/['"]/g, '').trim() : key.trim();
+        this.value = noQuotes ? value.replace(/['"]/g, '').trim() : value.trim();
+        this.value = this.value.replace(/;/, '');
+    }
+}
+export function getType(target) {
+    let what = typeof target;
+    if (what === 'object') {
+        return (target.constructor === Array) ? 'array' :
+            (target.constructor === Set) ? 'set' : 'object';
+    }
+    return what;
+}
+/**
+ * Split string of key:value pairs into Array of k-v pairs
+ * e.g.  'key:value; key:value; key:value;' -> ['key:value',...]
+ */
+export function buildRawList(source, delimiter = ';') {
+    return String(source)
+        .trim()
+        .split(delimiter)
+        .map((val) => val.trim())
+        .filter(val => val !== '');
+}
+/** Convert array of key:value strings to a iterable map object */
+export function buildMapFromList(styles, sanitize) {
+    const sanitizeValue = (it) => {
+        if (sanitize) {
+            it.value = sanitize(it.value);
+        }
+        return it;
+    };
+    return styles
+        .map(stringToKeyValue)
+        .filter(entry => !!entry)
+        .map(sanitizeValue)
+        .reduce(keyValuesToMap, {});
+}
+/** Convert Set<string> or raw Object to an iterable NgStyleMap */
+export function buildMapFromSet(source, sanitize) {
+    let list = [];
+    if (getType(source) === 'set') {
+        source.forEach(entry => list.push(entry));
+    }
+    else {
+        Object.keys(source).forEach((key) => {
+            list.push(`${key}:${source[key]}`);
+        });
+    }
+    return buildMapFromList(list, sanitize);
+}
+/** Convert 'key:value' -> [key, value] */
+export function stringToKeyValue(it) {
+    const [key, ...vals] = it.split(':');
+    return new NgStyleKeyValue(key, vals.join(':'));
+}
+/** Convert [ [key,value] ] -> { key : value } */
+export function keyValuesToMap(map, entry) {
+    if (!!entry.key) {
+        map[entry.key] = entry.value;
+    }
+    return map;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/extended/style/style.mjs

@@ -0,0 +1,130 @@
+/**
+ * @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, Inject, Optional, PLATFORM_ID, SecurityContext, Self, } from '@angular/core';
+import { isPlatformServer, NgStyle } from '@angular/common';
+import { BaseDirective2, SERVER_TOKEN, } from '@angular/flex-layout/core';
+import { buildRawList, getType, buildMapFromSet, stringToKeyValue, keyValuesToMap, } from './style-transforms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/flex-layout/core";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "@angular/common";
+export class StyleDirective extends BaseDirective2 {
+    constructor(elementRef, styler, marshal, sanitizer, differs, renderer2, ngStyleInstance, serverLoaded, platformId) {
+        super(elementRef, null, styler, marshal);
+        this.sanitizer = sanitizer;
+        this.ngStyleInstance = ngStyleInstance;
+        this.DIRECTIVE_KEY = 'ngStyle';
+        if (!this.ngStyleInstance) {
+            // Create an instance NgStyle Directive instance only if `ngStyle=""` has NOT been
+            // defined on the same host element; since the responsive variations may be defined...
+            this.ngStyleInstance = new NgStyle(elementRef, differs, renderer2);
+        }
+        this.init();
+        const styles = this.nativeElement.getAttribute('style') ?? '';
+        this.fallbackStyles = this.buildStyleMap(styles);
+        this.isServer = serverLoaded && isPlatformServer(platformId);
+    }
+    /** Add generated styles */
+    updateWithValue(value) {
+        const styles = this.buildStyleMap(value);
+        this.ngStyleInstance.ngStyle = { ...this.fallbackStyles, ...styles };
+        if (this.isServer) {
+            this.applyStyleToElement(styles);
+        }
+        this.ngStyleInstance.ngDoCheck();
+    }
+    /** Remove generated styles */
+    clearStyles() {
+        this.ngStyleInstance.ngStyle = this.fallbackStyles;
+        this.ngStyleInstance.ngDoCheck();
+    }
+    /**
+     * Convert raw strings to ngStyleMap; which is required by ngStyle
+     * NOTE: Raw string key-value pairs MUST be delimited by `;`
+     *       Comma-delimiters are not supported due to complexities of
+     *       possible style values such as `rgba(x,x,x,x)` and others
+     */
+    buildStyleMap(styles) {
+        // Always safe-guard (aka sanitize) style property values
+        const sanitizer = (val) => this.sanitizer.sanitize(SecurityContext.STYLE, val) ?? '';
+        if (styles) {
+            switch (getType(styles)) {
+                case 'string': return buildMapFromList(buildRawList(styles), sanitizer);
+                case 'array': return buildMapFromList(styles, sanitizer);
+                case 'set': return buildMapFromSet(styles, sanitizer);
+                default: return buildMapFromSet(styles, sanitizer);
+            }
+        }
+        return {};
+    }
+    // ******************************************************************
+    // Lifecycle Hooks
+    // ******************************************************************
+    /** For ChangeDetectionStrategy.onPush and ngOnChanges() updates */
+    ngDoCheck() {
+        this.ngStyleInstance.ngDoCheck();
+    }
+}
+StyleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: StyleDirective, deps: [{ token: i0.ElementRef }, { token: i1.StyleUtils }, { token: i1.MediaMarshaller }, { token: i2.DomSanitizer }, { token: i0.KeyValueDiffers }, { token: i0.Renderer2 }, { token: i3.NgStyle, optional: true, self: true }, { token: SERVER_TOKEN }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
+StyleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: StyleDirective, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: StyleDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.StyleUtils }, { type: i1.MediaMarshaller }, { type: i2.DomSanitizer }, { type: i0.KeyValueDiffers }, { type: i0.Renderer2 }, { type: i3.NgStyle, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SERVER_TOKEN]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+const inputs = [
+    'ngStyle',
+    'ngStyle.xs', 'ngStyle.sm', 'ngStyle.md', 'ngStyle.lg', 'ngStyle.xl',
+    'ngStyle.lt-sm', 'ngStyle.lt-md', 'ngStyle.lt-lg', 'ngStyle.lt-xl',
+    'ngStyle.gt-xs', 'ngStyle.gt-sm', 'ngStyle.gt-md', 'ngStyle.gt-lg'
+];
+const selector = `
+  [ngStyle],
+  [ngStyle.xs], [ngStyle.sm], [ngStyle.md], [ngStyle.lg], [ngStyle.xl],
+  [ngStyle.lt-sm], [ngStyle.lt-md], [ngStyle.lt-lg], [ngStyle.lt-xl],
+  [ngStyle.gt-xs], [ngStyle.gt-sm], [ngStyle.gt-md], [ngStyle.gt-lg]
+`;
+/**
+ * Directive to add responsive support for ngStyle.
+ *
+ */
+export class DefaultStyleDirective extends StyleDirective {
+    constructor() {
+        super(...arguments);
+        this.inputs = inputs;
+    }
+}
+DefaultStyleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: DefaultStyleDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DefaultStyleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: DefaultStyleDirective, selector: "\n  [ngStyle],\n  [ngStyle.xs], [ngStyle.sm], [ngStyle.md], [ngStyle.lg], [ngStyle.xl],\n  [ngStyle.lt-sm], [ngStyle.lt-md], [ngStyle.lt-lg], [ngStyle.lt-xl],\n  [ngStyle.gt-xs], [ngStyle.gt-sm], [ngStyle.gt-md], [ngStyle.gt-lg]\n", inputs: { ngStyle: "ngStyle", "ngStyle.xs": "ngStyle.xs", "ngStyle.sm": "ngStyle.sm", "ngStyle.md": "ngStyle.md", "ngStyle.lg": "ngStyle.lg", "ngStyle.xl": "ngStyle.xl", "ngStyle.lt-sm": "ngStyle.lt-sm", "ngStyle.lt-md": "ngStyle.lt-md", "ngStyle.lt-lg": "ngStyle.lt-lg", "ngStyle.lt-xl": "ngStyle.lt-xl", "ngStyle.gt-xs": "ngStyle.gt-xs", "ngStyle.gt-sm": "ngStyle.gt-sm", "ngStyle.gt-md": "ngStyle.gt-md", "ngStyle.gt-lg": "ngStyle.gt-lg" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: DefaultStyleDirective, decorators: [{
+            type: Directive,
+            args: [{ selector, inputs }]
+        }] });
+/** Build a styles map from a list of styles, while sanitizing bad values first */
+function buildMapFromList(styles, sanitize) {
+    const sanitizeValue = (it) => {
+        if (sanitize) {
+            it.value = sanitize(it.value);
+        }
+        return it;
+    };
+    return styles
+        .map(stringToKeyValue)
+        .filter(entry => !!entry)
+        .map(sanitizeValue)
+        .reduce(keyValuesToMap, {});
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"style.js","sourceRoot":"","sources":["../../../../../../projects/libs/flex-layout/extended/style/style.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 {\n  Directive,\n  DoCheck,\n  ElementRef,\n  Inject,\n  KeyValueDiffers,\n  Optional,\n  PLATFORM_ID,\n  Renderer2,\n  SecurityContext,\n  Self,\n} from '@angular/core';\nimport {isPlatformServer, NgStyle} from '@angular/common';\nimport {DomSanitizer} from '@angular/platform-browser';\nimport {\n  BaseDirective2,\n  StyleUtils,\n  MediaMarshaller,\n  SERVER_TOKEN,\n} from '@angular/flex-layout/core';\n\nimport {\n  NgStyleRawList,\n  NgStyleType,\n  NgStyleSanitizer,\n  buildRawList,\n  getType,\n  buildMapFromSet,\n  NgStyleMap,\n  NgStyleKeyValue,\n  stringToKeyValue,\n  keyValuesToMap,\n} from './style-transforms';\n\n@Directive()\nexport class StyleDirective extends BaseDirective2 implements DoCheck {\n\n  protected DIRECTIVE_KEY = 'ngStyle';\n  protected fallbackStyles: NgStyleMap;\n  protected isServer: boolean;\n\n  constructor(elementRef: ElementRef,\n              styler: StyleUtils,\n              marshal: MediaMarshaller,\n              protected sanitizer: DomSanitizer,\n              differs: KeyValueDiffers,\n              renderer2: Renderer2,\n              @Optional() @Self() private readonly ngStyleInstance: NgStyle,\n              @Inject(SERVER_TOKEN) serverLoaded: boolean,\n              @Inject(PLATFORM_ID) platformId: Object) {\n    super(elementRef, null!, styler, marshal);\n    if (!this.ngStyleInstance) {\n      // Create an instance NgStyle Directive instance only if `ngStyle=\"\"` has NOT been\n      // defined on the same host element; since the responsive variations may be defined...\n      this.ngStyleInstance = new NgStyle(elementRef, differs, renderer2);\n    }\n    this.init();\n    const styles = this.nativeElement.getAttribute('style') ?? '';\n    this.fallbackStyles = this.buildStyleMap(styles);\n    this.isServer = serverLoaded && isPlatformServer(platformId);\n  }\n\n  /** Add generated styles */\n  protected updateWithValue(value: any) {\n    const styles = this.buildStyleMap(value);\n    this.ngStyleInstance.ngStyle = {...this.fallbackStyles, ...styles};\n    if (this.isServer) {\n      this.applyStyleToElement(styles);\n    }\n    this.ngStyleInstance.ngDoCheck();\n  }\n\n  /** Remove generated styles */\n  protected clearStyles() {\n    this.ngStyleInstance.ngStyle = this.fallbackStyles;\n    this.ngStyleInstance.ngDoCheck();\n  }\n\n  /**\n   * Convert raw strings to ngStyleMap; which is required by ngStyle\n   * NOTE: Raw string key-value pairs MUST be delimited by `;`\n   *       Comma-delimiters are not supported due to complexities of\n   *       possible style values such as `rgba(x,x,x,x)` and others\n   */\n  protected buildStyleMap(styles: NgStyleType): NgStyleMap {\n    // Always safe-guard (aka sanitize) style property values\n    const sanitizer: NgStyleSanitizer = (val: any) =>\n      this.sanitizer.sanitize(SecurityContext.STYLE, val) ?? '';\n    if (styles) {\n      switch (getType(styles)) {\n        case 'string':  return buildMapFromList(buildRawList(styles),\n          sanitizer);\n        case 'array' :  return buildMapFromList(styles as NgStyleRawList, sanitizer);\n        case 'set'   :  return buildMapFromSet(styles, sanitizer);\n        default      :  return buildMapFromSet(styles, sanitizer);\n      }\n    }\n\n    return {};\n  }\n\n  // ******************************************************************\n  // Lifecycle Hooks\n  // ******************************************************************\n\n  /** For ChangeDetectionStrategy.onPush and ngOnChanges() updates */\n  ngDoCheck() {\n    this.ngStyleInstance.ngDoCheck();\n  }\n}\n\nconst inputs = [\n  'ngStyle',\n  'ngStyle.xs', 'ngStyle.sm', 'ngStyle.md', 'ngStyle.lg', 'ngStyle.xl',\n  'ngStyle.lt-sm', 'ngStyle.lt-md', 'ngStyle.lt-lg', 'ngStyle.lt-xl',\n  'ngStyle.gt-xs', 'ngStyle.gt-sm', 'ngStyle.gt-md', 'ngStyle.gt-lg'\n];\n\nconst selector = `\n  [ngStyle],\n  [ngStyle.xs], [ngStyle.sm], [ngStyle.md], [ngStyle.lg], [ngStyle.xl],\n  [ngStyle.lt-sm], [ngStyle.lt-md], [ngStyle.lt-lg], [ngStyle.lt-xl],\n  [ngStyle.gt-xs], [ngStyle.gt-sm], [ngStyle.gt-md], [ngStyle.gt-lg]\n`;\n\n/**\n * Directive to add responsive support for ngStyle.\n *\n */\n@Directive({selector, inputs})\nexport class DefaultStyleDirective extends StyleDirective implements DoCheck {\n  protected inputs = inputs;\n}\n\n/** Build a styles map from a list of styles, while sanitizing bad values first */\nfunction buildMapFromList(styles: NgStyleRawList, sanitize?: NgStyleSanitizer): NgStyleMap {\n  const sanitizeValue = (it: NgStyleKeyValue) => {\n    if (sanitize) {\n      it.value = sanitize(it.value);\n    }\n    return it;\n  };\n\n  return styles\n    .map(stringToKeyValue)\n    .filter(entry => !!entry)\n    .map(sanitizeValue)\n    .reduce(keyValuesToMap, {} as NgStyleMap);\n}\n"]}

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

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

package/esm2020/flex/flex/flex.mjs

@@ -0,0 +1,291 @@
+/**
+ * @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, Inject, Injectable, Input } from '@angular/core';
+import { BaseDirective2, LAYOUT_CONFIG, validateBasis, StyleBuilder, } from '@angular/flex-layout/core';
+import { takeUntil } from 'rxjs/operators';
+import { extendObject } from '@angular/flex-layout/_private-utils';
+import { isFlowHorizontal } from '@angular/flex-layout/_private-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/flex-layout/core";
+export class FlexStyleBuilder extends StyleBuilder {
+    constructor(layoutConfig) {
+        super();
+        this.layoutConfig = layoutConfig;
+    }
+    buildStyles(input, parent) {
+        let [grow, shrink, ...basisParts] = input.split(' ');
+        let basis = basisParts.join(' ');
+        // The flex-direction of this element's flex container. Defaults to 'row'.
+        const direction = (parent.direction.indexOf('column') > -1) ? 'column' : 'row';
+        const max = isFlowHorizontal(direction) ? 'max-width' : 'max-height';
+        const min = isFlowHorizontal(direction) ? 'min-width' : 'min-height';
+        const hasCalc = String(basis).indexOf('calc') > -1;
+        const usingCalc = hasCalc || (basis === 'auto');
+        const isPercent = String(basis).indexOf('%') > -1 && !hasCalc;
+        const hasUnits = String(basis).indexOf('px') > -1 || String(basis).indexOf('rem') > -1 ||
+            String(basis).indexOf('em') > -1 || String(basis).indexOf('vw') > -1 ||
+            String(basis).indexOf('vh') > -1;
+        let isValue = (hasCalc || hasUnits);
+        grow = (grow == '0') ? 0 : grow;
+        shrink = (shrink == '0') ? 0 : shrink;
+        // make box inflexible when shrink and grow are both zero
+        // should not set a min when the grow is zero
+        // should not set a max when the shrink is zero
+        const isFixed = !grow && !shrink;
+        let css = {};
+        // flex-basis allows you to specify the initial/starting main-axis size of the element,
+        // before anything else is computed. It can either be a percentage or an absolute value.
+        // It is, however, not the breaking point for flex-grow/shrink properties
+        //
+        // flex-grow can be seen as this:
+        //   0: Do not stretch. Either size to element's content width, or obey 'flex-basis'.
+        //   1: (Default value). Stretch; will be the same size to all other flex items on
+        //       the same row since they have a default value of 1.
+        //   ≥2 (integer n): Stretch. Will be n times the size of other elements
+        //      with 'flex-grow: 1' on the same row.
+        // Use `null` to clear existing styles.
+        const clearStyles = {
+            'max-width': null,
+            'max-height': null,
+            'min-width': null,
+            'min-height': null
+        };
+        switch (basis || '') {
+            case '':
+                const useColumnBasisZero = this.layoutConfig.useColumnBasisZero !== false;
+                basis = direction === 'row' ? '0%' : (useColumnBasisZero ? '0.000000001px' : 'auto');
+                break;
+            case 'initial': // default
+            case 'nogrow':
+                grow = 0;
+                basis = 'auto';
+                break;
+            case 'grow':
+                basis = '100%';
+                break;
+            case 'noshrink':
+                shrink = 0;
+                basis = 'auto';
+                break;
+            case 'auto':
+                break;
+            case 'none':
+                grow = 0;
+                shrink = 0;
+                basis = 'auto';
+                break;
+            default:
+                // Defaults to percentage sizing unless `px` is explicitly set
+                if (!isValue && !isPercent && !isNaN(basis)) {
+                    basis = basis + '%';
+                }
+                // Fix for issue 280
+                if (basis === '0%') {
+                    isValue = true;
+                }
+                if (basis === '0px') {
+                    basis = '0%';
+                }
+                // fix issue #5345
+                if (hasCalc) {
+                    css = extendObject(clearStyles, {
+                        'flex-grow': grow,
+                        'flex-shrink': shrink,
+                        'flex-basis': isValue ? basis : '100%'
+                    });
+                }
+                else {
+                    css = extendObject(clearStyles, {
+                        'flex': `${grow} ${shrink} ${isValue ? basis : '100%'}`
+                    });
+                }
+                break;
+        }
+        if (!(css['flex'] || css['flex-grow'])) {
+            if (hasCalc) {
+                css = extendObject(clearStyles, {
+                    'flex-grow': grow,
+                    'flex-shrink': shrink,
+                    'flex-basis': basis
+                });
+            }
+            else {
+                css = extendObject(clearStyles, {
+                    'flex': `${grow} ${shrink} ${basis}`
+                });
+            }
+        }
+        // Fix for issues 277, 534, and 728
+        if (basis !== '0%' && basis !== '0px' && basis !== '0.000000001px' && basis !== 'auto') {
+            css[min] = isFixed || (isValue && grow) ? basis : null;
+            css[max] = isFixed || (!usingCalc && shrink) ? basis : null;
+        }
+        // Fix for issue 528
+        if (!css[min] && !css[max]) {
+            if (hasCalc) {
+                css = extendObject(clearStyles, {
+                    'flex-grow': grow,
+                    'flex-shrink': shrink,
+                    'flex-basis': basis
+                });
+            }
+            else {
+                css = extendObject(clearStyles, {
+                    'flex': `${grow} ${shrink} ${basis}`
+                });
+            }
+        }
+        else {
+            // Fix for issue 660
+            if (parent.hasWrap) {
+                css[hasCalc ? 'flex-basis' : 'flex'] = css[max] ?
+                    (hasCalc ? css[max] : `${grow} ${shrink} ${css[max]}`) :
+                    (hasCalc ? css[min] : `${grow} ${shrink} ${css[min]}`);
+            }
+        }
+        return extendObject(css, { 'box-sizing': 'border-box' });
+    }
+}
+FlexStyleBuilder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexStyleBuilder, deps: [{ token: LAYOUT_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+FlexStyleBuilder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexStyleBuilder, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexStyleBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LAYOUT_CONFIG]
+                }] }]; } });
+const inputs = [
+    'fxFlex', 'fxFlex.xs', 'fxFlex.sm', 'fxFlex.md',
+    'fxFlex.lg', 'fxFlex.xl', 'fxFlex.lt-sm', 'fxFlex.lt-md',
+    'fxFlex.lt-lg', 'fxFlex.lt-xl', 'fxFlex.gt-xs', 'fxFlex.gt-sm',
+    'fxFlex.gt-md', 'fxFlex.gt-lg'
+];
+const selector = `
+  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],
+  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],
+  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],
+  [fxFlex.gt-md], [fxFlex.gt-lg]
+`;
+/**
+ * Directive to control the size of a flex item using flex-basis, flex-grow, and flex-shrink.
+ * Corresponds to the css `flex` shorthand property.
+ *
+ * @see https://css-tricks.com/snippets/css/a-guide-to-flexbox/
+ */
+export class FlexDirective extends BaseDirective2 {
+    constructor(elRef, styleUtils, layoutConfig, styleBuilder, marshal) {
+        super(elRef, styleBuilder, styleUtils, marshal);
+        this.layoutConfig = layoutConfig;
+        this.marshal = marshal;
+        this.DIRECTIVE_KEY = 'flex';
+        this.direction = undefined;
+        this.wrap = undefined;
+        this.flexGrow = '1';
+        this.flexShrink = '1';
+        this.init();
+    }
+    get shrink() { return this.flexShrink; }
+    set shrink(value) {
+        this.flexShrink = value || '1';
+        this.triggerReflow();
+    }
+    get grow() { return this.flexGrow; }
+    set grow(value) {
+        this.flexGrow = value || '1';
+        this.triggerReflow();
+    }
+    ngOnInit() {
+        if (this.parentElement) {
+            this.marshal.trackValue(this.parentElement, 'layout')
+                .pipe(takeUntil(this.destroySubject))
+                .subscribe(this.onLayoutChange.bind(this));
+            this.marshal.trackValue(this.nativeElement, 'layout-align')
+                .pipe(takeUntil(this.destroySubject))
+                .subscribe(this.triggerReflow.bind(this));
+        }
+    }
+    /**
+     * Caches the parent container's 'flex-direction' and updates the element's style.
+     * Used as a handler for layout change events from the parent flex container.
+     */
+    onLayoutChange(matcher) {
+        const layout = matcher.value;
+        const layoutParts = layout.split(' ');
+        this.direction = layoutParts[0];
+        this.wrap = layoutParts[1] !== undefined && layoutParts[1] === 'wrap';
+        this.triggerUpdate();
+    }
+    /** Input to this is exclusively the basis input value */
+    updateWithValue(value) {
+        const addFlexToParent = this.layoutConfig.addFlexToParent !== false;
+        if (this.direction === undefined) {
+            this.direction = this.getFlexFlowDirection(this.parentElement, addFlexToParent);
+        }
+        if (this.wrap === undefined) {
+            this.wrap = this.hasWrap(this.parentElement);
+        }
+        const direction = this.direction;
+        const isHorizontal = direction.startsWith('row');
+        const hasWrap = this.wrap;
+        if (isHorizontal && hasWrap) {
+            this.styleCache = flexRowWrapCache;
+        }
+        else if (isHorizontal && !hasWrap) {
+            this.styleCache = flexRowCache;
+        }
+        else if (!isHorizontal && hasWrap) {
+            this.styleCache = flexColumnWrapCache;
+        }
+        else if (!isHorizontal && !hasWrap) {
+            this.styleCache = flexColumnCache;
+        }
+        const basis = String(value).replace(';', '');
+        const parts = validateBasis(basis, this.flexGrow, this.flexShrink);
+        this.addStyles(parts.join(' '), { direction, hasWrap });
+    }
+    /** Trigger a style reflow, usually based on a shrink/grow input event */
+    triggerReflow() {
+        const activatedValue = this.activatedValue;
+        if (activatedValue !== undefined) {
+            const parts = validateBasis(activatedValue + '', this.flexGrow, this.flexShrink);
+            this.marshal.updateElement(this.nativeElement, this.DIRECTIVE_KEY, parts.join(' '));
+        }
+    }
+}
+FlexDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexDirective, deps: [{ token: i0.ElementRef }, { token: i1.StyleUtils }, { token: LAYOUT_CONFIG }, { token: FlexStyleBuilder }, { token: i1.MediaMarshaller }], target: i0.ɵɵFactoryTarget.Directive });
+FlexDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: FlexDirective, inputs: { shrink: ["fxShrink", "shrink"], grow: ["fxGrow", "grow"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: FlexDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.StyleUtils }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LAYOUT_CONFIG]
+                }] }, { type: FlexStyleBuilder }, { type: i1.MediaMarshaller }]; }, propDecorators: { shrink: [{
+                type: Input,
+                args: ['fxShrink']
+            }], grow: [{
+                type: Input,
+                args: ['fxGrow']
+            }] } });
+export class DefaultFlexDirective extends FlexDirective {
+    constructor() {
+        super(...arguments);
+        this.inputs = inputs;
+    }
+}
+DefaultFlexDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: DefaultFlexDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DefaultFlexDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: DefaultFlexDirective, selector: "\n  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],\n  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],\n  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],\n  [fxFlex.gt-md], [fxFlex.gt-lg]\n", inputs: { fxFlex: "fxFlex", "fxFlex.xs": "fxFlex.xs", "fxFlex.sm": "fxFlex.sm", "fxFlex.md": "fxFlex.md", "fxFlex.lg": "fxFlex.lg", "fxFlex.xl": "fxFlex.xl", "fxFlex.lt-sm": "fxFlex.lt-sm", "fxFlex.lt-md": "fxFlex.lt-md", "fxFlex.lt-lg": "fxFlex.lt-lg", "fxFlex.lt-xl": "fxFlex.lt-xl", "fxFlex.gt-xs": "fxFlex.gt-xs", "fxFlex.gt-sm": "fxFlex.gt-sm", "fxFlex.gt-md": "fxFlex.gt-md", "fxFlex.gt-lg": "fxFlex.gt-lg" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: DefaultFlexDirective, decorators: [{
+            type: Directive,
+            args: [{ inputs, selector }]
+        }] });
+const flexRowCache = new Map();
+const flexColumnCache = new Map();
+const flexRowWrapCache = new Map();
+const flexColumnWrapCache = new Map();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flex.js","sourceRoot":"","sources":["../../../../../../projects/libs/flex-layout/flex/flex/flex.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 {Directive, ElementRef, Inject, Injectable, Input, OnInit} from '@angular/core';\nimport {\n  BaseDirective2,\n  LayoutConfigOptions,\n  LAYOUT_CONFIG,\n  StyleUtils,\n  validateBasis,\n  StyleBuilder,\n  StyleDefinition,\n  MediaMarshaller,\n  ElementMatcher,\n} from '@angular/flex-layout/core';\nimport {takeUntil} from 'rxjs/operators';\n\nimport {extendObject} from '@angular/flex-layout/_private-utils';\nimport {isFlowHorizontal} from '@angular/flex-layout/_private-utils';\n\ninterface FlexBuilderParent {\n  direction: string;\n  hasWrap: boolean;\n}\n\n@Injectable({providedIn: 'root'})\nexport class FlexStyleBuilder extends StyleBuilder {\n  constructor(@Inject(LAYOUT_CONFIG) protected layoutConfig: LayoutConfigOptions) {\n    super();\n  }\n  buildStyles(input: string, parent: FlexBuilderParent) {\n    let [grow, shrink, ...basisParts]: (string|number)[] = input.split(' ');\n    let basis = basisParts.join(' ');\n\n    // The flex-direction of this element's flex container. Defaults to 'row'.\n    const direction = (parent.direction.indexOf('column') > -1) ? 'column' : 'row';\n\n    const max = isFlowHorizontal(direction) ? 'max-width' : 'max-height';\n    const min = isFlowHorizontal(direction) ? 'min-width' : 'min-height';\n\n    const hasCalc = String(basis).indexOf('calc') > -1;\n    const usingCalc = hasCalc || (basis === 'auto');\n    const isPercent = String(basis).indexOf('%') > -1 && !hasCalc;\n    const hasUnits = String(basis).indexOf('px') > -1 || String(basis).indexOf('rem') > -1 ||\n      String(basis).indexOf('em') > -1 || String(basis).indexOf('vw') > -1 ||\n      String(basis).indexOf('vh') > -1;\n\n    let isValue = (hasCalc || hasUnits);\n\n    grow = (grow == '0') ? 0 : grow;\n    shrink = (shrink == '0') ? 0 : shrink;\n\n    // make box inflexible when shrink and grow are both zero\n    // should not set a min when the grow is zero\n    // should not set a max when the shrink is zero\n    const isFixed = !grow && !shrink;\n\n    let css: {[key: string]: string | number | null} = {};\n\n    // flex-basis allows you to specify the initial/starting main-axis size of the element,\n    // before anything else is computed. It can either be a percentage or an absolute value.\n    // It is, however, not the breaking point for flex-grow/shrink properties\n    //\n    // flex-grow can be seen as this:\n    //   0: Do not stretch. Either size to element's content width, or obey 'flex-basis'.\n    //   1: (Default value). Stretch; will be the same size to all other flex items on\n    //       the same row since they have a default value of 1.\n    //   ≥2 (integer n): Stretch. Will be n times the size of other elements\n    //      with 'flex-grow: 1' on the same row.\n\n    // Use `null` to clear existing styles.\n    const clearStyles = {\n      'max-width': null,\n      'max-height': null,\n      'min-width': null,\n      'min-height': null\n    };\n    switch (basis || '') {\n      case '':\n        const useColumnBasisZero = this.layoutConfig.useColumnBasisZero !== false;\n        basis = direction === 'row' ? '0%' : (useColumnBasisZero ? '0.000000001px' : 'auto');\n        break;\n      case 'initial':   // default\n      case 'nogrow':\n        grow = 0;\n        basis = 'auto';\n        break;\n      case 'grow':\n        basis = '100%';\n        break;\n      case 'noshrink':\n        shrink = 0;\n        basis = 'auto';\n        break;\n      case 'auto':\n        break;\n      case 'none':\n        grow = 0;\n        shrink = 0;\n        basis = 'auto';\n        break;\n      default:\n        // Defaults to percentage sizing unless `px` is explicitly set\n        if (!isValue && !isPercent && !isNaN(basis as any)) {\n          basis = basis + '%';\n        }\n\n        // Fix for issue 280\n        if (basis === '0%') {\n          isValue = true;\n        }\n\n        if (basis === '0px') {\n          basis = '0%';\n        }\n\n        // fix issue #5345\n        if (hasCalc) {\n          css = extendObject(clearStyles, {\n            'flex-grow': grow,\n            'flex-shrink': shrink,\n            'flex-basis': isValue ? basis : '100%'\n          });\n        } else {\n          css = extendObject(clearStyles, {\n            'flex': `${grow} ${shrink} ${isValue ? basis : '100%'}`\n          });\n        }\n\n        break;\n    }\n\n    if (!(css['flex'] || css['flex-grow'])) {\n      if (hasCalc) {\n        css = extendObject(clearStyles, {\n          'flex-grow': grow,\n          'flex-shrink': shrink,\n          'flex-basis': basis\n        });\n      } else {\n        css = extendObject(clearStyles, {\n          'flex': `${grow} ${shrink} ${basis}`\n        });\n      }\n    }\n\n    // Fix for issues 277, 534, and 728\n    if (basis !== '0%' && basis !== '0px' && basis !== '0.000000001px' && basis !== 'auto') {\n      css[min] = isFixed || (isValue && grow) ? basis : null;\n      css[max] = isFixed || (!usingCalc && shrink) ? basis : null;\n    }\n\n    // Fix for issue 528\n    if (!css[min] && !css[max]) {\n      if (hasCalc) {\n        css = extendObject(clearStyles, {\n          'flex-grow': grow,\n          'flex-shrink': shrink,\n          'flex-basis': basis\n        });\n      } else {\n        css = extendObject(clearStyles, {\n          'flex': `${grow} ${shrink} ${basis}`\n        });\n      }\n    } else {\n      // Fix for issue 660\n      if (parent.hasWrap) {\n        css[hasCalc ? 'flex-basis' : 'flex'] = css[max] ?\n          (hasCalc ? css[max] : `${grow} ${shrink} ${css[max]}`) :\n          (hasCalc ? css[min] : `${grow} ${shrink} ${css[min]}`);\n      }\n    }\n\n    return extendObject(css, {'box-sizing': 'border-box'}) as StyleDefinition;\n  }\n}\n\nconst inputs = [\n  'fxFlex', 'fxFlex.xs', 'fxFlex.sm', 'fxFlex.md',\n  'fxFlex.lg', 'fxFlex.xl', 'fxFlex.lt-sm', 'fxFlex.lt-md',\n  'fxFlex.lt-lg', 'fxFlex.lt-xl', 'fxFlex.gt-xs', 'fxFlex.gt-sm',\n  'fxFlex.gt-md', 'fxFlex.gt-lg'\n];\nconst selector = `\n  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],\n  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],\n  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],\n  [fxFlex.gt-md], [fxFlex.gt-lg]\n`;\n\n/**\n * Directive to control the size of a flex item using flex-basis, flex-grow, and flex-shrink.\n * Corresponds to the css `flex` shorthand property.\n *\n * @see https://css-tricks.com/snippets/css/a-guide-to-flexbox/\n */\n@Directive()\nexport class FlexDirective extends BaseDirective2 implements OnInit {\n\n  protected DIRECTIVE_KEY = 'flex';\n  protected direction?: string = undefined;\n  protected wrap?: boolean = undefined;\n\n\n  @Input('fxShrink')\n  get shrink(): string { return this.flexShrink; }\n  set shrink(value: string) {\n    this.flexShrink = value || '1';\n    this.triggerReflow();\n  }\n\n  @Input('fxGrow')\n  get grow(): string { return this.flexGrow; }\n  set grow(value: string) {\n    this.flexGrow = value || '1';\n    this.triggerReflow();\n  }\n\n  protected flexGrow = '1';\n  protected flexShrink = '1';\n\n  constructor(elRef: ElementRef,\n              styleUtils: StyleUtils,\n              @Inject(LAYOUT_CONFIG) protected layoutConfig: LayoutConfigOptions,\n              styleBuilder: FlexStyleBuilder,\n              protected marshal: MediaMarshaller) {\n    super(elRef, styleBuilder, styleUtils, marshal);\n    this.init();\n  }\n\n  ngOnInit() {\n    if (this.parentElement) {\n      this.marshal.trackValue(this.parentElement, 'layout')\n        .pipe(takeUntil(this.destroySubject))\n        .subscribe(this.onLayoutChange.bind(this));\n      this.marshal.trackValue(this.nativeElement, 'layout-align')\n        .pipe(takeUntil(this.destroySubject))\n        .subscribe(this.triggerReflow.bind(this));\n    }\n  }\n\n  /**\n   * Caches the parent container's 'flex-direction' and updates the element's style.\n   * Used as a handler for layout change events from the parent flex container.\n   */\n  protected onLayoutChange(matcher: ElementMatcher) {\n    const layout: string = matcher.value;\n    const layoutParts = layout.split(' ');\n    this.direction = layoutParts[0];\n    this.wrap = layoutParts[1] !== undefined && layoutParts[1] === 'wrap';\n    this.triggerUpdate();\n  }\n\n  /** Input to this is exclusively the basis input value */\n  protected updateWithValue(value: string) {\n    const addFlexToParent = this.layoutConfig.addFlexToParent !== false;\n    if (this.direction === undefined) {\n      this.direction = this.getFlexFlowDirection(this.parentElement!, addFlexToParent);\n    }\n    if (this.wrap === undefined) {\n      this.wrap = this.hasWrap(this.parentElement!);\n    }\n    const direction = this.direction;\n    const isHorizontal = direction.startsWith('row');\n    const hasWrap = this.wrap;\n    if (isHorizontal && hasWrap) {\n      this.styleCache = flexRowWrapCache;\n    } else if (isHorizontal && !hasWrap) {\n      this.styleCache = flexRowCache;\n    } else if (!isHorizontal && hasWrap) {\n      this.styleCache = flexColumnWrapCache;\n    } else if (!isHorizontal && !hasWrap) {\n      this.styleCache = flexColumnCache;\n    }\n    const basis = String(value).replace(';', '');\n    const parts = validateBasis(basis, this.flexGrow, this.flexShrink);\n    this.addStyles(parts.join(' '), {direction, hasWrap});\n  }\n\n  /** Trigger a style reflow, usually based on a shrink/grow input event */\n  protected triggerReflow() {\n    const activatedValue = this.activatedValue;\n    if (activatedValue !== undefined) {\n      const parts = validateBasis(activatedValue + '', this.flexGrow, this.flexShrink);\n      this.marshal.updateElement(this.nativeElement, this.DIRECTIVE_KEY, parts.join(' '));\n    }\n  }\n}\n\n@Directive({inputs, selector})\nexport class DefaultFlexDirective extends FlexDirective {\n  protected inputs = inputs;\n}\n\nconst flexRowCache: Map<string, StyleDefinition> = new Map();\nconst flexColumnCache: Map<string, StyleDefinition> = new Map();\nconst flexRowWrapCache: Map<string, StyleDefinition> = new Map();\nconst flexColumnWrapCache: Map<string, StyleDefinition> = new Map();\n"]}