ng2-smart-table

ng2-smart-table

Version 1.7.2
Published 4 years ago
1.42 MB
2 dependencies
MIT license

Install

npm i ng2-smart-table

yarn add ng2-smart-table

pnpm add ng2-smart-table

Overview

Angular Smart Table

Index

Classes

Cell
DefaultEditor
DefaultFilter
LocalDataSource
Ng2SmartTableComponent
Ng2SmartTableModule
ɵa
ɵb
ɵba
ɵbb
ɵbc
ɵbd
ɵbe
ɵbf
ɵbg
ɵbh
ɵbi
ɵbj
ɵbk
ɵbl
ɵbm
ɵbn
ɵbo
ɵbp
ɵbq
ɵc
ɵd
ɵe
- getEditorType()
ɵf
ɵg
- onChange()
ɵh
ɵi
ɵj
ɵk
ɵl
ɵm
- cell
ɵn
ɵo
ɵp
ɵq
- query
ɵr
ɵs
ɵt
ɵu
ɵv
- inputControl
- ngOnInit()
ɵw
ɵx
ɵy
ɵz
ServerDataSource

Classes

class Cell

class Cell {}

constructor

constructor(value: any, row: Row, column: any, dataSet: DataSet);

property column

protected column: any;

property dataSet

protected dataSet: DataSet;

property newValue

newValue: any;

property PREPARE

protected static PREPARE: (value: any) => any;

property row

protected row: Row;

property value

protected value: any;

method getColumn

getColumn: () => Column;

method getId

getId: () => string;

method getRow

getRow: () => Row;

method getTitle

getTitle: () => string;

method getValue

getValue: () => any;

method isEditable

isEditable: () => boolean;

method setValue

setValue: (value: any) => any;

class DefaultEditor

class DefaultEditor implements Editor {}

property cell

cell: Cell;

property inputClass

inputClass: string;

property onClick

onClick: EventEmitter<any>;

property onEdited

onEdited: EventEmitter<any>;

property onStopEditing

onStopEditing: EventEmitter<any>;

class DefaultFilter

class DefaultFilter implements Filter, OnDestroy {}

property changesSubscription

changesSubscription: Subscription;

property column

column: Column;

property delay

delay: number;

property filter

filter: EventEmitter<string>;

property inputClass

inputClass: string;

property query

query: string;

method ngOnDestroy

ngOnDestroy: () => void;

method setFilter

setFilter: () => void;

class LocalDataSource

class LocalDataSource extends DataSource {}

constructor

constructor(data?: any[]);

property data

protected data: any[];

property filterConf

protected filterConf: any;

property filteredAndSorted

protected filteredAndSorted: any[];

property pagingConf

protected pagingConf: any;

property sortConf

protected sortConf: any[];

method add

add: (element: any) => Promise<any>;

method addFilter

addFilter: (
    fieldConf: any,
    andOperator?: boolean,
    doEmit?: boolean
) => LocalDataSource;

method append

append: (element: any) => Promise<any>;

method count

count: () => number;

method empty

empty: () => Promise<any>;

method filter

protected filter: (data: Array<any>) => Array<any>;

method find

find: (element: any) => Promise<any>;

method getAll

getAll: () => Promise<any>;

method getElements

getElements: () => Promise<any>;

method getFilter

getFilter: () => any;

method getFilteredAndSorted

getFilteredAndSorted: () => Promise<any>;

method getPaging

getPaging: () => any;

method getSort

getSort: () => any;

method load

load: (data: Array<any>) => Promise<any>;

method paginate

protected paginate: (data: Array<any>) => Array<any>;

method prepareData

protected prepareData: (data: Array<any>) => Array<any>;

method prepend

prepend: (element: any) => Promise<any>;

method remove

remove: (element: any) => Promise<any>;

method reset

reset: (silent?: boolean) => void;

method setFilter

setFilter: (
    conf: Array<any>,
    andOperator?: boolean,
    doEmit?: boolean
) => LocalDataSource;

