@ngflux/ngflux 1.0.0

package/types/ngflux-ngflux.d.ts

@@ -0,0 +1,254 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, ViewContainerRef, Injector } from '@angular/core';
+import * as _ngflux_ngflux from '@ngflux/ngflux';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+
+type ButtonDirection = 'normal' | 'reversed';
+type ButtonTheme = 'default' | 'primary' | 'secondary' | 'error' | 'danger' | 'success' | 'warning' | 'info' | 'light' | 'dark';
+type ButtonType = 'submit' | 'button' | 'reset' | 'menu';
+type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type ButtonOptions = {
+    icon?: string;
+    text: string;
+    theme?: ButtonTheme;
+    direction?: ButtonDirection;
+    size?: ButtonSize;
+};
+
+interface NgFluxComponent<T = any> {
+    new (...args: any[]): T;
+}
+
+type Pagination<T = any> = {
+    currentPage: number;
+    from: number;
+    lastPage: number;
+    perPage: number;
+    to: number;
+    total: number;
+    data: T[];
+};
+type PaginationTransformer<T = any> = {
+    getCurrentPage: (data: any) => number;
+    getFrom: (data: any) => number;
+    getLastPage: (data: any) => number;
+    getPerPage: (data: any) => number;
+    getTo: (data: any) => number;
+    getTotal: (data: any) => number;
+    getData: (data: any) => T[];
+};
+type PaginationInfo = {
+    limit: number;
+    page: number;
+};
+
+type LoadingOptions = {
+    component?: NgFluxComponent;
+};
+type DialogAlertOptions = {
+    okayButton?: ButtonOptions;
+};
+type DialogConfirmOptions = {
+    okayButton?: ButtonOptions;
+    cancelButton?: ButtonOptions;
+};
+type DialogPromptOptions = {
+    submitButton?: ButtonOptions;
+    cancelButton?: ButtonOptions;
+};
+type DialogOptions = {
+    alert?: DialogAlertOptions;
+    confirm?: DialogConfirmOptions;
+    prompt?: DialogPromptOptions;
+};
+type PaginationOptions = {
+    preload?: boolean;
+    transform?: PaginationTransformer;
+    limitEntries?: number[];
+    limit?: number;
+};
+type NgFluxConfig = {
+    loading?: LoadingOptions;
+    dialog?: DialogOptions;
+    pagination?: PaginationOptions;
+};
+declare const NGF_CONFIG: InjectionToken<NgFluxConfig>;
+
+type OnClosed<T = any> = (cmd: NgFluxDialogCommand<T>) => void;
+declare class NgFluxDialogRef<T = any> {
+    private readonly onClosed;
+    constructor(onClosed: OnClosed<T>);
+    readonly close: (value?: T) => void;
+}
+
+type NgFluxDialogRoot = {
+    viewContainer: Signal<ViewContainerRef>;
+    injector: Injector;
+};
+type NgFluxDialogConfig = {
+    closeOnEsc?: boolean;
+    closeOnBackBtn?: boolean;
+    backdropClose?: boolean;
+    closeBtn?: boolean;
+    data?: any;
+};
+type NgFluxDialogCommand<T = any> = {
+    name: string;
+    value?: T;
+};
+declare const NGF_DIALOG_DATA: InjectionToken<any>;
+type NgFluxDialogEvents<T = any> = {
+    readonly closing: Observable<T | null>;
+    readonly closed: Observable<T | null>;
+};
+type NgFluxDialogButtonObj<T = any> = ButtonOptions & {
+    onClick?: (e: MouseEvent, btn: NgFluxDialogButton<T>, dialogRef: NgFluxDialogRef<T>) => void;
+    disabled?: () => boolean;
+};
+type NgFluxDialogButton<T = any> = 'flex' | NgFluxDialogButtonObj<T>;
+type NgFluxDialogAlertOptions = {
+    title: string;
+    content: string;
+    buttons?: NgFluxDialogButton<boolean>[];
+};
+type NgFluxDialogConfirmOptions = {
+    title: string;
+    content: string;
+    okayButton?: NgFluxDialogButtonObj;
+    cancelButton?: NgFluxDialogButtonObj;
+};
+type NgFluxDialogPromptOptions = {
+    title: string;
+    content: string;
+    submitButton?: NgFluxDialogButtonObj;
+    cancelButton?: NgFluxDialogButtonObj;
+};
+
+type NgFluxLoadingEntry = {
+    text: string;
+};
+
+declare const provideNgFlux: (config?: NgFluxConfig) => _angular_core.EnvironmentProviders;
+
+declare class NgFluxRootComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxRootComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxRootComponent, "ngf-root", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NgFluxButton {
+    private readonly ref;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly theme: _angular_core.InputSignal<ButtonTheme | undefined>;
+    readonly type: _angular_core.InputSignal<ButtonType | undefined>;
+    readonly size: _angular_core.InputSignal<ButtonSize | undefined>;
+    readonly direction: _angular_core.InputSignal<ButtonDirection | undefined>;
+    readonly block: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly btnClassNames: _angular_core.Signal<string[]>;
+    readonly classNames: _angular_core.Signal<string>;
+    get bindClass(): string;
+    get isBlock(): boolean;
+    get isDisabled(): boolean;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxButton, "ngf-button", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NgFluxDialogBodyComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxDialogBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxDialogBodyComponent, "ngf-dialog-body", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NgFluxDialogFooterComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxDialogFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxDialogFooterComponent, "ngf-dialog-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NgFluxLoading {
+    private readonly internal;
+    readonly data: _angular_core.Signal<_ngflux_ngflux.NgFluxLoadingEntry | undefined>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    start(text?: string): void;
+    stop(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxLoading, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgFluxLoading>;
+}
+
+declare class NgFluxDialog {
+    private readonly internal;
+    open<T = any>(component: NgFluxComponent<any>, config?: NgFluxDialogConfig): NgFluxDialogEvents<T>;
+    readonly closeAll: () => void;
+    alert(title: string, content: string, buttons?: NgFluxDialogButton[]): rxjs.Observable<boolean | null>;
+    success(title: string, message: string, buttons?: NgFluxDialogButton[]): rxjs.Observable<boolean | null>;
+    error(title: string, message: string, buttons?: NgFluxDialogButton[]): rxjs.Observable<boolean | null>;
+    confirm(data: NgFluxDialogConfirmOptions): rxjs.Observable<any>;
+    prompt(data: NgFluxDialogPromptOptions): rxjs.Observable<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxDialog, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgFluxDialog>;
+}
+
+type OnClosedFn<T = any> = (ins: NgFluxDialogInstance<T>) => void;
+declare class NgFluxDialogInstance<T = any> {
+    private readonly viewContainer;
+    private readonly component;
+    private readonly injector;
+    private readonly onClosed;
+    readonly config: NgFluxDialogConfig;
+    private readonly xDialogComponentRef;
+    private readonly xClosing;
+    private readonly xAfterClosed;
+    readonly events: NgFluxDialogEvents<T>;
+    constructor(viewContainer: ViewContainerRef, component: NgFluxComponent<any>, injector: Injector, onClosed: OnClosedFn<T>, config: NgFluxDialogConfig);
+    private readonly onCommand;
+    private readonly afterClosedFn;
+    focus(): void;
+    close(data?: T): void;
+    send(cmd: NgFluxDialogCommand<T>): void;
+}
+
+declare class NgFluxDialogHeaderComponent {
+    readonly config: _ngflux_ngflux.NgFluxDialogConfig;
+    readonly dialogRef: NgFluxDialogRef<unknown>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxDialogHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxDialogHeaderComponent, "ngf-dialog-header", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NgFluxDialogRootComponent {
+    private readonly internal;
+    readonly injector: Injector;
+    readonly viewContainer: _angular_core.Signal<ViewContainerRef>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxDialogRootComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxDialogRootComponent, "ngf-dialog-root", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgFluxLoadingRootComponent {
+    private readonly config;
+    private readonly internal;
+    private readonly injector;
+    get isLoading(): boolean;
+    readonly viewContainer: _angular_core.Signal<ViewContainerRef>;
+    private componentRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxLoadingRootComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxLoadingRootComponent, "ngf-loading-root", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgFluxPagination {
+    private readonly config;
+    readonly data: _angular_core.InputSignal<any>;
+    readonly preload: _angular_core.InputSignal<boolean>;
+    readonly transform: _angular_core.InputSignal<PaginationTransformer | undefined>;
+    readonly limit: _angular_core.ModelSignal<number>;
+    readonly limitEntries: _angular_core.InputSignal<number[]>;
+    readonly callback: _angular_core.OutputEmitterRef<PaginationInfo>;
+    protected readonly value: _angular_core.Signal<Pagination>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFluxPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgFluxPagination, "ngf-pagination", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "preload": { "alias": "preload"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "limitEntries": { "alias": "limitEntries"; "required": false; "isSignal": true; }; }, { "limit": "limitChange"; "callback": "callback"; }, never, ["*"], true, never>;
+}
+
+export { NGF_CONFIG, NGF_DIALOG_DATA, NgFluxButton, NgFluxDialog, NgFluxDialogBodyComponent, NgFluxDialogFooterComponent, NgFluxDialogHeaderComponent, NgFluxDialogInstance, NgFluxDialogRef, NgFluxDialogRootComponent, NgFluxLoading, NgFluxLoadingRootComponent, NgFluxPagination, NgFluxRootComponent, provideNgFlux };
+export type { ButtonDirection, ButtonOptions, ButtonSize, ButtonTheme, ButtonType, NgFluxComponent, NgFluxConfig, NgFluxDialogAlertOptions, NgFluxDialogButton, NgFluxDialogButtonObj, NgFluxDialogCommand, NgFluxDialogConfig, NgFluxDialogConfirmOptions, NgFluxDialogEvents, NgFluxDialogPromptOptions, NgFluxDialogRoot, NgFluxLoadingEntry, Pagination, PaginationInfo, PaginationTransformer };