@ng-matero/extensions 19.4.1 → 20.0.1

package/column-resize/index.d.ts

@@ -1,5 +1,458 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewInit, OnDestroy, ElementRef, NgZone, Provider, Injector, ViewContainerRef, ChangeDetectorRef, Type } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { CdkTable, CdkColumnDef } from '@angular/cdk/table';
+import { Directionality } from '@angular/cdk/bidi';
+import { OverlayRef, Overlay } from '@angular/cdk/overlay';
+
+/** Indicates the width of a column. */
+interface ColumnSize {
+    /** The ID/name of the column, as defined in CdkColumnDef. */
+    readonly columnId: string;
+    /** The width in pixels of the column. */
+    readonly size: number;
+    /** The width in pixels of the column prior to this update, if known. */
+    readonly previousSize?: number;
+}
+/** Interface describing column size changes. */
+interface ColumnSizeAction extends ColumnSize {
+    /**
+     * Whether the resize action should be applied instantaneously. False for events triggered during
+     * a UI-triggered resize (such as with the mouse) until the mouse button is released. True
+     * for all programmatically triggered resizes.
+     */
+    readonly completeImmediately?: boolean;
+    /**
+     * Whether the resize action is being applied to a sticky/stickyEnd column.
+     */
+    readonly isStickyColumn?: boolean;
+}
 /**
- * Generated bundle index. Do not edit.
+ * Originating source of column resize events within a table.
+ * @docs-private
  */