Array of conf objects [ {field: string, search: string, filter: Function|null}, ]
Parameter conf
Parameter andOperator
Parameter doEmit
Returns
{LocalDataSource}

method setPage

setPage: (page: number, doEmit?: boolean) => LocalDataSource;

method setPaging

setPaging: (page: number, perPage: number, doEmit?: boolean) => LocalDataSource;

method setSort

setSort: (conf: Array<any>, doEmit?: boolean) => LocalDataSource;

Array of conf objects [ {field: string, direction: asc|desc|null, compare: Function|null}, ]
Parameter conf
Parameter doEmit
Returns
{LocalDataSource}

method sort

protected sort: (data: Array<any>) => Array<any>;

method update

update: (element: any, values: any) => Promise<any>;

class Ng2SmartTableComponent

class Ng2SmartTableComponent implements OnChanges, OnDestroy {}

property create

create: EventEmitter<any>;

property createConfirm

createConfirm: EventEmitter<any>;

property custom

custom: EventEmitter<any>;

property defaultSettings

defaultSettings: Object;

property delete

delete: EventEmitter<any>;

property deleteConfirm

deleteConfirm: EventEmitter<any>;

property edit

edit: EventEmitter<any>;

property editConfirm

editConfirm: EventEmitter<any>;

property grid

grid: Grid;

property isAllSelected

isAllSelected: boolean;

property isHideHeader

isHideHeader: boolean;

property isHideSubHeader

isHideSubHeader: boolean;

property isPagerDisplay

isPagerDisplay: boolean;

property perPageSelect

perPageSelect: any;

property rowClassFunction

rowClassFunction: Function;

property rowDeselect

rowDeselect: EventEmitter<any>;

property rowHover

rowHover: EventEmitter<any>;

property rowSelect

rowSelect: EventEmitter<any>;

property settings

settings: Object;

property source

source: any;

property tableClass

tableClass: string;

property tableId

tableId: string;

property userRowSelect

userRowSelect: EventEmitter<any>;

method changePage

changePage: ($event: any) => void;

method editRowSelect

editRowSelect: (row: Row) => void;

method filter

filter: ($event: any) => void;

method initGrid

initGrid: () => void;

method multipleSelectRow

multipleSelectRow: (row: Row) => void;

method ngOnChanges

ngOnChanges: (changes: { [propertyName: string]: SimpleChange }) => void;

method ngOnDestroy

ngOnDestroy: () => void;

method onMultipleSelectRow

onMultipleSelectRow: (row: Row) => void;

method onRowHover

onRowHover: (row: Row) => void;

method onSelectAllRows

onSelectAllRows: ($event: any) => void;

method onSelectRow

onSelectRow: (row: Row) => void;

method onUserSelectRow

onUserSelectRow: (row: Row) => void;

method prepareSettings

prepareSettings: () => Object;

method prepareSource

prepareSource: () => DataSource;

method selectRow

selectRow: (index: number, switchPageToSelectedRowPage?: boolean) => void;

method sort

sort: ($event: any) => void;

class Ng2SmartTableModule

class Ng2SmartTableModule {}

class ɵa

class CellModule {}

class ɵb

class CellComponent {}

property cell

cell: Cell;

property createConfirm

createConfirm: EventEmitter<any>;

property editConfirm

editConfirm: EventEmitter<any>;

property edited

edited: EventEmitter<any>;

property grid

grid: Grid;

property inputClass

inputClass: string;

property isInEditing

isInEditing: boolean;

property isNew

isNew: boolean;

property mode

mode: string;

property row

row: Row;

method onEdited

onEdited: (event: any) => void;

class ɵba

class TbodyEditDeleteComponent implements OnChanges {}

property delete

delete: EventEmitter<any>;

property deleteConfirm

deleteConfirm: EventEmitter<any>;

property deleteRowButtonContent

deleteRowButtonContent: string;

property edit

