cmat 0.0.28 → 0.0.30

package/components/upload/index.d.ts

@@ -1,5 +1,111 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/upload" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, AfterViewInit, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare class CmatUploadComponent implements OnInit, OnDestroy {
+    fileAlias: string;
+    filePath: string;
+    fileCategory: string;
+    editMode: boolean;
+    autoUpload: boolean;
+    id: string;
+    removeEvent: EventEmitter<CmatUploadComponent>;
+    uploadEvent: EventEmitter<any>;
+    progressPercentage: number;
+    loaded: number;
+    total: number;
+    isUploading: boolean;
+    private _fileService;
+    private _changeDetectorRef;
+    private _file;
+    private _unsubscribeAll;
+    get file(): any;
+    set file(file: any);
+    get fileType(): 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    upload(): void;
+    download(): void;
+    remove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatUploadComponent, "cmat-upload", ["cmatUpload"], { "fileAlias": { "alias": "fileAlias"; "required": false; }; "filePath": { "alias": "filePath"; "required": false; }; "fileCategory": { "alias": "fileCategory"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "autoUpload": { "alias": "autoUpload"; "required": false; }; "id": { "alias": "id"; "required": false; }; "file": { "alias": "file"; "required": false; }; }, { "removeEvent": "removeEvent"; "uploadEvent": "uploadEvent"; }, never, never, true, never>;
+}
+
+declare class CmatUploadQueueComponent implements OnDestroy, AfterViewInit {
+    fileUploads: QueryList<CmatUploadComponent>;
+    fileAlias: string;
+    filePath: string;
+    fileCategory: string;
+    required: boolean;
+    autoUpload: boolean;
+    multiple: boolean;
+    accept: string;
+    title: string;
+    editMode: boolean;
+    filesData: any[];
+    outputRemoveIdEvent: EventEmitter<string>;
+    outputUploadIdEvent: EventEmitter<string>;
+    outputFilesDataEvent: EventEmitter<any>;
+    id: string;
+    isHandSet: boolean;
+    private _changeDetectorRef;
+    private _cmatMediaWatcherService;
+    private _elementRef;
+    private _unsubscribeAll;
+    constructor();
+    onDrop(event: any): void;
+    onDropOver(event: any): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    add(file: any): void;
+    upload(event: any): void;
+    remove(event: CmatUploadComponent): void;
+    uploadAll(): void;
+    removeAll(): void;
+    choose(): void;
+    getData(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatUploadQueueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatUploadQueueComponent, "cmat-upload-queue", ["cmatUploadQueue"], { "fileAlias": { "alias": "fileAlias"; "required": false; }; "filePath": { "alias": "filePath"; "required": false; }; "fileCategory": { "alias": "fileCategory"; "required": false; }; "required": { "alias": "required"; "required": false; }; "autoUpload": { "alias": "autoUpload"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "title": { "alias": "title"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "filesData": { "alias": "filesData"; "required": false; }; }, { "outputRemoveIdEvent": "outputRemoveIdEvent"; "outputUploadIdEvent": "outputUploadIdEvent"; "outputFilesDataEvent": "outputFilesDataEvent"; }, never, never, true, never>;
+}
+
+declare class CmatFilesUtilService implements OnDestroy {
+    private _http;
+    private _urlStateConfigService;
+    private _config;
+    private _unsubscribeAll;
+    constructor();
+    ngOnDestroy(): void;
+    downloadFile(fileId: string, isStream?: boolean): Observable<any>;
+    downloadFileZip(fileIds?: string[]): Observable<any>;
+    uploadFile(file: FormData): Observable<any>;
+    deleteFile(fileId: string): Observable<any>;
+    getFileList(ids?: [], fileName?: string, fileCategory?: string, searchDate?: Date, pageIndex?: number, pageSize?: number): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatFilesUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatFilesUtilService>;
+}
+
+interface FileModel {
+    id?: string | null;
+    fileName: string;
+    filePath: string;
+    fileStatus?: 'Uploaded' | 'Processed';
+    length: number;
+    uploadUserId?: string;
+    uploadUserName?: string;
+    uploadDate: Date;
+    fileType: 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
+    fileCategory: string;
+    data?: any;
+}
+interface FileCategoryModel {
+    name: string;
+    value: number;
+}
+interface FileListModel {
+    data: FileModel[];
+    dataCount: number;
+    category: FileCategoryModel[];
+}
+
+export { CmatFilesUtilService, CmatUploadComponent, CmatUploadQueueComponent };
+export type { FileCategoryModel, FileListModel, FileModel };

package/components/x6-angular-shape/index.d.ts

@@ -1,5 +1,43 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/components/x6-angular-shape" />
-export * from './public-api';
+import { Node, NodeView, Dom } from '@antv/x6';
+import { TemplateRef, Type, Injector } from '@angular/core';
+
+declare class AngularShape<Properties extends AngularShape.Properties = AngularShape.Properties> extends Node<Properties> {
+}
+declare namespace AngularShape {
+    type Primer = 'rect' | 'circle' | 'path' | 'ellipse' | 'polygon' | 'polyline';
+    interface Properties extends Node.Properties {
+        primer?: Primer;
+    }
+}
+declare namespace AngularShape {
+}
+
+declare class AngularShapeView extends NodeView<AngularShape> {
+    getNodeContainer(): HTMLDivElement;
+    onMouseDown(e: Dom.MouseDownEvent, x: number, y: number): void;
+    unmount(): this;
+    confirmUpdate(flag: number): number;
+    protected renderAngularContent(): void;
+    protected unmountAngularContent(): HTMLDivElement;
+    private getNgArguments;
+    /** 当执行 node.setData() 时需要对实例设置新的输入值 */
+    private setInstanceInput;
+}
+declare namespace AngularShapeView {
+    const action: any;
+}
+
+type Content = TemplateRef<any> | Type<any>;
+type AngularShapeConfig = Node.Properties & {
+    shape: string;
+    injector: Injector;
+    content: Content;
+};
+declare const registerInfo: Map<string, {
+    injector: Injector;
+    content: Content;
+}>;
+declare function register(config: AngularShapeConfig): void;
+
+export { AngularShape, AngularShapeView, register, registerInfo };
+export type { AngularShapeConfig, Content };

package/directives/animate-on-scroll/index.d.ts

@@ -1,5 +1,30 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/animate-on-scroll" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, AfterViewInit } from '@angular/core';
+
+declare class CmatAnimationOnScrollDirective implements OnInit, OnDestroy, AfterViewInit {
+    animationName: string | null;
+    offset: number;
+    useScroll?: boolean;
+    threshold?: number;
+    private _offsetTop;
+    private _isVisible;
+    private _winHeight;
+    private _scrollSub;
+    private _resizeSub;
+    private _elementRef;
+    private _renderer;
+    private _scroll;
+    private get id();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private manageVisibility;
+    private addAnimationClass;
+    private setClass;
+    private getWinHeight;
+    private getOffsetTop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAnimationOnScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatAnimationOnScrollDirective, "[cmatAnimateOnScroll]", never, { "animationName": { "alias": "animationName"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "useScroll": { "alias": "useScroll"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { CmatAnimationOnScrollDirective };

package/directives/arrow-cursor/index.d.ts

@@ -1,5 +1,32 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/arrow-cursor" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, EventEmitter } from '@angular/core';
+
+declare class CmatArrowCursorDirective implements AfterViewInit, OnDestroy {
+    animationDuration: number;
+    orientation: 'horizontal' | 'vertical';
+    enabled: boolean;
+    selector: string;
+    clickEvent: EventEmitter<string | null>;
+    cursorAnimationFrame: any;
+    isPhone: boolean;
+    arrowCursor: HTMLDivElement | null;
+    cursorClientX: number;
+    cursorClientY: number;
+    cursorIcon: SVGElement | null;
+    cursorSide: string | null;
+    oldCursorSide: string | null;
+    private _document;
+    private _cmatMediaWatcherService;
+    private _unsubscribeAll;
+    onMouseEnter(event: any): void;
+    onMouseLeave(event: any): void;
+    onMouseOver(event: any): void;
+    onClick(event: Event): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    moveCursor(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatArrowCursorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatArrowCursorDirective, "[cmatArrowCursor]", never, { "animationDuration": { "alias": "animationDuration"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "selector": { "alias": "selector"; "required": false; }; }, { "clickEvent": "clickEvent"; }, never, never, true, never>;
+}
+
+export { CmatArrowCursorDirective };

package/directives/autofocus/index.d.ts

@@ -1,5 +1,11 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/autofocus" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+declare class CmatAutofocusDirective {
+    element: ElementRef<any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAutofocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatAutofocusDirective, "[cmatAutofocus]", never, {}, {}, never, never, true, never>;
+}
+
+export { CmatAutofocusDirective };

package/directives/data-exporter/index.d.ts

@@ -1,5 +1,41 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/data-exporter" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { WritingOptions } from 'xlsx';
+
+interface ExporterListInfo {
+    code: string;
+    label: string;
+}
+declare enum ExportType {
+    XLS = "xls",
+    XLSX = "xlsx",
+    CSV = "csv",
+    TXT = "txt",
+    JSON = "json"
+}
+interface Options {
+    fileName?: string;
+}
+interface TxtOptions extends Options {
+    delimiter?: string;
+}
+interface ExcelOptions extends Options, Omit<WritingOptions, 'bookType'> {
+    columnWidths: number[];
+}
+
+declare class CmatDataExporterDirective implements OnChanges {
+    dataSource: any[];
+    exportColumns: ExporterListInfo[];
+    options?: Options | ExcelOptions | TxtOptions;
+    exportType: ExportType | 'xls' | 'xlsx' | 'csv' | 'txt' | 'json';
+    private _serviceLocator;
+    private _data;
+    private _exporterService;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _loadExporter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDataExporterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDataExporterDirective, "button[cmatDataExporter]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "exportColumns": { "alias": "exportColumns"; "required": false; }; "options": { "alias": "options"; "required": false; }; "exportType": { "alias": "exportType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { CmatDataExporterDirective, ExportType };
+export type { ExcelOptions, ExporterListInfo, Options, TxtOptions };

package/directives/debounce/index.d.ts

@@ -1,5 +1,32 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/debounce" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { Subject } from 'rxjs';
+
+declare abstract class AbstractDebounceDirective implements OnInit, OnDestroy {
+    debounceTime: number;
+    emitChanged: EventEmitter<any>;
+    emitEvent$: Subject<any>;
+    subscription$: Subject<void>;
+    constructor();
+    ngOnInit(): void;
+    emitChange(value: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDebounceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDebounceDirective, never, never, { "debounceTime": { "alias": "debounceTime"; "required": false; }; }, { "emitChanged": "emitChanged"; }, never, never, true, never>;
+}
+
+declare class CmatDebounceClickDirective extends AbstractDebounceDirective {
+    constructor();
+    onKeyUp(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceClickDirective, "[cmatDebounceClick]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CmatDebounceKeyupDirective extends AbstractDebounceDirective {
+    constructor();
+    onKeyUp(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceKeyupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceKeyupDirective, "input[cmatDebounceKeyup]", never, {}, {}, never, never, true, never>;
+}
+
+export { CmatDebounceClickDirective, CmatDebounceKeyupDirective };

package/directives/digit-only/index.d.ts

@@ -1,5 +1,54 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/digit-only" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnChanges, ElementRef, SimpleChanges, OnInit } from '@angular/core';
+
+declare class CmatDigitOnlyDirective implements OnChanges {
+    decimal: boolean;
+    decimalSeparator: string;
+    allowNegatives: boolean;
+    allowPaste: boolean;
+    negativeSign: string;
+    min: number;
+    max: number;
+    pattern?: string | RegExp;
+    inputElement: HTMLInputElement;
+    value: string;
+    el: ElementRef<any>;
+    private _regex;
+    private _hasDecimalPoint;
+    private _hasNegativeSign;
+    private _navigationKeys;
+    constructor();
+    onBeforeInput(e: InputEvent): any;
+    onInputChange(event: any): void;
+    onKeyDown(e: KeyboardEvent): any;
+    onPaste(event: any): void;
+    onDrop(event: DragEvent): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _pasteData;
+    private _insertAtCursor;
+    private _triggerEvent;
+    private _sanitizeInput;
+    private _getNegativeSignRegExp;
+    private _isValidDecimal;
+    private _getSelection;
+    private _forecastValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDigitOnlyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDigitOnlyDirective, "[cmatDigitOnly]", never, { "decimal": { "alias": "decimal"; "required": false; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; }; "allowNegatives": { "alias": "allowNegatives"; "required": false; }; "allowPaste": { "alias": "allowPaste"; "required": false; }; "negativeSign": { "alias": "negativeSign"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CmatMaskDirective implements OnInit {
+    el: ElementRef<any>;
+    inputElement: HTMLInputElement;
+    value: string;
+    regex: RegExp;
+    private _navigationKeys;
+    constructor();
+    onInputChange(event: any): void;
+    onKeyDown(e: KeyboardEvent): void;
+    ngOnInit(): void;
+    private _forecastValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatMaskDirective, "[cmatMask]", never, {}, {}, never, never, true, never>;
+}
+
+export { CmatDigitOnlyDirective, CmatMaskDirective };

package/directives/equal-validator/index.d.ts

@@ -1,5 +1,14 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="cmat/directives/equal-validator" />
-export * from './public-api';
+import { Validator, AbstractControl } from '@angular/forms';
+import * as i0 from '@angular/core';
+
+declare class CmatEqualValidatorDirective implements Validator {
+    private _validateEqual;
+    private _reverse;
+    private static _validateNoReverse;
+    private static _validateReverse;
+    validate(c: AbstractControl): Record<string, any> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatEqualValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatEqualValidatorDirective, "[cmatValidateEqual][formControlName],[cmatValidateEqual][formControl],[cmatValidateEqual][ngModel]", never, {}, {}, never, never, true, never>;
+}
+
+export { CmatEqualValidatorDirective };

package/fesm2022/cmat-components-adapter.mjs

@@ -1,7 +1,6 @@
-import * as i1 from '@angular/material/core';
 import { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';
 import * as i0 from '@angular/core';
-import { InjectionToken, Optional, Inject, Injectable } from '@angular/core';
+import { InjectionToken, inject, Injectable } from '@angular/core';
 import dayjs from 'dayjs';
 import localeData from 'dayjs/plugin/localeData';
 import customParseFormat from 'dayjs/plugin/customParseFormat';
@@ -148,7 +147,9 @@ function range$2(length, valueFunction) {
     return valuesArray;
 }
 class CNativeDatetimeAdapter extends DatetimeAdapter {
-    constructor(matDateLocale, _delegate) {
+    constructor() {
+        const matDateLocale = inject(MAT_DATE_LOCALE, { optional: true });
+        const _delegate = inject(DateAdapter);
         super(_delegate);
         this.setLocale(matDateLocale);
     }
@@ -249,17 +250,12 @@ class CNativeDatetimeAdapter extends DatetimeAdapter {
         }
         return result;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: CNativeDatetimeAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: i1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: CNativeDatetimeAdapter }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: CNativeDatetimeAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: CNativeDatetimeAdapter }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: CNativeDatetimeAdapter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: CNativeDatetimeAdapter, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [MAT_DATE_LOCALE]
-                }] }, { type: i1.DateAdapter }] });
+        }], ctorParameters: () => [] });
 
 const CMAT_NATIVE_DATETIME_FORMATS = {
     parse: {},
@@ -284,7 +280,9 @@ function range$1(length, valueFunction) {
     return valuesArray;
 }
 class DayjsDatetimeAdapter extends DatetimeAdapter {
-    constructor(matDateLocale, _delegate) {
+    constructor() {
+        const matDateLocale = inject(MAT_DATE_LOCALE, { optional: true });
+        const _delegate = inject(DateAdapter);
         super(_delegate);
         this.setLocale(matDateLocale || dayjs.locale());
         dayjs.extend(localeData);
@@ -357,17 +355,12 @@ class DayjsDatetimeAdapter extends DatetimeAdapter {
     _getDateInNextMonth(date) {
         return super.clone(date).date(1).add(1, 'month');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: DayjsDatetimeAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: i1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: DayjsDatetimeAdapter }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: DayjsDatetimeAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: DayjsDatetimeAdapter }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: DayjsDatetimeAdapter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: DayjsDatetimeAdapter, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [MAT_DATE_LOCALE]
-                }] }, { type: i1.DateAdapter }] });
+        }], ctorParameters: () => [] });
 
 const CMAT_DAYJS_DATETIME_FORMATS = {
     parse: {
@@ -410,10 +403,10 @@ function range(length, valueFunction) {
 }
 /** Adapts Dayjs Dates for use with Angular Material. */
 class DayjsDateAdapter extends DateAdapter {
-    constructor(dateLocale, _options) {
+    constructor() {
         super();
-        this.dateLocale = dateLocale;
-        this._options = _options;
+        this._options = inject(CMAT_DAYJS_DATE_ADAPTER_OPTIONS, { optional: true });
+        const dateLocale = inject(MAT_DATE_LOCALE, { optional: true });
         this._initializeParser(dateLocale);
     }
     get _shouldUseUtc() {
@@ -563,22 +556,12 @@ class DayjsDateAdapter extends DateAdapter {
         dayjs.extend(localeData);
         this.setLocale(dateLocale);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: DayjsDateAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: CMAT_DAYJS_DATE_ADAPTER_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: DayjsDateAdapter }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: DayjsDateAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: DayjsDateAdapter }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.9", ngImport: i0, type: DayjsDateAdapter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.2", ngImport: i0, type: DayjsDateAdapter, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [MAT_DATE_LOCALE]
-                }] }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [CMAT_DAYJS_DATE_ADAPTER_OPTIONS]
-                }] }] });
+        }], ctorParameters: () => [] });
 
 const CMAT_DAYJS_DATE_FORMATS = {
     parse: {