wassname/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/wassname/DefinitelyTyped.git synced 2026-08-29 11:12:23 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
796e02caace603efa00d00ca9f07dc0affc1dd4c
DefinitelyTyped/ui-grid/ui-grid.d.ts
T

872 lines
37 KiB
TypeScript
Raw Blame History

// Type definitions for ui-grid
// Project: http://www.ui-grid.info/
// Definitions by: Ben Tesser <https://github.com/btesser>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
// These are very definitely preliminary. Please feel free to improve.
// Changelog:
// 7/8/2015 ui-grid v3.0.0-rc.22-482dc67
// Added primary interfaces for row, column, api, grid, columnDef, and gridOptions. Needs more tests!
/// <reference path='../angularjs/angular.d.ts' />
declare module uiGrid {
export interface UIGridConstants {
LOG_DEBUG_MESSAGES: boolean;
LOG_WARN_MESSAGES: boolean;
LOG_ERROR_MESSAGES: boolean;
CUSTOM_FILTERS: RegExp;
COL_FIELD: RegExp;
MODEL_COL_FIELD: RegExp;
TOOLTIP: RegExp;
DISPLAY_CELL_TEMPLATE: RegExp;
TEMPLATE_REGEXP: RegExp;
FUNC_REGEXP: RegExp;
DOT_REGEXP: RegExp;
APOS_REGEXP: RegExp;
BRACKET_REGEXP: RegExp;
COL_CLASS_PREFIX: string;
events: {
GRID_SCROLL: string;
COLUMN_MENU_SHOWN: string;
ITEM_DRAGGING: string;
COLUMN_HEADER_CLICK: string;
};
keymap: {
TAB: number;
STRG: number;
CAPSLOCK: number;
CTRL: number;
CTRLRIGHT: number;
CTRLR: number;
SHIFT: number;
RETURN: number;
ENTER: number;
BACKSPACE: number;
BCKSP: number;
ALT: number;
ALTR: number;
ALTRIGHT: number;
SPACE: number;
WIN: number;
MAC: number;
FN: number;
PG_UP: number;
PG_DOWN: number;
UP: number;
DOWN: number;
LEFT: number;
RIGHT: number;
ESC: number;
DEL: number;
F1: number;
F2: number;
F3: number;
F4: number;
F5: number;
F6: number;
F7: number;
F8: number;
F9: number;
F10: number;
F11: number;
F12: number;
};
ASC: string;
DESC: string;
filter: {
STARTS_WITH: number;
ENDS_WITH: number;
EXACT: number;
CONTAINS: number;
GREATER_THAN: number;
GREATER_THAN_OR_EQUAL: number;
LESS_THAN: number;
LESS_THAN_OR_EQUAL: number;
NOT_EQUAL: number;
SELECT: string;
INPUT: string;
};
scrollDirection: {
UP: string;
DOWN: string;
LEFT: string;
RIGHT: string;
NONE: string;
};
aggregationTypes: {
sum: number;
count: number;
avg: number;
min: number;
max: number;
};
CURRENCY_SYMBOLS: Array<string>;
dataChange: {
ALL: string;
EDIT: string;
ROW: string;
COLUMN: string;
OPTIONS: string;
}
scrollbars: {
NEVER: number;
ALWAYS: number;
}
}
export interface IGridInstance {
appScope?: ng.IScope;
columnFooterHeight?: number;
footerHeight?: number;
isScrollingHorizontally?: boolean;
isScrollingVertically?: boolean;
scrollDirection?: number;
addRowHeaderColumn(column: IGridColumn): void;
assignTypes(): void;
buildColumnDefsFromData(rowBuilder: IRowBuilder): void;
buildColumns(options: IBuildColumnsOptions): ng.IPromise<any>;
buildStyles(): void;
callDataChangeCallbacks(type: number): void;
clearAllFilters(refreshRows: boolean, clearConditions: boolean, clearFlags: boolean): void;
columnRefreshCallback(name: string): void;
createLeftContainer(): void;
createRightContainer(): void;
flagScrollingHorizontally(): void;
flagScrollingVertically(): void;
getCellDisplayValue(row: IGridRow, col: IGridColumn): string;
getCellValue(row: IGridRow, col: IGridColumn): any;
getColDef(name: string): IColumnDef;
getColumn(name: string): IGridColumn;
getColumnSorting(): Array<IGridColumn>;
getGridQualifiedColField(col: IGridColumn): any;
getOnlyDataColumns(): Array<IGridColumn>;
getRow(rowEntity: any, rows?: Array<IGridRow>): IGridRow;
handleWindowResize(): void;
hasLeftContainer(): boolean;
hasRightContainer(): boolean;
hasLeftContainerColumns(): boolean;
hasRightContainerColumns(): boolean;
isRTL(): boolean;
isRowHeaderColumn(col: IGridColumn): boolean;
modifyRows(): void;
notifyDataChange(type: string): void;
precompileCellTemplates(): void;
processRowBuilders(gridRow: IGridRow): IGridRow;
processRowsCallback(name: string): void;
queueGridRefresh(): void;
queueRefresh(): void;
redrawCanvas(rowsAdded?: boolean): void;
refresh(rowsAltered?: boolean): void;
refreshCanvas(buildStyles?: boolean): ng.IPromise<any>;
refreshRows(): ng.IPromise<any>;
registerColumnBuilder(columnBuilder: IColumnBuilder): void;
registerColumnsProcessor(columnProcessor: IColumnProcessor, priority: number): void;
registerDataChangeCallback(callback: (grid: IGridInstance) => void, types: Array<string>): Function;
registerRowBuilder(rowBuilder: IRowBuilder): void;
registerRowsProcessor(rowProcessor: IRowProcessor, priority: number): void;
registerStyleComputation(styleComputation: ($scope: ng.IScope) => string): void;
removeRowsProcessor(rows: IRowProcessor): void;
resetColumnSorting(excludedColumn: IGridColumn): void;
scrollTo(rowEntity: IGridRow, colDef: IColumnDef): ng.IPromise<any>;
scrollToIfNecessary(gridRow: IGridRow, gridCol: IGridColumn): ng.IPromise<any>;
sortColumn(column: IGridColumn, direction?: string, add?: boolean): ng.IPromise<IGridColumn>;
updateCanvasHeight(): void;
updateFooterHeightCallback(name: string): void;
}
export interface IBuildColumnsOptions {
orderByColumnDefs?: boolean;
}
export interface IColumnBuilder {
(colDef: IColumnDef, col: IGridColumn, gridOptions: IGridOptions): void;
}
export interface IRowBuilder {
(row: IGridRow, gridOptions: IGridOptions): void;
}
export interface IRowProcessor {
(renderedRowsToProcess: Array<IGridRow>, columns: Array<IGridColumn>): Array<IGridRow>;
}
export interface IColumnProcessor {
(renderedColumnsToProcess: Array<IGridColumn>, rows: Array<IGridRow>): Array<IGridColumn>;
}
export interface IGridOptions {
aggregationCalcThrottle?: number;
appScopeProvider?: ng.IScope | Object;
columnDefs?: IColumnDef;
columnFooterHeight?: number;
columnVirtualizationThreshold?: number;
data?: Array<any> | string;
enableColumnMenus?: boolean;
enablePagiationControls?: boolean;
enableFiltering?: boolean;
enableHorizontalScrollbar?: boolean;
enableMinHeightCheck?: boolean;
enableRowHashing?: boolean;
enableRowSelection?: boolean;
enableSorting?: boolean;
enableVerticalScrollbar?: boolean;
excessColumns?: number;
excessRows?: number;
excludeProperties?: Array<string>;
flatEntityAccess?: boolean;
footerTemplate?: string;
gridFooterTemplate?: string;
gridMenuCustomItems?: Array<IMenuItem>;
gridMenuShowHideColumns?: boolean;
gridMenuTitleFilter?: (title: string) => ng.IPromise<string> | string;
headerTemplate?: string;
horizontalScrollThreshold?: number;
infiniteScrollDown?: boolean;
infiniteScrollRowsFromEnd?: number;
infiniteScrollUp?: boolean;
maxVisibleColumnCount?: number;
minRowsToShow?: number;
minimumColumnSize?: number;
onRegisterApi?: (gridApi: IGridApi) => void;
rowHeight?: number;
rowTemplate?: string;
scrollDebounce?: number;
scrollThreshold?: number;
showColumnFooter?: boolean;
showGridFooter?: boolean;
showHeader?: boolean;
useExternalFiltering?: boolean;
useExternalSorting?: boolean;
virtualizationThreshold?: number;
wheelScrollThrottle?: number;
getRowIdentity?(): any;
rowEquality?(entityA: IGridRow, entityB: IGridRow): boolean;
rowIdentity? (): any;
totalItems?: number;
paginationPageSize?: number;
paginationCurrentPage?: number;
}
export interface IGridCoreApi {
addRowHeaderColumn(column: IColumnDef): void;
addToGridMenu(grid: IGridInstance, items: Array<IMenuItem>): void;
clearAllFilters(refreshRows?: boolean, clearConditions?: boolean, clearFlags?: boolean): ng.IPromise<Array<IGridRow>>;
clearRowInvisible(rowEntity: any): void;
getVisibleRows(grid: IGridInstance): Array<IGridRow>;
handleWindowResize(): void;
notifiyDataChange(type: string): void;
refreshRows(): ng.IPromise<boolean>;
registerColumnsProcessor(processorFunction: IColumnProcessor, priority: number): void;
registerRowsProcessor(rowProcessor: IRowProcessor, priority: number): void;
removeFromGridMenu(grid: IGridInstance, id: string): void;
scrollTo(entity: any, colDef: IColumnDef): void; /*A row entity can be anything?*/
scrollToIfNecessary(gridRow: IGridRow, gridCol: IGridColumn): void;
setRowInvisible(rowEntity: any): void;
sortHandleNulls(a: any,b: any): number;
queueGridRefresh(): void;
queueRefresh(): void;
on: {
sortChanged: (scope: ng.IScope, handler: (grid: IGridInstance, sortColumns: Array<IColumnDef>) => void) => void;
columnVisiblityChanged: (scope: ng.IScope, handler: (grid: IGridColumn) => void) => void;
canvasHeightChanged: (scope: ng.IScope, handler: (oldHeight: number, newHeight: number) => void) => void;
/**
* filterChangedis raised after the filter is changed. The nature of the watch expression doesn't allow notification
* of what changed, so the receiver of this event will need to re-extract the filter conditions from the columns.
* http://ui-grid.info/docs/#/api/ui.grid.core.api:PublicApi
*/
filterChanged: (scope: ng.IScope, handler: () => void) => void;
rowsRendered: (scope: ng.IScope, handler: () => void) => void;
rowsVisibleChanged: (scope: ng.IScope, handler: () => void) => void;
scrollBegin: (scope: ng.IScope, handler: () => void) => void;
scrollEnd: (scope: ng.IScope, handler: () => void) => void;
}
}
export interface IGridSelectionApi {
toggleRowSelection: (rowEntity: IGridRow, event?: Event) => void;
selectRow: (rowEntity: IGridRow, event?: Event) => void;
selectRowByVisibleIndex: (rowEntity: number, event?: Event) => void;
unSelectRow: (rowEntity: IGridRow, event?: Event) => void;
selectAllRows: (event?: Event) => void;
selectAllVisibleRows: (event?: Event) => void;
clearSelectedRows: (event?: Event) => void;
getSelectedRows: () => Array<IGridRow>;
getSelectedGridRows: () => Array<IGridRow>;
setMultiSelect: (multiSelect: boolean) => void;
setModifierKeysToMultiSelect: (multiSelect: boolean) => void;
getSelectAllState: () => boolean;
on: {
rowSelectionChanged: (scope: ng.IScope, handler: (row: IGridRow, event?: Event) => void) => void;
rowSelectionChangedBatch: (scope: ng.IScope, handler: (row: Array<IGridRow>, event?: Event) => void) => void;
}
}
export interface IGridPaginationApi {
getPage: () => number;
getTotalPages: () => number;
nextPage: () => void;
previousPage: () => void;
seek: () => void;
on: {
paginationChanged: (scope: ng.IScope, handler: (newPage: number, pageSize: number) => void) => void;
}
}
export interface IGridRowEditApi {
flushDirtyRows(grid?: IGridInstance): ng.IPromise<boolean>;
getDirtyRows(grid?: IGridInstance): Array<IGridRow>;
getErrorRows(grid?: IGridInstance): Array<IGridRow>;
setRowsClean(dataRows: Array<any>): Array<any>;
setRowsDirty(dataRows: Array<any>): Array<any>;
setSavePromise(rowEntity: Object, savePromise: ng.IPromise<any>): void;
on: {
saveRow: (scope: ng.IScope, handler: (rowEntity: Array<any>) => void) => void
}
}
export interface IGridApiConstructor {
new (grid: IGridInstance): IGridApi;
}
export interface IGridApi {
/**
* Registers a new event for the given feature. The event will get a .raise and .on prepended to it
*
* .raise.eventName() - takes no arguments
*
* .on.eventName(scope, callBackFn, _this)
* scope - a scope reference to add a deregister call to the scopes .$on('destroy').
* Scope is optional and can be a null value, but in this case you must deregister it yourself via the returned
* deregister function
* callBackFn - The function to call
* _this - optional this context variable for callbackFn. If omitted, grid.api will be used for the context
*
* .on.eventName returns a dereg function that will remove the listener. It's not necessary to use it as the
* listener will be removed when the scope is destroyed.
* @param featureName name of the feature that raises the event
* @param eventName name of the event
*/
registerEvent(featureName: string, eventName: string): void;
/**
* Registers features and events from a simple objectMap.
* eventObjectMap must be in this format (multiple features allowed)
* @param eventObjectMap map of feature/event names
*/
registerEventsFromObject(eventObjectMap: any): void;
/**
* Registers a new event for the given feature
* @param featureName name of the feature
* @param methodName name of the method
* @param callBackFn function to execute
* @param _this binds to callBackFn. Defaults to gridApi.grid
*/
registerMethod(featureName: string, methodName: string, callBackFn: Function, _this: any): void;
/**
* Registers features and methods from a simple objectMap.
* eventObjectMap must be in this format (multiple features allowed)
* {featureName: { methodNameOne:function(args){}, methodNameTwo:function(args){} }
* @param eventObjectMap map of feature/event names
* @param _this binds this to _this for all functions. Defaults to gridApi.grid
*/
registerMethodsFromObject(eventObjectMap: any, _this: any): void;
/**
* Used to execute a function while disabling the specified event listeners.
* Disables the listenerFunctions, executes the callbackFn, and then enables the listenerFunctions again
* @param listenerFuncs listenerFunc or array of listenerFuncs to suppress.
* These must be the same functions that were used in the .on.eventName method
* @param callBackFn function to execute
*/
suppressEvents(listenerFuncs: Function | Array<Function>, callBackFn: Function): void;
/**
* Core Api
*/
core: IGridCoreApi;
/**
* Selection api
*/
selection: IGridSelectionApi;
/**
* Pagination api
*/
pagination: IGridPaginationApi;
/**
* Grid Row Edit Api
*/
rowEdit: IGridRowEditApi;
/**
* A grid instance is made available in the gridApi.
*/
grid: IGridInstance;
}
export interface IGridRowConstructor {
/**
* GridRow is the viewModel for one logical row on the grid.
* A grid Row is not necessarily a one-to-one relation to gridOptions.data.
* @param entity the array item from GridOptions.data
* @param index the current position of the row in the array
* @param reference to the parent grid
*/
new(entity: any, index: number, reference: IGridInstance): IGridRow;
}
export interface IGridRow {
/** A reference to an item in gridOptions.data[] */
entity: any;
/** A reference back to the grid */
grid: IGridInstance;
/**
* height of each individual row. changing the height will flag all
* row renderContainers to recalculate their canvas height
*/
height: number;
/** uniqueId of row */
uid: string;
/** if true, row will be rendered */
visible: boolean;
// Additional features enabled by other modules
/** enable editing on row, grouping for example might disable editing on group header rows */
enableCellEdit: boolean;
/**
* Enable row selection for this row, only settable by internal code.
*
* The grouping feature, for example, might set group header rows to not be selectable.
* Defaults to true
* @default true
*/
enableSelection: boolean;
/**
* Selected state of row.
* Should be readonly.
* Make any changes to selected state using setSelected().
* Defaults to false
*
* @readonly
* @default false
*/
isSelected: boolean;
/**
* If set to false, then don't export this row,
* notwithstanding visible or other settings
* Defaults to true
* @default true
*/
exporterEnableExporting: boolean;
/**
* Sets the isSelected property and updates the selectedCount
* Changes to isSelected state should only be made via this function
* @param selected Value to set
*/
setSelected(selected: boolean): void;
/**
* Clears an override on the row that forces it to always be invisible.
* Emits the rowsVisibleChanged event if it changed the row visibility.
*
* This method can be called from the api, passing in the gridRow we want altered.
* It should really work by calling gridRow.clearRowInvisible,
* but that's not the way I coded it, and too late to change now.
* Changed to just call the internal function row.clearThisRowInvisible().
* @param row the row we want to clear the invisible flag
*/
clearRowInvisible(row: IGridRow): void;
/**
* Clears any override on the row visibility, returning it to normal visibility calculations.
* Emits the rowsVisibleChanged event
* @param reason the reason (usually the module) for the row to be invisible. E.g. grouping, user, filter
* @param fromRowsProcessor whether we were called from a rowsProcessor, passed through to evaluateRowVisibility
*/
clearRowInvisible(reason: string, fromRowsProcessor: boolean): void;
/**
* Determines whether the row should be visible based on invisibleReason,
* and if it changes the row visibility, then emits the rowsVisibleChanged event.
* Queues a grid refresh, but doesn't call it directly to avoid hitting lots of
* grid refreshes.
*/
evaluateRowVisibility(fromRowProcessor: boolean): void;
/**
* returns the qualified field name minus the row path ie: entity.fieldA
* @param col column instance
* @returns resulting name that can be evaluated against a row
*/
getEntityQualifiedColField(col: IGridColumn): string;
/**
* returns the qualified field name as it exists on scope ie: row.entity.fieldA
* @param col column instance
* @returns resulting name that can be evaluated on scope
*/
getQualifiedColField(col: IGridColumn): string;
/**
* Sets an override on the row that forces it to always be invisible.
* Emits the rowsVisibleChanged event if it changed the row visibility.
* This method can be called from the api, passing in the gridRow we want altered.
* It should really work by calling gridRow.setRowInvisible,
* but that's not the way I coded it, and too late to change now.
* Changed to just call the internal function row.setThisRowInvisible().
* @param row the row we want to set to invisible
*/
setRowInvisible(row: IGridRow): void;
/**
* Sets an override on the row that forces it to always be invisible.
* Emits the rowsVisibleChanged event if it changed the row visibility
* @param reason the reason (usually the module) for the row to be invisible. E.g. grouping, user, filter
* @param fromRowsProcessor whether we were called from a rowsProcessor, passed through to evaluateRowVisibility
*/
setThisRowInvisible(reason: string, fromRowsProcessor: boolean): void;
}
export interface IGridColumnConstructor {
/**
* Represents the viewModel for each column.
* Any state or methods needed for a Grid Column are defined on this prototype
* @param gridCol Column definition
* @param index the current position of the column in the array
* @param grid reference to the grid
*/
new(gridCol: IColumnDef, index: number, grid: IGridInstance): IGridColumn;
}
export interface IGridColumn {
/**
* Column name that will be shown in the header.
* If displayName is not provided then one is generated using the name.
*/
displayName?: string;
/**
* field must be provided if you wish to bind to a property in the data source.
* Should be an angular expression that evaluates against grid.options.data array element.
* Can be a complex expression: employee.address.city, or can be a function: employee.getFullAddress().
* See the angular docs on binding expressions.
*/
field?: string;
/** Filter on this column */
filter?: IFilterOptions;
/** Filters for this column. Includes 'term' property bound to filter input elements */
filters?: Array<IFilterOptions>;
name?: string;
/** Sort on this column */
sort?: ISortInfo
/** Algorithm to use for sorting this column. Takes 'a' and 'b' parameters like any normal sorting function. */
sortingAlgorithm?: (a: any, b: any) => number;
/**
* Initializes a column
* @param colDef the column def to associate with this column
* @param uid The unique and immutable uid we'd like to allocate to this column
* @param grid the grid we'd like to create this column in
*/
GridColumn(colDef: IColumnDef, uid: number, grid: IGridInstance): void;
/**
* Gets the aggregation label from colDef.aggregationLabel if specified or by using i18n,
* including deciding whether or not to display based on colDef.aggregationHideLabel.
* @param label the i18n lookup value to use for the column label
*/
getAggregationText(label: string): void;
/**
* gets the aggregation value based on the aggregation type for this column.
* Debounced using scrollDebounce option setting
*/
getAggregationValue(): string;
/**
* Returns the class name for the column
* @param prefixDot if true, will return .className instead of className
*/
getColClass(prefixDot: boolean): string;
/** Returns the class definition for th column */
getColClassDefinition(): string;
/**
* Returns the render container object that this column belongs to.
* Columns will be default be in the body render container
* if they aren't allocated to one specifically.
*/
getRenderContainer(): any; // @todo replace with interface for render container
/** Hides the column by setting colDef.visible = false */
hideColumn(): void;
/** Returns true if column is in the left render container */
isPinnedLeft(): boolean;
/** Returns true if column is in the right render container */
isPinnedRight(): boolean;
/**
* Sets a property on the column using the passed in columnDef,
* and setting the defaultValue if the value cannot be found on the colDef
* @param colDef the column def to look in for the property value
* @param propName the property name we'd like to set
* @param defaultValue the value to use if the colDef doesn't provide the setting
*/
setPropertyOrDefault(colDef: IColumnDef, propName: string, defaultValue: any): void;
/** Makes the column visible by setting colDef.visible = true */
showColumn(): void;
/**
* Moves settings from the columnDef down onto the column, and sets properties as appropriate
* @param colDef the column def to look in for property value
* @param isNew whether the column is being newly created, if not we're updating an existing
* column, and some items such as the sort shouldn't be copied down
*/
updateColumnDef(colDef: IColumnDef, isNew: boolean): void;
}
/**
* Definition / configuration of an individual column,
* which would typically be one of many column definitions within the
* gridOptions.columnDefs array
*/
export interface IColumnDef {
/**
* defaults to false
* if set to true hides the label text in the aggregation footer, so only the value is displayed.
*/
aggregationHideLabel?: boolean;
/**
* The aggregation that you'd like to show in the columnFooter for this column.
* Valid values are in uiGridConstants, and currently include:
* uiGridConstants.aggregationTypes.count, uiGridConstants.aggregationTypes.sum,
* uiGridConstants.aggregationTypes.avg, uiGridConstants.aggregationTypes.min,
* uiGridConstants.aggregationTypes.max.
*
* You can also provide a function as the aggregation type,
* in this case your function needs to accept the full set of visible rows,
* and return a value that should be shown
*/
aggregationType?: number | Function;
/**
* cellClass can be a string specifying the class to append to a cell
* or it can be a function(row,rowRenderIndex, col, colRenderIndex)
* that returns a class name
*/
cellClass?: string | ICellClassGetter;
/** cellFilter is a filter to apply to the content of each cell */
cellFilter?: string;
/**
* a custom template for each cell in this column.
* The default is ui-grid/uiGridCell.
* If you are using the cellNav feature,
* this template must contain a div that can receive focus.
*/
cellTemplate?: string;
/**
* Whether or not to show a tooltip when a user hovers over the cell.
* If set to false, no tooltip.
* If true, the cell value is shown in the tooltip (useful if you have long values in your cells),
* if a function then that function is called passing in the row and the col cellTooltip(row, col)
* and the return value is shown in the tooltip,
* if it is a static string then displays that static string.
* Defaults to false
* @default false
*/
cellTooltip?: boolean | string | ICellTooltipGetter;
/**
* Column name that will be shown in the header.
* If displayName is not provided then one is generated using the name.
*/
displayName?: string;
/**
* if column menus are enabled, controls the column menus for this specific column
* (i.e. if gridOptions.enableColumnMenus, then you can control column menus using this option.
* If gridOptions.enableColumnMenus === false then you get no column menus irrespective of the value of this
* option
* ). Defaults to true.
* @default true
*/
enableColumnMenu?: boolean;
/**
* Override for column menus everywhere - if set to false then you get no column menus.
* Defaults to true
* @default true
*/
enableColumnMenus?: boolean;
/** turn off filtering for an individual column, where you've turned on filtering for the overall grid */
enableFiltering?: boolean;
/**
* When set to false, this setting prevents a user from hiding the column using the column menu or the grid
* menu.
* @default true
*/
enableHiding?: boolean;
/**
* When enabled, this setting adds sort widgets to the column header, allowing sorting of the data in the
* individual column.
* @default true
*/
enableSorting?: boolean;
/**
* field must be provided if you wish to bind to a property in the data source.
* Should be an angular expression that evaluates against grid.options.data array element
* Can be a complex expression: employee.address.city, or can be a function: employee.getFullAddress().
* See the angular docs on binding expressions.
*/
field?: string;
/**
* Specify a single filter field on this column.
* A filter consists of a condition, a term, and a placeholder:
*/
filter?: IFilterOptions;
/**
* @default false
* When true uiGrid will apply the cellFilter before applying search filters
*/
filterCellFiltered?: boolean;
/**
* a custom template for the filter input. The default is ui-grid/ui-grid-filter
*/
filterHeaderTemplate?: string;
/** Specify multiple filter fields */
filters?: Array<IFilterOptions>;
/**
* footerCellClass can be a string specifying the class to append to a cell or it can be
* a function(row,rowRenderIndex, col, colRenderIndex) that returns a class name
*/
footerCellClass?: string | IHeaderFooterCellClassGetter;
/** footerCellFilter is a filter to apply to the content of the column footer */
footerCellFilter?: string;
/** a custom template for the footer for this column. The default is ui-grid/uiGridFooterCell */
footerCellTemplate?: string;
/**
* headerCellClass can be a string specifying the class to append to a cell or it can be
* a function(row,rowRenderIndex, col, colRenderIndex) that returns a class name
*/
headerCellClass?: string | IHeaderFooterCellClassGetter;
/** headerCellFilter is a filter to apply to the content of the column header */
headerCellFilter?: string;
/** a custom template for the header for this column. The default is ui-grid/uiGridHeaderCell */
headerCellTemplate?: string;
/**
* Whether or not to show a tooltip when a user hovers over the header cell.
* If set to false, no tooltip.
* If true, the displayName is shown in the tooltip
* (useful if you have long values in your headers),
* if a function then that function is called passing in the row and the col
* headerTooltip( col ), and the return value is shown in the tooltip,
* if a static string then shows that static string.
* @default false
*/
headerTooltip?: boolean | string | IHeaderTooltipGetter;
/** sets the maximum column width */
maxWidth?: number;
/** used to add menu items to a column. Refer to the tutorial on this functionality */
menuItems?: Array<IMenuItem>;
/** Sets the minimum column width */
minWidth?: number;
/**
* (mandatory) each column should have a name,
* although for backward compatibility with 2.x name can be omitted if field is present
*/
name?: string;
/** An object of sort information */
sort?: ISortInfo;
/**
* @default false
* When true uiGrid will apply the cellFilter before sorting the data
* Note that when using this option uiGrid will assume that the displayed value is a string,
* and use the sortAlpha sortFn.
* It is possible to return a non-string value from an angularjs filter,
* in which case you should define a sortingAlgorithm for the column
* which handles the returned type.
* You may specify one of the sortingAlgorithms found in the rowSorter service.
*/
sortCellFiltered?: boolean;
/** Algorithm to use for sorting this column */
sortingAlgorithm?: (a: any, b: any) => number;
/**
* When enabled, this setting hides the removeSort option in the menu,
* and prevents users from manually removing the sort
* @default false
*/
suppressRemoveSort?: boolean;
/**
* the type of the column, used in sorting. If not provided then the grid will guess the type.
* Add this only if the grid guessing is not to your satisfaction.
* Note that if you choose date, your dates should be in a javascript date type
* One of:
* 'string', 'boolean', 'number', 'date', 'object', 'numberStr'
*/
type?: string;
/**
* sets whether or not the column is visible
* @default true
*/
visible?: boolean;
/**
* sets the column width. Can be either a number or a percentage, or an * for auto.
*/
width?: number | string;
}
export interface ICellClassGetter {
(gridRow?: IGridRow, gridCol?: IGridColumn, colRenderIndex?: number): string;
}
export interface ICellTooltipGetter {
(gridRow: IGridRow, gridCol: IGridColumn): string;
}
export interface IHeaderTooltipGetter {
(gridCol: IGridColumn): string;
}
export interface IHeaderFooterCellClassGetter {
(gridRow: IGridRow, rowRenderIndex: number, gridCol: IGridColumn, colRenderIndex: number): string;
}
export interface IMenuItem {
/** controls the title that is displayed in the menu */
title?: string;
/** the icon shown alongside that title */
icon?: string;
/** the method to call when the menu is clicked */
action?: ($event: ng.IAngularEvent) => void;
/** a function to evaluate to determine whether or not to show the item */
shown?: () => boolean;
/** a function to evaluate to determine whether or not the item is currently selected */
active?: () => boolean;
/** context to pass to the action function, available in this.context in your handler */
context?: any;
/** if set to true, the menu should stay open after the action, defaults to false */
leaveOpen?: boolean;
}
export interface ISortInfo {
direction?: string;
ignoreSort?: boolean;
priority?: number;
}
export interface IFilterOptions {
/**
* condition defines how rows are chosen as matching the filter term.
* This can be set to one of the constants in uiGridConstants.filter,
* or you can supply a custom filter function that gets passed the
* following arguments: [searchTerm, cellValue, row, column].
*/
condition?: number;
/**
* If set, the filter field will be pre-populated with this value
*/
term?: string;
/** String that will be set to the <input>.placeholder attribute */
placeholder?: string;
/**
* set this to true if you have defined a custom function in condition,
* and your custom function doesn't require a term
* (so it can run even when the term is null)
*/
noTerm?: boolean;
/**
* only flag currently available is caseSensitive, set to false if you don't want case sensitive matching
*/
flags?: IFilterFlags;
/**
* defaults to uiGridConstants.filter.INPUT, which gives a text box. If set to uiGridConstants.filter.SELECT
* then a select box will be shown with options selectOptions
*/
type?: number;
/**
* options in the format [{ value: 1, label: 'male' }]. No i18n filter is provided, you need to perform the i18n
* on the values before you provide them
*/
selectOptions?: Array<ISelectOption>;
/**
* If set to true then the 'x' button that cancels/clears the filter will not be shown.
* @default false
*/
disableCancelButton?: boolean;
}
export interface ISelectOption {
value: number;
label: string;
}
export interface IFilterFlags {
caseSensitive?: boolean;
}
}
Reference in New Issue View Git Blame Copy Permalink