edit: EventEmitter<any>;

property editConfirm

editConfirm: EventEmitter<any>;

property editRowButtonContent

editRowButtonContent: string;

property editRowSelect

editRowSelect: EventEmitter<any>;

property grid

grid: Grid;

property isActionDelete

isActionDelete: boolean;

property isActionEdit

isActionEdit: boolean;

property row

row: Row;

property source

source: DataSource;

method ngOnChanges

ngOnChanges: () => void;

method onDelete

onDelete: (event: any) => void;

method onEdit

onEdit: (event: any) => void;

class ɵbb

class TbodyCustomComponent {}

property custom

custom: EventEmitter<any>;

property grid

grid: Grid;

property row

row: Row;

property source

source: any;

method onCustom

onCustom: (action: any, event: any) => void;

class ɵbc

class Ng2SmartTableTbodyComponent {}

property cancel

cancel: EventEmitter<any>;

property custom

custom: EventEmitter<any>;

property delete

delete: EventEmitter<any>;

property deleteConfirm

deleteConfirm: EventEmitter<any>;

property edit

edit: EventEmitter<any>;

property editConfirm

editConfirm: EventEmitter<any>;

property edited

edited: EventEmitter<any>;

property editInputClass

editInputClass: string;

property editRowSelect

editRowSelect: EventEmitter<any>;

property grid

grid: Grid;

property isActionAdd

isActionAdd: boolean;

property isActionDelete

isActionDelete: boolean;

property isActionEdit

isActionEdit: boolean;

property isMultiSelectVisible

isMultiSelectVisible: boolean;

property mode

mode: string;

property multipleSelectRow

multipleSelectRow: EventEmitter<any>;

property noDataMessage

noDataMessage: boolean;

property rowClassFunction

rowClassFunction: Function;

property rowHover

rowHover: EventEmitter<any>;

property save

save: EventEmitter<any>;

property showActionColumnLeft

showActionColumnLeft: boolean;

property showActionColumnRight

showActionColumnRight: boolean;

property source

source: DataSource;

property tableColumnsCount

readonly tableColumnsCount: number;

property userSelectRow

userSelectRow: EventEmitter<any>;

method getVisibleCells

getVisibleCells: (cells: Array<Cell>) => Array<Cell>;

method ngOnChanges

ngOnChanges: () => void;

class ɵbd

class THeadModule {}

class ɵbe

class ActionsComponent implements OnChanges {}

property cancelButtonContent

cancelButtonContent: string;

property create

create: EventEmitter<any>;

property createButtonContent

createButtonContent: string;

property grid

grid: Grid;

method ngOnChanges

ngOnChanges: () => void;

class ɵbf

class ActionsTitleComponent implements AfterViewInit, OnChanges {}

constructor

constructor(ref: ElementRef);

property actionsColumnTitle

actionsColumnTitle: string;

property grid

grid: Grid;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: () => void;

class ɵbg

class AddButtonComponent implements AfterViewInit, OnChanges {}

constructor

constructor(ref: ElementRef);

property addNewButtonContent

addNewButtonContent: string;

property create

create: EventEmitter<any>;

property grid

grid: Grid;

property isActionAdd

isActionAdd: boolean;

property source

source: DataSource;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: () => void;

method onAdd

onAdd: (event: any) => void;

class ɵbh

class CheckboxSelectAllComponent {}

property grid

grid: Grid;

property isAllSelected

isAllSelected: boolean;

property source

source: DataSource;

class ɵbi

class ColumnTitleComponent {}

property column

column: Column;

property sort

sort: EventEmitter<any>;

property source

source: DataSource;

class ɵbj

class TitleComponent implements OnChanges {}

property column

column: Column;

property currentDirection

currentDirection: string;

property dataChangedSub

protected dataChangedSub: Subscription;

property sort

sort: EventEmitter<any>;

property source

source: DataSource;

method changeSortDirection

changeSortDirection: () => string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

class ɵbk

