@ng-matero/extensions 12.5.3 → 12.6.0

package/esm2015/colorpicker/colorpicker.js

@@ -0,0 +1,361 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ESCAPE, hasModifierKey, UP_ARROW } from '@angular/cdk/keycodes';
+import { OverlayConfig, Overlay, } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, Optional, Output, TemplateRef, ViewContainerRef, ViewEncapsulation, } from '@angular/core';
+import { mixinColor } from '@angular/material/core';
+import { Subject, Subscription, merge } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { mtxColorpickerAnimations } from './colorpicker-animations';
+import { TinyColor } from '@ctrl/tinycolor';
+/** Used to generate a unique ID for each colorpicker instance. */
+let colorpickerUid = 0;
+/** Injection token that determines the scroll handling while the panel is open. */
+export const MTX_COLORPICKER_SCROLL_STRATEGY = new InjectionToken('mtx-colorpicker-scroll-strategy');
+export function MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY(overlay) {
+    return () => overlay.scrollStrategies.reposition();
+}
+export const MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER = {
+    provide: MTX_COLORPICKER_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY,
+};
+// Boilerplate for applying mixins to MtxColorpickerContent.
+/** @docs-private */
+const _MtxColorpickerContentBase = mixinColor(class {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+    }
+});
+export class MtxColorpickerContent extends _MtxColorpickerContentBase {
+    constructor(elementRef, _changeDetectorRef) {
+        super(elementRef);
+        this._changeDetectorRef = _changeDetectorRef;
+        /** Current state of the animation. */
+        this._animationState = 'enter-dropdown';
+        /** Emits when an animation has finished. */
+        this._animationDone = new Subject();
+    }
+    _startExitAnimation() {
+        this._animationState = 'void';
+        this._changeDetectorRef.markForCheck();
+    }
+    ngOnDestroy() {
+        this._animationDone.complete();
+    }
+    // https://github.com/scttcper/ngx-color/issues/292
+    getHex8(e) {
+        const alpha = e.color.rgb.a;
+        return alpha === 1 ? e.color.hex : new TinyColor(e.color.rgb).toHex8String();
+    }
+}
+/** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+MtxColorpickerContent.decorators = [
+    { type: Component, args: [{
+                selector: 'mtx-colorpicker-content',
+                template: "<ng-template [ngIf]=\"picker.content\" [ngIfElse]=\"default\"\n             [ngTemplateOutlet]=\"picker.content\">\n</ng-template>\n<ng-template #default>\n  <color-chrome [color]=\"picker.selected\"\n                (onChangeComplete)=\"picker.select(getHex8($event))\">\n  </color-chrome>\n</ng-template>\n",
+                host: {
+                    'class': 'mtx-colorpicker-content',
+                    '[@transformPanel]': '_animationState',
+                    '(@transformPanel.done)': '_animationDone.next()',
+                },
+                animations: [mtxColorpickerAnimations.transformPanel],
+                exportAs: 'mtxColorpickerContent',
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                inputs: ['color'],
+                styles: [".mtx-colorpicker-content{display:block;border-radius:4px}\n"]
+            },] }
+];
+/**
+ * @type {function(): !Array<(null|{
+ *   type: ?,
+ *   decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>),
+ * })>}
+ * @nocollapse
+ */
+MtxColorpickerContent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: ChangeDetectorRef }
+];
+export class MtxColorpicker {
+    constructor(_overlay, _ngZone, _viewContainerRef, scrollStrategy, _dir, _document) {
+        this._overlay = _overlay;
+        this._ngZone = _ngZone;
+        this._viewContainerRef = _viewContainerRef;
+        this._dir = _dir;
+        this._document = _document;
+        this._inputStateChanges = Subscription.EMPTY;
+        /** Emits when the colorpicker has been opened. */
+        this.openedStream = new EventEmitter();
+        /** Emits when the colorpicker has been closed. */
+        this.closedStream = new EventEmitter();
+        /** Preferred position of the colorpicker in the X axis. */
+        this.xPosition = 'start';
+        /** Preferred position of the colorpicker in the Y axis. */
+        this.yPosition = 'below';
+        this._restoreFocus = true;
+        this._opened = false;
+        /** The id for the colorpicker panel. */
+        this.id = `mtx-colorpicker-${colorpickerUid++}`;
+        this._validSelected = '';
+        /** The element that was focused before the colorpicker was opened. */
+        this._focusedElementBeforeOpen = null;
+        /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */
+        this._backdropHarnessClass = `${this.id}-backdrop`;
+        /** Emits when the datepicker is disabled. */
+        this._disabledChange = new Subject();
+        /** Emits new selected color when selected color changes. */
+        this._selectedChanged = new Subject();
+        this._scrollStrategy = scrollStrategy;
+    }
+    get disabled() {
+        return this._disabled === undefined && this.pickerInput
+            ? this.pickerInput.disabled
+            : !!this._disabled;
+    }
+    set disabled(value) {
+        const newValue = coerceBooleanProperty(value);
+        if (newValue !== this._disabled) {
+            this._disabled = newValue;
+            this._disabledChange.next(newValue);
+        }
+    }
+    /**
+     * Whether to restore focus to the previously-focused element when the panel is closed.
+     * Note that automatic focus restoration is an accessibility feature and it is recommended that
+     * you provide your own equivalent, if you decide to turn it off.
+     */
+    get restoreFocus() {
+        return this._restoreFocus;
+    }
+    set restoreFocus(value) {
+        this._restoreFocus = coerceBooleanProperty(value);
+    }
+    /** Whether the panel is open. */
+    get opened() {
+        return this._opened;
+    }
+    set opened(value) {
+        coerceBooleanProperty(value) ? this.open() : this.close();
+    }
+    /** Color palette to use on the colorpicker's panel. */
+    get color() {
+        return this._color || (this.pickerInput ? this.pickerInput.getThemePalette() : undefined);
+    }
+    set color(value) {
+        this._color = value;
+    }
+    /** The currently selected color. */
+    get selected() {
+        return this._validSelected;
+    }
+    set selected(value) {
+        this._validSelected = value;
+    }
+    ngOnChanges() { }
+    ngOnDestroy() {
+        this._destroyOverlay();
+        this.close();
+        this._inputStateChanges.unsubscribe();
+        this._disabledChange.complete();
+    }
+    /** Selects the given color */
+    select(nextVal) {
+        const oldValue = this.selected;
+        this.selected = nextVal;
+        // TODO: `nextVal` should compare with `oldValue`
+        this._selectedChanged.next(nextVal);
+    }
+    /**
+     * Register an input with this colorpicker.
+     * @param input The colorpicker input to register with this colorpicker.
+     */
+    registerInput(input) {
+        if (this.pickerInput) {
+            throw Error('A Colorpicker can only be associated with a single input.');
+        }
+        this.pickerInput = input;
+        this._inputStateChanges = input._valueChange.subscribe((value) => (this.selected = value));
+    }
+    open() {
+        if (this._opened || this.disabled) {
+            return;
+        }
+        if (!this.pickerInput) {
+            throw Error('Attempted to open an Colorpicker with no associated input.');
+        }
+        if (this._document) {
+            this._focusedElementBeforeOpen = this._document.activeElement;
+        }
+        this._openOverlay();
+        this._opened = true;
+        this.openedStream.emit();
+    }
+    /** Close the panel. */
+    close() {
+        if (!this._opened) {
+            return;
+        }
+        if (this._componentRef) {
+            const instance = this._componentRef.instance;
+            instance._startExitAnimation();
+            instance._animationDone.pipe(take(1)).subscribe(() => this._destroyOverlay());
+        }
+        const completeClose = () => {
+            // The `_opened` could've been reset already if
+            // we got two events in quick succession.
+            if (this._opened) {
+                this._opened = false;
+                this.closedStream.emit();
+                this._focusedElementBeforeOpen = null;
+            }
+        };
+        if (this._restoreFocus &&
+            this._focusedElementBeforeOpen &&
+            typeof this._focusedElementBeforeOpen.focus === 'function') {
+            // Because IE moves focus asynchronously, we can't count on it being restored before we've
+            // marked the colorpicker as closed. If the event fires out of sequence and the element that
+            // we're refocusing opens the colorpicker on focus, the user could be stuck with not being
+            // able to close the panel at all. We work around it by making the logic, that marks
+            // the colorpicker as closed, async as well.
+            this._focusedElementBeforeOpen.focus();
+            setTimeout(completeClose);
+        }
+        else {
+            completeClose();
+        }
+    }
+    /** Forwards relevant values from the colorpicker to the colorpicker content inside the overlay. */
+    _forwardContentValues(instance) {
+        instance.picker = this;
+        instance.color = this.color;
+    }
+    /** Open the colopicker as a popup. */
+    _openOverlay() {
+        this._destroyOverlay();
+        const labelId = this.pickerInput.getOverlayLabelId();
+        const portal = new ComponentPortal(MtxColorpickerContent, this._viewContainerRef);
+        const overlayRef = (this._overlayRef = this._overlay.create(new OverlayConfig({
+            positionStrategy: this._getDropdownStrategy(),
+            hasBackdrop: true,
+            backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],
+            direction: this._dir,
+            scrollStrategy: this._scrollStrategy(),
+            panelClass: `mtx-colorpicker-popup`,
+        })));
+        const overlayElement = overlayRef.overlayElement;
+        overlayElement.setAttribute('role', 'dialog');
+        if (labelId) {
+            overlayElement.setAttribute('aria-labelledby', labelId);
+        }
+        this._getCloseStream(overlayRef).subscribe(event => {
+            if (event) {
+                event.preventDefault();
+            }
+            this.close();
+        });
+        this._componentRef = overlayRef.attach(portal);
+        this._forwardContentValues(this._componentRef.instance);
+        // Update the position once the panel has rendered. Only relevant in dropdown mode.
+        this._ngZone.onStable.pipe(take(1)).subscribe(() => overlayRef.updatePosition());
+    }
+    _destroyOverlay() {
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
+            this._overlayRef = this._componentRef = null;
+        }
+    }
+    /** Gets a position strategy that will open the panel as a dropdown. */
+    _getDropdownStrategy() {
+        const strategy = this._overlay
+            .position()
+            .flexibleConnectedTo(this.pickerInput.getConnectedOverlayOrigin())
+            .withTransformOriginOn('.mtx-colorpicker-content')
+            .withFlexibleDimensions(false)
+            .withViewportMargin(8)
+            .withLockedPosition();
+        return this._setConnectedPositions(strategy);
+    }
+    /** Sets the positions of the colorpicker in dropdown mode based on the current configuration. */
+    _setConnectedPositions(strategy) {
+        const primaryX = this.xPosition === 'end' ? 'end' : 'start';
+        const secondaryX = primaryX === 'start' ? 'end' : 'start';
+        const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';
+        const secondaryY = primaryY === 'top' ? 'bottom' : 'top';
+        return strategy.withPositions([
+            {
+                originX: primaryX,
+                originY: secondaryY,
+                overlayX: primaryX,
+                overlayY: primaryY,
+            },
+            {
+                originX: primaryX,
+                originY: primaryY,
+                overlayX: primaryX,
+                overlayY: secondaryY,
+            },
+            {
+                originX: secondaryX,
+                originY: secondaryY,
+                overlayX: secondaryX,
+                overlayY: primaryY,
+            },
+            {
+                originX: secondaryX,
+                originY: primaryY,
+                overlayX: secondaryX,
+                overlayY: secondaryY,
+            },
+        ]);
+    }
+    /** Gets an observable that will emit when the overlay is supposed to be closed. */
+    _getCloseStream(overlayRef) {
+        return merge(overlayRef.backdropClick(), overlayRef.detachments(), overlayRef.keydownEvents().pipe(filter(event => {
+            // Closing on alt + up is only valid when there's an input associated with the colorpicker.
+            return ((event.keyCode === ESCAPE && !hasModifierKey(event)) ||
+                (this.pickerInput && hasModifierKey(event, 'altKey') && event.keyCode === UP_ARROW));
+        })));
+    }
+}
+/** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+MtxColorpicker.decorators = [
+    { type: Component, args: [{
+                selector: 'mtx-colorpicker',
+                template: '',
+                exportAs: 'mtxColorpicker',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+/**
+ * @type {function(): !Array<(null|{
+ *   type: ?,
+ *   decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>),
+ * })>}
+ * @nocollapse
+ */
+MtxColorpicker.ctorParameters = () => [
+    { type: Overlay },
+    { type: NgZone },
+    { type: ViewContainerRef },
+    { type: undefined, decorators: [{ type: Inject, args: [MTX_COLORPICKER_SCROLL_STRATEGY,] }] },
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
+];
+/** @type {!Object<string, !Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+MtxColorpicker.propDecorators = {
+    content: [{ type: Input }],
+    openedStream: [{ type: Output, args: ['opened',] }],
+    closedStream: [{ type: Output, args: ['closed',] }],
+    disabled: [{ type: Input }],
+    xPosition: [{ type: Input }],
+    yPosition: [{ type: Input }],
+    restoreFocus: [{ type: Input }],
+    opened: [{ type: Input }],
+    color: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"colorpicker.js","sourceRoot":"","sources":["../../../../projects/extensions/colorpicker/colorpicker.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directionality } from '@angular/cdk/bidi';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ESCAPE, hasModifierKey, UP_ARROW } from '@angular/cdk/keycodes';\nimport {\n  ScrollStrategy,\n  OverlayConfig,\n  Overlay,\n  OverlayRef,\n  FlexibleConnectedPositionStrategy,\n} from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  TemplateRef,\n  ViewContainerRef,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { CanColor, mixinColor, ThemePalette } from '@angular/material/core';\nimport { Subject, Subscription, merge } from 'rxjs';\nimport { filter, take } from 'rxjs/operators';\nimport { mtxColorpickerAnimations } from './colorpicker-animations';\nimport { MtxColorpickerInput } from './colorpicker-input';\n\nimport { ColorEvent } from 'ngx-color';\n\nimport { TinyColor } from '@ctrl/tinycolor';\n\n/** Used to generate a unique ID for each colorpicker instance. */\nlet colorpickerUid = 0;\n\n/** Injection token that determines the scroll handling while the panel is open. */\nexport const MTX_COLORPICKER_SCROLL_STRATEGY = new InjectionToken<() => ScrollStrategy>(\n  'mtx-colorpicker-scroll-strategy'\n);\n\nexport function MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy {\n  return () => overlay.scrollStrategies.reposition();\n}\n\n/** Possible positions for the colorpicker dropdown along the X axis. */\nexport type ColorpickerDropdownPositionX = 'start' | 'end';\n\n/** Possible positions for the colorpicker dropdown along the Y axis. */\nexport type ColorpickerDropdownPositionY = 'above' | 'below';\n\nexport const MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n  provide: MTX_COLORPICKER_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY,\n};\n\n// Boilerplate for applying mixins to MtxColorpickerContent.\n/** @docs-private */\nconst _MtxColorpickerContentBase = mixinColor(\n  class {\n    constructor(public _elementRef: ElementRef) {}\n  }\n);\n\n@Component({\n  selector: 'mtx-colorpicker-content',\n  templateUrl: './colorpicker-content.html',\n  styleUrls: ['colorpicker-content.scss'],\n  host: {\n    'class': 'mtx-colorpicker-content',\n    '[@transformPanel]': '_animationState',\n    '(@transformPanel.done)': '_animationDone.next()',\n  },\n  animations: [mtxColorpickerAnimations.transformPanel],\n  exportAs: 'mtxColorpickerContent',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  inputs: ['color'],\n})\nexport class MtxColorpickerContent\n  extends _MtxColorpickerContentBase\n  implements OnDestroy, CanColor\n{\n  picker!: MtxColorpicker;\n\n  /** Current state of the animation. */\n  _animationState: 'enter-dropdown' | 'void' = 'enter-dropdown';\n\n  /** Emits when an animation has finished. */\n  readonly _animationDone = new Subject<void>();\n\n  constructor(elementRef: ElementRef, private _changeDetectorRef: ChangeDetectorRef) {\n    super(elementRef);\n  }\n\n  _startExitAnimation() {\n    this._animationState = 'void';\n    this._changeDetectorRef.markForCheck();\n  }\n\n  ngOnDestroy() {\n    this._animationDone.complete();\n  }\n\n  // https://github.com/scttcper/ngx-color/issues/292\n  getHex8(e: ColorEvent): string {\n    const alpha = e.color.rgb.a;\n    return alpha === 1 ? e.color.hex : new TinyColor(e.color.rgb).toHex8String();\n  }\n}\n\n@Component({\n  selector: 'mtx-colorpicker',\n  template: '',\n  exportAs: 'mtxColorpicker',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class MtxColorpicker implements OnChanges, OnDestroy {\n  private _scrollStrategy: () => ScrollStrategy;\n  private _inputStateChanges = Subscription.EMPTY;\n\n  /** Custom colorpicker content set by the consumer. */\n  @Input() content!: TemplateRef<any>;\n\n  /** Emits when the colorpicker has been opened. */\n  @Output('opened') openedStream: EventEmitter<void> = new EventEmitter<void>();\n\n  /** Emits when the colorpicker has been closed. */\n  @Output('closed') closedStream: EventEmitter<void> = new EventEmitter<void>();\n\n  @Input() get disabled() {\n    return this._disabled === undefined && this.pickerInput\n      ? this.pickerInput.disabled\n      : !!this._disabled;\n  }\n  set disabled(value: boolean) {\n    const newValue = coerceBooleanProperty(value);\n\n    if (newValue !== this._disabled) {\n      this._disabled = newValue;\n      this._disabledChange.next(newValue);\n    }\n  }\n  private _disabled!: boolean;\n\n  /** Preferred position of the colorpicker in the X axis. */\n  @Input()\n  xPosition: ColorpickerDropdownPositionX = 'start';\n\n  /** Preferred position of the colorpicker in the Y axis. */\n  @Input()\n  yPosition: ColorpickerDropdownPositionY = 'below';\n\n  /**\n   * Whether to restore focus to the previously-focused element when the panel is closed.\n   * Note that automatic focus restoration is an accessibility feature and it is recommended that\n   * you provide your own equivalent, if you decide to turn it off.\n   */\n  @Input()\n  get restoreFocus(): boolean {\n    return this._restoreFocus;\n  }\n  set restoreFocus(value: boolean) {\n    this._restoreFocus = coerceBooleanProperty(value);\n  }\n  private _restoreFocus = true;\n\n  /** Whether the panel is open. */\n  @Input()\n  get opened(): boolean {\n    return this._opened;\n  }\n  set opened(value: boolean) {\n    coerceBooleanProperty(value) ? this.open() : this.close();\n  }\n  private _opened = false;\n\n  /** The id for the colorpicker panel. */\n  id = `mtx-colorpicker-${colorpickerUid++}`;\n\n  /** Color palette to use on the colorpicker's panel. */\n  @Input()\n  get color(): ThemePalette {\n    return this._color || (this.pickerInput ? this.pickerInput.getThemePalette() : undefined);\n  }\n  set color(value: ThemePalette) {\n    this._color = value;\n  }\n  private _color: ThemePalette;\n\n  /** The currently selected color. */\n  get selected(): string {\n    return this._validSelected;\n  }\n  set selected(value: string) {\n    this._validSelected = value;\n  }\n  private _validSelected: string = '';\n\n  /** A reference to the overlay when the picker is opened as a popup. */\n  private _overlayRef!: OverlayRef | null;\n\n  /** Reference to the component instance rendered in the overlay. */\n  private _componentRef!: ComponentRef<MtxColorpickerContent> | null;\n\n  /** The element that was focused before the colorpicker was opened. */\n  private _focusedElementBeforeOpen: HTMLElement | null = null;\n\n  /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */\n  private _backdropHarnessClass = `${this.id}-backdrop`;\n\n  /** The input element this colorpicker is associated with. */\n  pickerInput!: MtxColorpickerInput;\n\n  /** Emits when the datepicker is disabled. */\n  readonly _disabledChange = new Subject<boolean>();\n\n  /** Emits new selected color when selected color changes. */\n  readonly _selectedChanged = new Subject<string>();\n\n  constructor(\n    private _overlay: Overlay,\n    private _ngZone: NgZone,\n    private _viewContainerRef: ViewContainerRef,\n    @Inject(MTX_COLORPICKER_SCROLL_STRATEGY) scrollStrategy: any,\n    @Optional() private _dir: Directionality,\n    @Optional() @Inject(DOCUMENT) private _document: any\n  ) {\n    this._scrollStrategy = scrollStrategy;\n  }\n\n  ngOnChanges() {}\n\n  ngOnDestroy() {\n    this._destroyOverlay();\n    this.close();\n    this._inputStateChanges.unsubscribe();\n    this._disabledChange.complete();\n  }\n\n  /** Selects the given color */\n  select(nextVal: string): void {\n    const oldValue = this.selected;\n    this.selected = nextVal;\n\n    // TODO: `nextVal` should compare with `oldValue`\n    this._selectedChanged.next(nextVal);\n  }\n\n  /**\n   * Register an input with this colorpicker.\n   * @param input The colorpicker input to register with this colorpicker.\n   */\n  registerInput(input: MtxColorpickerInput): void {\n    if (this.pickerInput) {\n      throw Error('A Colorpicker can only be associated with a single input.');\n    }\n    this.pickerInput = input;\n    this._inputStateChanges = input._valueChange.subscribe(\n      (value: string) => (this.selected = value)\n    );\n  }\n\n  open(): void {\n    if (this._opened || this.disabled) {\n      return;\n    }\n    if (!this.pickerInput) {\n      throw Error('Attempted to open an Colorpicker with no associated input.');\n    }\n\n    if (this._document) {\n      this._focusedElementBeforeOpen = this._document.activeElement;\n    }\n\n    this._openOverlay();\n    this._opened = true;\n    this.openedStream.emit();\n  }\n\n  /** Close the panel. */\n  close(): void {\n    if (!this._opened) {\n      return;\n    }\n\n    if (this._componentRef) {\n      const instance = this._componentRef.instance;\n      instance._startExitAnimation();\n      instance._animationDone.pipe(take(1)).subscribe(() => this._destroyOverlay());\n    }\n\n    const completeClose = () => {\n      // The `_opened` could've been reset already if\n      // we got two events in quick succession.\n      if (this._opened) {\n        this._opened = false;\n        this.closedStream.emit();\n        this._focusedElementBeforeOpen = null;\n      }\n    };\n\n    if (\n      this._restoreFocus &&\n      this._focusedElementBeforeOpen &&\n      typeof this._focusedElementBeforeOpen.focus === 'function'\n    ) {\n      // Because IE moves focus asynchronously, we can't count on it being restored before we've\n      // marked the colorpicker as closed. If the event fires out of sequence and the element that\n      // we're refocusing opens the colorpicker on focus, the user could be stuck with not being\n      // able to close the panel at all. We work around it by making the logic, that marks\n      // the colorpicker as closed, async as well.\n      this._focusedElementBeforeOpen.focus();\n      setTimeout(completeClose);\n    } else {\n      completeClose();\n    }\n  }\n\n  /** Forwards relevant values from the colorpicker to the colorpicker content inside the overlay. */\n  protected _forwardContentValues(instance: MtxColorpickerContent) {\n    instance.picker = this;\n    instance.color = this.color;\n  }\n\n  /** Open the colopicker as a popup. */\n  private _openOverlay(): void {\n    this._destroyOverlay();\n\n    const labelId = this.pickerInput.getOverlayLabelId();\n    const portal = new ComponentPortal<MtxColorpickerContent>(\n      MtxColorpickerContent,\n      this._viewContainerRef\n    );\n    const overlayRef = (this._overlayRef = this._overlay.create(\n      new OverlayConfig({\n        positionStrategy: this._getDropdownStrategy(),\n        hasBackdrop: true,\n        backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],\n        direction: this._dir,\n        scrollStrategy: this._scrollStrategy(),\n        panelClass: `mtx-colorpicker-popup`,\n      })\n    ));\n    const overlayElement = overlayRef.overlayElement;\n    overlayElement.setAttribute('role', 'dialog');\n\n    if (labelId) {\n      overlayElement.setAttribute('aria-labelledby', labelId);\n    }\n\n    this._getCloseStream(overlayRef).subscribe(event => {\n      if (event) {\n        event.preventDefault();\n      }\n      this.close();\n    });\n\n    this._componentRef = overlayRef.attach(portal);\n    this._forwardContentValues(this._componentRef.instance);\n\n    // Update the position once the panel has rendered. Only relevant in dropdown mode.\n    this._ngZone.onStable.pipe(take(1)).subscribe(() => overlayRef.updatePosition());\n  }\n\n  private _destroyOverlay() {\n    if (this._overlayRef) {\n      this._overlayRef.dispose();\n      this._overlayRef = this._componentRef = null;\n    }\n  }\n\n  /** Gets a position strategy that will open the panel as a dropdown. */\n  private _getDropdownStrategy() {\n    const strategy = this._overlay\n      .position()\n      .flexibleConnectedTo(this.pickerInput.getConnectedOverlayOrigin())\n      .withTransformOriginOn('.mtx-colorpicker-content')\n      .withFlexibleDimensions(false)\n      .withViewportMargin(8)\n      .withLockedPosition();\n\n    return this._setConnectedPositions(strategy);\n  }\n\n  /** Sets the positions of the colorpicker in dropdown mode based on the current configuration. */\n  private _setConnectedPositions(strategy: FlexibleConnectedPositionStrategy) {\n    const primaryX = this.xPosition === 'end' ? 'end' : 'start';\n    const secondaryX = primaryX === 'start' ? 'end' : 'start';\n    const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';\n    const secondaryY = primaryY === 'top' ? 'bottom' : 'top';\n\n    return strategy.withPositions([\n      {\n        originX: primaryX,\n        originY: secondaryY,\n        overlayX: primaryX,\n        overlayY: primaryY,\n      },\n      {\n        originX: primaryX,\n        originY: primaryY,\n        overlayX: primaryX,\n        overlayY: secondaryY,\n      },\n      {\n        originX: secondaryX,\n        originY: secondaryY,\n        overlayX: secondaryX,\n        overlayY: primaryY,\n      },\n      {\n        originX: secondaryX,\n        originY: primaryY,\n        overlayX: secondaryX,\n        overlayY: secondaryY,\n      },\n    ]);\n  }\n\n  /** Gets an observable that will emit when the overlay is supposed to be closed. */\n  private _getCloseStream(overlayRef: OverlayRef) {\n    return merge(\n      overlayRef.backdropClick(),\n      overlayRef.detachments(),\n      overlayRef.keydownEvents().pipe(\n        filter(event => {\n          // Closing on alt + up is only valid when there's an input associated with the colorpicker.\n          return (\n            (event.keyCode === ESCAPE && !hasModifierKey(event)) ||\n            (this.pickerInput && hasModifierKey(event, 'altKey') && event.keyCode === UP_ARROW)\n          );\n        })\n      )\n    );\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}

