@acorex/components 16.0.2 → 17.0.1

package/common/lib/components/color-component.class.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import { AXStyleColorType } from '../classes/styles.class';
+import { MXBaseComponent } from './base-component.class';
+export declare class MXColorComponent extends MXBaseComponent {
+    colorChange: EventEmitter<AXStyleColorType>;
+    private _color;
+    /**
+     *  Predefined color schemes
+     */
+    get color(): AXStyleColorType;
+    set color(value: AXStyleColorType);
+}

package/common/lib/components/colorlook-component.class.d.ts

@@ -0,0 +1,6 @@
+import { MXColorComponent } from './color-component.class';
+import { MXLookComponent } from './look-component.class';
+declare const MXColorLookComponent_base: import("polytype").Polytype.ClusteredConstructor<[typeof MXColorComponent, typeof MXLookComponent]>;
+export declare class MXColorLookComponent extends MXColorLookComponent_base {
+}
+export {};

package/common/lib/components/input-base-value-component.class.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from '@angular/core';
+import { AXHtmlEvent } from '../classes/events.class';
+import { MXValueComponent } from './value-component.class';
+import * as i0 from "@angular/core";
+export declare class MXInputBaseValueComponent<T = string> extends MXValueComponent<T> {
+    placeholder: string;
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onKeyDown: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onKeyUp: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onKeyPress: EventEmitter<AXHtmlEvent<KeyboardEvent>>;
+    protected emitOnKeydownEvent(e: KeyboardEvent): void;
+    protected emitOnKeyupEvent(e: KeyboardEvent): void;
+    protected emitOnKeypressEvent(e: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXInputBaseValueComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXInputBaseValueComponent<any>>;
+}

package/common/lib/components/interactive-component.class.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from '@angular/core';
+import { AXFocusEvent } from '../classes/events.class';
+import { MXBaseComponent } from './base-component.class';
+export declare class MXInteractiveComponent extends MXBaseComponent {
+    protected onTouchedCallback: () => void;
+    registerOnTouched(fn: () => void): void;
+    private _touched;
+    get touched(): boolean;
+    protected markAsTouched(): void;
+    disabledChange: EventEmitter<boolean>;
+    private _disabled;
+    /**
+     *  If set to true, it disables the component.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    setDisabledState(isDisabled: boolean): void;
+    _tabIndex: number;
+    /**
+     *  Specifies the tabindex of the component.
+     */
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    /**
+     *  Fires each time the component gets focused.
+     *  @event
+     */
+    onFocus: EventEmitter<AXFocusEvent>;
+    protected emitOnFocusEvent(e: FocusEvent): void;
+    /**
+     *  Fires each time the component gets blurred.
+     *  @event
+     */
+    onBlur: EventEmitter<AXFocusEvent>;
+    protected emitOnBlurEvent(e: FocusEvent): void;
+    focus(): void;
+    blur(): void;
+    /**
+     *  Check component is focused or has any focused element.
+     */
+    hasFocus(): boolean;
+}

package/common/lib/components/look-component.class.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from '@angular/core';
+import { AXStyleLookType } from '../classes/styles.class';
+import { MXBaseComponent } from './base-component.class';
+import * as i0 from "@angular/core";
+export declare abstract class MXLookableComponent {
+    look: AXStyleLookType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXLookableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXLookableComponent>;
+}
+export declare class MXLookComponent extends MXBaseComponent {
+    lookChange: EventEmitter<AXStyleLookType>;
+    private _look?;
+    /**
+     *  Predefined look schemes
+     */
+    get look(): AXStyleLookType;
+    set look(value: AXStyleLookType);
+}

package/common/lib/components/selection-base.component.class.d.ts

@@ -0,0 +1,48 @@
+import { InjectionToken } from '@angular/core';
+import { MXValueComponent } from './value-component.class';
+import * as i0 from "@angular/core";
+export declare class MXSelectionBridgeService {
+    selectedItems: unknown[];
+    cacheList: {
+        [key: string | number]: unknown;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXSelectionBridgeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXSelectionBridgeService>;
+}
+export declare const AX_SELECTION_DATA_TOKEN: InjectionToken<MXSelectionBridgeService>;
+export declare abstract class MXSelectionValueComponent<T = unknown> extends MXValueComponent<unknown> {
+    private dataService;
+    disabledCallback: (e: {
+        item: T;
+        index: number;
+    }) => boolean;
+    private _valueField;
+    get valueField(): string;
+    set valueField(v: string);
+    private _textField;
+    get textField(): string;
+    set textField(v: string);
+    private _disabledField;
+    get disabledField(): string;
+    set disabledField(v: string);
+    private _multiple;
+    get multiple(): boolean;
+    set multiple(v: boolean);
+    get selectedItems(): unknown[];
+    internalSetValue(value: unknown): any;
+    emitOnValueChangedEvent(oldValue?: unknown, newValue?: unknown): void;
+    abstract getItemByKey(key: unknown): unknown | Promise<unknown>;
+    protected normalizeItemsList(items: unknown[], findBykey?: boolean): unknown[];
+    private normalizeItem;
+    private _normalizeSelectedItems;
+    unselectItems(...items: T[]): void;
+    selectItems(...items: T[]): void;
+    toggleSelect(...items: T[]): void;
+    isItemSelected(item: T): boolean;
+    isItemDisabled(item: T): boolean;
+    protected getDisplayText(item: T): any;
+    protected getValue(item: T): any;
+    protected clearSelectionCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXSelectionValueComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXSelectionValueComponent<any>>;
+}

package/common/lib/components/value-component.class.d.ts

@@ -0,0 +1,67 @@
+import { AXValidationSummary } from '@acorex/core/validation';
+import { EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { AXFormValidationRule } from '../classes/components.class';
+import { AXValueChangedEvent } from '../classes/events.class';
+import { AXComponentState } from './base-component.class';
+import { MXInteractiveComponent } from './interactive-component.class';
+import * as i0 from "@angular/core";
+export declare class MXValueComponent<T = any> extends MXInteractiveComponent implements ControlValueAccessor {
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onValueChanged: EventEmitter<AXValueChangedEvent<any>>;
+    /**
+     * @deprecated The event should not be used, use ngModelChange instead
+     */
+    valueChange: EventEmitter<any>;
+    readonlyChange: EventEmitter<boolean>;
+    private _readonly;
+    /**
+     *  If set to true, user cannot change the value of component.
+     */
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private _name;
+    get name(): string;
+    set name(value: string);
+    private _dirty;
+    get dirty(): boolean;
+    markAsDirty(): void;
+    private _isUserInteraction;
+    initValue: T;
+    defaultValue: T;
+    private _value;
+    /**
+     * @deprecated The property should not be used, use ngModel instead
+     */
+    get value(): T;
+    set value(v: T);
+    stateChange: EventEmitter<AXComponentState>;
+    private _state;
+    get state(): AXComponentState;
+    set state(value: AXComponentState);
+    protected emitOnValueChangedEvent(oldValue?: any, newValue?: any): void;
+    protected internalSetValue(value: any): T;
+    protected internalGetValue(value: any): T;
+    protected internalValueChanged(value: any): void;
+    protected ngOnInit(): void;
+    protected ngOnDestroy(): void;
+    protected registerValidation(): void;
+    private validationService;
+    validationRulesChange: EventEmitter<AXFormValidationRule[]>;
+    private validationRules;
+    get isRequired(): boolean;
+    addValidationRule(rule: AXFormValidationRule): void;
+    removeValidationRule(rule: AXFormValidationRule): void;
+    validate(): Promise<AXValidationSummary>;
+    protected setState(state: AXComponentState, ...args: any[]): void;
+    protected onChangeCallback: (value: T) => void;
+    registerOnChange(fn: (value: T) => void): void;
+    writeValue(value: T): void;
+    commitValue(value: T, u?: boolean): void;
+    clear(e?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXValueComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXValueComponent<any>>;
+}

package/common/lib/directives/auto-focus.directive.d.ts

@@ -0,0 +1,15 @@
+import { AfterViewInit, ElementRef, Renderer2 } from '@angular/core';
+import { AXFocusableComponent } from '../classes/components.class';
+import * as i0 from "@angular/core";
+export declare class AXAutoFocusDirective implements AfterViewInit {
+    private renderer;
+    private el;
+    _host: AXFocusableComponent;
+    autoFocus?: boolean;
+    time: number;
+    constructor(renderer: Renderer2, el: ElementRef<HTMLElement>, _host: AXFocusableComponent);
+    ngAfterViewInit(): void;
+    protected doFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXAutoFocusDirective, [null, null, { optional: true; host: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXAutoFocusDirective, "[axAutoFocus]", never, { "autoFocus": { "alias": "axAutoFocus"; "required": false; }; "time": { "alias": "axAutoFocusTime"; "required": false; }; }, {}, never, never, false, never>;
+}

package/common/lib/directives/delayed-value-changed.directive.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class AXNgModelDelayedValueChangedDirective implements OnDestroy {
+    private ngModel;
+    axDelayedValueChanged: EventEmitter<any>;
+    axDelayTimeChange: EventEmitter<number>;
+    private _delayTime;
+    get delayTime(): number;
+    set delayTime(v: number);
+    private subscription;
+    ngOnDestroy(): void;
+    constructor(ngModel: NgModel);
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXNgModelDelayedValueChangedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXNgModelDelayedValueChangedDirective, "[axDelayedValueChanged]", never, { "delayTime": { "alias": "delayTime"; "required": false; }; }, { "axDelayedValueChanged": "axDelayedValueChanged"; "axDelayTimeChange": "axDelayTimeChange"; }, never, never, true, never>;
+}

package/common/lib/directives/hotkey.directive.d.ts

@@ -0,0 +1,22 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { AXComponent } from '../classes/components.class';
+import { AXHotkeysService } from '../services/hotkey.service';
+import * as i0 from "@angular/core";
+export type AXHotKeyAction = {
+    [key: string]: string | Function;
+    parmas?: any;
+};
+export declare class AXHotkeyDirective implements AfterViewInit {
+    private el;
+    _host: AXComponent;
+    private hs;
+    axHotkey: string | AXHotKeyAction | AXHotKeyAction[];
+    private _subs;
+    constructor(el: ElementRef<HTMLElement>, _host: AXComponent, hs: AXHotkeysService);
+    ngAfterViewInit(): void;
+    private _addDefaultAction;
+    private _addHotKeyAction;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeyDirective, [null, { optional: true; host: true; self: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXHotkeyDirective, "[axHotkey]", never, { "axHotkey": { "alias": "axHotkey"; "required": false; }; }, {}, never, never, false, never>;
+}

package/common/lib/directives/infinite-scroll.directive.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface AXScrollPosition {
+    scrollHeight: number;
+    scrollTop: number;
+    clientHeight: number;
+}
+export declare class AXInfiniteScrollerDirective implements AfterViewInit {
+    private elm;
+    private scrollEvent$;
+    private userScrolledDown$;
+    private requestOnScroll$;
+    scrollCallback: Function;
+    immediateCallback: any;
+    scrollPercent: number;
+    constructor(elm: ElementRef);
+    ngAfterViewInit(): void;
+    private registerScrollEvent;
+    private streamScrollEvents;
+    private requestCallbackOnScroll;
+    private isUserScrollingDown;
+    private isScrollExpectedPercent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXInfiniteScrollerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXInfiniteScrollerDirective, "[axInfiniteScroller]", never, { "scrollCallback": { "alias": "scrollCallback"; "required": false; }; "immediateCallback": { "alias": "immediateCallback"; "required": false; }; "scrollPercent": { "alias": "scrollPercent"; "required": false; }; }, {}, never, never, false, never>;
+}

package/common/lib/directives/responsive.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AXResponsiveDirective implements OnDestroy {
+    private _elementRef;
+    private _observer;
+    constructor(_elementRef: ElementRef<HTMLDivElement>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXResponsiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXResponsiveDirective, "[axResponsive]", never, {}, {}, never, never, false, never>;
+}

package/common/lib/directives/ripple.directive.d.ts

@@ -0,0 +1,16 @@
+import { ChangeDetectorRef, ElementRef, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AXRippleDirective implements OnDestroy {
+    private el;
+    private cdr;
+    enabled?: boolean;
+    axRippleColor: string;
+    ripple: HTMLSpanElement | null;
+    constructor(el: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private onElementClick;
+    private createRipple;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXRippleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXRippleDirective, "[axRipple]", never, { "enabled": { "alias": "axRipple"; "required": false; }; "axRippleColor": { "alias": "axRippleColor"; "required": false; }; }, {}, never, never, true, never>;
+}

package/common/lib/services/dom.service.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class AXDomService {
+    generateElementId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXDomService>;
+}

package/common/lib/services/hotkey.service.d.ts

@@ -0,0 +1,31 @@
+import { EventManager } from '@angular/platform-browser';
+import { Observable } from 'rxjs/internal/Observable';
+import * as i0 from "@angular/core";
+type Options = {
+    /**
+     * element - An html element
+     */
+    element: any;
+    /**
+     * keys - string of keys like (Control.f)
+     */
+    keys: string;
+};
+export declare class AXHotkeysService {
+    private eventManager;
+    private document;
+    defaults: Partial<Options>;
+    constructor(eventManager: EventManager, document: Document);
+    /**
+     * Add shortcut
+     *
+     *
+     * @param options
+     * @returns Observable
+     *
+     */
+    addShortcut(options: Partial<Options>): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeysService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXHotkeysService>;
+}
+export {};

package/common/lib/types/direction.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A token that specifies the direction of component.
+ */
+export type AXDirection = 'vertical' | 'horizontal';

package/common/lib/types/orientation.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A token that specifies the orientation of component.
+ */
+export type AXOrientation = 'vertical' | 'horizontal';

package/common/lib/types/placement.d.ts

@@ -0,0 +1,30 @@
+export type AXPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'end' | 'end-top' | 'end-bottom' | 'start' | 'start-top' | 'start-bottom';
+export type AXPlacementType = AXConnectedPosition | AXConnectedPosition[] | AXPlacement | AXPlacement[];
+export declare function convertToPlacement(value: AXPlacementType): AXConnectedPosition[];
+export interface AXConnectedPosition {
+    originX: 'start' | 'center' | 'end';
+    originY: 'top' | 'center' | 'bottom';
+    overlayX: 'start' | 'center' | 'end';
+    overlayY: 'top' | 'center' | 'bottom';
+    weight?: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+export declare const AX_PLACEMENT_TOP: AXConnectedPosition;
+export declare const AX_PLACEMENT_TOP_START: AXConnectedPosition;
+export declare const AX_PLACEMENT_TOP_END: AXConnectedPosition;
+export declare const AX_PLACEMENT_BOTTOM: AXConnectedPosition;
+export declare const AX_PLACEMENT_BOTTOM_START: AXConnectedPosition;
+export declare const AX_PLACEMENT_BOTTOM_END: AXConnectedPosition;
+export declare const AX_PLACEMENT_START: AXConnectedPosition;
+export declare const AX_PLACEMENT_START_TOP: AXConnectedPosition;
+export declare const AX_PLACEMENT_START_BOTTOM: AXConnectedPosition;
+export declare const AX_PLACEMENT_END: AXConnectedPosition;
+export declare const AX_PLACEMENT_END_TOP: AXConnectedPosition;
+export declare const AX_PLACEMENT_END_BOTTOM: AXConnectedPosition;
+export declare const AX_PLACEMENT_MAP: {
+    [key: string]: {
+        origin: AXConnectedPosition;
+        alts?: AXConnectedPosition[];
+    };
+};

package/common/lib/types/range.d.ts

@@ -0,0 +1,4 @@
+export interface AXRange<T> {
+    from: T;
+    end: T;
+}

package/common/lib/types/selection-mode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A token that specifies the  selection mode of component.
+ */
+export type AXSelectionMode = 'single' | 'multiple' | 'none';

package/data-pager/README.md

@@ -0,0 +1,3 @@
+# @acorex/components/data-pager
+
+Secondary entry point of `@acorex/components`. It can be used by importing from `@acorex/components/data-pager`.

package/data-pager/index.d.ts

@@ -0,0 +1,9 @@
+export * from './lib/data-pager-base.component';
+export * from './lib/data-pager-info.component';
+export * from './lib/data-pager-input-selector.component';
+export * from './lib/data-pager-next-buttons.components';
+export * from './lib/data-pager-numeric-selector.component';
+export * from './lib/data-pager-pagesize-dropdown.component';
+export * from './lib/data-pager-prev-buttons.component';
+export * from './lib/data-pager.component';
+export * from './lib/data-pager.module';

package/data-pager/lib/data-pager-base.component.d.ts

@@ -0,0 +1,54 @@
+import { AXEvent, AXOptionChangedEvent, MXInteractiveComponent } from '@acorex/components/common';
+import { AXUnsubscriber } from '@acorex/core/utils';
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A token that specifies the  display mode of datapager component.
+ */
+export type AXDataPagerDisplayMode = 'full' | 'compact' | 'custom';
+export interface AXDataPagerData {
+    range: {
+        from: number;
+        to: number;
+    };
+    page: number;
+    skip: number;
+    take: number;
+    totalPages: number;
+    totalItems: number;
+}
+export declare class AXDataPagerChangedEvent extends AXEvent implements AXDataPagerData {
+    range: {
+        from: number;
+        to: number;
+    };
+    page: number;
+    skip: number;
+    take: number;
+    totalPages: number;
+    totalItems: number;
+}
+export declare abstract class AXDataPagerParentComponent {
+    abstract readonly: boolean;
+    abstract disabled: boolean;
+    abstract onChanged: EventEmitter<AXDataPagerChangedEvent>;
+    abstract onOptionChanged: EventEmitter<AXOptionChangedEvent>;
+    abstract get displayInfo(): AXDataPagerData;
+    abstract size: any;
+    abstract goNextPage(): void;
+    abstract goLastPage(): void;
+    abstract goFirstPage(): void;
+    abstract goPrevPage(): void;
+    abstract goToPage(page: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerParentComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXDataPagerParentComponent>;
+}
+export declare abstract class AXDataPagerChild extends MXInteractiveComponent {
+    protected _parent: AXDataPagerParentComponent;
+    protected _unsubscriber: AXUnsubscriber;
+    constructor();
+    ngAfterViewInit(): void;
+    protected abstract applyParent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerChild, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXDataPagerChild>;
+}

package/data-pager/lib/data-pager-info.component.d.ts

@@ -0,0 +1,11 @@
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXDataPagerChild } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerInfoComponent extends AXDataPagerChild {
+    text: string;
+    protected _textFormatted: string;
+    protected translateService: AXTranslationService;
+    protected applyParent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerInfoComponent, "ax-data-pager-info", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
+}

package/data-pager/lib/data-pager-input-selector.component.d.ts

@@ -0,0 +1,11 @@
+import { AXValueChangedEvent } from '@acorex/components/common';
+import { AXDataPagerChild } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerInputSelectorComponent extends AXDataPagerChild {
+    protected _totalPages: number;
+    protected _currentPage: number;
+    protected applyParent(): void;
+    protected _handleValueChanged(e: AXValueChangedEvent<number>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerInputSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerInputSelectorComponent, "ax-data-pager-input-selector", never, {}, {}, never, never, false, never>;
+}

package/data-pager/lib/data-pager-next-buttons.components.d.ts

@@ -0,0 +1,10 @@
+import { AXClickEvent } from '@acorex/components/common';
+import { AXDataPagerChild } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerNextButtonsComponent extends AXDataPagerChild {
+    protected applyParent(): void;
+    _emitOnLastPageClick(e: AXClickEvent): void;
+    _emitOnNextPageClick(e: AXClickEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerNextButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerNextButtonsComponent, "ax-data-pager-next-buttons", never, {}, {}, never, never, false, never>;
+}

package/data-pager/lib/data-pager-numeric-selector.component.d.ts

@@ -0,0 +1,13 @@
+import { AXButtonItem } from '@acorex/components/button';
+import { AXDataPagerChild } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerNumericSelectorComponent extends AXDataPagerChild {
+    _items: AXButtonItem[];
+    _currentPage: number;
+    _lastPage: number;
+    private _displayCount;
+    protected applyParent(): void;
+    _handleOnItemClick(e: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerNumericSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerNumericSelectorComponent, "ax-data-pager-numeric-selector", never, {}, {}, never, never, false, never>;
+}

package/data-pager/lib/data-pager-pagesize-dropdown.component.d.ts

@@ -0,0 +1,14 @@
+import { AXClickEvent } from '@acorex/components/common';
+import { AXDataPagerChild } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerPageSizesComponent extends AXDataPagerChild {
+    _size: number;
+    _items: any[];
+    private _sizes;
+    get sizes(): number[];
+    set sizes(v: number[]);
+    protected applyParent(): void;
+    _emitOnItemClick(e: AXClickEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerPageSizesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerPageSizesComponent, "ax-data-pager-page-sizes", never, { "sizes": { "alias": "sizes"; "required": false; }; }, {}, never, never, false, never>;
+}

package/data-pager/lib/data-pager-prev-buttons.component.d.ts

@@ -0,0 +1,10 @@
+import { AXClickEvent } from '@acorex/components/common';
+import { AXDataPagerChild } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerPrevButtonsComponent extends AXDataPagerChild {
+    protected applyParent(): void;
+    _emitOnFirstPageClick(e: AXClickEvent): void;
+    _emitOnPrevPageClick(e: AXClickEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerPrevButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerPrevButtonsComponent, "ax-data-pager-prev-buttons", never, {}, {}, never, never, false, never>;
+}

package/data-pager/lib/data-pager.component.d.ts

@@ -0,0 +1,34 @@
+import { AXPagedComponent, MXValueComponent } from '@acorex/components/common';
+import { EventEmitter } from '@angular/core';
+import { AXDataPagerChangedEvent, AXDataPagerData } from './data-pager-base.component';
+import * as i0 from "@angular/core";
+export declare class AXDataPagerComponent extends MXValueComponent<number> {
+    private _parent;
+    private _size;
+    get size(): number;
+    set size(v: number);
+    private _total;
+    get total(): number;
+    set total(v: number);
+    private _totalPages;
+    get totalPages(): number;
+    private set totalPages(value);
+    displayModeChange: EventEmitter<string>;
+    private _displayMode;
+    get displayMode(): string;
+    set displayMode(v: string);
+    onChanged: EventEmitter<AXDataPagerChangedEvent>;
+    constructor(_parent: AXPagedComponent);
+    ngAfterViewInit(): void;
+    protected internalValueChanged(value: any): void;
+    protected internalGetValue(value: any): number;
+    get displayInfo(): AXDataPagerData;
+    private _emitChangedEvent;
+    goNextPage(): void;
+    goLastPage(): void;
+    goFirstPage(): void;
+    goPrevPage(): void;
+    goToPage(page: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXDataPagerComponent, "ax-data-pager", never, { "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "size": { "alias": "size"; "required": false; }; "total": { "alias": "total"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; }, { "valueChange": "valueChange"; "onValueChanged": "onValueChanged"; "disabledChange": "disabledChange"; "readonlyChange": "readonlyChange"; "displayModeChange": "displayModeChange"; "onChanged": "onChanged"; }, never, ["ax-prefix", "ax-suffix"], false, never>;
+}

package/data-pager/lib/data-pager.module.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./data-pager.component";
+import * as i2 from "./data-pager-next-buttons.components";
+import * as i3 from "./data-pager-prev-buttons.component";
+import * as i4 from "./data-pager-pagesize-dropdown.component";
+import * as i5 from "./data-pager-numeric-selector.component";
+import * as i6 from "./data-pager-input-selector.component";
+import * as i7 from "./data-pager-info.component";
+import * as i8 from "@angular/common";
+import * as i9 from "@angular/forms";
+import * as i10 from "@acorex/components/button";
+import * as i11 from "@acorex/components/button-group";
+import * as i12 from "@acorex/components/number-box";
+import * as i13 from "@acorex/components/dropdown";
+import * as i14 from "@acorex/components/decorators";
+import * as i15 from "@acorex/core/translation";
+export declare class AXDataPagerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDataPagerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXDataPagerModule, [typeof i1.AXDataPagerComponent, typeof i2.AXDataPagerNextButtonsComponent, typeof i3.AXDataPagerPrevButtonsComponent, typeof i4.AXDataPagerPageSizesComponent, typeof i5.AXDataPagerNumericSelectorComponent, typeof i6.AXDataPagerInputSelectorComponent, typeof i7.AXDataPagerInfoComponent], [typeof i8.CommonModule, typeof i9.FormsModule, typeof i10.AXButtonModule, typeof i11.AXButtonGroupModule, typeof i12.AXNumberBoxModule, typeof i13.AXDropdownModule, typeof i14.AXDecoratorModule, typeof i15.AXTranslationModule], [typeof i1.AXDataPagerComponent, typeof i2.AXDataPagerNextButtonsComponent, typeof i3.AXDataPagerPrevButtonsComponent, typeof i4.AXDataPagerPageSizesComponent, typeof i5.AXDataPagerNumericSelectorComponent, typeof i6.AXDataPagerInputSelectorComponent, typeof i7.AXDataPagerInfoComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXDataPagerModule>;
+}