class TheadFitlersRowComponent implements OnChanges {}

property create

create: EventEmitter<any>;

property filter

filter: EventEmitter<any>;

property filterInputClass

filterInputClass: string;

property grid

grid: Grid;

property isMultiSelectVisible

isMultiSelectVisible: boolean;

property showActionColumnLeft

showActionColumnLeft: boolean;

property showActionColumnRight

showActionColumnRight: boolean;

property source

source: DataSource;

method getVisibleColumns

getVisibleColumns: (columns: Array<Column>) => Array<Column>;

method ngOnChanges

ngOnChanges: () => void;

class ɵbl

class TheadFormRowComponent implements OnChanges {}

property addInputClass

addInputClass: string;

property create

create: EventEmitter<any>;

property createConfirm

createConfirm: EventEmitter<any>;

property grid

grid: Grid;

property isMultiSelectVisible

isMultiSelectVisible: boolean;

property row

row: Row;

property showActionColumnLeft

showActionColumnLeft: boolean;

property showActionColumnRight

showActionColumnRight: boolean;

method getVisibleCells

getVisibleCells: (cells: Array<Cell>) => Array<Cell>;

method ngOnChanges

ngOnChanges: () => void;

method onCreate

onCreate: (event: any) => void;

class ɵbm

class TheadTitlesRowComponent implements OnChanges {}

property grid

grid: Grid;

property isAllSelected

isAllSelected: boolean;

property isMultiSelectVisible

isMultiSelectVisible: boolean;

property selectAllRows

selectAllRows: EventEmitter<any>;

property showActionColumnLeft

showActionColumnLeft: boolean;

property showActionColumnRight

showActionColumnRight: boolean;

property sort

sort: EventEmitter<any>;

property source

source: DataSource;

method getVisibleColumns

getVisibleColumns: (columns: Array<Column>) => Array<Column>;

method ngOnChanges

ngOnChanges: () => void;

class ɵbn

class Ng2SmartTableTheadComponent implements OnChanges {}

property create

create: EventEmitter<any>;

property createConfirm

createConfirm: EventEmitter<any>;

property filter

filter: EventEmitter<any>;

property grid

grid: Grid;

property isAllSelected

isAllSelected: boolean;

property isHideHeader

isHideHeader: boolean;

property isHideSubHeader

isHideSubHeader: boolean;

property selectAllRows

selectAllRows: EventEmitter<any>;

property sort

sort: EventEmitter<any>;

property source

source: DataSource;

method ngOnChanges

ngOnChanges: () => void;

class ɵbo

class Row {}

constructor

constructor(index: number, data: any, _dataSet: DataSet);

property cells

cells: Cell[];

property data

protected data: any;

property index

index: number;

property isInEditing

isInEditing: boolean;

property isSelected

isSelected: boolean;

method createCell

createCell: (column: Column) => Cell;

method getCell

getCell: (column: Column) => Cell;

method getCells

getCells: () => Cell[];

method getData

getData: () => any;

method getIsSelected

getIsSelected: () => boolean;

method getNewData

getNewData: () => any;

method process

process: () => void;

method setData

setData: (data: any) => any;

class ɵbp

class DataSet {}

constructor

constructor(data: any[], columnSettings: Object);

property columns

protected columns: Column[];

property columnSettings

protected columnSettings: Object;

property data

protected data: any[];

property newRow

newRow: Row;

property rows

protected rows: Row[];

property selectedRow

protected selectedRow: Row;

property willSelect

protected willSelect: string;

method createColumns

createColumns: (settings: any) => void;

Create columns by mapping from the settings
Parameter settings

method createNewRow

createNewRow: () => void;

method createRows

createRows: () => void;

Create rows based on current data prepared in data source

method deselectAll

deselectAll: () => void;

method findRowByData

findRowByData: (data: any) => Row;

method getColumns

getColumns: () => Array<Column>;

method getFirstRow

getFirstRow: () => Row;

method getLastRow