-/// <amd-module name="@ng-matero/extensions/column-resize" />
-export * from './public-api';
+declare class ColumnResizeNotifierSource {
+    /** Emits when an in-progress resize is canceled. */
+    readonly resizeCanceled: Subject<ColumnSizeAction>;
+    /** Emits when a resize is applied. */
+    readonly resizeCompleted: Subject<ColumnSize>;
+    /** Triggers a resize action. */
+    readonly triggerResize: Subject<ColumnSizeAction>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResizeNotifierSource, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnResizeNotifierSource>;
+}
+/** Service for triggering column resizes imperatively or being notified of them. */
+declare class ColumnResizeNotifier {
+    private readonly _source;
+    /** Emits whenever a column is resized. */
+    readonly resizeCompleted: Observable<ColumnSize>;
+    /** Instantly resizes the specified column. */
+    resize(columnId: string, size: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResizeNotifier, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnResizeNotifier>;
+}
+
+/** Coordinates events between the column resize directives. */
+declare class HeaderRowEventDispatcher {
+    private readonly _ngZone;
+    /**
+     * Emits the currently hovered header cell or null when no header cells are hovered.
+     * Exposed publicly for events to feed in, but subscribers should use headerCellHoveredDistinct,
+     * defined below.
+     */
+    readonly headerCellHovered: Subject<Element | null>;
+    /**
+     * Emits the header cell for which a user-triggered resize is active or null
+     * when no resize is in progress.
+     */
+    readonly overlayHandleActiveForCell: Subject<Element | null>;
+    /** Distinct and shared version of headerCellHovered. */
+    readonly headerCellHoveredDistinct: Observable<Element | null>;
+    /**
+     * Emits the header that is currently hovered or hosting an active resize event (with active
+     * taking precedence).
+     */
+    readonly headerRowHoveredOrActiveDistinct: Observable<Element | null>;
+    private readonly _headerRowHoveredOrActiveDistinctReenterZone;
+    private _lastSeenRow;
+    private _lastSeenRowHover;
+    /**
+     * Emits whether the specified row should show its overlay controls.
+     * Emission occurs within the NgZone.
+     */
+    resizeOverlayVisibleForHeaderRow(row: Element): Observable<boolean>;
+    private _enterZone;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderRowEventDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeaderRowEventDispatcher>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/** Configurable options for column resize. */
+interface ColumnResizeOptions {
+    liveResizeUpdates?: boolean;
+}
+declare const COLUMN_RESIZE_OPTIONS: InjectionToken<ColumnResizeOptions>;
+/**
+ * Base class for ColumnResize directives which attach to mat-table elements to
+ * provide common events and services for column resizing.
+ */
+declare abstract class ColumnResize implements AfterViewInit, OnDestroy {
+    private _renderer;
+    private _eventCleanups;
+    protected readonly destroyed: Subject<void>;
+    abstract readonly columnResizeNotifier: ColumnResizeNotifier;
+    abstract readonly elementRef: ElementRef<HTMLElement>;
+    protected abstract readonly eventDispatcher: HeaderRowEventDispatcher;
+    protected abstract readonly ngZone: NgZone;
+    protected abstract readonly notifier: ColumnResizeNotifierSource;
+    /** Unique ID for this table instance. */
+    protected readonly selectorId: string;
+    /** The id attribute of the table, if specified. */
+    id?: string;
+    /** @docs-private Whether a call to updateStickyColumnStyles is pending after a resize. */
+    _flushPending: boolean;
+    /**
+     * Whether to update the column's width continuously as the mouse position
+     * changes, or to wait until mouseup to apply the new size.
+     */
+    liveResizeUpdates: boolean;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Gets the unique CSS class name for this table instance. */
+    getUniqueCssClass(): string;
+    /** Gets the ID for this table used for column size persistance. */
+    getTableId(): string;
+    /** Called when a column in the table is resized. Applies a css class to the table element. */
+    setResized(): void;
+    private _listenForRowHoverEvents;
+    private _listenForResizeActivity;
+    private _listenForHoverActivity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResize, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnResize, never, never, { "liveResizeUpdates": { "alias": "liveResizeUpdates"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/**
+ * Explicitly enables column resizing for a table-based cdk-table.
+ * Individual columns must be annotated specifically.
+ */
+declare class CdkColumnResize extends ColumnResize {
+    readonly columnResizeNotifier: ColumnResizeNotifier;
+    readonly elementRef: ElementRef<HTMLElement>;
+    protected readonly eventDispatcher: HeaderRowEventDispatcher;
+    protected readonly ngZone: NgZone;
+    protected readonly notifier: ColumnResizeNotifierSource;
+    protected readonly table: CdkTable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkColumnResize, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkColumnResize, "table[cdk-table][columnResize]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/**
+ * Explicitly enables column resizing for a flexbox-based cdk-table.
+ * Individual columns must be annotated specifically.
+ */
+declare class CdkColumnResizeFlex extends ColumnResize {
+    readonly columnResizeNotifier: ColumnResizeNotifier;
+    readonly elementRef: ElementRef<HTMLElement>;
+    protected readonly eventDispatcher: HeaderRowEventDispatcher;
+    protected readonly ngZone: NgZone;
+    protected readonly notifier: ColumnResizeNotifierSource;
+    protected readonly table: CdkTable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkColumnResizeFlex, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkColumnResizeFlex, "cdk-table[columnResize]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * One of two NgModules for use with CdkColumnResize.
+ * When using this module, columns are not resizable by default.
+ */
+declare class CdkColumnResizeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkColumnResizeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkColumnResizeModule, never, [typeof CdkColumnResize, typeof CdkColumnResizeFlex], [typeof CdkColumnResize, typeof CdkColumnResizeFlex]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkColumnResizeModule>;
+}
+
+/**
+ * Can be provided by the host application to enable persistence of column resize state.
+ */
+declare abstract class ColumnSizeStore {
+    /** Returns the persisted size of the specified column in the specified table. */
+    abstract getSize(tableId: string, columnId: string): Observable<number | null> | null;
+    /** Persists the size of the specified column in the specified table. */
+    abstract setSize(tableId: string, columnId: string, sizePx: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnSizeStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnSizeStore>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/**
+ * @docs-private
+ */
+declare class _Schedule {
+    tasks: (() => unknown)[];
+    endTasks: (() => unknown)[];
+}
+/** Injection token used to provide a coalesced style scheduler. */
+declare const _COALESCED_STYLE_SCHEDULER: InjectionToken<_CoalescedStyleScheduler>;
+/**
+ * Allows grouping up CSSDom mutations after the current execution context.
+ * This can significantly improve performance when separate consecutive functions are
+ * reading from the CSSDom and then mutating it.
+ *
+ * @docs-private
+ */
+declare class _CoalescedStyleScheduler {
+    private _currentSchedule;
+    private _ngZone;
+    constructor(...args: unknown[]);
+    /**
+     * Schedules the specified task to run at the end of the current VM turn.
+     */
+    schedule(task: () => unknown): void;
+    /**
+     * Schedules the specified task to run after other scheduled tasks at the end of the current
+     * VM turn.
+     */
+    scheduleEnd(task: () => unknown): void;
+    private _createScheduleIfNeeded;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_CoalescedStyleScheduler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<_CoalescedStyleScheduler>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/** Tracks state of resize events in progress. */
+declare class ResizeRef {
+    readonly origin: ElementRef;
+    readonly overlayRef: OverlayRef;
+    readonly minWidthPx: number;
+    readonly maxWidthPx: number;
+    readonly liveUpdates: boolean;
+    constructor(origin: ElementRef, overlayRef: OverlayRef, minWidthPx: number, maxWidthPx: number, liveUpdates?: boolean);
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/**
+ * Base class for a component shown over the edge of a resizable column that is responsible
+ * for handling column resize mouse events and displaying any visible UI on the column edge.
+ */
+declare abstract class ResizeOverlayHandle implements AfterViewInit, OnDestroy {
+    private _renderer;
+    protected readonly destroyed: Subject<void>;
+    protected abstract readonly columnDef: CdkColumnDef;
+    protected abstract readonly document: Document;
+    protected abstract readonly directionality: Directionality;
+    protected abstract readonly elementRef: ElementRef;
+    protected abstract readonly eventDispatcher: HeaderRowEventDispatcher;
+    protected abstract readonly ngZone: NgZone;
+    protected abstract readonly resizeNotifier: ColumnResizeNotifierSource;
+    protected abstract readonly resizeRef: ResizeRef;
+    protected abstract readonly styleScheduler: _CoalescedStyleScheduler;
+    private _cumulativeDeltaX;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _listenForMouseEvents;
+    private _dragStarted;
+    protected updateResizeActive(active: boolean): void;
+    private _triggerResize;
+    private _computeNewSize;
+    private _getOriginWidth;
+    private _getOriginOffset;
+    private _updateOverlayOffset;
+    private _isLtr;
+    private _notifyResizeEnded;
+    private _observableFromEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeOverlayHandle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeOverlayHandle, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/**
+ * Provides an implementation for resizing a column.
+ * The details of how resizing works for tables for flex mat-tables are quite different.
+ */
+declare abstract class ResizeStrategy {
+    protected abstract readonly columnResize: ColumnResize;
+    protected abstract readonly styleScheduler: _CoalescedStyleScheduler;
+    protected abstract readonly table: CdkTable<unknown>;
+    private _pendingResizeDelta;
+    /** Updates the width of the specified column. */
+    abstract applyColumnSize(cssFriendlyColumnName: string, columnHeader: HTMLElement, sizeInPx: number, previousSizeInPx?: number): void;
+    /** Applies a minimum width to the specified column, updating its current width as needed. */
+    abstract applyMinColumnSize(cssFriendlyColumnName: string, columnHeader: HTMLElement, minSizeInPx: number): void;
+    /** Applies a maximum width to the specified column, updating its current width as needed. */
+    abstract applyMaxColumnSize(cssFriendlyColumnName: string, columnHeader: HTMLElement, minSizeInPx: number): void;
+    /** Adjusts the width of the table element by the specified delta. */
+    protected updateTableWidthAndStickyColumns(delta: number): void;
+    /** Gets the style.width pixels on the specified element if present, otherwise its offsetWidth. */
+    protected getElementWidth(element: HTMLElement): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeStrategy>;
+}
+/**
+ * The optimally performing resize strategy for &lt;table&gt; elements with table-layout: fixed.
+ * Tested against and outperformed:
+ *   CSS selector
+ *   CSS selector w/ CSS variable
+ *   Updating all cell nodes
+ */
+declare class TableLayoutFixedResizeStrategy extends ResizeStrategy {
+    protected readonly columnResize: ColumnResize;
+    protected readonly styleScheduler: _CoalescedStyleScheduler;
+    protected readonly table: CdkTable<unknown>;
+    applyColumnSize(_: string, columnHeader: HTMLElement, sizeInPx: number, previousSizeInPx?: number): void;
+    applyMinColumnSize(_: string, columnHeader: HTMLElement, sizeInPx: number): void;
+    applyMaxColumnSize(_: string, columnHeader: HTMLElement, sizeInPx: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableLayoutFixedResizeStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableLayoutFixedResizeStrategy>;
+}
+/**
+ * The optimally performing resize strategy for flex mat-tables.
+ * Tested against and outperformed:
+ *   CSS selector w/ CSS variable
+ *   Updating all mat-cell nodes
+ */
+declare class CdkFlexTableResizeStrategy extends ResizeStrategy implements OnDestroy {
+    protected readonly columnResize: ColumnResize;
+    protected readonly styleScheduler: _CoalescedStyleScheduler;
+    protected readonly table: CdkTable<unknown>;
+    private readonly _nonce;
+    private readonly _document;
+    private readonly _columnIndexes;
+    private readonly _columnProperties;
+    private _styleElement?;
+    private _indexSequence;
+    protected readonly defaultMinSize = 0;
+    protected readonly defaultMaxSize: number;
+    applyColumnSize(cssFriendlyColumnName: string, columnHeader: HTMLElement, sizeInPx: number, previousSizeInPx?: number): void;
+    applyMinColumnSize(cssFriendlyColumnName: string, _: HTMLElement, sizeInPx: number): void;
+    applyMaxColumnSize(cssFriendlyColumnName: string, _: HTMLElement, sizeInPx: number): void;
+    protected getColumnCssClass(cssFriendlyColumnName: string): string;
+    ngOnDestroy(): void;
+    private _getPropertyValue;
+    private _getAppliedWidth;
+    private _applyProperty;
+    private _getStyleSheet;
+    private _getColumnPropertiesMap;
+    private _applySizeCss;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkFlexTableResizeStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CdkFlexTableResizeStrategy>;
+}
+declare const TABLE_LAYOUT_FIXED_RESIZE_STRATEGY_PROVIDER: Provider;
+declare const FLEX_RESIZE_STRATEGY_PROVIDER: Provider;
+
+/**
+ * Base class for Resizable directives which are applied to column headers to make those columns
+ * resizable.
+ */
+declare abstract class Resizable<HandleComponent extends ResizeOverlayHandle> implements AfterViewInit, OnDestroy {
+    protected isResizable: boolean;
+    protected minWidthPxInternal: number;
+    protected maxWidthPxInternal: number;
+    protected inlineHandle?: HTMLElement;
+    protected overlayRef?: OverlayRef;
+    protected readonly destroyed: Subject<void>;
+    protected abstract readonly columnDef: CdkColumnDef;
+    protected abstract readonly columnResize: ColumnResize;
+    protected abstract readonly directionality: Directionality;
+    protected abstract readonly document: Document;
+    protected abstract readonly elementRef: ElementRef;
+    protected abstract readonly eventDispatcher: HeaderRowEventDispatcher;
+    protected abstract readonly injector: Injector;
+    protected abstract readonly ngZone: NgZone;
+    protected abstract readonly overlay: Overlay;
+    protected abstract readonly resizeNotifier: ColumnResizeNotifierSource;
+    protected abstract readonly resizeStrategy: ResizeStrategy;
+    protected abstract readonly styleScheduler: _CoalescedStyleScheduler;
+    protected abstract readonly viewContainerRef: ViewContainerRef;
+    protected abstract readonly changeDetectorRef: ChangeDetectorRef;
+    private _viewInitialized;
+    private _isDestroyed;
+    /** The minimum width to allow the column to be sized to. */
+    get minWidthPx(): number;
+    set minWidthPx(value: number);
+    /** The maximum width to allow the column to be sized to. */
+    get maxWidthPx(): number;
+    set maxWidthPx(value: number);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected abstract getInlineHandleCssClassName(): string;
+    protected abstract getOverlayHandleComponentType(): Type<HandleComponent>;
+    private _createOverlayForHandle;
+    private _listenForRowHoverEvents;
+    private _listenForResizeEvents;
+    private _completeResizeOperation;
+    private _cleanUpAfterResize;
+    private _createHandlePortal;
+    private _showHandleOverlay;
+    private _updateOverlayHandleHeight;
+    private _applySize;
+    private _applyMinWidthPx;
+    private _applyMaxWidthPx;
+    private _appendInlineHandle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Resizable<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Resizable<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+declare const TABLE_PROVIDERS: Provider[];
+declare const FLEX_PROVIDERS: Provider[];
+
+export { COLUMN_RESIZE_OPTIONS, CdkColumnResize, CdkColumnResizeFlex, CdkColumnResizeModule, CdkFlexTableResizeStrategy, ColumnResize, ColumnResizeNotifier, ColumnResizeNotifierSource, ColumnSizeStore, FLEX_PROVIDERS, FLEX_RESIZE_STRATEGY_PROVIDER, HeaderRowEventDispatcher, Resizable, ResizeOverlayHandle, ResizeRef, ResizeStrategy, TABLE_LAYOUT_FIXED_RESIZE_STRATEGY_PROVIDER, TABLE_PROVIDERS, TableLayoutFixedResizeStrategy, _COALESCED_STYLE_SCHEDULER, _CoalescedStyleScheduler, _Schedule };
+export type { ColumnResizeOptions, ColumnSize, ColumnSizeAction };

package/core/index.d.ts

@@ -1,5 +1,147 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ng-matero/extensions/core" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider, PipeTransform, TemplateRef } from '@angular/core';
+import * as i1 from '@angular/material/core';
+import { DateAdapter } from '@angular/material/core';
+import * as i1$1 from '@angular/common';
+import { Observable } from 'rxjs';
+
+interface MtxDatetimeFormats {
+    parse: {
+        dateInput?: any;
+        monthInput?: any;
+        yearInput?: any;
+        timeInput?: any;
+        datetimeInput?: any;
+    };
+    display: {
+        dateInput: any;
+        monthInput: any;
+        yearInput?: any;
+        timeInput: any;
+        datetimeInput: any;
+        monthYearLabel: any;
+        dateA11yLabel: any;
+        monthYearA11yLabel: any;
+        popupHeaderDateLabel: any;
+    };
+}
+declare const MTX_DATETIME_FORMATS: InjectionToken<MtxDatetimeFormats>;
+
+declare class NativeDatetimeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDatetimeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NativeDatetimeModule, never, [typeof i1.NativeDateModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NativeDatetimeModule>;
+}
+declare function provideNativeDatetimeAdapter(formats?: MtxDatetimeFormats): Provider[];
+declare class MtxNativeDatetimeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxNativeDatetimeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MtxNativeDatetimeModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MtxNativeDatetimeModule>;
+}
+
+declare abstract class DatetimeAdapter<D> extends DateAdapter<D> {
+    protected _delegate: DateAdapter<D, any>;
+    abstract getHour(date: D): number;
+    abstract getMinute(date: D): number;
+    abstract getFirstDateOfMonth(date: D): D;
+    abstract getWeek(date: D, firstDayOfWeek: number): number;
+    abstract isInNextMonth(startDate: D, endDate: D): boolean;
+    abstract getHourNames(): string[];
+    abstract getMinuteNames(): string[];
+    abstract addCalendarHours(date: D, months: number): D;
+    abstract addCalendarMinutes(date: D, minutes: number): D;
+    abstract createDatetime(year: number, month: number, date: number, hour: number, minute: number): D;
+    getValidDateOrNull(obj: any): D | null;
+    compareDatetime(first: D, second: D, respectMinutePart?: boolean): number | boolean;
+    sameDatetime(first: D | null, second: D | null): boolean;
+    sameYear(first: D, second: D): boolean;
+    sameDay(first: D, second: D): boolean;
+    sameHour(first: D, second: D): boolean;
+    sameMinute(first: D, second: D): boolean;
+    sameMonthAndYear(first: D | null, second: D | null): boolean;
+    clone(date: D): D;
+    addCalendarYears(date: D, years: number): D;
+    addCalendarMonths(date: D, months: number): D;
+    addCalendarDays(date: D, days: number): D;
+    getYear(date: D): number;
+    getMonth(date: D): number;
+    getDate(date: D): number;
+    getDayOfWeek(date: D): number;
+    getMonthNames(style: any): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: any): string[];
+    getYearName(date: D): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: D): number;
+    createDate(year: number, month: number, date: number): D;
+    today(): D;
+    parse(value: any, parseFormat: any): D | null;
+    format(date: D, displayFormat: any): string;
+    toIso8601(date: D): string;
+    isDateInstance(obj: any): boolean;
+    isValid(date: D): boolean;
+    invalid(): D;
+    clampDate(date: D, min?: D | null, max?: D | null): D;
+}
+
+declare class NativeDatetimeAdapter extends DatetimeAdapter<Date> {
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
+    clone(date: Date): Date;
+    getHour(date: Date): number;
+    getMinute(date: Date): number;
+    isInNextMonth(startDate: Date, endDate: Date): boolean;
+    getWeek(date: Date, firstDayOfWeek: number): number;
+    createDatetime(year: number, month: number, date: number, hour: number, minute: number): Date;
+    getFirstDateOfMonth(date: Date): Date;
+    getHourNames(): string[];
+    getMinuteNames(): string[];
+    addCalendarYears(date: Date, years: number): Date;
+    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarDays(date: Date, days: number): Date;
+    addCalendarHours(date: Date, hours: number): Date;
+    addCalendarMinutes(date: Date, minutes: number): Date;
+    toIso8601(date: Date): string;
+    private getDateInNextMonth;
+    /**
+     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
+     * other browsers do not. We remove them to make output consistent and because they interfere with
+     * date parsing.
+     * @param str The string to strip direction characters from.
+     * @returns The stripped string.
+     */
+    private _stripDirectionalityCharacters;
+    /**
+     * Pads a number to make it two digits.
+     * @param n The number to pad.
+     * @returns The padded number.
+     */
+    private _2digit;
+    /** Creates a date but allows the month and date to overflow. */
+    private _createDateWithOverflow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDatetimeAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NativeDatetimeAdapter>;
+}
+
+declare const MTX_NATIVE_DATETIME_FORMATS: MtxDatetimeFormats;
+
+declare class MtxToObservablePipe implements PipeTransform {
+    transform(value: Observable<any> | unknown): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxToObservablePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MtxToObservablePipe, "toObservable", true>;
+}
+
+declare class MtxIsTemplateRefPipe implements PipeTransform {
+    transform(obj: any): obj is TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxIsTemplateRefPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MtxIsTemplateRefPipe, "isTemplateRef", true>;
+}
+
+declare class MtxPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtxPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MtxPipesModule, never, [typeof i1$1.CommonModule, typeof MtxToObservablePipe, typeof MtxIsTemplateRefPipe], [typeof MtxToObservablePipe, typeof MtxIsTemplateRefPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MtxPipesModule>;
+}
+
+export { DatetimeAdapter, MTX_DATETIME_FORMATS, MTX_NATIVE_DATETIME_FORMATS, MtxIsTemplateRefPipe, MtxNativeDatetimeModule, MtxPipesModule, MtxToObservablePipe, NativeDatetimeAdapter, NativeDatetimeModule, provideNativeDatetimeAdapter };
+export type { MtxDatetimeFormats };

package/core/theming/_color-api-backwards-compatibility.scss

@@ -8,39 +8,32 @@
 // from the bundle.
 $_overrides-only: true;
 
-@mixin color-variant-styles($theme, $color-variant) {
-  $primary-options: (color-variant: $color-variant, emit-overrides-only: $_overrides-only);
-
-  // Some components use the secondary color rather than primary color for `.mat-primary`.
-  // Those components should use the $secondary-color-variant.
-  $secondary-options: (
-    color-variant: if($color-variant == primary, secondary, $color-variant),
-    emit-overrides-only: $_overrides-only
-  );
+@mixin _color-variant-styles($theme, $color-variant) {
+  $secondary-when-primary: if($color-variant == primary, secondary, $color-variant);
 
   &.mtx-split-gutter {
-    @include split-theme.color($theme, $primary-options...);
+    @include split-theme.color($theme, $color-variant);
   }
 
   &.mtx-datetimepicker-content {
-    @include datetimepicker-theme.color($theme, $primary-options...);
+    @include datetimepicker-theme.color($theme, $color-variant);
   }
 
   &.ng-dropdown-panel {
-    @include select-theme.color($theme, $secondary-options...);
+    @include select-theme.color($theme, $secondary-when-primary);
   }
 }
 
 @mixin color-variants-backwards-compatibility($theme) {
   .mat-primary {
-    @include color-variant-styles($theme, primary);
+    @include _color-variant-styles($theme, primary);
   }
 
   .mat-accent {
-    @include color-variant-styles($theme, tertiary);
+    @include _color-variant-styles($theme, tertiary);
   }
 
   .mat-warn {
-    @include color-variant-styles($theme, error);
+    @include _color-variant-styles($theme, error);
   }
 }