package/esm2015/colorpicker/mtxColorpicker.js

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

package/esm2015/colorpicker/public-api.js

@@ -0,0 +1,6 @@
+export * from './colorpicker-module';
+export { MTX_COLORPICKER_SCROLL_STRATEGY, MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY, MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, MtxColorpickerContent, MtxColorpicker, } from './colorpicker';
+export { MTX_COLORPICKER_VALUE_ACCESSOR, MTX_COLORPICKER_VALIDATORS, MtxColorpickerInput, } from './colorpicker-input';
+export * from './colorpicker-toggle';
+export * from './colorpicker-animations';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2V4dGVuc2lvbnMvY29sb3JwaWNrZXIvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLE9BQU8sRUFDTCwrQkFBK0IsRUFDL0IsdUNBQXVDLEVBQ3ZDLGdEQUFnRCxFQUNoRCxxQkFBcUIsRUFHckIsY0FBYyxHQUNmLE1BQU0sZUFBZSxDQUFDO0FBQ3ZCLE9BQU8sRUFDTCw4QkFBOEIsRUFDOUIsMEJBQTBCLEVBQzFCLG1CQUFtQixHQUNwQixNQUFNLHFCQUFxQixDQUFDO0FBQzdCLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29sb3JwaWNrZXItbW9kdWxlJztcbmV4cG9ydCB7XG4gIE1UWF9DT0xPUlBJQ0tFUl9TQ1JPTExfU1RSQVRFR1ksXG4gIE1UWF9DT0xPUlBJQ0tFUl9TQ1JPTExfU1RSQVRFR1lfRkFDVE9SWSxcbiAgTVRYX0NPTE9SUElDS0VSX1NDUk9MTF9TVFJBVEVHWV9GQUNUT1JZX1BST1ZJREVSLFxuICBNdHhDb2xvcnBpY2tlckNvbnRlbnQsXG4gIENvbG9ycGlja2VyRHJvcGRvd25Qb3NpdGlvblgsXG4gIENvbG9ycGlja2VyRHJvcGRvd25Qb3NpdGlvblksXG4gIE10eENvbG9ycGlja2VyLFxufSBmcm9tICcuL2NvbG9ycGlja2VyJztcbmV4cG9ydCB7XG4gIE1UWF9DT0xPUlBJQ0tFUl9WQUxVRV9BQ0NFU1NPUixcbiAgTVRYX0NPTE9SUElDS0VSX1ZBTElEQVRPUlMsXG4gIE10eENvbG9ycGlja2VySW5wdXQsXG59IGZyb20gJy4vY29sb3JwaWNrZXItaW5wdXQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2xvcnBpY2tlci10b2dnbGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2xvcnBpY2tlci1hbmltYXRpb25zJztcbiJdfQ==