getLastRow: () => Row;

method getRows

getRows: () => Array<Row>;

method multipleSelectRow

multipleSelectRow: (row: Row) => Row;

method select

select: (selectedRowIndex?: number) => Row | undefined;

method selectFirstRow

selectFirstRow: () => Row | undefined;

method selectLastRow

selectLastRow: () => Row | undefined;

method selectPreviousRow

selectPreviousRow: () => Row;

method selectRow

selectRow: (row: Row) => Row | undefined;

method selectRowByIndex

selectRowByIndex: (index: number) => Row | undefined;

method setData

setData: (data: Array<any>) => void;

method willSelectFirstRow

willSelectFirstRow: () => void;

method willSelectLastRow

willSelectLastRow: () => void;

class ɵbq

abstract class DataSource {}

property onAddedSource

protected onAddedSource: Subject<any>;

property onChangedSource

protected onChangedSource: Subject<any>;

property onRemovedSource

protected onRemovedSource: Subject<any>;

property onUpdatedSource

protected onUpdatedSource: Subject<any>;

method add

add: (element: any) => Promise<any>;

method addFilter

addFilter: (fieldConf: {}, andOperator?: boolean, doEmit?: boolean) => void;

method append

append: (element: any) => Promise<any>;

method count

abstract count: () => number;

method emitOnAdded

protected emitOnAdded: (element: any) => void;

method emitOnChanged

protected emitOnChanged: (action: string) => void;

method emitOnRemoved

protected emitOnRemoved: (element: any) => void;

method emitOnUpdated

protected emitOnUpdated: (element: any) => void;

method empty

empty: () => Promise<any>;

method getAll

abstract getAll: () => Promise<any>;

method getElements

abstract getElements: () => Promise<any>;

method getFilter

abstract getFilter: () => any;

method getPaging

abstract getPaging: () => any;

method getSort

abstract getSort: () => any;

method load

load: (data: Array<any>) => Promise<any>;

method onAdded

onAdded: () => Observable<any>;

method onChanged

onChanged: () => Observable<any>;

method onRemoved

onRemoved: () => Observable<any>;

method onUpdated

onUpdated: () => Observable<any>;

method prepend

prepend: (element: any) => Promise<any>;

method refresh

refresh: () => void;

method remove

remove: (element: any) => Promise<any>;

method setFilter

setFilter: (conf: Array<any>, andOperator?: boolean, doEmit?: boolean) => void;

method setPage

setPage: (page: number, doEmit?: boolean) => void;

method setPaging

setPaging: (page: number, perPage: number, doEmit?: boolean) => void;

method setSort

setSort: (conf: Array<any>, doEmit?: boolean) => void;

method update

update: (element: any, values: any) => Promise<any>;

class ɵc

class EditCellDefault {}

property cell

cell: Cell;

property edited

edited: EventEmitter<any>;

property inputClass

inputClass: string;

method onClick

onClick: (event: any) => void;

method onEdited

onEdited: (event: any) => boolean;

method onStopEditing

onStopEditing: () => boolean;

class ɵd

class CustomEditComponent extends EditCellDefault implements OnChanges, OnDestroy {}

constructor

constructor(resolver: ComponentFactoryResolver);

property customComponent

customComponent: any;

property dynamicTarget

dynamicTarget: any;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnDestroy

ngOnDestroy: () => void;

class ɵe

class DefaultEditComponent extends EditCellDefault {}

constructor

constructor();

method getEditorType

getEditorType: () => string;

class ɵf

class EditCellComponent {}

property cell

cell: Cell;

property edited

edited: EventEmitter<any>;

property inputClass

inputClass: string;

method getEditorType

getEditorType: () => string;

method onEdited

onEdited: (event: any) => boolean;

class ɵg

class CheckboxEditorComponent extends DefaultEditor {}

constructor

constructor();

method onChange

onChange: (event: any) => void;

class ɵh

class CompleterEditorComponent extends DefaultEditor implements OnInit {}

