@angular/flex-layout

  • Version 12.0.0-beta.34
  • Published
  • 3.08 MB
  • 1 dependency
  • MIT license

Install

npm i @angular/flex-layout
yarn add @angular/flex-layout
pnpm add @angular/flex-layout

Overview

Angular Flex-Layout

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable BREAKPOINT

const BREAKPOINT: any;

    variable BREAKPOINT_PRINT

    const BREAKPOINT_PRINT: { alias: string; mediaQuery: string; priority: number };

      variable BREAKPOINTS

      const BREAKPOINTS: any;
      • Injection token unique to the flex-layout library. Use this token when build a custom provider (see below).

      variable BROWSER_PROVIDER

      const BROWSER_PROVIDER: {
      provide: any;
      useFactory: typeof removeStyles;
      deps: InjectionToken<Document>[];
      multi: boolean;
      };
      • Provider to remove SSR styles on the browser

      variable CLASS_NAME

      const CLASS_NAME: string;

        variable DEFAULT_BREAKPOINTS

        const DEFAULT_BREAKPOINTS: BreakPoint[];
        • NOTE: Smaller ranges have HIGHER priority since the match is more specific

        variable DEFAULT_CONFIG

        const DEFAULT_CONFIG: LayoutConfigOptions;

          variable LAYOUT_CONFIG

          const LAYOUT_CONFIG: any;

            variable ORIENTATION_BREAKPOINTS

            const ORIENTATION_BREAKPOINTS: BreakPoint[];
            • Extended Breakpoints for handset/tablets with landscape or portrait orientations

            variable ɵMockMatchMediaProvider

            const ɵMockMatchMediaProvider: {
            provide: typeof MatchMedia;
            useClass: typeof MockMatchMedia;
            };
            • Pre-configured provider for MockMatchMedia

            variable ScreenTypes

            const ScreenTypes: {
            HANDSET: string;
            TABLET: string;
            WEB: string;
            HANDSET_PORTRAIT: string;
            TABLET_PORTRAIT: string;
            WEB_PORTRAIT: string;
            HANDSET_LANDSCAPE: string;
            TABLET_LANDSCAPE: string;
            WEB_LANDSCAPE: string;
            };

              variable SERVER_TOKEN

              const SERVER_TOKEN: any;
              • Token that is provided to tell whether the FlexLayoutServerModule has been included in the bundle

                NOTE: This can be manually provided to disable styles when using SSR

              variable VERSION

              const VERSION: any;
              • Current version of Angular Flex-Layout.

              Functions

              function coerceArray

              coerceArray: <T>(value: T | T[]) => T[];
              • Wraps the provided value in an array, unless the provided value is an array.

              function mergeAlias

              mergeAlias: (dest: MediaChange, source: BreakPoint | null) => MediaChange;
              • For the specified MediaChange, make sure it contains the breakpoint alias and suffix (if available).

              function removeStyles

              removeStyles: (_document: Document, platformId: Object) => () => void;
              • Find all of the server-generated stylings, if any, and remove them This will be in the form of inline classes and the style block in the head of the DOM

              function sortAscendingPriority

              sortAscendingPriority: <T extends WithPriority>(a: T, b: T) => number;
              • HOF to sort the breakpoints by ascending priority

              function sortDescendingPriority

              sortDescendingPriority: <T extends WithPriority>(
              a: T | null,
              b: T | null
              ) => number;
              • HOF to sort the breakpoints by descending priority

              function validateBasis

              validateBasis: (basis: string, grow?: string, shrink?: string) => string[];
              • The flex API permits 3 or 1 parts of the value: - flex-grow flex-shrink flex-basis, or - flex-basis

              Classes

              class BaseDirective2

              abstract class BaseDirective2 implements OnChanges, OnDestroy {}

                constructor

                protected constructor(
                elementRef: any,
                styleBuilder: StyleBuilder,
                styler: StyleUtils,
                marshal: MediaMarshaller
                );

                  property activatedValue

                  activatedValue: string;
                  • Access to the activated value for the directive

                  property currentValue

                  protected currentValue: any;

                    property destroySubject

                    protected destroySubject: any;

                      property DIRECTIVE_KEY

                      protected DIRECTIVE_KEY: string;

                        property elementRef

                        protected elementRef: any;

                          property inputs

                          protected inputs: string[];

                            property marshal

                            protected marshal: MediaMarshaller;

                              property mru

                              protected mru: StyleDefinition;
                              • The most recently used styles for the builder

                              property nativeElement

                              readonly nativeElement: HTMLElement;
                              • Access to the HTMLElement for the directive

                              property parentElement

                              readonly parentElement: HTMLElement;
                              • Access to host element's parent DOM node

                              property styleBuilder

                              protected styleBuilder: StyleBuilder;

                                property styleCache

                                protected styleCache: Map<string, StyleDefinition>;
                                • Cache map for style computation

                                property styler

                                protected styler: StyleUtils;

                                  method addStyles

                                  protected addStyles: (input: string, parent?: Object) => void;
                                  • Add styles to the element using predefined style builder

                                  method applyStyleToElement

                                  protected applyStyleToElement: (
                                  style: StyleDefinition,
                                  value?: string | number,
                                  element?: HTMLElement
                                  ) => void;
                                  • Applies styles given via string pair or object map to the directive element

                                  method clearStyles

                                  protected clearStyles: () => void;
                                  • Remove generated styles from an element using predefined style builder

                                  method getFlexFlowDirection

                                  protected getFlexFlowDirection: (
                                  target: HTMLElement,
                                  addIfMissing?: boolean
                                  ) => string;
                                  • Determine the DOM element's Flexbox flow (flex-direction).

                                    Check inline style first then check computed (stylesheet) style. And optionally add the flow value to element's inline style.

                                  method hasWrap

                                  protected hasWrap: (target: HTMLElement) => boolean;

                                    method init

                                    protected init: (extraTriggers?: Observable<any>[]) => void;
                                    • Register with central marshaller service

                                    method ngOnChanges

                                    ngOnChanges: (changes: any) => void;
                                    • For changes

                                    method ngOnDestroy

                                    ngOnDestroy: () => void;

                                      method setValue

                                      protected setValue: (val: any, bp: string) => void;

                                        method triggerUpdate

                                        protected triggerUpdate: () => void;
                                        • Force trigger style updates on DOM element

                                        method updateWithValue

                                        protected updateWithValue: (input: string) => void;

                                          class BreakPointRegistry

                                          class BreakPointRegistry {}
                                          • Registry of 1..n MediaQuery breakpoint ranges This is published as a provider and may be overridden from custom, application-specific ranges

                                          constructor

                                          constructor(list: BreakPoint[]);

                                            property aliases

                                            readonly aliases: string[];
                                            • Get list of all registered (non-empty) breakpoint aliases

                                            property items

                                            readonly items: BreakPoint[];

                                              property overlappings

                                              readonly overlappings: BreakPoint[];
                                              • Get all the breakpoints whose ranges could overlapping normal ranges; e.g. gt-sm overlaps md, lg, and xl

                                              property suffixes

                                              readonly suffixes: string[];
                                              • Aliases are mapped to properties using suffixes e.g. 'gt-sm' for property 'layout' uses suffix 'GtSm' for property layoutGtSM.

                                              method findByAlias

                                              findByAlias: (alias: string) => OptionalBreakPoint;
                                              • Search breakpoints by alias (e.g. gt-xs)

                                              method findByQuery

                                              findByQuery: (query: string) => OptionalBreakPoint;

                                                class ClassDirective

                                                class ClassDirective extends BaseDirective2 implements DoCheck {}

                                                  constructor

                                                  constructor(
                                                  elementRef: any,
                                                  styler: any,
                                                  marshal: any,
                                                  iterableDiffers: any,
                                                  keyValueDiffers: any,
                                                  renderer2: any,
                                                  ngClassInstance: any
                                                  );

                                                    property DIRECTIVE_KEY

                                                    protected DIRECTIVE_KEY: string;

                                                      property ngClassInstance

                                                      protected readonly ngClassInstance: any;

                                                        method ngDoCheck

                                                        ngDoCheck: () => void;
                                                        • For ChangeDetectionStrategy.onPush and ngOnChanges() updates

                                                        method updateWithValue

                                                        protected updateWithValue: (value: any) => void;

                                                          class CoreModule

                                                          class CoreModule {}
                                                          • ***************************************************************** Define module for common Angular Layout utilities *****************************************************************

                                                          class DefaultClassDirective

                                                          class DefaultClassDirective extends ClassDirective {}
                                                          • Directive to add responsive support for ngClass. This maintains the core functionality of 'ngClass' and adds responsive API Note: this class is a no-op when rendered on the server

                                                          property inputs

                                                          protected inputs: string[];

                                                            class DefaultFlexAlignDirective

                                                            class DefaultFlexAlignDirective extends FlexAlignDirective {}

                                                              property inputs

                                                              protected inputs: string[];

                                                                class DefaultFlexDirective

                                                                class DefaultFlexDirective extends FlexDirective {}

                                                                  property inputs

                                                                  protected inputs: string[];

                                                                    class DefaultFlexOffsetDirective

                                                                    class DefaultFlexOffsetDirective extends FlexOffsetDirective {}

                                                                      property inputs

                                                                      protected inputs: string[];

                                                                        class DefaultFlexOrderDirective

                                                                        class DefaultFlexOrderDirective extends FlexOrderDirective {}

                                                                          property inputs

                                                                          protected inputs: string[];

                                                                            class DefaultImgSrcDirective

                                                                            class DefaultImgSrcDirective extends ImgSrcDirective {}
                                                                            • This directive provides a responsive API for the HTML 'src' attribute and will update the img.src property upon each responsive activation.

                                                                              e.g. <img src="defaultScene.jpg" src.xs="mobileScene.jpg">

                                                                              See Also

                                                                              • https://css-tricks.com/responsive-images-youre-just-changing-resolutions-use-src/

                                                                            property inputs

                                                                            protected inputs: string[];

                                                                              class DefaultLayoutAlignDirective

                                                                              class DefaultLayoutAlignDirective extends LayoutAlignDirective {}

                                                                                property inputs

                                                                                protected inputs: string[];

                                                                                  class DefaultLayoutDirective

                                                                                  class DefaultLayoutDirective extends LayoutDirective {}

                                                                                    property inputs

                                                                                    protected inputs: string[];

                                                                                      class DefaultLayoutGapDirective

                                                                                      class DefaultLayoutGapDirective extends LayoutGapDirective {}

                                                                                        property inputs

                                                                                        protected inputs: string[];

                                                                                          class DefaultShowHideDirective

                                                                                          class DefaultShowHideDirective extends ShowHideDirective {}
                                                                                          • 'show' Layout API directive

                                                                                          property inputs

                                                                                          protected inputs: string[];

                                                                                            class DefaultStyleDirective

                                                                                            class DefaultStyleDirective extends StyleDirective implements DoCheck {}
                                                                                            • Directive to add responsive support for ngStyle.

                                                                                            property inputs

                                                                                            protected inputs: string[];

                                                                                              class ExtendedModule

                                                                                              class ExtendedModule {}
                                                                                              • ***************************************************************** Define module for the Extended API *****************************************************************

                                                                                              class FlexAlignDirective

                                                                                              class FlexAlignDirective extends BaseDirective2 {}
                                                                                              • 'flex-align' flexbox styling directive Allows element-specific overrides for cross-axis alignments in a layout container

                                                                                                See Also

                                                                                                • https://css-tricks.com/almanac/properties/a/align-self/

                                                                                              constructor

                                                                                              constructor(
                                                                                              elRef: any,
                                                                                              styleUtils: any,
                                                                                              styleBuilder: FlexAlignStyleBuilder,
                                                                                              marshal: any
                                                                                              );

                                                                                                property DIRECTIVE_KEY

                                                                                                protected DIRECTIVE_KEY: string;

                                                                                                  property styleCache

                                                                                                  protected styleCache: Map<string, any>;

                                                                                                    class FlexAlignStyleBuilder

                                                                                                    class FlexAlignStyleBuilder extends StyleBuilder {}

                                                                                                      method buildStyles

                                                                                                      buildStyles: (input: string) => any;

                                                                                                        class FlexDirective

                                                                                                        class FlexDirective extends BaseDirective2 implements OnInit {}
                                                                                                        • 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 Also

                                                                                                          • https://css-tricks.com/snippets/css/a-guide-to-flexbox/

                                                                                                        constructor

                                                                                                        constructor(
                                                                                                        elRef: any,
                                                                                                        styleUtils: any,
                                                                                                        layoutConfig: any,
                                                                                                        styleBuilder: FlexStyleBuilder,
                                                                                                        marshal: any
                                                                                                        );

                                                                                                          property direction

                                                                                                          protected direction?: string;

                                                                                                            property DIRECTIVE_KEY

                                                                                                            protected DIRECTIVE_KEY: string;

                                                                                                              property flexGrow

                                                                                                              protected flexGrow: string;

                                                                                                                property flexShrink

                                                                                                                protected flexShrink: string;

                                                                                                                  property grow

                                                                                                                  grow: string;

                                                                                                                    property layoutConfig

                                                                                                                    protected layoutConfig: any;

                                                                                                                      property marshal

                                                                                                                      protected marshal: any;

                                                                                                                        property shrink

                                                                                                                        shrink: string;

                                                                                                                          property wrap

                                                                                                                          protected wrap?: boolean;

                                                                                                                            method ngOnInit

                                                                                                                            ngOnInit: () => void;

                                                                                                                              method onLayoutChange

                                                                                                                              protected onLayoutChange: (matcher: any) => void;
                                                                                                                              • 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.

                                                                                                                              method triggerReflow

                                                                                                                              protected triggerReflow: () => void;
                                                                                                                              • Trigger a style reflow, usually based on a shrink/grow input event

                                                                                                                              method updateWithValue

                                                                                                                              protected updateWithValue: (value: string) => void;
                                                                                                                              • Input to this is exclusively the basis input value

                                                                                                                              class FlexFillDirective

                                                                                                                              class FlexFillDirective extends BaseDirective2 {}
                                                                                                                              • 'fxFill' flexbox styling directive Maximizes width and height of element in a layout container

                                                                                                                                NOTE: fxFill is NOT responsive API!!

                                                                                                                              constructor

                                                                                                                              constructor(
                                                                                                                              elRef: any,
                                                                                                                              styleUtils: any,
                                                                                                                              styleBuilder: FlexFillStyleBuilder,
                                                                                                                              marshal: any
                                                                                                                              );

                                                                                                                                property styleCache

                                                                                                                                protected styleCache: Map<string, any>;

                                                                                                                                  class FlexFillStyleBuilder

                                                                                                                                  class FlexFillStyleBuilder extends StyleBuilder {}

                                                                                                                                    method buildStyles

                                                                                                                                    buildStyles: (
                                                                                                                                    _input: string
                                                                                                                                    ) => {
                                                                                                                                    margin: number;
                                                                                                                                    width: string;
                                                                                                                                    height: string;
                                                                                                                                    'min-width': string;
                                                                                                                                    'min-height': string;
                                                                                                                                    };

                                                                                                                                      class FlexLayoutModule

                                                                                                                                      class FlexLayoutModule {}
                                                                                                                                      • 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

                                                                                                                                      constructor

                                                                                                                                      constructor(serverModuleLoaded: boolean, platformId: Object);

                                                                                                                                        method withConfig

                                                                                                                                        static withConfig: (
                                                                                                                                        configOptions: any,
                                                                                                                                        breakpoints?: BreakPoint | BreakPoint[]
                                                                                                                                        ) => any;
                                                                                                                                        • Initialize the FlexLayoutModule with a set of config options, which sets the corresponding tokens accordingly

                                                                                                                                        class FlexModule

                                                                                                                                        class FlexModule {}
                                                                                                                                        • ***************************************************************** Define module for the Flex API *****************************************************************

                                                                                                                                        class FlexOffsetDirective

                                                                                                                                        class FlexOffsetDirective extends BaseDirective2 implements OnChanges {}
                                                                                                                                        • 'flex-offset' flexbox styling directive Configures the 'margin-left' of the element in a layout container

                                                                                                                                        constructor

                                                                                                                                        constructor(
                                                                                                                                        elRef: any,
                                                                                                                                        directionality: any,
                                                                                                                                        styleBuilder: FlexOffsetStyleBuilder,
                                                                                                                                        marshal: any,
                                                                                                                                        styler: any
                                                                                                                                        );

                                                                                                                                          property directionality

                                                                                                                                          protected directionality: any;

                                                                                                                                            property DIRECTIVE_KEY

                                                                                                                                            protected DIRECTIVE_KEY: string;

                                                                                                                                              method updateWithValue

                                                                                                                                              protected updateWithValue: (value?: string | number) => void;
                                                                                                                                              • Using the current fxFlexOffset value, update the inline CSS NOTE: this will assign margin-left if the parent flex-direction == 'row', otherwise margin-top is used for the offset.

                                                                                                                                              class FlexOffsetStyleBuilder

                                                                                                                                              class FlexOffsetStyleBuilder extends StyleBuilder {}

                                                                                                                                                method buildStyles

                                                                                                                                                buildStyles: (offset: string, parent: FlexOffsetParent) => any;

                                                                                                                                                  class FlexOrderDirective

                                                                                                                                                  class FlexOrderDirective extends BaseDirective2 implements OnChanges {}
                                                                                                                                                  • 'flex-order' flexbox styling directive Configures the positional ordering of the element in a sorted layout container

                                                                                                                                                    See Also

                                                                                                                                                    • https://css-tricks.com/almanac/properties/o/order/

                                                                                                                                                  constructor

                                                                                                                                                  constructor(
                                                                                                                                                  elRef: any,
                                                                                                                                                  styleUtils: any,
                                                                                                                                                  styleBuilder: FlexOrderStyleBuilder,
                                                                                                                                                  marshal: any
                                                                                                                                                  );

                                                                                                                                                    property DIRECTIVE_KEY

                                                                                                                                                    protected DIRECTIVE_KEY: string;

                                                                                                                                                      property styleCache

                                                                                                                                                      protected styleCache: Map<string, any>;

                                                                                                                                                        class FlexOrderStyleBuilder

                                                                                                                                                        class FlexOrderStyleBuilder extends StyleBuilder {}

                                                                                                                                                          method buildStyles

                                                                                                                                                          buildStyles: (value: string) => { order: string | number };

                                                                                                                                                            class FlexStyleBuilder

                                                                                                                                                            class FlexStyleBuilder extends StyleBuilder {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(layoutConfig: any);

                                                                                                                                                                property layoutConfig

                                                                                                                                                                protected layoutConfig: any;

                                                                                                                                                                  method buildStyles

                                                                                                                                                                  buildStyles: (input: string, parent: FlexBuilderParent) => any;

                                                                                                                                                                    class GridModule

                                                                                                                                                                    class GridModule {}
                                                                                                                                                                    • ***************************************************************** Define module for the CSS Grid API *****************************************************************

                                                                                                                                                                    class ImgSrcDirective

                                                                                                                                                                    class ImgSrcDirective extends BaseDirective2 {}

                                                                                                                                                                      constructor

                                                                                                                                                                      constructor(
                                                                                                                                                                      elementRef: any,
                                                                                                                                                                      styleBuilder: ImgSrcStyleBuilder,
                                                                                                                                                                      styler: any,
                                                                                                                                                                      marshal: any,
                                                                                                                                                                      platformId: Object,
                                                                                                                                                                      serverModuleLoaded: boolean
                                                                                                                                                                      );

                                                                                                                                                                        property defaultSrc

                                                                                                                                                                        protected defaultSrc: string;

                                                                                                                                                                          property DIRECTIVE_KEY

                                                                                                                                                                          protected DIRECTIVE_KEY: string;

                                                                                                                                                                            property platformId

                                                                                                                                                                            protected platformId: Object;

                                                                                                                                                                              property serverModuleLoaded

                                                                                                                                                                              protected serverModuleLoaded: boolean;

                                                                                                                                                                                property styleCache

                                                                                                                                                                                protected styleCache: Map<string, any>;

                                                                                                                                                                                  method updateWithValue

                                                                                                                                                                                  protected updateWithValue: (value?: string) => void;
                                                                                                                                                                                  • Use the [responsively] activated input value to update the host img src attribute or assign a default img.src='' if the src has not been defined.

                                                                                                                                                                                    Do nothing to standard <img src=""> usages, only when responsive keys are present do we actually call setAttribute()

                                                                                                                                                                                  class ImgSrcStyleBuilder

                                                                                                                                                                                  class ImgSrcStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                    method buildStyles

                                                                                                                                                                                    buildStyles: (url: string) => { content: string };

                                                                                                                                                                                      class LayoutAlignDirective

                                                                                                                                                                                      class LayoutAlignDirective extends BaseDirective2 {}
                                                                                                                                                                                      • 'layout-align' flexbox styling directive Defines positioning of child elements along main and cross axis in a layout container Optional values: {main-axis} values or {main-axis cross-axis} value pairs

                                                                                                                                                                                        See Also

                                                                                                                                                                                        • https://css-tricks.com/almanac/properties/j/justify-content/

                                                                                                                                                                                        • https://css-tricks.com/almanac/properties/a/align-items/

                                                                                                                                                                                        • https://css-tricks.com/almanac/properties/a/align-content/

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(
                                                                                                                                                                                      elRef: any,
                                                                                                                                                                                      styleUtils: any,
                                                                                                                                                                                      styleBuilder: LayoutAlignStyleBuilder,
                                                                                                                                                                                      marshal: any
                                                                                                                                                                                      );

                                                                                                                                                                                        property DIRECTIVE_KEY

                                                                                                                                                                                        protected DIRECTIVE_KEY: string;

                                                                                                                                                                                          property inline

                                                                                                                                                                                          protected inline: boolean;

                                                                                                                                                                                            property layout

                                                                                                                                                                                            protected layout: string;

                                                                                                                                                                                              method onLayoutChange

                                                                                                                                                                                              protected onLayoutChange: (matcher: any) => void;
                                                                                                                                                                                              • Cache the parent container 'flex-direction' and update the 'flex' styles

                                                                                                                                                                                              method updateWithValue

                                                                                                                                                                                              protected updateWithValue: (value: string) => void;

                                                                                                                                                                                              class LayoutAlignStyleBuilder

                                                                                                                                                                                              class LayoutAlignStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                method buildStyles

                                                                                                                                                                                                buildStyles: (align: string, parent: LayoutAlignParent) => any;

                                                                                                                                                                                                  class LayoutDirective

                                                                                                                                                                                                  class LayoutDirective extends BaseDirective2 implements OnChanges {}
                                                                                                                                                                                                  • 'layout' flexbox styling directive Defines the positioning flow direction for the child elements: row or column Optional values: column or row (default)

                                                                                                                                                                                                    See Also

                                                                                                                                                                                                    • https://css-tricks.com/almanac/properties/f/flex-direction/

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                  elRef: any,
                                                                                                                                                                                                  styleUtils: any,
                                                                                                                                                                                                  styleBuilder: LayoutStyleBuilder,
                                                                                                                                                                                                  marshal: any
                                                                                                                                                                                                  );

                                                                                                                                                                                                    property DIRECTIVE_KEY

                                                                                                                                                                                                    protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                      property styleCache

                                                                                                                                                                                                      protected styleCache: Map<string, any>;

                                                                                                                                                                                                        class LayoutGapDirective

                                                                                                                                                                                                        class LayoutGapDirective
                                                                                                                                                                                                        extends BaseDirective2
                                                                                                                                                                                                        implements AfterContentInit, OnDestroy {}
                                                                                                                                                                                                        • 'layout-padding' styling directive Defines padding of child elements in a layout container

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                        elRef: any,
                                                                                                                                                                                                        zone: any,
                                                                                                                                                                                                        directionality: any,
                                                                                                                                                                                                        styleUtils: any,
                                                                                                                                                                                                        styleBuilder: LayoutGapStyleBuilder,
                                                                                                                                                                                                        marshal: any
                                                                                                                                                                                                        );

                                                                                                                                                                                                          property childrenNodes

                                                                                                                                                                                                          readonly childrenNodes: HTMLElement[];
                                                                                                                                                                                                          • Special accessor to query for all child 'element' nodes regardless of type, class, etc

                                                                                                                                                                                                          property directionality

                                                                                                                                                                                                          protected directionality: any;

                                                                                                                                                                                                            property DIRECTIVE_KEY

                                                                                                                                                                                                            protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                              property layout

                                                                                                                                                                                                              protected layout: string;

                                                                                                                                                                                                                property observer

                                                                                                                                                                                                                protected observer?: MutationObserver;

                                                                                                                                                                                                                  property observerSubject

                                                                                                                                                                                                                  protected observerSubject: any;

                                                                                                                                                                                                                    property styleUtils

                                                                                                                                                                                                                    protected styleUtils: any;

                                                                                                                                                                                                                      property zone

                                                                                                                                                                                                                      protected zone: any;

                                                                                                                                                                                                                        method buildChildObservable

                                                                                                                                                                                                                        protected buildChildObservable: () => void;

                                                                                                                                                                                                                          method clearStyles

                                                                                                                                                                                                                          protected clearStyles: () => void;
                                                                                                                                                                                                                          • We need to override clearStyles because in most cases mru isn't populated

                                                                                                                                                                                                                          method ngAfterContentInit

                                                                                                                                                                                                                          ngAfterContentInit: () => void;

                                                                                                                                                                                                                            method ngOnDestroy

                                                                                                                                                                                                                            ngOnDestroy: () => void;

                                                                                                                                                                                                                              method onLayoutChange

                                                                                                                                                                                                                              protected onLayoutChange: (matcher: any) => void;
                                                                                                                                                                                                                              • Cache the parent container 'flex-direction' and update the 'margin' styles

                                                                                                                                                                                                                              method updateWithValue

                                                                                                                                                                                                                              protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                              method willDisplay

                                                                                                                                                                                                                              protected willDisplay: (source: HTMLElement) => boolean;
                                                                                                                                                                                                                              • Determine if an element will show or hide based on current activation

                                                                                                                                                                                                                              class LayoutGapStyleBuilder

                                                                                                                                                                                                                              class LayoutGapStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                constructor(_styler: any);

                                                                                                                                                                                                                                  method buildStyles

                                                                                                                                                                                                                                  buildStyles: (gapValue: string, parent: LayoutGapParent) => any;

                                                                                                                                                                                                                                    method sideEffect

                                                                                                                                                                                                                                    sideEffect: (gapValue: string, _styles: any, parent: LayoutGapParent) => void;

                                                                                                                                                                                                                                      class LayoutStyleBuilder

                                                                                                                                                                                                                                      class LayoutStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                        method buildStyles

                                                                                                                                                                                                                                        buildStyles: (
                                                                                                                                                                                                                                        input: string
                                                                                                                                                                                                                                        ) => {
                                                                                                                                                                                                                                        display: string;
                                                                                                                                                                                                                                        'box-sizing': string;
                                                                                                                                                                                                                                        'flex-direction': string;
                                                                                                                                                                                                                                        'flex-wrap': string | null;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          class MediaChange

                                                                                                                                                                                                                                          class MediaChange {}
                                                                                                                                                                                                                                          • Class instances emitted [to observers] for each mql notification

                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                          matches?: boolean,
                                                                                                                                                                                                                                          mediaQuery?: string,
                                                                                                                                                                                                                                          mqAlias?: string,
                                                                                                                                                                                                                                          suffix?: string,
                                                                                                                                                                                                                                          priority?: number
                                                                                                                                                                                                                                          );
                                                                                                                                                                                                                                          • Parameter matches

                                                                                                                                                                                                                                            whether the mediaQuery is currently activated

                                                                                                                                                                                                                                            Parameter mediaQuery

                                                                                                                                                                                                                                            e.g. (min-width: 600px) and (max-width: 959px)

                                                                                                                                                                                                                                            Parameter mqAlias

                                                                                                                                                                                                                                            e.g. gt-sm, md, gt-lg

                                                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                                                            e.g. GtSM, Md, GtLg

                                                                                                                                                                                                                                            Parameter priority

                                                                                                                                                                                                                                            the priority of activation for the given breakpoint

                                                                                                                                                                                                                                          property matches

                                                                                                                                                                                                                                          matches: boolean;

                                                                                                                                                                                                                                            property mediaQuery

                                                                                                                                                                                                                                            mediaQuery: string;

                                                                                                                                                                                                                                              property mqAlias

                                                                                                                                                                                                                                              mqAlias: string;

                                                                                                                                                                                                                                                property priority

                                                                                                                                                                                                                                                priority: number;

                                                                                                                                                                                                                                                  property property

                                                                                                                                                                                                                                                  property: string;

                                                                                                                                                                                                                                                    property suffix

                                                                                                                                                                                                                                                    suffix: string;

                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                      value: any;

                                                                                                                                                                                                                                                        method clone

                                                                                                                                                                                                                                                        clone: () => MediaChange;
                                                                                                                                                                                                                                                        • Create an exact copy of the MediaChange

                                                                                                                                                                                                                                                        class MediaMarshaller

                                                                                                                                                                                                                                                        class MediaMarshaller {}
                                                                                                                                                                                                                                                        • MediaMarshaller - register responsive values from directives and trigger them based on media query events

                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                        matchMedia: MatchMedia,
                                                                                                                                                                                                                                                        breakpoints: BreakPointRegistry,
                                                                                                                                                                                                                                                        hook: PrintHook
                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                          property activatedAlias

                                                                                                                                                                                                                                                          readonly activatedAlias: string;

                                                                                                                                                                                                                                                            property breakpoints

                                                                                                                                                                                                                                                            protected breakpoints: BreakPointRegistry;

                                                                                                                                                                                                                                                              property hook

                                                                                                                                                                                                                                                              protected hook: PrintHook;

                                                                                                                                                                                                                                                                property matchMedia

                                                                                                                                                                                                                                                                protected matchMedia: MatchMedia;

                                                                                                                                                                                                                                                                  method clearElement

                                                                                                                                                                                                                                                                  clearElement: (element: HTMLElement, key: string) => void;
                                                                                                                                                                                                                                                                  • clear the styles for a given element

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                    Parameter key

                                                                                                                                                                                                                                                                  method getValue

                                                                                                                                                                                                                                                                  getValue: (element: HTMLElement, key: string, bp?: string) => any;
                                                                                                                                                                                                                                                                  • get the value for an element and key and optionally a given breakpoint

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                    Parameter key

                                                                                                                                                                                                                                                                    Parameter bp

                                                                                                                                                                                                                                                                  method hasValue

                                                                                                                                                                                                                                                                  hasValue: (element: HTMLElement, key: string) => boolean;
                                                                                                                                                                                                                                                                  • whether the element has values for a given key

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                    Parameter key

                                                                                                                                                                                                                                                                  method init

                                                                                                                                                                                                                                                                  init: (
                                                                                                                                                                                                                                                                  element: HTMLElement,
                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                  updateFn?: UpdateCallback,
                                                                                                                                                                                                                                                                  clearFn?: ClearCallback,
                                                                                                                                                                                                                                                                  extraTriggers?: Observable<any>[]
                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                  • initialize the marshaller with necessary elements for delegation on an element

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                    Parameter key

                                                                                                                                                                                                                                                                    Parameter updateFn

                                                                                                                                                                                                                                                                    optional callback so that custom bp directives don't have to re-provide this

                                                                                                                                                                                                                                                                    Parameter clearFn

                                                                                                                                                                                                                                                                    optional callback so that custom bp directives don't have to re-provide this

                                                                                                                                                                                                                                                                    Parameter extraTriggers

                                                                                                                                                                                                                                                                    other triggers to force style updates (e.g. layout, directionality, etc)

                                                                                                                                                                                                                                                                  method onMediaChange

                                                                                                                                                                                                                                                                  onMediaChange: (mc: MediaChange) => void;
                                                                                                                                                                                                                                                                  • Update styles on breakpoint activates or deactivates

                                                                                                                                                                                                                                                                    Parameter mc

                                                                                                                                                                                                                                                                  method releaseElement

                                                                                                                                                                                                                                                                  releaseElement: (element: HTMLElement) => void;
                                                                                                                                                                                                                                                                  • release all references to a given element

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                  method setValue

                                                                                                                                                                                                                                                                  setValue: (element: HTMLElement, key: string, val: any, bp: string) => void;
                                                                                                                                                                                                                                                                  • Set the value for an input on a directive

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                    the element in question

                                                                                                                                                                                                                                                                    Parameter key

                                                                                                                                                                                                                                                                    the type of the directive (e.g. flex, layout-gap, etc)

                                                                                                                                                                                                                                                                    Parameter bp

                                                                                                                                                                                                                                                                    the breakpoint suffix (empty string = default)

                                                                                                                                                                                                                                                                    Parameter val

                                                                                                                                                                                                                                                                    the value for the breakpoint

                                                                                                                                                                                                                                                                  method trackValue

                                                                                                                                                                                                                                                                  trackValue: (element: HTMLElement, key: string) => any;
                                                                                                                                                                                                                                                                  • Track element value changes for a specific key

                                                                                                                                                                                                                                                                  method triggerUpdate

                                                                                                                                                                                                                                                                  triggerUpdate: (element: HTMLElement, key?: string) => void;
                                                                                                                                                                                                                                                                  • trigger an update for a given element and key (e.g. layout)

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                    Parameter key

                                                                                                                                                                                                                                                                  method updateElement

                                                                                                                                                                                                                                                                  updateElement: (element: HTMLElement, key: string, value: any) => void;
                                                                                                                                                                                                                                                                  • update a given element with the activated values for a given key

                                                                                                                                                                                                                                                                    Parameter element

                                                                                                                                                                                                                                                                    Parameter key

                                                                                                                                                                                                                                                                    Parameter value

                                                                                                                                                                                                                                                                  method updateStyles

                                                                                                                                                                                                                                                                  updateStyles: () => void;
                                                                                                                                                                                                                                                                  • update all styles for all elements on the current breakpoint

                                                                                                                                                                                                                                                                  class MediaObserver

                                                                                                                                                                                                                                                                  class MediaObserver implements OnDestroy {}
                                                                                                                                                                                                                                                                  • MediaObserver enables applications to listen for 1..n mediaQuery activations and to determine if a mediaQuery is currently activated.

                                                                                                                                                                                                                                                                    Since a breakpoint change will first deactivate 1...n mediaQueries and then possibly activate 1..n mediaQueries, the MediaObserver will debounce notifications and report ALL *activations* in 1 event notification. The reported activations will be sorted in descending priority order.

                                                                                                                                                                                                                                                                    This class uses the BreakPoint Registry to inject alias information into the raw MediaChange notification. For custom mediaQuery notifications, alias information will not be injected and those fields will be ''.

                                                                                                                                                                                                                                                                    Note: Developers should note that only mediaChange activations (not de-activations) are announced by the MediaObserver.

                                                                                                                                                                                                                                                                    // RxJS import { filter } from 'rxjs/operators'; import { MediaObserver } from '@angular/flex-layout';

                                                                                                                                                                                                                                                                    @Component({ ... }) export class AppComponent { status: string = '';

                                                                                                                                                                                                                                                                    constructor(mediaObserver: MediaObserver) { const media$ = mediaObserver.asObservable().pipe( filter((changes: MediaChange[]) => true) // silly noop filter );

                                                                                                                                                                                                                                                                    media$.subscribe((changes: MediaChange[]) => { let status = ''; changes.forEach( change => { status += '${change.mqAlias}' = (${change.mediaQuery}) <br/> ; }); this.status = status; });

                                                                                                                                                                                                                                                                    } }

                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                  breakpoints: BreakPointRegistry,
                                                                                                                                                                                                                                                                  matchMedia: MatchMedia,
                                                                                                                                                                                                                                                                  hook: PrintHook
                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                    property breakpoints

                                                                                                                                                                                                                                                                    protected breakpoints: BreakPointRegistry;

                                                                                                                                                                                                                                                                      property filterOverlaps

                                                                                                                                                                                                                                                                      filterOverlaps: boolean;
                                                                                                                                                                                                                                                                      • Filter MediaChange notifications for overlapping breakpoints

                                                                                                                                                                                                                                                                      property hook

                                                                                                                                                                                                                                                                      protected hook: PrintHook;

                                                                                                                                                                                                                                                                        property matchMedia

                                                                                                                                                                                                                                                                        protected matchMedia: MatchMedia;

                                                                                                                                                                                                                                                                          property media$

                                                                                                                                                                                                                                                                          readonly media$: any;
                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                            Use asObservable() instead. @breaking-change 8.0.0-beta.25 @deletion-target 10.0.0

                                                                                                                                                                                                                                                                          method asObservable

                                                                                                                                                                                                                                                                          asObservable: () => any;
                                                                                                                                                                                                                                                                          • Observe changes to current activation 'list'

                                                                                                                                                                                                                                                                          method isActive

                                                                                                                                                                                                                                                                          isActive: (value: string | string[]) => boolean;
                                                                                                                                                                                                                                                                          • Allow programmatic query to determine if one or more media query/alias match the current viewport size.

                                                                                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                                                                                            One or more media queries (or aliases) to check.

                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                            Whether any of the media queries match.

                                                                                                                                                                                                                                                                          method ngOnDestroy

                                                                                                                                                                                                                                                                          ngOnDestroy: () => void;
                                                                                                                                                                                                                                                                          • Completes the active subject, signalling to all complete for all MediaObserver subscribers

                                                                                                                                                                                                                                                                          class MediaTrigger

                                                                                                                                                                                                                                                                          class MediaTrigger {}
                                                                                                                                                                                                                                                                          • Class

                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                          breakpoints: BreakPointRegistry,
                                                                                                                                                                                                                                                                          matchMedia: MatchMedia,
                                                                                                                                                                                                                                                                          layoutConfig: LayoutConfigOptions,
                                                                                                                                                                                                                                                                          _platformId: Object,
                                                                                                                                                                                                                                                                          _document: any
                                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                                            property breakpoints

                                                                                                                                                                                                                                                                            protected breakpoints: BreakPointRegistry;

                                                                                                                                                                                                                                                                              property layoutConfig

                                                                                                                                                                                                                                                                              protected layoutConfig: LayoutConfigOptions;

                                                                                                                                                                                                                                                                                property matchMedia

                                                                                                                                                                                                                                                                                protected matchMedia: MatchMedia;

                                                                                                                                                                                                                                                                                  method activate

                                                                                                                                                                                                                                                                                  activate: (list: string[]) => void;
                                                                                                                                                                                                                                                                                  • Manually activate range of breakpoints

                                                                                                                                                                                                                                                                                    Parameter list

                                                                                                                                                                                                                                                                                    array of mediaQuery or alias strings

                                                                                                                                                                                                                                                                                  method restore

                                                                                                                                                                                                                                                                                  restore: () => void;
                                                                                                                                                                                                                                                                                  • Restore original, 'real' breakpoints and emit events to trigger stream notification

                                                                                                                                                                                                                                                                                  class ɵgrid_privatea

                                                                                                                                                                                                                                                                                  class GridAlignStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                    method buildStyles

                                                                                                                                                                                                                                                                                    buildStyles: (input: string) => { [key: string]: string };

                                                                                                                                                                                                                                                                                      class ɵgrid_privateb

                                                                                                                                                                                                                                                                                      class GridAlignDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                        elementRef: any,
                                                                                                                                                                                                                                                                                        styleBuilder: GridAlignStyleBuilder,
                                                                                                                                                                                                                                                                                        styler: any,
                                                                                                                                                                                                                                                                                        marshal: any
                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                          property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                          protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                            property styleCache

                                                                                                                                                                                                                                                                                            protected styleCache: Map<string, any>;

                                                                                                                                                                                                                                                                                              class ɵgrid_privateba

                                                                                                                                                                                                                                                                                              class DefaultGridGapDirective extends GridGapDirective {}
                                                                                                                                                                                                                                                                                              • 'grid-gap' CSS Grid styling directive Configures the gap between items in the grid Syntax: <row gap> []

                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-17

                                                                                                                                                                                                                                                                                              property inputs

                                                                                                                                                                                                                                                                                              protected inputs: string[];

                                                                                                                                                                                                                                                                                                class ɵgrid_privatebb

                                                                                                                                                                                                                                                                                                class GridRowStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                  method buildStyles

                                                                                                                                                                                                                                                                                                  buildStyles: (input: string) => { 'grid-row': string };

                                                                                                                                                                                                                                                                                                    class ɵgrid_privatebc

                                                                                                                                                                                                                                                                                                    class GridRowDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                      elementRef: any,
                                                                                                                                                                                                                                                                                                      styleBuilder: GridRowStyleBuilder,
                                                                                                                                                                                                                                                                                                      styler: any,
                                                                                                                                                                                                                                                                                                      marshal: any
                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                        property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                        protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                          property styleCache

                                                                                                                                                                                                                                                                                                          protected styleCache: Map<string, any>;

                                                                                                                                                                                                                                                                                                            class ɵgrid_privatebd

                                                                                                                                                                                                                                                                                                            class DefaultGridRowDirective extends GridRowDirective {}
                                                                                                                                                                                                                                                                                                            • 'grid-row' CSS Grid styling directive Configures the name or position of an element within the grid

                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                              • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-26

                                                                                                                                                                                                                                                                                                            property inputs

                                                                                                                                                                                                                                                                                                            protected inputs: string[];

                                                                                                                                                                                                                                                                                                              class ɵgrid_privatebe

                                                                                                                                                                                                                                                                                                              class GridRowsStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                method buildStyles

                                                                                                                                                                                                                                                                                                                buildStyles: (
                                                                                                                                                                                                                                                                                                                input: string,
                                                                                                                                                                                                                                                                                                                parent: GridRowsParent
                                                                                                                                                                                                                                                                                                                ) => { display: string; 'grid-auto-rows': string; 'grid-template-rows': string };

                                                                                                                                                                                                                                                                                                                  class ɵgrid_privatebf

                                                                                                                                                                                                                                                                                                                  class GridRowsDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                    elementRef: any,
                                                                                                                                                                                                                                                                                                                    styleBuilder: GridRowsStyleBuilder,
                                                                                                                                                                                                                                                                                                                    styler: any,
                                                                                                                                                                                                                                                                                                                    marshal: any
                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                      property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                      protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                        property inline

                                                                                                                                                                                                                                                                                                                        inline: boolean;

                                                                                                                                                                                                                                                                                                                          method updateWithValue

                                                                                                                                                                                                                                                                                                                          protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                                                                                                                            class ɵgrid_privatebg

                                                                                                                                                                                                                                                                                                                            class DefaultGridRowsDirective extends GridRowsDirective {}
                                                                                                                                                                                                                                                                                                                            • 'grid-template-rows' CSS Grid styling directive Configures the sizing for the rows in the grid Syntax: <column value> [auto]

                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                              • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-13

                                                                                                                                                                                                                                                                                                                            property inputs

                                                                                                                                                                                                                                                                                                                            protected inputs: string[];

                                                                                                                                                                                                                                                                                                                              class ɵgrid_privatec

                                                                                                                                                                                                                                                                                                                              class DefaultGridAlignDirective extends GridAlignDirective {}
                                                                                                                                                                                                                                                                                                                              • 'align' CSS Grid styling directive for grid children Defines positioning of child elements along row and column axis in a grid container Optional values: {row-axis} values or {row-axis column-axis} value pairs

                                                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                                                • https://css-tricks.com/snippets/css/complete-guide-grid/#prop-justify-self

                                                                                                                                                                                                                                                                                                                                • https://css-tricks.com/snippets/css/complete-guide-grid/#prop-align-self

                                                                                                                                                                                                                                                                                                                              property inputs

                                                                                                                                                                                                                                                                                                                              protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                class ɵgrid_privated

                                                                                                                                                                                                                                                                                                                                class GridAlignColumnsStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                  method buildStyles

                                                                                                                                                                                                                                                                                                                                  buildStyles: (input: string, parent: GridAlignColumnsParent) => any;

                                                                                                                                                                                                                                                                                                                                    class ɵgrid_privatee

                                                                                                                                                                                                                                                                                                                                    class GridAlignColumnsDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                      elementRef: any,
                                                                                                                                                                                                                                                                                                                                      styleBuilder: GridAlignColumnsStyleBuilder,
                                                                                                                                                                                                                                                                                                                                      styler: any,
                                                                                                                                                                                                                                                                                                                                      marshal: any
                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                        property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                        protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                          property inline

                                                                                                                                                                                                                                                                                                                                          inline: boolean;

                                                                                                                                                                                                                                                                                                                                            method updateWithValue

                                                                                                                                                                                                                                                                                                                                            protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                              class ɵgrid_privatef

                                                                                                                                                                                                                                                                                                                                              class DefaultGridAlignColumnsDirective extends GridAlignColumnsDirective {}
                                                                                                                                                                                                                                                                                                                                              • 'column alignment' CSS Grid styling directive Configures the alignment in the column direction

                                                                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                                                                • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-19

                                                                                                                                                                                                                                                                                                                                                • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-21

                                                                                                                                                                                                                                                                                                                                              property inputs

                                                                                                                                                                                                                                                                                                                                              protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                                class ɵgrid_privateg

                                                                                                                                                                                                                                                                                                                                                class GridAlignRowsStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                  method buildStyles

                                                                                                                                                                                                                                                                                                                                                  buildStyles: (input: string, parent: GridAlignRowsParent) => any;

                                                                                                                                                                                                                                                                                                                                                    class ɵgrid_privateh

                                                                                                                                                                                                                                                                                                                                                    class GridAlignRowsDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                      elementRef: any,
                                                                                                                                                                                                                                                                                                                                                      styleBuilder: GridAlignRowsStyleBuilder,
                                                                                                                                                                                                                                                                                                                                                      styler: any,
                                                                                                                                                                                                                                                                                                                                                      marshal: any
                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                        property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                        protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                          property inline

                                                                                                                                                                                                                                                                                                                                                          inline: boolean;

                                                                                                                                                                                                                                                                                                                                                            method updateWithValue

                                                                                                                                                                                                                                                                                                                                                            protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                                              class ɵgrid_privatei

                                                                                                                                                                                                                                                                                                                                                              class DefaultGridAlignRowsDirective extends GridAlignRowsDirective {}
                                                                                                                                                                                                                                                                                                                                                              • 'row alignment' CSS Grid styling directive Configures the alignment in the row direction

                                                                                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                                                                                • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-18

                                                                                                                                                                                                                                                                                                                                                                • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-20

                                                                                                                                                                                                                                                                                                                                                              property inputs

                                                                                                                                                                                                                                                                                                                                                              protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                                                class ɵgrid_privatej

                                                                                                                                                                                                                                                                                                                                                                class GridAreaStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                                  method buildStyles

                                                                                                                                                                                                                                                                                                                                                                  buildStyles: (input: string) => { 'grid-area': string };

                                                                                                                                                                                                                                                                                                                                                                    class ɵgrid_privatek

                                                                                                                                                                                                                                                                                                                                                                    class GridAreaDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                      elRef: any,
                                                                                                                                                                                                                                                                                                                                                                      styleUtils: any,
                                                                                                                                                                                                                                                                                                                                                                      styleBuilder: GridAreaStyleBuilder,
                                                                                                                                                                                                                                                                                                                                                                      marshal: any
                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                        property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                        protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                          property styleCache

                                                                                                                                                                                                                                                                                                                                                                          protected styleCache: Map<string, any>;

                                                                                                                                                                                                                                                                                                                                                                            class ɵgrid_privatel

                                                                                                                                                                                                                                                                                                                                                                            class DefaultGridAreaDirective extends GridAreaDirective {}
                                                                                                                                                                                                                                                                                                                                                                            • 'grid-area' CSS Grid styling directive Configures the name or position of an element within the grid

                                                                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                                                                              • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-27

                                                                                                                                                                                                                                                                                                                                                                            property inputs

                                                                                                                                                                                                                                                                                                                                                                            protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                                                              class ɵgrid_privatem

                                                                                                                                                                                                                                                                                                                                                                              class GridAreasStyleBuiler extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                method buildStyles

                                                                                                                                                                                                                                                                                                                                                                                buildStyles: (
                                                                                                                                                                                                                                                                                                                                                                                input: string,
                                                                                                                                                                                                                                                                                                                                                                                parent: GridAreasParent
                                                                                                                                                                                                                                                                                                                                                                                ) => { display: string; 'grid-template-areas': string };

                                                                                                                                                                                                                                                                                                                                                                                  class ɵgrid_privaten

                                                                                                                                                                                                                                                                                                                                                                                  class GridAreasDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                    elRef: any,
                                                                                                                                                                                                                                                                                                                                                                                    styleUtils: any,
                                                                                                                                                                                                                                                                                                                                                                                    styleBuilder: GridAreasStyleBuiler,
                                                                                                                                                                                                                                                                                                                                                                                    marshal: any
                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                      property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                                      protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                        property inline

                                                                                                                                                                                                                                                                                                                                                                                        inline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                          method updateWithValue

                                                                                                                                                                                                                                                                                                                                                                                          protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                            class ɵgrid_privateo

                                                                                                                                                                                                                                                                                                                                                                                            class DefaultGridAreasDirective extends GridAreasDirective {}
                                                                                                                                                                                                                                                                                                                                                                                            • 'grid-template-areas' CSS Grid styling directive Configures the names of elements within the grid

                                                                                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                                                                                              • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-14

                                                                                                                                                                                                                                                                                                                                                                                            property inputs

                                                                                                                                                                                                                                                                                                                                                                                            protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                                                                              class ɵgrid_privatep

                                                                                                                                                                                                                                                                                                                                                                                              class GridAutoStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                method buildStyles

                                                                                                                                                                                                                                                                                                                                                                                                buildStyles: (
                                                                                                                                                                                                                                                                                                                                                                                                input: string,
                                                                                                                                                                                                                                                                                                                                                                                                parent: GridAutoParent
                                                                                                                                                                                                                                                                                                                                                                                                ) => { display: string; 'grid-auto-flow': string };

                                                                                                                                                                                                                                                                                                                                                                                                  class ɵgrid_privateq

                                                                                                                                                                                                                                                                                                                                                                                                  class GridAutoDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                    elementRef: any,
                                                                                                                                                                                                                                                                                                                                                                                                    styleBuilder: GridAutoStyleBuilder,
                                                                                                                                                                                                                                                                                                                                                                                                    styler: any,
                                                                                                                                                                                                                                                                                                                                                                                                    marshal: any
                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                      property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                                                      protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                                        property inline

                                                                                                                                                                                                                                                                                                                                                                                                        inline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                          method updateWithValue

                                                                                                                                                                                                                                                                                                                                                                                                          protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            class ɵgrid_privater

                                                                                                                                                                                                                                                                                                                                                                                                            class DefaultGridAutoDirective extends GridAutoDirective {}
                                                                                                                                                                                                                                                                                                                                                                                                            • 'grid-auto-flow' CSS Grid styling directive Configures the auto placement algorithm for the grid

                                                                                                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                                                                                                              • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-23

                                                                                                                                                                                                                                                                                                                                                                                                            property inputs

                                                                                                                                                                                                                                                                                                                                                                                                            protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                                                                                              class ɵgrid_privates

                                                                                                                                                                                                                                                                                                                                                                                                              class GridColumnStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                                method buildStyles

                                                                                                                                                                                                                                                                                                                                                                                                                buildStyles: (input: string) => { 'grid-column': string };

                                                                                                                                                                                                                                                                                                                                                                                                                  class ɵgrid_privatet

                                                                                                                                                                                                                                                                                                                                                                                                                  class GridColumnDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                    elementRef: any,
                                                                                                                                                                                                                                                                                                                                                                                                                    styleBuilder: GridColumnStyleBuilder,
                                                                                                                                                                                                                                                                                                                                                                                                                    styler: any,
                                                                                                                                                                                                                                                                                                                                                                                                                    marshal: any
                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                      property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                                                                      protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property styleCache

                                                                                                                                                                                                                                                                                                                                                                                                                        protected styleCache: Map<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                          class ɵgrid_privateu

                                                                                                                                                                                                                                                                                                                                                                                                                          class DefaultGridColumnDirective extends GridColumnDirective {}
                                                                                                                                                                                                                                                                                                                                                                                                                          • 'grid-column' CSS Grid styling directive Configures the name or position of an element within the grid

                                                                                                                                                                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                                                                                                                                                                            • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-26

                                                                                                                                                                                                                                                                                                                                                                                                                          property inputs

                                                                                                                                                                                                                                                                                                                                                                                                                          protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                            class ɵgrid_privatev

                                                                                                                                                                                                                                                                                                                                                                                                                            class GridColumnsStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                                              method buildStyles

                                                                                                                                                                                                                                                                                                                                                                                                                              buildStyles: (
                                                                                                                                                                                                                                                                                                                                                                                                                              input: string,
                                                                                                                                                                                                                                                                                                                                                                                                                              parent: GridColumnsParent
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                              display: string;
                                                                                                                                                                                                                                                                                                                                                                                                                              'grid-auto-columns': string;
                                                                                                                                                                                                                                                                                                                                                                                                                              'grid-template-columns': string;
                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                class ɵgrid_privatew

                                                                                                                                                                                                                                                                                                                                                                                                                                class GridColumnsDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                  elementRef: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                  styleBuilder: GridColumnsStyleBuilder,
                                                                                                                                                                                                                                                                                                                                                                                                                                  styler: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                  marshal: any
                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                    property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                                                                                    protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                      inline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method updateWithValue

                                                                                                                                                                                                                                                                                                                                                                                                                                        protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                          class ɵgrid_privatex

                                                                                                                                                                                                                                                                                                                                                                                                                                          class DefaultGridColumnsDirective extends GridColumnsDirective {}
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 'grid-template-columns' CSS Grid styling directive Configures the sizing for the columns in the grid Syntax: <column value> [auto]

                                                                                                                                                                                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                            • https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-13

                                                                                                                                                                                                                                                                                                                                                                                                                                          property inputs

                                                                                                                                                                                                                                                                                                                                                                                                                                          protected inputs: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                            class ɵgrid_privatey

                                                                                                                                                                                                                                                                                                                                                                                                                                            class GridGapStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              method buildStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                              buildStyles: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              input: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                              parent: GridGapParent
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => { display: string; 'grid-gap': string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                class ɵgrid_privatez

                                                                                                                                                                                                                                                                                                                                                                                                                                                class GridGapDirective extends BaseDirective2 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                  elRef: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  styleUtils: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  styleBuilder: GridGapStyleBuilder,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  marshal: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                      inline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method updateWithValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected updateWithValue: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ɵMatchMedia

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MatchMedia implements OnDestroy {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • MediaMonitor configures listeners to mediaQuery changes and publishes an Observable facade to convert mediaQuery change callbacks to subscriber notifications. These notifications will be performed within the ng Zone to trigger change detections and component updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: both mediaQuery activations and de-activations are announced in notifications

                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(_zone: any, _platformId: Object, _document: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property activations

                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly activations: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Publish list of all current activations

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                            registry: Map<string, MediaQueryList>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly source: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Initialize source with 'all' so all non-responsive APIs trigger style updates

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method buildMQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected buildMQL: (query: string) => MediaQueryList;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Call window.matchMedia() to build a MediaQueryList; which supports 0..n listeners for activation/deactivation

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                              isActive: (mediaQuery: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • For the specified mediaQuery?

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method ngOnDestroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                              ngOnDestroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method observe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                observe: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (): any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (mediaQueries: string[]): any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (mediaQueries: string[], filterOthers: boolean): any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • External observers can watch for all (or a specific) mql changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If a mediaQuery is not specified, then ALL mediaQuery activations will be announced.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method registerQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerQuery: (mediaQuery: string | string[]) => MediaChange[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Based on the BreakPointRegistry provider, register internal listeners for each unique mediaQuery. Each listener emits specific MediaChange data to observers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ɵMockMatchMedia

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class MockMatchMedia extends MatchMedia {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • MockMatchMedia mocks calls to the Window API matchMedia with a build of a simulated MockMediaQueryListener. Methods are available to simulate an activation of a mediaQuery range and to clearAll mediaQuery listeners.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _zone: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _platformId: Object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _document: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _breakpoints: BreakPointRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property autoRegisterQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  autoRegisterQueries: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasActivated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly hasActivated: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property useOverlaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      useOverlaps: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method activate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        activate: (mediaQuery: string, useOverlaps?: boolean) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Feature to support manual, simulated activation of a mediaQuery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method buildMQL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected buildMQL: (query: string) => MediaQueryList;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Call window.matchMedia() to build a MediaQueryList; which supports 0..n listeners for activation/deactivation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method clearAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        clearAll: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Easy method to clear all listeners for all mediaQueries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PrintHook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PrintHook implements OnDestroy {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • PrintHook - Use to intercept print MediaQuery activations and force layouts to render with the specified print alias/breakpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Used in MediaMarshaller and MediaObserver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        breakpoints: BreakPointRegistry,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        layoutConfig: LayoutConfigOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _document: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property breakpoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected breakpoints: BreakPointRegistry;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property layoutConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected layoutConfig: LayoutConfigOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property printAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly printAlias: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • What is the desired mqAlias to use while printing?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property printBreakPoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly printBreakPoints: BreakPoint[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Lookup breakpoints associated with print aliases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method blockPropagation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              blockPropagation: () => (event: MediaChange) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Stop mediaChange event propagation in event streams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method collectActivations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              collectActivations: (event: MediaChange) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • To restore pre-Print Activations, we must capture the proper list of breakpoint activations BEFORE print starts. OnBeforePrint() is supported; so 'print' mediaQuery activations are used as a fallback in browsers without beforeprint support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > But activated breakpoints are deactivated BEFORE 'print' activation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Let's capture all de-activations using the following logic:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When not printing: - clear cache when activating non-print breakpoint - update cache (and sort) when deactivating

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When printing: - sort and save when starting print - restore as activatedTargets and clear when stop printing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getEventBreakpoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getEventBreakpoints: ({ mediaQuery }: MediaChange) => BreakPoint[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Lookup breakpoint associated with mediaQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method interceptEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interceptEvents: (target: HookTarget) => (event: MediaChange) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Prepare RxJS filter operator with partial application pipeable filter predicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isPrintEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPrintEvent: (e: MediaChange) => Boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Is the MediaChange event for any 'print'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method ngOnDestroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ngOnDestroy: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Teardown logic for the service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method startPrinting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected startPrinting: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              target: HookTarget,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bpList: OptionalBreakPoint[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Save current activateBreakpoints (for later restore) and substitute only the printAlias breakpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method stopPrinting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected stopPrinting: (target: HookTarget) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • For any print de-activations, reset the entire print queue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method updateEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              updateEvent: (event: MediaChange) => MediaChange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Update event with printAlias mediaQuery information

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method withPrintQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              withPrintQuery: (queries: string[]) => string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add 'print' mediaQuery: to listen for matchMedia activations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ShowHideDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ShowHideDirective extends BaseDirective2 implements AfterViewInit, OnChanges {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                elementRef: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                styleBuilder: ShowHideStyleBuilder,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                styler: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                marshal: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                layoutConfig: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                platformId: Object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverModuleLoaded: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property display

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected display: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Original DOM Element CSS display style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasFlexChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected hasFlexChild: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hasLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected hasLayout: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property layoutConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected layoutConfig: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property platformId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected platformId: Object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property serverModuleLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected serverModuleLoaded: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDisplayStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getDisplayStyle: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Override accessor to the current HTMLElement's display style Note: Show/Hide will not change the display to 'flex' but will set it to 'block' unless it was already explicitly specified inline or in a CSS stylesheet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method ngAfterViewInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ngAfterViewInit: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ngOnChanges: (changes: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • On changes to any properties... Default to use the non-responsive Input value ('fxShow') Then conditionally override with the mq-activated Input's current value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method trackExtraTriggers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected trackExtraTriggers: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Watch for these extra triggers to update fxShow, fxHide stylings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method updateWithValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected updateWithValue: (value?: boolean | string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Validate the visibility value and then update the host's inline display style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ShowHideStyleBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ShowHideStyleBuilder extends StyleBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method buildStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buildStyles: (show: string, parent: ShowHideParent) => { display: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StyleBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abstract class StyleBuilder {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A class that encapsulates CSS style generation for common directives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property shouldCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shouldCache: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Whether to cache the generated output styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method buildStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abstract buildStyles: (input: string, parent?: Object) => StyleDefinition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build the styles given an input string and configuration object from a host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sideEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sideEffect: (_input: string, _styles: StyleDefinition, _parent?: Object) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Run a side effect computation given the input string and the computed styles from the build task and the host configuration object NOTE: This should be a no-op unless an algorithm is provided in a subclass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StyleDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StyleDirective extends BaseDirective2 implements DoCheck {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      elementRef: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      styler: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      marshal: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sanitizer: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      differs: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      renderer2: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ngStyleInstance: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serverLoaded: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      platformId: Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property DIRECTIVE_KEY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected DIRECTIVE_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fallbackStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected fallbackStyles: NgStyleMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isServer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected isServer: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sanitizer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected sanitizer: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method buildStyleMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected buildStyleMap: (styles: NgStyleType) => NgStyleMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method clearStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected clearStyles: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Remove generated styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method ngDoCheck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ngDoCheck: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • For ChangeDetectionStrategy.onPush and ngOnChanges() updates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method updateWithValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected updateWithValue: (value: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Add generated styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class StylesheetMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class StylesheetMap {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Utility to emulate a CSS stylesheet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This utility class stores all of the styles for a given HTML element as a readonly stylesheet map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property stylesheet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly stylesheet: Map<HTMLElement, Map<string, string | number>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method addStyleToElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addStyleToElement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  element: HTMLElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  style: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: string | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Add an individual style to an HTML element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method clearStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clearStyles: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Clear the virtual stylesheet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getStyleForElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getStyleForElement: (el: HTMLElement, styleName: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Retrieve a given style for an HTML element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class StyleUtils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class StyleUtils {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _serverStylesheet: StylesheetMap,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _serverModuleLoaded: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _platformId: Object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    layoutConfig: LayoutConfigOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method applyStyleToElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      applyStyleToElement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      element: HTMLElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      style: StyleDefinition | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value?: string | number | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Applies styles given via string pair or object map to the directive element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method applyStyleToElements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      applyStyleToElements: (style: StyleDefinition, elements?: HTMLElement[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Applies styles given via string pair or object map to the directive's element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getFlowDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getFlowDirection: (target: HTMLElement) => [string, string];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Determine the DOM element's Flexbox flow (flex-direction)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Check inline style first then check computed (stylesheet) style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method hasWrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hasWrap: (target: HTMLElement) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method lookupAttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lookupAttributeValue: (element: HTMLElement, attribute: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Find the DOM element's raw attribute value (if any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method lookupInlineStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lookupInlineStyle: (element: HTMLElement, styleName: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Find the DOM element's inline style value (if any)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method lookupStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lookupStyle: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        element: HTMLElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        styleName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inlineOnly?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Determine the inline or inherited CSS style NOTE: platform-server has no implementation for getComputedStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BreakPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BreakPoint {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property alias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        alias: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property mediaQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mediaQuery: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property overlapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            overlapping?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property priority

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              priority?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property suffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                suffix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ElementMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ElementMatcher {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    element: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FlexOffsetParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FlexOffsetParent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isRtl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isRtl: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              layout: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface HookTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface HookTarget {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Interface to apply PrintHook to call anonymous target.updateStyles()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property activatedBreakpoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activatedBreakpoints: BreakPoint[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method updateStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateStyles: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LayoutAlignParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LayoutAlignParent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        layout: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LayoutConfigOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LayoutConfigOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • a set of configuration options for FlexLayoutModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property addFlexToParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addFlexToParent?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property addOrientationBps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addOrientationBps?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property disableDefaultBps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              disableDefaultBps?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property disableVendorPrefixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disableVendorPrefixes?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mediaTriggerAutoRestore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mediaTriggerAutoRestore?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property printWithBreakpoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    printWithBreakpoints?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property serverLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serverLoaded?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ssrObserveBreakpoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ssrObserveBreakpoints?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property useColumnBasisZero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          useColumnBasisZero?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface LayoutGapParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface LayoutGapParent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property directionality

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              directionality: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                items: HTMLElement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  layout: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ShowHideParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ShowHideParent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property display

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      display: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isServer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isServer: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MediaQuerySubscriber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MediaQuerySubscriber = (changes: MediaChange) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OptionalBreakPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OptionalBreakPoint = BreakPoint | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StyleDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StyleDefinition = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [property: string]: string | number | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Definition of a css style. Either a property name (e.g. "flex-basis") or an object map of property name and value (e.g. {display: 'none', flex-order: 5})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (54)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (5)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@angular/flex-layout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@angular/flex-layout)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@angular/flex-layout"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>