@webilix/ngx-table-m3 0.0.1

package/lib/filters/date/filter-date.component.d.ts

@@ -0,0 +1,13 @@
+import { IViewConfig } from '../../views';
+import { IFilterDate } from './filter-date.interface';
+import * as i0 from "@angular/core";
+export declare class FilterDateComponent {
+    data: {
+        filter: IFilterDate;
+        viewConfig: IViewConfig;
+    };
+    value?: Date;
+    onChange: (value?: Date) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterDateComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/filters/date/filter-date.interface.d.ts

@@ -0,0 +1,16 @@
+import { FilterMethods } from '../filter.interface';
+export interface IFilterDate {
+    readonly type: 'DATE';
+    readonly minDate?: Date;
+    readonly maxDate?: Date;
+    readonly toParam?: (value: Date) => string;
+}
+export declare class FilterDateMethods<T> extends FilterMethods<IFilterDate, Date> {
+    toParam(value: Date): string;
+    value(value: string, filter: IFilterDate): Date | undefined;
+    query(value: Date): string;
+    active(value: Date, filter: IFilterDate): {
+        value: string;
+        english: boolean;
+    };
+}

package/lib/filters/filter.component.d.ts

@@ -0,0 +1,35 @@
+import { Injector, OnInit } from '@angular/core';
+import { IViewConfig } from '../views';
+import { IFilter } from './filter.interface';
+import * as i0 from "@angular/core";
+export declare class FilterComponent implements OnInit {
+    data: {
+        filter: IFilter;
+        viewConfig: IViewConfig;
+    };
+    closeContainer: (response?: any) => void;
+    filterInfo: {
+        DATE: {
+            readonly methods: import("./filter.interface").FilterMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+        "MULTI-SELECT": {
+            readonly methods: import("./filter.interface").FilterMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+        SEARCH: {
+            readonly methods: import("./filter.interface").FilterMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+        SELECT: {
+            readonly methods: import("./filter.interface").FilterMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+    };
+    value?: any;
+    injector: Injector;
+    ngOnInit(): void;
+    onKeydown(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent, "filter", never, {}, {}, never, never, true, never>;
+}

package/lib/filters/filter.info.d.ts

@@ -0,0 +1,8 @@
+import { ComponentType } from '@angular/cdk/portal';
+import { Filter, FilterMethods } from '.';
+export declare const FilterInfo: {
+    [key in Filter['type']]: {
+        readonly methods: FilterMethods<any, any>;
+        readonly component: ComponentType<any>;
+    };
+};

package/lib/filters/filter.interface.d.ts

@@ -0,0 +1,24 @@
+import { InjectionToken } from '@angular/core';
+import { IViewConfig } from '../views';
+import { IFilterDate, IFilterMultiSelect, IFilterSearch, IFilterSelect } from '.';
+export type Filter = IFilterDate | IFilterMultiSelect | IFilterSearch | IFilterSelect;
+export interface IFilter {
+    readonly filter: Filter;
+    readonly title: string;
+    readonly value?: any;
+}
+export declare abstract class FilterMethods<F /** FILTER **/, V /** VALUE **/> {
+    abstract toParam(value: V): string;
+    abstract value(value: string, filter: F): V | undefined;
+    abstract query(value: V): string;
+    abstract active(value: V, filter: F): {
+        value: string;
+        english: boolean;
+    };
+}
+export declare const FILTER_DATA: InjectionToken<{
+    filter: any;
+    viewConfig: IViewConfig;
+}>;
+export declare const FILTER_VALUE: InjectionToken<any>;
+export declare const FILTER_CHANGE: InjectionToken<(value?: any) => void>;

package/lib/filters/filter.service.d.ts

@@ -0,0 +1,18 @@
+import { ActivatedRoute } from '@angular/router';
+import { NgxHelperContainerService } from '@webilix/ngx-helper-m3';
+import { IViewConfig } from '../views';
+import { INgxTable } from '../ngx-table.interface';
+import { IFilter } from './filter.interface';
+import * as i0 from "@angular/core";
+export type Filters = {
+    [key: string]: IFilter;
+};
+export declare class FilterService {
+    private readonly activatedRoute;
+    private readonly ngxHelperContainerService;
+    constructor(activatedRoute: ActivatedRoute, ngxHelperContainerService: NgxHelperContainerService);
+    getFilters<T>(ngxTable: INgxTable<T>): Filters;
+    updateFilter(filter: IFilter, viewConfig: IViewConfig): Promise<IFilter | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilterService>;
+}

package/lib/filters/index.d.ts

@@ -0,0 +1,10 @@
+export * from './date/filter-date.component';
+export * from './date/filter-date.interface';
+export * from './multi-select/filter-multi-select.component';
+export * from './multi-select/filter-multi-select.interface';
+export * from './search/filter-search.component';
+export * from './search/filter-search.interface';
+export * from './select/filter-select.component';
+export * from './select/filter-select.interface';
+export * from './filter.component';
+export * from './filter.interface';

package/lib/filters/multi-select/filter-multi-select.component.d.ts

@@ -0,0 +1,14 @@
+import { IViewConfig } from '../../views';
+import { IFilterMultiSelect } from './filter-multi-select.interface';
+import * as i0 from "@angular/core";
+export declare class FilterMultiSelectComponent {
+    data: {
+        filter: IFilterMultiSelect;
+        viewConfig: IViewConfig;
+    };
+    value?: string[];
+    onChange: (value?: string[]) => void;
+    updateValue(id: string, checked: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterMultiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterMultiSelectComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/filters/multi-select/filter-multi-select.interface.d.ts

@@ -0,0 +1,19 @@
+import { FilterMethods } from '../filter.interface';
+export interface IFilterMultiSelect {
+    readonly type: 'MULTI-SELECT';
+    readonly options: {
+        readonly id: string;
+        readonly title: string;
+    }[];
+    readonly english?: boolean;
+    readonly toParam?: (value: string[]) => string;
+}
+export declare class FilterMultiSelectMethods<T> extends FilterMethods<IFilterMultiSelect, string[]> {
+    toParam(value: string[]): string;
+    value(value: string, filter: IFilterMultiSelect): string[] | undefined;
+    query(value: string[]): string;
+    active(value: string[], filter: IFilterMultiSelect): {
+        value: string;
+        english: boolean;
+    };
+}

package/lib/filters/search/filter-search.component.d.ts

@@ -0,0 +1,20 @@
+import { AfterViewInit } from '@angular/core';
+import { IViewConfig } from '../../views';
+import { IFilterSearch, IFilterSearchValue } from './filter-search.interface';
+import * as i0 from "@angular/core";
+export declare class FilterSearchComponent implements AfterViewInit {
+    private searchInput?;
+    data: {
+        filter: IFilterSearch;
+        viewConfig: IViewConfig;
+    };
+    value?: IFilterSearchValue;
+    onChange: (value?: IFilterSearchValue) => void;
+    query?: string;
+    mode?: 'PHRASE' | 'ALL' | 'EACH';
+    ngAfterViewInit(): void;
+    updateQuery(query: string): void;
+    updateMode(mode: 'PHRASE' | 'ALL' | 'EACH'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSearchComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/filters/search/filter-search.interface.d.ts

@@ -0,0 +1,20 @@
+import { FilterMethods } from '../filter.interface';
+export interface IFilterSearchValue {
+    readonly query: string;
+    readonly mode: 'PHRASE' | 'ALL' | 'EACH';
+}
+export interface IFilterSearch {
+    readonly type: 'SEARCH';
+    readonly mode?: 'PHRASE' | 'ALL' | 'EACH';
+    readonly english?: boolean;
+    readonly toParam?: (value: IFilterSearchValue) => string;
+}
+export declare class FilterSearchMethods<T> extends FilterMethods<IFilterSearch, IFilterSearchValue> {
+    toParam(value: IFilterSearchValue): string;
+    value(value: string, filter: IFilterSearch): IFilterSearchValue | undefined;
+    query(value: IFilterSearchValue): string;
+    active(value: IFilterSearchValue, filter: IFilterSearch): {
+        value: string;
+        english: boolean;
+    };
+}

package/lib/filters/select/filter-select.component.d.ts

@@ -0,0 +1,13 @@
+import { IViewConfig } from '../../views';
+import { IFilterSelect } from './filter-select.interface';
+import * as i0 from "@angular/core";
+export declare class FilterSelectComponent {
+    data: {
+        filter: IFilterSelect;
+        viewConfig: IViewConfig;
+    };
+    value?: string;
+    onChange: (value?: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSelectComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/filters/select/filter-select.interface.d.ts

@@ -0,0 +1,19 @@
+import { FilterMethods } from '../filter.interface';
+export interface IFilterSelect {
+    readonly type: 'SELECT';
+    readonly options: {
+        readonly id: string;
+        readonly title: string;
+    }[];
+    readonly english?: boolean;
+    readonly toParam?: (value: string) => string;
+}
+export declare class FilterSelectMethods<T> extends FilterMethods<IFilterSelect, string> {
+    toParam(value: string): string;
+    value(value: string, filter: IFilterSelect): string | undefined;
+    query(value: string): string;
+    active(value: string, filter: IFilterSelect): {
+        value: string;
+        english: boolean;
+    };
+}

package/lib/ngx-table.component.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { IViewConfig, IViewFilter, IViewOrder } from './views';
+import { FilterService } from './filters/filter.service';
+import { ViewService } from './views/view.service';
+import { INgxTableConfig } from './ngx-table.config';
+import { INgxTable, INgxTableFilter, INgxTablePagination } from './ngx-table.interface';
+import * as i0 from "@angular/core";
+export declare class NgxTableComponent<T> implements OnInit, OnChanges {
+    private readonly activatedRoute;
+    private readonly router;
+    private readonly filterService;
+    private readonly viewService;
+    private readonly config?;
+    loading: boolean;
+    ngxTable: INgxTable<T>;
+    data: T[];
+    pagination?: INgxTablePagination | null;
+    filterChanged: EventEmitter<INgxTableFilter>;
+    isMobile: boolean;
+    loaderClass: string;
+    emptyClass: string;
+    viewConfig: IViewConfig;
+    private filter;
+    hasFilter: boolean;
+    constructor(activatedRoute: ActivatedRoute, router: Router, filterService: FilterService, viewService: ViewService, config?: Partial<INgxTableConfig> | undefined);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onResize(): void;
+    setQueryParams(): void;
+    pageChanged(page: number): void;
+    orderChanged(order: IViewOrder): void;
+    filterItemChanged(filter: IViewFilter): void;
+    filterCleared(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTableComponent<any>, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxTableComponent<any>, "ngx-table", never, { "loading": { "alias": "loading"; "required": true; }; "ngxTable": { "alias": "ngxTable"; "required": true; }; "data": { "alias": "data"; "required": true; }; "pagination": { "alias": "pagination"; "required": false; }; }, { "filterChanged": "filterChanged"; }, never, never, true, never>;
+}

package/lib/ngx-table.config.d.ts

@@ -0,0 +1,45 @@
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+export interface INgxTableConfig {
+    readonly mobileWidth: number;
+    readonly alternateRows: boolean;
+    readonly iconSize: number;
+    readonly cssClasses: {
+        readonly loader?: string;
+        readonly empty?: string;
+        readonly en?: string;
+        readonly deactive?: string;
+    };
+    readonly colors: {
+        readonly border?: string;
+        readonly background?: string;
+        readonly headerText?: string;
+        readonly headerBackground?: string;
+        readonly oddRowsBackground?: string;
+        readonly evenRowsBackground?: string;
+        readonly cardBackground?: string;
+        readonly paginationBackground?: string;
+        readonly highlightText?: string;
+        readonly highlightBackground?: string;
+        readonly inputText?: string;
+        readonly inputBackground?: string;
+    };
+    readonly action: {
+        readonly buttonSize?: string;
+        readonly buttonColor?: string;
+        readonly menuColor?: string;
+        readonly warnColor?: string;
+        readonly menuTitle?: string;
+    };
+    readonly stickyView: {
+        readonly headerTop?: string | {
+            readonly desktopView: string;
+            readonly mobileView: string;
+        };
+        readonly paginationBottom?: string | {
+            readonly desktopView: string;
+            readonly mobileView: string;
+        };
+    };
+}
+export declare const NGX_TABLE_CONFIG: InjectionToken<Partial<INgxTableConfig>>;
+export declare const provideNgxTableConfig: (config: Partial<INgxTableConfig>) => EnvironmentProviders;

package/lib/ngx-table.interface.d.ts

@@ -0,0 +1,43 @@
+import { IAction, IActionDelete, IActionLog, IActionStatus, IActionUpdate, IColumnDate, IColumnDuration, IColumnMobile, IColumnNumber, IColumnText } from './columns';
+export type NgxTableColumn<T> = IColumnDate<T> | IColumnDuration<T> | IColumnMobile<T> | IColumnNumber<T> | IColumnText<T>;
+export type NgxTableAction<T> = 'DIVIDER' | IAction<T> | IActionUpdate<T> | IActionDelete<T> | IActionStatus<T> | IActionLog<T>;
+export interface INgxTable<T> {
+    readonly route?: string[];
+    readonly type: string;
+    readonly columns: NgxTableColumn<T>[];
+    readonly rows?: {
+        readonly icon?: (data: T) => string | {
+            icon: string;
+            color: string;
+        };
+        readonly color?: (data: T) => string;
+        readonly description?: (data: T) => string | undefined;
+        readonly isDeactive?: (data: T) => boolean;
+    };
+    readonly actions?: NgxTableAction<T>[];
+    readonly mobileView?: boolean;
+}
+export interface INgxTableFilter {
+    readonly page: number;
+    readonly order?: {
+        readonly id: string;
+        readonly type: 'ASC' | 'DESC';
+        readonly param: string;
+    };
+    readonly filter: {
+        [id: string]: {
+            readonly value: any;
+            readonly param: string;
+        };
+    };
+}
+export interface INgxTablePagination {
+    readonly item: {
+        readonly perPage: number;
+        readonly total: number;
+    };
+    readonly page: {
+        readonly current: number;
+        readonly total: number;
+    };
+}

package/lib/views/action/view-action.component.d.ts

@@ -0,0 +1,27 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { Router } from '@angular/router';
+import { NgxTableAction } from '../../ngx-table.interface';
+import { IViewConfig } from '../view.interface';
+import * as i0 from "@angular/core";
+interface Action<T> {
+    readonly title: string;
+    readonly icon: string;
+    readonly action: (data: T) => string[] | void;
+    readonly color: string;
+    readonly isDisabled: boolean;
+}
+export declare class ViewActionComponent<T> implements OnChanges {
+    private readonly router;
+    actions: NgxTableAction<T>[];
+    item: T;
+    viewConfig: IViewConfig;
+    isMobile: boolean;
+    inRow: Action<T>[];
+    inMenu: ('DIVIDER' | Action<T>)[];
+    constructor(router: Router);
+    ngOnChanges(changes: SimpleChanges): void;
+    onClick(action: (data: T) => string[] | void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewActionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewActionComponent<any>, "view-action", never, { "actions": { "alias": "actions"; "required": true; }; "item": { "alias": "item"; "required": true; }; "viewConfig": { "alias": "viewConfig"; "required": true; }; "isMobile": { "alias": "isMobile"; "required": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/views/card/toolbar/view-card-toolbar.component.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { Filters } from '../../../filters/filter.service';
+import { IViewConfig, IViewOrder } from '../../view.interface';
+import { Orders } from '../../view.service';
+import * as i0 from "@angular/core";
+export declare class ViewCardToolbarComponent implements OnChanges {
+    orders: Orders;
+    filters: Filters;
+    viewConfig: IViewConfig;
+    orderChanged: EventEmitter<IViewOrder>;
+    updateFilter: EventEmitter<string>;
+    clearFilter: EventEmitter<void>;
+    orderKeys: string[];
+    filterKeys: string[];
+    showClear: boolean;
+    private swipeStart?;
+    private swipeLeft;
+    ngOnChanges(changes: SimpleChanges): void;
+    updateOrder(id: string, type: 'ASC' | 'DESC'): void;
+    swipe(event: MouseEvent | TouchEvent, action: 'START' | 'MOVE' | 'END', toolbar: HTMLElement, container: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewCardToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewCardToolbarComponent, "view-card-toolbar", never, { "orders": { "alias": "orders"; "required": true; }; "filters": { "alias": "filters"; "required": true; }; "viewConfig": { "alias": "viewConfig"; "required": true; }; }, { "orderChanged": "orderChanged"; "updateFilter": "updateFilter"; "clearFilter": "clearFilter"; }, never, never, true, never>;
+}

package/lib/views/card/view-card.component.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { INgxTable } from '../../ngx-table.interface';
+import { Filters, FilterService } from '../../filters/filter.service';
+import { Orders, ViewService } from '../view.service';
+import { IViewConfig, IViewFilter, IViewOrder } from '..';
+import * as i0 from "@angular/core";
+export declare class ViewCardComponent<T> implements OnChanges {
+    private readonly filterService;
+    private readonly viewService;
+    private toolbarHeight;
+    ngxTable: INgxTable<T>;
+    data: T[];
+    viewConfig: IViewConfig;
+    orderChanged: EventEmitter<IViewOrder>;
+    filterChanged: EventEmitter<IViewFilter>;
+    filterCleared: EventEmitter<void>;
+    hasIcon: boolean;
+    hasAction: boolean;
+    titleIndex: number;
+    subTitleIndex?: number;
+    icons: {
+        icon: string;
+        color?: string;
+    }[];
+    colors: string[];
+    descriptions: (string | undefined)[];
+    deactives: number[];
+    orders: Orders;
+    filters: Filters;
+    hasToolbar: boolean;
+    headerTop: string;
+    hasContent: boolean;
+    constructor(filterService: FilterService, viewService: ViewService);
+    ngOnChanges(changes: SimpleChanges): void;
+    updateFilter(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewCardComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewCardComponent<any>, "view-card", never, { "ngxTable": { "alias": "ngxTable"; "required": true; }; "data": { "alias": "data"; "required": true; }; "viewConfig": { "alias": "viewConfig"; "required": true; }; }, { "orderChanged": "orderChanged"; "filterChanged": "filterChanged"; "filterCleared": "filterCleared"; }, never, never, true, never>;
+}

package/lib/views/index.d.ts

@@ -0,0 +1,4 @@
+export * from './card/view-card.component';
+export * from './pagination/view-pagination.component';
+export * from './table/view-table.component';
+export * from './view.interface';

package/lib/views/pagination/view-pagination.component.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { INgxTablePagination } from '../../ngx-table.interface';
+import { IViewConfig } from '..';
+import * as i0 from "@angular/core";
+export declare class ViewPaginationComponent implements OnInit, OnChanges {
+    private readonly elementRef;
+    private stylePosition;
+    private styleBottom;
+    type: string;
+    pagination: INgxTablePagination;
+    viewConfig: IViewConfig;
+    isMobile: boolean;
+    stickyBottom?: {
+        desktopView: string;
+        mobileView: string;
+    };
+    pageChanged: EventEmitter<number>;
+    pages: number[];
+    hasShadow: boolean;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onScroll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewPaginationComponent, "view-pagination", never, { "type": { "alias": "type"; "required": true; }; "pagination": { "alias": "pagination"; "required": true; }; "viewConfig": { "alias": "viewConfig"; "required": true; }; "isMobile": { "alias": "isMobile"; "required": true; }; "stickyBottom": { "alias": "stickyBottom"; "required": true; }; }, { "pageChanged": "pageChanged"; }, never, never, true, never>;
+}

package/lib/views/table/view-table.component.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { INgxTable } from '../../ngx-table.interface';
+import { Filters, FilterService } from '../../filters/filter.service';
+import { Orders, ViewService } from '../view.service';
+import { IViewConfig, IViewFilter, IViewOrder } from '..';
+import * as i0 from "@angular/core";
+export declare class ViewTableComponent<T> implements OnChanges {
+    private readonly viewService;
+    private readonly filterService;
+    ngxTable: INgxTable<T>;
+    data: T[];
+    viewConfig: IViewConfig;
+    orderChanged: EventEmitter<IViewOrder>;
+    filterChanged: EventEmitter<IViewFilter>;
+    filterCleared: EventEmitter<void>;
+    hasIcon: boolean;
+    hasAction: boolean;
+    titleIndex: number;
+    subTitleIndex?: number;
+    icons: {
+        icon: string;
+        color?: string;
+    }[];
+    colors: string[];
+    descriptions: (string | undefined)[];
+    deactives: number[];
+    orders: Orders;
+    filters: Filters;
+    activeFilters: {
+        id: string;
+        title: string;
+        value: string;
+        english: boolean;
+    }[];
+    constructor(viewService: ViewService, filterService: FilterService);
+    ngOnChanges(changes: SimpleChanges): void;
+    updateOrder(id: string): void;
+    updateFilter(id: string): void;
+    clearFilter(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewTableComponent<any>, "view-table", never, { "ngxTable": { "alias": "ngxTable"; "required": true; }; "data": { "alias": "data"; "required": true; }; "viewConfig": { "alias": "viewConfig"; "required": true; }; }, { "orderChanged": "orderChanged"; "filterChanged": "filterChanged"; "filterCleared": "filterCleared"; }, never, never, true, never>;
+}

package/lib/views/value/view-value.component.d.ts

@@ -0,0 +1,60 @@
+import { Injector, OnChanges, SimpleChanges } from '@angular/core';
+import { Router } from '@angular/router';
+import { NgxTableColumn } from '../../ngx-table.interface';
+import { IViewConfig } from '../view.interface';
+import * as i0 from "@angular/core";
+export declare class ViewValueComponent<T> implements OnChanges {
+    private readonly router;
+    private textAlign;
+    column: NgxTableColumn<T>;
+    item: T;
+    viewConfig: IViewConfig;
+    isDeactive?: boolean;
+    isCard?: boolean;
+    isCardTitle?: boolean;
+    isCardSubTitle?: boolean;
+    columnInfo: {
+        DATE: {
+            readonly methods: import("../../columns").ColumnMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+        DURATION: {
+            readonly methods: import("../../columns").ColumnMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+        MOBILE: {
+            readonly methods: import("../../columns").ColumnMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+        NUMBER: {
+            readonly methods: import("../../columns").ColumnMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+        TEXT: {
+            readonly methods: import("../../columns").ColumnMethods<any, any>;
+            readonly component: import("@angular/cdk/portal").ComponentType<any>;
+        };
+    };
+    injector: Injector;
+    value: any;
+    subValue?: {
+        value: string;
+        isEN: boolean;
+    };
+    color?: string;
+    hasClick: boolean;
+    copyText?: string;
+    isCopied: boolean;
+    private copyTimeout;
+    constructor(router: Router);
+    ngOnChanges(changes: SimpleChanges): void;
+    getValue(): any;
+    getSubValue(): {
+        value: string;
+        isEN: boolean;
+    } | undefined;
+    onClick(): void;
+    onCopy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewValueComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewValueComponent<any>, "view-value", never, { "column": { "alias": "column"; "required": true; }; "item": { "alias": "item"; "required": true; }; "viewConfig": { "alias": "viewConfig"; "required": true; }; "isDeactive": { "alias": "isDeactive"; "required": false; }; "isCard": { "alias": "isCard"; "required": false; }; "isCardTitle": { "alias": "isCardTitle"; "required": false; }; "isCardSubTitle": { "alias": "isCardSubTitle"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/views/view.interface.d.ts

@@ -0,0 +1,41 @@
+export interface IViewConfig {
+    readonly alternateRows: boolean;
+    readonly iconSize: string;
+    readonly enClass: string;
+    readonly deactiveClass: string;
+    readonly borderColor: string;
+    readonly backgroundColor: string;
+    readonly headerTextColor: string;
+    readonly headerBackgroundColor: string;
+    readonly oddRowsBackgroundColor: string;
+    readonly evenRowsBackgroundColor: string;
+    readonly cardBackgroundColor: string;
+    readonly paginationBackgroundColor: string;
+    readonly highlightText: string;
+    readonly highlightBackground: string;
+    readonly inputText: string;
+    readonly inputBackground: string;
+    readonly actionButtonSize: string;
+    readonly actionButtonColor: string;
+    readonly actionMenuColor: string;
+    readonly actionWarnColor: string;
+    readonly actionMenuTitle: string;
+    readonly stickyView?: {
+        readonly headerTop?: {
+            readonly desktopView: string;
+            readonly mobileView: string;
+        };
+        readonly paginationBottom?: {
+            readonly desktopView: string;
+            readonly mobileView: string;
+        };
+    };
+}
+export interface IViewOrder {
+    readonly id: string;
+    readonly type: 'ASC' | 'DESC';
+}
+export interface IViewFilter {
+    readonly id: string;
+    readonly value: any;
+}