constructor

constructor(completerService: CompleterService);

property completerStr

completerStr: string;

method ngOnInit

ngOnInit: () => void;

method onEditedCompleter

onEditedCompleter: (event: { title: '' }) => boolean;

class ɵi

class InputEditorComponent extends DefaultEditor {}

constructor

constructor();

class ɵj

class SelectEditorComponent extends DefaultEditor {}

constructor

constructor();

class ɵk

class TextareaEditorComponent extends DefaultEditor {}

constructor

constructor();

class ɵl

class CustomViewComponent implements OnInit, OnDestroy {}

constructor

constructor(resolver: ComponentFactoryResolver);

property cell

cell: Cell;

property customComponent

customComponent: any;

property dynamicTarget

dynamicTarget: any;

method callOnComponentInit

protected callOnComponentInit: () => void;

method createCustomComponent

protected createCustomComponent: () => void;

method getPatch

protected getPatch: () => ViewCell;

method ngOnDestroy

ngOnDestroy: () => void;

method ngOnInit

ngOnInit: () => void;

method patchInstance

protected patchInstance: () => void;

class ɵm

class ViewCellComponent {}

property cell

cell: Cell;

class ɵn

class FilterModule {}

class ɵo

class FilterDefault {}

property column

column: Column;

property filter

filter: EventEmitter<any>;

property inputClass

inputClass: string;

property query

query: string;

property source

source: DataSource;

method onFilter

onFilter: (query: string) => void;

class ɵp

class FilterComponent extends FilterDefault implements OnChanges {}

property dataChangedSub

protected dataChangedSub: Subscription;

property query

query: string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

class ɵq

class DefaultFilterComponent extends FilterDefault {}

property query

query: string;

class ɵr

class CustomFilterComponent extends FilterDefault implements OnChanges, OnDestroy {}

constructor

constructor(resolver: ComponentFactoryResolver);

property customComponent

customComponent: any;

property dynamicTarget

dynamicTarget: any;

property query

query: string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnDestroy

ngOnDestroy: () => void;

class ɵs

class CheckboxFilterComponent extends DefaultFilter implements OnInit {}

constructor

constructor();

property filterActive

filterActive: boolean;

property inputControl

inputControl: FormControl;

method ngOnInit

ngOnInit: () => void;

method resetFilter

resetFilter: (event: any) => void;

class ɵt

class CompleterFilterComponent extends DefaultFilter implements OnInit {}

constructor

constructor(completerService: CompleterService);

property completerContent

completerContent: Subject<any>;

method inputTextChanged

inputTextChanged: (event: string) => void;

method ngOnInit

ngOnInit: () => void;

class ɵu

class InputFilterComponent extends DefaultFilter implements OnInit, OnChanges {}

constructor

constructor();

property inputControl

inputControl: FormControl;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnInit

ngOnInit: () => void;

class ɵv

class SelectFilterComponent extends DefaultFilter implements OnInit {}

constructor

constructor();

property inputControl

inputControl: NgControl;

method ngOnInit

ngOnInit: () => void;

class ɵw

class PagerModule {}

class ɵx

class PagerComponent implements OnChanges {}

property changePage

changePage: EventEmitter<any>;

property count

protected count: number;

property currentPerPage

currentPerPage: any;

property dataChangedSub

protected dataChangedSub: Subscription;

property page

protected page: number;

property pages

protected pages: any[];

property perPage

protected perPage: number;

property perPageSelect

perPageSelect: any[];

property source

source: DataSource;

method getLast

getLast: () => number;

method getPage

getPage: () => number;

method getPages

getPages: () => Array<any>;

method initPages

initPages: () => void;

method isPageOutOfBounce

isPageOutOfBounce: () => boolean;

method next

next: () => boolean;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onChangePerPage

onChangePerPage: (event: any) => void;

method paginate

paginate: (page: number) => boolean;

method prev

prev: () => boolean;

method processPageChange