package/esm2015/datetimepicker/calendar-body.js

@@ -55,6 +55,7 @@ MtxCalendarBody.decorators = [
                 host: {
                     class: 'mtx-calendar-body',
                 },
+                exportAs: 'mtxCalendarBody',
                 encapsulation: ViewEncapsulation.None,
                 changeDetection: ChangeDetectionStrategy.OnPush,
                 styles: [".mtx-calendar-body{min-width:224px}.mtx-calendar-body-label{height:0;line-height:0;text-align:left;padding:7.1428571429% 4.7142857143%}[dir=rtl] .mtx-calendar-body-label{text-align:right}.mtx-calendar-body-cell{position:relative;width:14.2857142857%;height:0;line-height:0;padding:7.1428571429% 0;text-align:center;outline:none;cursor:pointer}.mtx-calendar-body-disabled{cursor:default;pointer-events:none}.mtx-calendar-body-cell-content{position:absolute;top:5%;left:5%;display:flex;align-items:center;justify-content:center;box-sizing:border-box;width:90%;height:90%;border:1px solid transparent;border-radius:999px}\n"]
@@ -72,4 +73,4 @@ MtxCalendarBody.propDecorators = {
     activeCell: [{ type: Input }],
     selectedValueChange: [{ type: Output }]
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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