cmat 0.0.86 → 0.0.88

package/types/cmat-components-transfer-picker.d.ts

@@ -1,11 +1,9 @@
-import { CdkOverlayOrigin, OverlayRef } from '@angular/cdk/overlay';
-import { CdkPortal } from '@angular/cdk/portal';
-import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, AfterViewInit, EventEmitter } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, AfterViewInit } from '@angular/core';
+import { OverlayRef } from '@angular/cdk/overlay';
 import { FormControl } from '@angular/forms';
+import * as cmat_components_transfer_picker from 'cmat/components/transfer-picker';
 import { SelectionModel } from '@angular/cdk/collections';
-import { CdkTree } from '@angular/cdk/tree';
-import { Observable } from 'rxjs';
 
 declare class CmatTransferItemNode {
     [key: string]: unknown;
@@ -46,11 +44,11 @@ interface CmatSourceOptions {
 }
 
 declare class CmatTransferPickerFilterComponent implements OnInit, OnDestroy {
-    filters: CmatTransferFilterItem[] | undefined;
-    overlayOrigin: CdkOverlayOrigin;
-    filterTemplate: CdkPortal;
+    readonly filters: _angular_core.InputSignal<CmatTransferFilterItem[] | undefined>;
     overlayRef: OverlayRef;
     filterData: CmatTransferFilterData;
+    private readonly _overlayOrigin;
+    private readonly _filterTemplate;
     private _overlay;
     private _service;
     constructor();
@@ -60,34 +58,38 @@ declare class CmatTransferPickerFilterComponent implements OnInit, OnDestroy {
     onConditionChange(event: 'or' | 'and'): void;
     changeFilterData(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerFilterComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerFilterComponent, "cmat-transfer-picker-filter", ["cmatTransferPickerFilter"], { "filters": { "alias": "filters"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTransferPickerFilterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatTransferPickerFilterComponent, "cmat-transfer-picker-filter", ["cmatTransferPickerFilter"], { "filters": { "alias": "filters"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class CmatTransferPickerSearchComponent implements OnInit {
-    searchPlaceholder: string | undefined;
+    readonly searchPlaceholder: _angular_core.InputSignal<string | undefined>;
     keyword: FormControl;
     private _service;
     constructor();
     ngOnInit(): void;
     reset(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerSearchComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerSearchComponent, "cmat-transfer-picker-search", ["cmatTransferPickerSearch"], { "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTransferPickerSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatTransferPickerSearchComponent, "cmat-transfer-picker-search", ["cmatTransferPickerSearch"], { "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class CmatTransferPickerSourceComponent implements OnInit, AfterViewInit {
-    tree: CdkTree<CmatTransferItemNode>;
+declare class CmatTransferPickerSourceComponent implements AfterViewInit {
     nestedNodeMap: Map<CmatTransferItemNode, CmatTransferItemFlatNode>;
-    readonly dataSource: i0.WritableSignal<CmatTransferItemNode[]>;
-    readonly dataFlatNodes: i0.WritableSignal<CmatTransferItemFlatNode[]>;
+    readonly dataFlatNodes: _angular_core.WritableSignal<CmatTransferItemFlatNode[]>;
     checklistSelection: SelectionModel<CmatTransferItemFlatNode>;
-    readonly options: i0.WritableSignal<CmatSourceOptions>;
-    readonly committedSelection: i0.WritableSignal<CmatTransferItemFlatNode[]>;
-    readonly committedValueSet: i0.Signal<Set<string | number>>;
+    readonly committedSelection: _angular_core.WritableSignal<CmatTransferItemFlatNode[]>;
+    readonly committedValueSet: _angular_core.Signal<Set<string | number>>;
+    private readonly _tree;
     private readonly _flatNodeByValue;
     private _service;
-    private readonly _destroyRef;
-    ngOnInit(): void;
+    readonly dataSource: _angular_core.Signal<CmatTransferItemNode[]>;
+    readonly refreshDataSourceChange: _angular_core.Signal<{
+        clear: boolean;
+        nonce: number;
+    }>;
+    readonly options: _angular_core.Signal<void | cmat_components_transfer_picker.CmatSourceOptions>;
+    readonly selectedValuesChange: _angular_core.Signal<string[]>;
+    constructor();
     ngAfterViewInit(): void;
     getCommittedSelection(): CmatTransferItemFlatNode[];
     commitSelection(): CmatTransferItemFlatNode[];
@@ -111,33 +113,31 @@ declare class CmatTransferPickerSourceComponent implements OnInit, AfterViewInit
     private _cloneFlatNodes;
     private _getParentNode;
     private _selectNodesByValues;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerSourceComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerSourceComponent, "cmat-transfer-picker-source", ["cmatTransferPickerSource"], {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTransferPickerSourceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatTransferPickerSourceComponent, "cmat-transfer-picker-source", ["cmatTransferPickerSource"], {}, {}, never, never, true, never>;
 }
 
 declare class CmatTransferPickerTargetComponent {
-    committedSelection: CmatTransferItemFlatNode[];
-    clearItemChange: EventEmitter<CmatTransferItemFlatNode>;
-    constructor();
+    readonly committedSelection: _angular_core.InputSignal<CmatTransferItemFlatNode[]>;
+    readonly clearItemChange: _angular_core.OutputEmitterRef<CmatTransferItemFlatNode>;
     clearItem(item: CmatTransferItemFlatNode): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerTargetComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerTargetComponent, "cmat-transfer-picker-target", ["cmatTransferPickerTarget"], { "committedSelection": { "alias": "committedSelection"; "required": false; }; }, { "clearItemChange": "clearItemChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTransferPickerTargetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatTransferPickerTargetComponent, "cmat-transfer-picker-target", ["cmatTransferPickerTarget"], { "committedSelection": { "alias": "committedSelection"; "required": false; "isSignal": true; }; }, { "clearItemChange": "clearItemChange"; }, never, never, true, never>;
 }
 
 declare class CmatTransferPickerComponent implements OnInit, AfterViewInit {
-    title: string;
-    filterable: boolean;
-    searchable: boolean;
-    searchPlaceholder: string;
-    dataSource: CmatTransferItemNode[];
-    filters: CmatTransferFilterItem[];
-    selectedValues: string[];
-    selectChange: EventEmitter<CmatTransferItemFlatNode[]>;
-    source: CmatTransferPickerSourceComponent;
-    readonly committedSelection: i0.WritableSignal<CmatTransferItemFlatNode[]>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly filterable: _angular_core.InputSignal<boolean>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly dataSource: _angular_core.InputSignal<CmatTransferItemNode[]>;
+    readonly filters: _angular_core.InputSignal<CmatTransferFilterItem[]>;
+    readonly selectedValues: _angular_core.InputSignal<string[]>;
+    readonly selectChange: _angular_core.OutputEmitterRef<CmatTransferItemFlatNode[]>;
+    readonly committedSelection: _angular_core.WritableSignal<CmatTransferItemFlatNode[]>;
+    private readonly source;
     private _service;
     private readonly _injector;
-    constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
     pick(): void;
@@ -145,8 +145,8 @@ declare class CmatTransferPickerComponent implements OnInit, AfterViewInit {
     onClearItemChange(item: CmatTransferItemFlatNode): void;
     private _commitSelection;
     private _emitterChange;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerComponent, "cmat-transfer-picker", ["cmatTransferPicker"], { "title": { "alias": "title"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "selectedValues": { "alias": "selectedValues"; "required": false; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTransferPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatTransferPickerComponent, "cmat-transfer-picker", ["cmatTransferPicker"], { "title": { "alias": "title"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "selectedValues": { "alias": "selectedValues"; "required": false; "isSignal": true; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
 }
 
 declare class CmatTransferPickerService {
@@ -163,20 +163,15 @@ declare class CmatTransferPickerService {
     private _compareMap;
     private _conditionMap;
     private _refreshNonce;
-    private readonly _dataSourceChange$;
-    private readonly _refreshDataSourceChange$;
-    private readonly _filtersChange$;
-    private readonly _sourceOptionsChange$;
-    private readonly _selectedValuesChange$;
-    constructor();
-    get dataSourceChange(): Observable<CmatTransferItemNode[]>;
-    get refreshDataSourceChange(): Observable<{
+    readonly dataSourceChange: _angular_core.Signal<CmatTransferItemNode[]>;
+    readonly refreshDataSourceChange: _angular_core.Signal<{
         clear: boolean;
         nonce: number;
     }>;
-    get filtersChange(): Observable<CmatTransferFilterItem[]>;
-    get sourceOptionsChange(): Observable<CmatSourceOptions | void>;
-    get selectedValuesChange(): Observable<string[]>;
+    readonly filtersChange: _angular_core.Signal<CmatTransferFilterItem[]>;
+    readonly sourceOptionsChange: _angular_core.Signal<void | CmatSourceOptions>;
+    readonly selectedValuesChange: _angular_core.Signal<string[]>;
+    constructor();
     get dataSource(): CmatTransferItemNode[];
     set dataSource(data: CmatTransferItemNode[]);
     set sourceOptions(value: CmatSourceOptions);
@@ -189,8 +184,8 @@ declare class CmatTransferPickerService {
     private _filterDataSourceByType;
     private _setFilteredDataSourceByFilters;
     private _setFilteredDataSourceByKeyword;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CmatTransferPickerService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTransferPickerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CmatTransferPickerService>;
 }
 
 export { CmatTransferFilterCondition, CmatTransferItemFlatNode, CmatTransferItemNode, CmatTransferPickerComponent, CmatTransferPickerFilterComponent, CmatTransferPickerSearchComponent, CmatTransferPickerService, CmatTransferPickerSourceComponent, CmatTransferPickerTargetComponent };

package/types/cmat-components-treetable.d.ts

@@ -1,7 +1,6 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { OnChanges, TemplateRef, WritableSignal, SimpleChanges } from '@angular/core';
 import { MatTableDataSource } from '@angular/material/table';
-import { Subject } from 'rxjs';
 
 declare class CmatTreeTableNode {
     [propName: string]: unknown;
@@ -14,17 +13,17 @@ declare class CmatTreeTableNode {
 }
 
 declare class CmatTreeTableColumnDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTreeTableColumnDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatTreeTableColumnDirective, "ng-template[cmatTreeTableColumn]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTreeTableColumnDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CmatTreeTableColumnDirective, "ng-template[cmatTreeTableColumn]", never, {}, {}, never, never, true, never>;
 }
 declare class CmatTreeTableComponent implements OnChanges {
-    data: CmatTreeTableNode[];
-    verticalSeparator: boolean;
-    initExpand: boolean;
-    tableClass: string;
-    showControlColumn: boolean;
-    nodeClicked: Subject<CmatTreeTableNode>;
-    customColumnTpl?: TemplateRef<unknown>;
+    readonly data: _angular_core.InputSignal<CmatTreeTableNode[] | undefined>;
+    readonly verticalSeparator: _angular_core.InputSignal<boolean>;
+    readonly initExpand: _angular_core.InputSignal<boolean>;
+    readonly tableClass: _angular_core.InputSignal<string>;
+    readonly showControlColumn: _angular_core.InputSignal<boolean>;
+    readonly nodeClicked: _angular_core.OutputEmitterRef<CmatTreeTableNode>;
+    readonly customColumnTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
     readonly displayedColumns: WritableSignal<string[]>;
     readonly dataSource: WritableSignal<MatTableDataSource<CmatTreeTableNode>>;
     private _treeTable;
@@ -35,8 +34,8 @@ declare class CmatTreeTableComponent implements OnChanges {
     private _switchNodeVisible;
     private _generateDataSource;
     private _getFlattenNodes;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTreeTableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTreeTableComponent, "cmat-treetable", ["cmatTreeTable"], { "data": { "alias": "data"; "required": false; }; "verticalSeparator": { "alias": "verticalSeparator"; "required": false; }; "initExpand": { "alias": "initExpand"; "required": false; }; "tableClass": { "alias": "tableClass"; "required": false; }; "showControlColumn": { "alias": "showControlColumn"; "required": false; }; }, { "nodeClicked": "nodeClicked"; }, ["customColumnTpl"], never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatTreeTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatTreeTableComponent, "cmat-treetable", ["cmatTreeTable"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "verticalSeparator": { "alias": "verticalSeparator"; "required": false; "isSignal": true; }; "initExpand": { "alias": "initExpand"; "required": false; "isSignal": true; }; "tableClass": { "alias": "tableClass"; "required": false; "isSignal": true; }; "showControlColumn": { "alias": "showControlColumn"; "required": false; "isSignal": true; }; }, { "nodeClicked": "nodeClicked"; }, ["customColumnTpl"], never, true, never>;
 }
 
 export { CmatTreeTableColumnDirective, CmatTreeTableComponent, CmatTreeTableNode };

package/types/cmat-components-upload.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, EventEmitter, AfterViewInit, OnChanges, QueryList, SimpleChanges } from '@angular/core';
+import { OnInit, AfterViewInit } from '@angular/core';
 import { HttpResponse, HttpEvent } from '@angular/common/http';
 import { Observable } from 'rxjs';
 
@@ -29,24 +29,24 @@ interface FileListModel {
 }
 
 declare class CmatUploadComponent implements OnInit {
-    fileAlias: string;
-    filePath: string;
-    fileCategory: string;
-    isPublic: boolean;
-    editMode: boolean;
-    autoUpload: boolean;
-    id: string | null;
-    removeEvent: EventEmitter<CmatUploadComponent>;
-    uploadEvent: EventEmitter<FileModel>;
+    readonly removeEvent: _angular_core.OutputEmitterRef<CmatUploadComponent>;
+    readonly uploadEvent: _angular_core.OutputEmitterRef<FileModel>;
+    readonly fileAlias: _angular_core.InputSignal<string>;
+    readonly filePath: _angular_core.InputSignal<string>;
+    readonly fileCategory: _angular_core.InputSignal<string>;
+    readonly isPublic: _angular_core.InputSignal<boolean>;
+    readonly editMode: _angular_core.InputSignal<boolean>;
+    readonly autoUpload: _angular_core.InputSignal<boolean>;
+    readonly file: _angular_core.ModelSignal<FileModel>;
+    readonly id: _angular_core.InputSignal<string | null>;
     readonly progressPercentage: _angular_core.WritableSignal<number>;
     readonly loaded: _angular_core.WritableSignal<number>;
     readonly total: _angular_core.WritableSignal<number>;
     readonly isUploading: _angular_core.WritableSignal<boolean>;
+    readonly uploadedId: _angular_core.WritableSignal<string | null>;
     private _fileService;
     private readonly _destroyRef;
-    private _file;
-    get file(): FileModel;
-    set file(file: FileModel);
+    constructor();
     get fileType(): 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
     get fileSize(): number;
     ngOnInit(): void;
@@ -54,35 +54,31 @@ declare class CmatUploadComponent implements OnInit {
     download(): void;
     remove(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatUploadComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatUploadComponent, "cmat-upload", ["cmatUpload"], { "fileAlias": { "alias": "fileAlias"; "required": false; }; "filePath": { "alias": "filePath"; "required": false; }; "fileCategory": { "alias": "fileCategory"; "required": false; }; "isPublic": { "alias": "isPublic"; "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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatUploadComponent, "cmat-upload", ["cmatUpload"], { "fileAlias": { "alias": "fileAlias"; "required": false; "isSignal": true; }; "filePath": { "alias": "filePath"; "required": false; "isSignal": true; }; "fileCategory": { "alias": "fileCategory"; "required": false; "isSignal": true; }; "isPublic": { "alias": "isPublic"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": false; "isSignal": true; }; "autoUpload": { "alias": "autoUpload"; "required": false; "isSignal": true; }; "file": { "alias": "file"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "removeEvent": "removeEvent"; "uploadEvent": "uploadEvent"; "file": "fileChange"; }, never, never, true, never>;
 }
 
-declare class CmatUploadQueueComponent implements AfterViewInit, OnChanges {
-    fileUploads: QueryList<CmatUploadComponent>;
-    fileAlias: string;
-    filePath: string;
-    fileCategory: string;
-    isPublic: boolean;
-    required: boolean;
-    autoUpload: boolean;
-    multiple: boolean;
-    accept: string;
-    title: string;
-    editMode: boolean;
-    filesData: FileModel[];
-    outputRemoveIdEvent: EventEmitter<string>;
-    outputUploadIdEvent: EventEmitter<string>;
-    outputFilesDataEvent: EventEmitter<FileModel[]>;
+declare class CmatUploadQueueComponent implements AfterViewInit {
+    readonly outputRemoveIdEvent: _angular_core.OutputEmitterRef<string>;
+    readonly outputUploadIdEvent: _angular_core.OutputEmitterRef<string>;
+    readonly outputFilesDataEvent: _angular_core.OutputEmitterRef<FileModel[]>;
+    readonly fileAlias: _angular_core.InputSignal<string>;
+    readonly filePath: _angular_core.InputSignal<string>;
+    readonly fileCategory: _angular_core.InputSignal<string>;
+    readonly isPublic: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly autoUpload: _angular_core.InputSignal<boolean>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly editMode: _angular_core.InputSignal<boolean>;
+    readonly filesData: _angular_core.ModelSignal<FileModel[]>;
     id: string;
-    readonly isHandSet: _angular_core.WritableSignal<boolean>;
-    readonly fileDataSource: _angular_core.WritableSignal<FileModel[]>;
+    private readonly fileUploads;
     private _cmatMediaWatcherService;
     private _elementRef;
-    private readonly _destroyRef;
-    constructor();
+    readonly isHandSet: _angular_core.Signal<boolean>;
     onDrop(event: DragEvent): void;
     onDropOver(event: DragEvent): void;
-    ngOnChanges(changes: SimpleChanges): void;
     ngAfterViewInit(): void;
     add(file: File): void;
     upload(event: FileModel): void;
@@ -92,15 +88,14 @@ declare class CmatUploadQueueComponent implements AfterViewInit, OnChanges {
     choose(): void;
     private isFileTypeAccepted;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatUploadQueueComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatUploadQueueComponent, "cmat-upload-queue", ["cmatUploadQueue"], { "fileAlias": { "alias": "fileAlias"; "required": false; }; "filePath": { "alias": "filePath"; "required": false; }; "fileCategory": { "alias": "fileCategory"; "required": false; }; "isPublic": { "alias": "isPublic"; "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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CmatUploadQueueComponent, "cmat-upload-queue", ["cmatUploadQueue"], { "fileAlias": { "alias": "fileAlias"; "required": false; "isSignal": true; }; "filePath": { "alias": "filePath"; "required": false; "isSignal": true; }; "fileCategory": { "alias": "fileCategory"; "required": false; "isSignal": true; }; "isPublic": { "alias": "isPublic"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "autoUpload": { "alias": "autoUpload"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": false; "isSignal": true; }; "filesData": { "alias": "filesData"; "required": false; "isSignal": true; }; }, { "outputRemoveIdEvent": "outputRemoveIdEvent"; "outputUploadIdEvent": "outputUploadIdEvent"; "outputFilesDataEvent": "outputFilesDataEvent"; "filesData": "filesDataChange"; }, never, never, true, never>;
 }
 
 declare class CmatFilesUtilService {
     private _http;
     private _urlStateConfigService;
     private readonly _destroyRef;
-    private _config;
-    constructor();
+    private readonly _config;
     downloadFile(fileId: string, isStream?: boolean): Observable<HttpResponse<Blob>>;
     downloadFileZip(fileIds?: string[]): Observable<HttpResponse<Blob>>;
     uploadFile(file: FormData): Observable<HttpEvent<Record<string, unknown>>>;

package/types/cmat-components-x6-angular-shape.d.ts

@@ -1,5 +1,5 @@
 import { Node, NodeProperties, NodeView, Dom } from '@antv/x6';
-import { TemplateRef, Type, Injector } from '@angular/core';
+import { Injector, TemplateRef, Type } from '@angular/core';
 
 declare class AngularShape<Properties extends AngularShape.Properties = AngularShape.Properties> extends Node<Properties> {
 }

package/types/cmat-directives-animate-on-scroll.d.ts

@@ -1,11 +1,11 @@
-import * as i0 from '@angular/core';
+import * as _angular_core 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;
+    readonly animationName: _angular_core.InputSignal<string | null>;
+    readonly offset: _angular_core.InputSignal<number>;
+    readonly useScroll: _angular_core.InputSignal<boolean | undefined>;
+    readonly threshold: _angular_core.InputSignal<number | undefined>;
     private _offsetTop;
     private _isVisible;
     private _winHeight;
@@ -23,8 +23,8 @@ declare class CmatAnimationOnScrollDirective implements OnInit, OnDestroy, After
     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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatAnimationOnScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CmatAnimationOnScrollDirective, "[cmatAnimateOnScroll]", never, { "animationName": { "alias": "animationName"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "useScroll": { "alias": "useScroll"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { CmatAnimationOnScrollDirective };

package/types/cmat-directives-arrow-cursor.d.ts

@@ -1,37 +1,35 @@
-import * as i0 from '@angular/core';
-import { AfterViewInit, OnDestroy, EventEmitter } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
 
-declare class CmatArrowCursorDirective implements AfterViewInit, OnDestroy {
-    animationDuration: number;
-    orientation: 'horizontal' | 'vertical';
-    enabled: boolean;
-    selector: string;
-    clickEvent: EventEmitter<string | null>;
-    cursorAnimationFrame: number | null;
-    isPhone: boolean;
-    arrowCursor: HTMLDivElement | null;
-    cursorClientX: number;
-    cursorClientY: number;
-    cursorIcon: SVGElement | null;
-    cursorSide: string | null;
-    oldCursorSide: string | null;
+declare class CmatArrowCursorDirective implements OnDestroy {
+    readonly animationDuration: _angular_core.InputSignal<number>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly enabled: _angular_core.InputSignal<boolean>;
+    readonly selector: _angular_core.InputSignal<string>;
+    readonly clickEvent: _angular_core.OutputEmitterRef<string | null>;
+    private _arrowCursor;
+    private _cursorIcon;
+    private readonly _cursorAnimationFrame;
+    private readonly _cursorClientX;
+    private readonly _cursorClientY;
+    private readonly _cursorSide;
+    private readonly _oldCursorSide;
     private _document;
     private _cmatMediaWatcherService;
-    private readonly _destroyRef;
     private _isCursorActive;
     private readonly _boundMoveCursor;
+    readonly isPhone: _angular_core.Signal<boolean>;
     onMouseEnter(event: MouseEvent): void;
     onMouseLeave(event: MouseEvent): void;
     onMouseOver(event: MouseEvent): void;
     onClick(event: Event): void;
-    ngAfterViewInit(): void;
     ngOnDestroy(): void;
     moveCursor(): void;
     private _startCursorLoop;
     private _stopCursorLoop;
     private _applyCursorRotation;
-    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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatArrowCursorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CmatArrowCursorDirective, "[cmatArrowCursor]", never, { "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "selector": { "alias": "selector"; "required": false; "isSignal": true; }; }, { "clickEvent": "clickEvent"; }, never, never, true, never>;
 }
 
 export { CmatArrowCursorDirective };

package/types/cmat-directives-data-exporter.d.ts

@@ -1,4 +1,4 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { OnChanges, SimpleChanges } from '@angular/core';
 import { WritingOptions } from 'xlsx';
 
@@ -25,20 +25,20 @@ interface ExcelOptions extends Options, Omit<WritingOptions, 'bookType'> {
 
 type DataExporterItem = Record<string, unknown>;
 declare class CmatDataExporterDirective implements OnChanges {
-    dataSource: DataExporterItem[];
-    exportColumns: ExporterListInfo[];
-    options?: Options | ExcelOptions | TxtOptions;
-    exportType: ExportType | 'xls' | 'xlsx' | 'csv' | 'txt' | 'json';
-    transformBoolean: boolean;
-    transformDate: boolean;
-    dateFormat: string;
+    readonly dataSource: _angular_core.InputSignal<DataExporterItem[]>;
+    readonly exportColumns: _angular_core.InputSignal<ExporterListInfo[]>;
+    readonly options: _angular_core.InputSignal<Options | TxtOptions | ExcelOptions | undefined>;
+    readonly exportType: _angular_core.InputSignal<"xls" | "xlsx" | "csv" | "txt" | "json" | ExportType>;
+    readonly transformBoolean: _angular_core.InputSignal<boolean>;
+    readonly transformDate: _angular_core.InputSignal<boolean>;
+    readonly dateFormat: _angular_core.InputSignal<string>;
     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; }; "transformBoolean": { "alias": "transformBoolean"; "required": false; }; "transformDate": { "alias": "transformDate"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatDataExporterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CmatDataExporterDirective, "button[cmatDataExporter]", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "exportColumns": { "alias": "exportColumns"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "exportType": { "alias": "exportType"; "required": false; "isSignal": true; }; "transformBoolean": { "alias": "transformBoolean"; "required": false; "isSignal": true; }; "transformDate": { "alias": "transformDate"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { CmatDataExporterDirective, ExportType };

package/types/cmat-directives-debounce.d.ts

@@ -1,17 +1,17 @@
 import * as i0 from '@angular/core';
-import { OnInit, EventEmitter } from '@angular/core';
+import { OnInit } from '@angular/core';
 import { Subject } from 'rxjs';
 
 declare abstract class AbstractDebounceDirective implements OnInit {
-    debounceTime: number;
-    emitChanged: EventEmitter<unknown>;
+    readonly emitChanged: i0.OutputEmitterRef<unknown>;
+    readonly debounceTime: i0.InputSignal<number>;
     emitEvent$: Subject<unknown>;
     private readonly _destroyRef;
     constructor();
     ngOnInit(): void;
     emitChange(value: unknown): 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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDebounceDirective, never, never, { "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; }, { "emitChanged": "emitChanged"; }, never, never, true, never>;
 }
 
 declare class CmatDebounceClickDirective extends AbstractDebounceDirective {
@@ -25,7 +25,7 @@ declare class CmatDebounceKeyupDirective extends AbstractDebounceDirective {
     constructor();
     onKeyUp(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceKeyupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceKeyupDirective, "input[cmatDebounceKeyup]", never, {}, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceKeyupDirective, "input,textarea[cmatDebounceKeyup]", never, {}, {}, never, never, true, never>;
 }
 
 export { CmatDebounceClickDirective, CmatDebounceKeyupDirective };

package/types/cmat-directives-digit-only.d.ts

@@ -1,15 +1,15 @@
-import * as i0 from '@angular/core';
+import * as _angular_core 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;
+    readonly decimal: _angular_core.InputSignal<boolean>;
+    readonly decimalSeparator: _angular_core.InputSignal<string>;
+    readonly allowNegatives: _angular_core.InputSignal<boolean>;
+    readonly allowPaste: _angular_core.InputSignal<boolean>;
+    readonly negativeSign: _angular_core.InputSignal<string>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly pattern: _angular_core.InputSignal<string | RegExp | undefined>;
     inputElement: HTMLInputElement;
     value: string;
     el: ElementRef<HTMLInputElement>;
@@ -32,8 +32,8 @@ declare class CmatDigitOnlyDirective implements OnChanges {
     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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatDigitOnlyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CmatDigitOnlyDirective, "[cmatDigitOnly]", never, { "decimal": { "alias": "decimal"; "required": false; "isSignal": true; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; "isSignal": true; }; "allowNegatives": { "alias": "allowNegatives"; "required": false; "isSignal": true; }; "allowPaste": { "alias": "allowPaste"; "required": false; "isSignal": true; }; "negativeSign": { "alias": "negativeSign"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class CmatMaskDirective implements OnInit {
@@ -47,8 +47,8 @@ declare class CmatMaskDirective implements OnInit {
     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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatMaskDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CmatMaskDirective, "[cmatMask]", never, {}, {}, never, never, true, never>;
 }
 
 export { CmatDigitOnlyDirective, CmatMaskDirective };

package/types/cmat-directives-seamless-auto-scroll.d.ts

@@ -1,11 +1,11 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { OnInit, AfterViewInit, OnDestroy, TemplateRef } from '@angular/core';
 
 declare class CmatSeamlessAutoScrollDirective implements OnInit, AfterViewInit, OnDestroy {
-    data: unknown[];
-    speed: number;
-    direction: 'up' | 'down' | 'left' | 'right';
-    itemTemplate: TemplateRef<unknown>;
+    readonly itemTemplate: _angular_core.Signal<TemplateRef<any>>;
+    readonly data: _angular_core.InputSignal<unknown[]>;
+    readonly speed: _angular_core.InputSignal<number>;
+    readonly direction: _angular_core.InputSignal<"up" | "down" | "left" | "right">;
     private _viewContainer;
     private _containerElement;
     private _contentElement;
@@ -22,8 +22,8 @@ declare class CmatSeamlessAutoScrollDirective implements OnInit, AfterViewInit,
     private _updateAnimationParams;
     private _listenResize;
     private _getDirection;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatSeamlessAutoScrollDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatSeamlessAutoScrollDirective, "[cmatSeamlessAutoScroll]", never, { "data": { "alias": "data"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, {}, ["itemTemplate"], never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CmatSeamlessAutoScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CmatSeamlessAutoScrollDirective, "[cmatSeamlessAutoScroll]", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, ["itemTemplate"], never, true, never>;
 }
 
 export { CmatSeamlessAutoScrollDirective };