processPageChange: (changes: any) => void;

We change the page here depending on the action performed against data source if a new element was added to the end of the table - then change the page to the last if a new element was added to the beginning of the table - then to the first page
Parameter changes

method shouldShow

shouldShow: () => boolean;

class ɵy

class TBodyModule {}

class ɵz

class TbodyCreateCancelComponent implements OnChanges {}

property cancelButtonContent

cancelButtonContent: string;

property editConfirm

editConfirm: EventEmitter<any>;

property grid

grid: Grid;

property row

row: Row;

property saveButtonContent

saveButtonContent: string;

method ngOnChanges

ngOnChanges: () => void;

method onCancelEdit

onCancelEdit: (event: any) => void;

method onSave

onSave: (event: any) => void;

class ServerDataSource

class ServerDataSource extends LocalDataSource {}

constructor

constructor(http: HttpClient, conf?: {} | ServerSourceConf);

property conf

protected conf: ServerSourceConf;

property http

protected http: HttpClient;

property lastRequestCount

protected lastRequestCount: number;

method addFilterRequestParams

protected addFilterRequestParams: (httpParams: HttpParams) => HttpParams;

method addPagerRequestParams

protected addPagerRequestParams: (httpParams: HttpParams) => HttpParams;

method addSortRequestParams

protected addSortRequestParams: (httpParams: HttpParams) => HttpParams;

method count

count: () => number;

method createRequesParams

protected createRequesParams: () => HttpParams;

method extractDataFromResponse

protected extractDataFromResponse: (res: any) => Array<any>;

Extracts array of data from server response
Parameter res
Returns
{any}

method extractTotalFromResponse

protected extractTotalFromResponse: (res: any) => number;

Extracts total rows count from the server response Looks for the count in the heders first, then in the response body
Parameter res
Returns
{any}

method getElements

getElements: () => Promise<any>;

method requestElements

protected requestElements: () => Observable<any>;

Interfaces

interface Editor

interface Editor {}

property cell

cell: Cell;

property inputClass

inputClass: string;

property onClick

onClick: EventEmitter<any>;

property onEdited

onEdited: EventEmitter<any>;

property onStopEditing

onStopEditing: EventEmitter<any>;

interface Filter

interface Filter {}

property changesSubscription

changesSubscription?: Subscription;

property column

column: Column;

property delay

delay?: number;

property filter

filter: EventEmitter<string>;

property inputClass

inputClass: string;

property query

query: string;

interface ViewCell

interface ViewCell {}

property rowData

rowData: any;

property value

value: string | number;

Package Files (52)

Dependencies (2)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (4)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ng2-smart-table.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ng2-smart-table)

HTML

<a href="https://www.jsdocs.io/package/ng2-smart-table"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 3 years ago.
Package analyzed in 4030 ms.
Missing or incorrect documentation? Open an issue for this package.

ng2-smart-table

Install

Overview

Index

Classes

Interfaces

Classes

class Cell

constructor

property column

property dataSet

property newValue

property PREPARE

property row

property value

method getColumn

method getId

method getRow

method getTitle

method getValue

method isEditable

method setValue

class DefaultEditor

property cell

property inputClass

property onClick

property onEdited

property onStopEditing

class DefaultFilter

property changesSubscription

property column

property delay

property filter

property inputClass

property query

method ngOnDestroy

method setFilter

class LocalDataSource

constructor

property data

property filterConf

property filteredAndSorted

property pagingConf

property sortConf

method add

method addFilter

method append

method count

method empty

method filter

method find

method getAll

method getElements

method getFilter

method getFilteredAndSorted

method getPaging

method getSort

method load

method paginate

method prepareData

method prepend

method remove

method reset

method setFilter

Parameter conf

Parameter andOperator

Parameter doEmit

Returns

method setPage

method setPaging

method setSort

Parameter conf

Parameter doEmit

Returns

method sort

method update

class Ng2SmartTableComponent

property create

property createConfirm

property custom