ng-table
Version:
Table + AngularJS ================= [](https://travis-ci.org/esvit/ng-table) [](https://coveralls.io/r/esvit/ng-table) [![seman
1,259 lines (1,219 loc) • 109 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("angular"));
else if(typeof define === 'function' && define.amd)
define(["angular"], factory);
else if(typeof exports === 'object')
exports["ng-table"] = factory(require("angular"));
else
root["ng-table"] = factory(root["angular"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_0__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // identity function for calling harmory imports with the correct context
/******/ __webpack_require__.i = function(value) { return value; };
/******/
/******/ // define getter function for harmory exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 51);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/* unknown exports provided */
/* all exports used */
/*!**************************!*\
!*** external "angular" ***!
\**************************/
/***/ function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_0__;
/***/ },
/* 1 */
/* unknown exports provided */
/* all exports used */
/*!***************************!*\
!*** ./src/core/index.ts ***!
\***************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
"use strict";
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
var angular = __webpack_require__(/*! angular */ 0);
var data_1 = __webpack_require__(/*! ./data */ 3);
var grouping_1 = __webpack_require__(/*! ./grouping */ 37);
var ngTableDefaults_1 = __webpack_require__(/*! ./ngTableDefaults */ 7);
var ngTableSettings_1 = __webpack_require__(/*! ./ngTableSettings */ 10);
var ngTableParams_1 = __webpack_require__(/*! ./ngTableParams */ 9);
var ngTableEventsChannel_1 = __webpack_require__(/*! ./ngTableEventsChannel */ 8);
var ngTableCoreModule = angular.module('ngTable-core', [])
.provider('ngTableDefaultGetData', data_1.NgTableDefaultGetDataProvider)
.factory('ngTableDefaultGetGroups', grouping_1.ngTableDefaultGetGroups)
.value('ngTableDefaults', ngTableDefaults_1.ngTableDefaults)
.service('ngTableEventsChannel', ngTableEventsChannel_1.NgTableEventsChannel)
.service('ngTableSettings', ngTableSettings_1.NgTableSettings)
.run(ngTableParams_1.NgTableParams.init);
exports.ngTableCoreModule = ngTableCoreModule;
// note: if you are using ES6 or typescript prefer:
// import { NgTableParams } from 'ng-table';
ngTableCoreModule.value('NgTableParams', ngTableParams_1.NgTableParams);
var ngTableDefaults_2 = __webpack_require__(/*! ./ngTableDefaults */ 7);
exports.IDefaults = ngTableDefaults_2.IDefaults;
__export(__webpack_require__(/*! ./ngTableEventsChannel */ 8));
var ngTableSettings_2 = __webpack_require__(/*! ./ngTableSettings */ 10);
exports.ISettings = ngTableSettings_2.ISettings;
__export(__webpack_require__(/*! ./ngTableParams */ 9));
__export(__webpack_require__(/*! ./data */ 3));
__export(__webpack_require__(/*! ./filtering */ 36));
__export(__webpack_require__(/*! ./grouping/publicExports */ 39));
__export(__webpack_require__(/*! ./paging */ 40));
__export(__webpack_require__(/*! ./sorting */ 41));
/***/ },
/* 2 */
/* unknown exports provided */
/* all exports used */
/*!******************************!*\
!*** ./src/browser/index.ts ***!
\******************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
"use strict";
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
var angular = __webpack_require__(/*! angular */ 0);
var ngTable_directive_1 = __webpack_require__(/*! ./ngTable.directive */ 13);
var ngTableColumn_1 = __webpack_require__(/*! ./ngTableColumn */ 14);
var ngTableColumnsBinding_directive_1 = __webpack_require__(/*! ./ngTableColumnsBinding.directive */ 15);
var ngTableController_1 = __webpack_require__(/*! ./ngTableController */ 16);
exports.NgTableController = ngTableController_1.NgTableController;
var ngTableDynamic_directive_1 = __webpack_require__(/*! ./ngTableDynamic.directive */ 17);
var ngTableFilterConfig_1 = __webpack_require__(/*! ./ngTableFilterConfig */ 18);
exports.NgTableFilterConfigProvider = ngTableFilterConfig_1.NgTableFilterConfigProvider;
exports.NgTableFilterConfig = ngTableFilterConfig_1.NgTableFilterConfig;
var ngTableFilterRow_directive_1 = __webpack_require__(/*! ./ngTableFilterRow.directive */ 19);
var ngTableFilterRowController_1 = __webpack_require__(/*! ./ngTableFilterRowController */ 20);
var ngTableGroupRow_directive_1 = __webpack_require__(/*! ./ngTableGroupRow.directive */ 21);
var ngTableGroupRowController_1 = __webpack_require__(/*! ./ngTableGroupRowController */ 22);
var ngTablePagination_directive_1 = __webpack_require__(/*! ./ngTablePagination.directive */ 23);
var ngTableSelectFilterDs_directive_1 = __webpack_require__(/*! ./ngTableSelectFilterDs.directive */ 24);
var ngTableSorterRow_directive_1 = __webpack_require__(/*! ./ngTableSorterRow.directive */ 25);
var ngTableSorterRowController_1 = __webpack_require__(/*! ./ngTableSorterRowController */ 26);
__webpack_require__(/*! ./filters/number.html */ 43);
__webpack_require__(/*! ./filters/select.html */ 45);
__webpack_require__(/*! ./filters/select-multiple.html */ 44);
__webpack_require__(/*! ./filters/text.html */ 46);
__webpack_require__(/*! ./pager.html */ 49);
__webpack_require__(/*! ./header.html */ 48);
var ngTableBrowserModule = angular.module('ngTable-browser', [])
.directive('ngTable', ngTable_directive_1.ngTable)
.service('ngTableColumn', ngTableColumn_1.NgTableColumn)
.directive('ngTableColumnsBinding', ngTableColumnsBinding_directive_1.ngTableColumnsBinding)
.controller('ngTableController', ngTableController_1.NgTableController)
.directive('ngTableDynamic', ngTableDynamic_directive_1.ngTableDynamic)
.provider('ngTableFilterConfig', ngTableFilterConfig_1.NgTableFilterConfigProvider)
.directive('ngTableFilterRow', ngTableFilterRow_directive_1.ngTableFilterRow)
.controller('ngTableFilterRowController', ngTableFilterRowController_1.NgTableFilterRowController)
.directive('ngTableGroupRow', ngTableGroupRow_directive_1.ngTableGroupRow)
.controller('ngTableGroupRowController', ngTableGroupRowController_1.NgTableGroupRowController)
.directive('ngTablePagination', ngTablePagination_directive_1.ngTablePagination)
.directive('ngTableSelectFilterDs', ngTableSelectFilterDs_directive_1.ngTableSelectFilterDs)
.directive('ngTableSorterRow', ngTableSorterRow_directive_1.ngTableSorterRow)
.controller('ngTableSorterRowController', ngTableSorterRowController_1.NgTableSorterRowController);
exports.ngTableBrowserModule = ngTableBrowserModule;
__export(__webpack_require__(/*! ./public-interfaces */ 27));
/***/ },
/* 3 */
/* unknown exports provided */
/* all exports used */
/*!********************************!*\
!*** ./src/core/data/index.ts ***!
\********************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
"use strict";
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
__export(__webpack_require__(/*! ./dataSettings */ 28));
__export(__webpack_require__(/*! ./getData */ 29));
__export(__webpack_require__(/*! ./interceptor */ 30));
__export(__webpack_require__(/*! ./ngTableDefaultGetData */ 31));
__export(__webpack_require__(/*! ./results */ 32));
/***/ },
/* 4 */
/* unknown exports provided */
/* all exports used */
/*!***************************************!*\
!*** ./src/core/grouping/getGroup.ts ***!
\***************************************/
/***/ function(module, exports) {
"use strict";
"use strict";
/***/ },
/* 5 */
/* unknown exports provided */
/* all exports used */
/*!********************************************!*\
!*** ./src/core/grouping/groupSettings.ts ***!
\********************************************/
/***/ function(module, exports) {
"use strict";
"use strict";
/***/ },
/* 6 */
/* unknown exports provided */
/* all exports used */
/*!*******************************************!*\
!*** ./src/core/grouping/groupingFunc.ts ***!
\*******************************************/
/***/ function(module, exports) {
"use strict";
"use strict";
/***/ },
/* 7 */
/* unknown exports provided */
/* all exports used */
/*!*************************************!*\
!*** ./src/core/ngTableDefaults.ts ***!
\*************************************/
/***/ function(module, exports) {
"use strict";
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
"use strict";
/**
* Default values for ngTable
*/
exports.ngTableDefaults = {
params: {},
settings: {}
};
/***/ },
/* 8 */
/* unknown exports provided */
/* all exports used */
/*!******************************************!*\
!*** ./src/core/ngTableEventsChannel.ts ***!
\******************************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
"use strict";
var ng1 = __webpack_require__(/*! angular */ 0);
var NgTableEventsChannel = (function () {
function NgTableEventsChannel($rootScope) {
this.$rootScope = $rootScope;
var events = this;
events = this.addTableParamsEvent('afterCreated', events);
events = this.addTableParamsEvent('afterReloadData', events);
events = this.addTableParamsEvent('datasetChanged', events);
events = this.addTableParamsEvent('pagesChanged', events);
events = this.addTableParamsEvent('afterDataFiltered', events);
events = this.addTableParamsEvent('afterDataSorted', events);
}
NgTableEventsChannel.prototype.addTableParamsEvent = function (eventName, target) {
var fnName = eventName.charAt(0).toUpperCase() + eventName.substring(1);
var event = (_a = {},
_a['on' + fnName] = this.createEventSubscriptionFn(eventName),
_a['publish' + fnName] = this.createPublishEventFn(eventName),
_a
);
return ng1.extend(target, event);
var _a;
};
NgTableEventsChannel.prototype.createPublishEventFn = function (eventName) {
var _this = this;
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i - 0] = arguments[_i];
}
(_a = _this.$rootScope).$broadcast.apply(_a, ['ngTable:' + eventName].concat(args));
var _a;
};
};
NgTableEventsChannel.prototype.createEventSubscriptionFn = function (eventName) {
var _this = this;
return function (handler, eventSelectorOrScope, eventSelector) {
var actualEvtSelector;
var scope = _this.$rootScope;
if (isScopeLike(eventSelectorOrScope)) {
scope = eventSelectorOrScope;
actualEvtSelector = createEventSelectorFn(eventSelector);
}
else {
actualEvtSelector = createEventSelectorFn(eventSelectorOrScope);
}
return scope.$on('ngTable:' + eventName, function (event, params) {
var eventArgs = [];
for (var _i = 2; _i < arguments.length; _i++) {
eventArgs[_i - 2] = arguments[_i];
}
// don't send events published by the internal NgTableParams created by ngTableController
if (params.isNullInstance)
return;
var fnArgs = [params].concat(eventArgs);
if (actualEvtSelector.apply(this, fnArgs)) {
handler.apply(this, fnArgs);
}
});
};
function createEventSelectorFn(eventSelector) {
if (!eventSelector) {
return function (publisher) { return true; };
}
else if (isEventSelectorFunc(eventSelector)) {
return eventSelector;
}
else {
// shorthand for subscriber to only receive events from a specific publisher instance
return function (publisher) { return publisher === eventSelector; };
}
}
function isEventSelectorFunc(val) {
return typeof val === 'function';
}
function isScopeLike(val) {
return val && typeof val.$new === 'function';
}
};
NgTableEventsChannel.$inject = ['$rootScope'];
return NgTableEventsChannel;
}());
exports.NgTableEventsChannel = NgTableEventsChannel;
/***/ },
/* 9 */
/* unknown exports provided */
/* all exports used */
/*!***********************************!*\
!*** ./src/core/ngTableParams.ts ***!
\***********************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
"use strict";
var ng1 = __webpack_require__(/*! angular */ 0);
var util_1 = __webpack_require__(/*! ./util */ 11);
/**
* @private
*/
function isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
/**
* Parameters manager for an ngTable directive
*/
var NgTableParams = (function () {
function NgTableParams(baseParameters, baseSettings) {
var _this = this;
/**
* The page of data rows currently being displayed in the table
*/
this.data = [];
this.defaultSettings = NgTableParams.ngTableSettings.createDefaults();
this.isCommittedDataset = false;
this.initialEvents = [];
this._params = {
page: 1,
count: 10,
filter: {},
sorting: {},
group: {}
};
this._settings = this.defaultSettings;
// the ngTableController "needs" to create a dummy/null instance and it's important to know whether an instance
// is one of these
if (typeof baseParameters === "boolean") {
this.isNullInstance = true;
}
this.reloadPages = (function () {
var currentPages;
return function () {
var oldPages = currentPages;
var newPages = _this.generatePagesArray(_this.page(), _this.total(), _this.count());
if (!ng1.equals(oldPages, newPages)) {
currentPages = newPages;
NgTableParams.ngTableEventsChannel.publishPagesChanged(_this, newPages, oldPages);
}
};
})();
ng1.extend(this._params, NgTableParams.ngTableDefaults.params);
this.settings(baseSettings);
this.parameters(baseParameters, true);
NgTableParams.ngTableEventsChannel.publishAfterCreated(this);
// run events during construction after the initial create event. That way a consumer
// can subscribe to all events for a table without "dropping" an event
ng1.forEach(this.initialEvents, function (event) {
event();
});
this.initialEvents = null;
}
NgTableParams.prototype.count = function (count) {
// reset to first page because can be blank page
return count !== undefined ? this.parameters({
'count': count,
'page': 1
}) : this._params.count;
};
NgTableParams.prototype.filter = function (filter) {
if (filter != null && typeof filter === 'object') {
return this.parameters({
'filter': filter,
'page': 1
});
}
else if (filter === true) {
var keys = Object.keys(this._params.filter);
var significantFilter = {};
for (var i = 0; i < keys.length; i++) {
var filterValue = this._params.filter[keys[i]];
if (filterValue != null && filterValue !== '') {
significantFilter[keys[i]] = filterValue;
}
}
return significantFilter;
}
else {
return this._params.filter;
}
};
/**
* Generate array of pages.
* When no arguments supplied, the current parameter state of this `NgTableParams` instance will be used
* @param currentPage Which page must be active
* @param totalItems Total quantity of items
* @param pageSize Quantity of items on page
* @param maxBlocks Quantity of blocks for pagination
* @returns Array of pages
*/
NgTableParams.prototype.generatePagesArray = function (currentPage, totalItems, pageSize, maxBlocks) {
if (!arguments.length) {
currentPage = this.page();
totalItems = this.total();
pageSize = this.count();
}
var maxPage, maxPivotPages, minPage, numPages;
maxBlocks = maxBlocks && maxBlocks < 6 ? 6 : maxBlocks;
var pages = [];
numPages = Math.ceil(totalItems / pageSize);
if (numPages > 1) {
pages.push({
type: 'prev',
number: Math.max(1, currentPage - 1),
active: currentPage > 1
});
pages.push({
type: 'first',
number: 1,
active: currentPage > 1,
current: currentPage === 1
});
maxPivotPages = Math.round((this._settings.paginationMaxBlocks - this._settings.paginationMinBlocks) / 2);
minPage = Math.max(2, currentPage - maxPivotPages);
maxPage = Math.min(numPages - 1, currentPage + maxPivotPages * 2 - (currentPage - minPage));
minPage = Math.max(2, minPage - (maxPivotPages * 2 - (maxPage - minPage)));
var i = minPage;
while (i <= maxPage) {
if ((i === minPage && i !== 2) || (i === maxPage && i !== numPages - 1)) {
pages.push({
type: 'more',
active: false
});
}
else {
pages.push({
type: 'page',
number: i,
active: currentPage !== i,
current: currentPage === i
});
}
i++;
}
pages.push({
type: 'last',
number: numPages,
active: currentPage !== numPages,
current: currentPage === numPages
});
pages.push({
type: 'next',
number: Math.min(numPages, currentPage + 1),
active: currentPage < numPages
});
}
return pages;
};
NgTableParams.prototype.group = function (group, sortDirection) {
if (group === undefined) {
return this._params.group;
}
var newParameters = {
page: 1
};
if (util_1.isGroupingFun(group) && sortDirection !== undefined) {
group.sortDirection = sortDirection;
newParameters.group = group;
}
else if (typeof group === 'string' && sortDirection !== undefined) {
newParameters.group = (_a = {}, _a[group] = sortDirection, _a);
}
else {
newParameters.group = group;
}
this.parameters(newParameters);
return this;
var _a;
};
/**
* Returns true when an attempt to `reload` the current `parameter` values have resulted in a failure.
* This method will continue to return true until the `reload` is successfully called or when the
* `parameter` values have changed
*/
NgTableParams.prototype.hasErrorState = function () {
return !!(this.errParamsMemento && ng1.equals(this.errParamsMemento, this.createComparableParams()));
};
/**
* Returns true if `filter` has significant filter value(s) (any value except null, undefined, or empty string),
* otherwise false
*/
NgTableParams.prototype.hasFilter = function () {
return Object.keys(this.filter(true)).length > 0;
};
/**
* Return true when a change to `filters` require the `reload` method
* to be run so as to ensure the data presented to the user reflects these filters
*/
NgTableParams.prototype.hasFilterChanges = function () {
var previousFilter = (this.prevParamsMemento && this.prevParamsMemento.params.filter);
return !ng1.equals((this._params.filter), previousFilter) || this.hasGlobalSearchFieldChanges();
};
NgTableParams.prototype.hasGroup = function (group, sortDirection) {
if (group == null) {
return util_1.isGroupingFun(this._params.group) || Object.keys(this._params.group).length > 0;
}
if (util_1.isGroupingFun(group)) {
if (sortDirection == null) {
return this._params.group === group;
}
else {
return this._params.group === group && group.sortDirection === sortDirection;
}
}
else {
if (sortDirection == null) {
return Object.keys(this._params.group).indexOf(group) !== -1;
}
else {
return this._params.group[group] === sortDirection;
}
}
};
/**
* Return true when a change to this instance should require the `reload` method
* to be run so as to ensure the data rows presented to the user reflects the current state.
*
* Note that this method will return false when the `reload` method has run but fails. In this case
* `hasErrorState` will return true.
*
* The built-in `ngTable` directives will watch for when this function returns true and will then call
* the `reload` method to load its data rows
*/
NgTableParams.prototype.isDataReloadRequired = function () {
// note: using != as want to treat null and undefined the same
return !this.isCommittedDataset || !ng1.equals(this.createComparableParams(), this.prevParamsMemento)
|| this.hasGlobalSearchFieldChanges();
};
/**
* Returns true if sorting by the field supplied. Where direction supplied
* the field must also be sorted by that direction to return true
*/
NgTableParams.prototype.isSortBy = function (field, direction) {
if (direction !== undefined) {
return this._params.sorting[field] !== undefined && this._params.sorting[field] == direction;
}
else {
return this._params.sorting[field] !== undefined;
}
};
/**
* Returns sorting values in a format that can be consumed by the angular `$orderBy` filter service
*/
NgTableParams.prototype.orderBy = function () {
return util_1.convertSortToOrderBy(this._params.sorting);
};
NgTableParams.prototype.page = function (page) {
return page !== undefined ? this.parameters({
'page': page
}) : this._params.page;
};
NgTableParams.prototype.parameters = function (newParameters, parseParamsFromUrl) {
parseParamsFromUrl = parseParamsFromUrl || false;
if (typeof newParameters !== undefined) {
for (var key in newParameters) {
var value = newParameters[key];
if (parseParamsFromUrl && key.indexOf('[') >= 0) {
var keys = key.split(/\[(.*)\]/).reverse();
var lastKey = '';
for (var i = 0, len = keys.length; i < len; i++) {
var name = keys[i];
if (name !== '') {
var v = value;
value = {};
value[lastKey = name] = (isNumber(v) ? parseFloat(v) : v);
}
}
if (lastKey === 'sorting') {
this._params[lastKey] = {};
}
this._params[lastKey] = ng1.extend(this._params[lastKey] || {}, value[lastKey]);
}
else {
if (key === 'group') {
this._params[key] = this.parseGroup(newParameters[key]);
}
else {
this._params[key] = (isNumber(newParameters[key]) ? parseFloat(newParameters[key]) : newParameters[key]);
}
}
}
this.log('ngTable: set parameters', this._params);
return this;
}
return this._params;
};
/**
* Trigger a reload of the data rows
*/
NgTableParams.prototype.reload = function () {
var _this = this;
var pData = null;
this._settings.$loading = true;
this.prevParamsMemento = ng1.copy(this.createComparableParams());
this.isCommittedDataset = true;
if (this.hasGroup()) {
pData = this.runInterceptorPipeline(NgTableParams.$q.when(this._settings.getGroups(this)));
}
else {
var fn = this._settings.getData;
pData = this.runInterceptorPipeline(NgTableParams.$q.when(fn(this)));
}
this.log('ngTable: reload data');
var oldData = this.data;
return pData.then(function (data) {
_this._settings.$loading = false;
_this.errParamsMemento = null;
_this.data = data;
// note: I think it makes sense to publish this event even when data === oldData
// subscribers can always set a filter to only receive the event when data !== oldData
NgTableParams.ngTableEventsChannel.publishAfterReloadData(_this, data, oldData);
_this.reloadPages();
return data;
}).catch(function (reason) {
_this.errParamsMemento = _this.prevParamsMemento;
// "rethrow"
return NgTableParams.$q.reject(reason);
});
};
NgTableParams.prototype.settings = function (newSettings) {
var _this = this;
if (ng1.isDefined(newSettings)) {
var settings = NgTableParams.ngTableSettings.merge(this._settings, newSettings);
var originalDataset_1 = this._settings.dataset;
this._settings = settings;
// note: using != as want null and undefined to be treated the same
var hasDatasetChanged = newSettings.hasOwnProperty('dataset') && (newSettings.dataset != originalDataset_1);
if (hasDatasetChanged) {
if (this.isCommittedDataset) {
this.page(1); // reset page as a new dataset has been supplied
}
this.isCommittedDataset = false;
var fireEvent = function () {
NgTableParams.ngTableEventsChannel.publishDatasetChanged(_this, newSettings.dataset, originalDataset_1);
};
if (this.initialEvents) {
this.initialEvents.push(fireEvent);
}
else {
fireEvent();
}
}
this.log('ngTable: set settings', this._settings);
return this;
}
return this._settings;
};
NgTableParams.prototype.sorting = function (sorting, direction) {
if (typeof sorting === 'string') {
this.parameters({
'sorting': (_a = {}, _a[sorting] = direction, _a)
});
return this;
}
return sorting !== undefined ? this.parameters({
'sorting': sorting
}) : this._params.sorting;
var _a;
};
NgTableParams.prototype.total = function (total) {
return total !== undefined ? this.settings({
'total': total
}) : this._settings.total;
};
/**
* Returns the current parameter values uri-encoded. Set `asString` to
* true for the parameters to be returned as an array of strings of the form 'paramName=value'
* otherwise parameters returned as a key-value object
*/
NgTableParams.prototype.url = function (asString) {
// this function is an example of Typescript gone bad!!
asString = asString || false;
var pairs = (asString ? [] : {});
for (var key in this._params) {
if (this._params.hasOwnProperty(key)) {
var item = this._params[key], name = encodeURIComponent(key);
if (typeof item === "object") {
for (var subkey in item) {
if (isSignificantValue(item[subkey], key)) {
var pname = name + "[" + encodeURIComponent(subkey) + "]";
collectValue(item[subkey], pname);
}
}
}
else if (!ng1.isFunction(item) && isSignificantValue(item, key)) {
collectValue(item, name);
}
}
}
return pairs;
function collectValue(value, key) {
if (isArray(pairs)) {
pairs.push(key + "=" + encodeURIComponent(value));
}
else {
pairs[key] = encodeURIComponent(value);
}
}
function isArray(pairs) {
return asString;
}
function isSignificantValue(value, key) {
return key === "group" ? true : typeof value !== undefined && value !== "";
}
};
NgTableParams.prototype.createComparableParams = function () {
var group = this._params.group;
return {
params: this._params,
groupSortDirection: util_1.isGroupingFun(group) ? group.sortDirection : undefined
};
};
NgTableParams.prototype.hasGlobalSearchFieldChanges = function () {
var currentVal = (this._params.filter && this._params.filter['$']);
var previousVal = (this.prevParamsMemento && this.prevParamsMemento.params.filter && this.prevParamsMemento.params.filter['$']);
return !ng1.equals(currentVal, previousVal);
};
NgTableParams.prototype.log = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i - 0] = arguments[_i];
}
if (this._settings.debugMode && NgTableParams.$log.debug) {
(_a = NgTableParams.$log).debug.apply(_a, args);
}
var _a;
};
NgTableParams.prototype.parseGroup = function (group) {
var defaultSort = this._settings.groupOptions && this._settings.groupOptions.defaultSort;
if (!group) {
return group;
}
else if (util_1.isGroupingFun(group)) {
if (group.sortDirection == null) {
group.sortDirection = defaultSort;
}
return group;
}
else if (typeof group === 'object') {
for (var key in group) {
if (group[key] == null) {
group[key] = defaultSort;
}
}
return group;
}
else {
return (_a = {},
_a[group] = defaultSort,
_a
);
}
var _a;
};
NgTableParams.prototype.runInterceptorPipeline = function (fetchedData) {
var _this = this;
var interceptors = this._settings.interceptors || [];
return interceptors.reduce(function (result, interceptor) {
var thenFn = (interceptor.response && interceptor.response.bind(interceptor)) || NgTableParams.$q.when;
var rejectFn = (interceptor.responseError && interceptor.responseError.bind(interceptor)) || NgTableParams.$q.reject;
return result.then(function (data) {
return thenFn(data, _this);
}, function (reason) {
return rejectFn(reason, _this);
});
}, fetchedData);
};
NgTableParams.init = function ($q, $log, ngTableDefaults, ngTableEventsChannel, ngTableSettings) {
NgTableParams.$q = $q;
NgTableParams.$log = $log;
NgTableParams.ngTableDefaults = ngTableDefaults;
NgTableParams.ngTableEventsChannel = ngTableEventsChannel;
NgTableParams.ngTableSettings = ngTableSettings;
};
return NgTableParams;
}());
exports.NgTableParams = NgTableParams;
NgTableParams.init.$inject = ['$q', '$log', 'ngTableDefaults', 'ngTableEventsChannel', 'ngTableSettings'];
/***/ },
/* 10 */
/* unknown exports provided */
/* all exports used */
/*!*************************************!*\
!*** ./src/core/ngTableSettings.ts ***!
\*************************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
"use strict";
var ng1 = __webpack_require__(/*! angular */ 0);
/**
* @private
*/
var NgTableSettings = (function () {
function NgTableSettings(ngTableDefaults, ngTableDefaultGetData, ngTableDefaultGetGroups) {
var _this = this;
this.ngTableDefaults = ngTableDefaults;
this.ngTableDefaultGetData = ngTableDefaultGetData;
this.ngTableDefaultGetGroups = ngTableDefaultGetGroups;
this.defaults = {
$loading: false,
dataset: null,
total: 0,
defaultSort: 'desc',
counts: [10, 25, 50, 100],
filterOptions: {
filterComparator: undefined,
filterDelay: 500,
filterDelayThreshold: 10000,
filterFilterName: undefined,
filterFn: undefined,
filterLayout: 'stack'
},
getData: function (params) {
return _this.ngTableDefaultGetData(params.settings().dataset, params);
},
getGroups: this.ngTableDefaultGetGroups,
groupOptions: {
defaultSort: 'asc',
isExpanded: true
},
interceptors: [],
paginationMaxBlocks: 11,
paginationMinBlocks: 5,
sortingIndicator: 'span'
};
}
NgTableSettings.prototype.createDefaults = function () {
return this.merge(this.defaults, this.ngTableDefaults.settings);
};
NgTableSettings.prototype.merge = function (existing, newSettings) {
newSettings = ng1.extend({}, newSettings);
if (newSettings.filterOptions) {
newSettings.filterOptions = ng1.extend({}, existing.filterOptions || {}, newSettings.filterOptions);
}
if (newSettings.groupOptions) {
newSettings.groupOptions = ng1.extend({}, existing.groupOptions || {}, newSettings.groupOptions);
}
if (ng1.isArray(newSettings.dataset)) {
//auto-set the total from passed in dataset
newSettings.total = newSettings.dataset.length;
}
var results = ng1.extend({}, existing, newSettings);
if (ng1.isArray(newSettings.dataset)) {
this.optimizeFilterDelay(results);
}
return ng1.extend({}, existing, newSettings);
};
NgTableSettings.prototype.optimizeFilterDelay = function (settings) {
// don't debounce by default filter input when working with small synchronous datasets
if (settings.filterOptions.filterDelay === this.defaults.filterOptions.filterDelay &&
settings.total <= settings.filterOptions.filterDelayThreshold &&
settings.getData === this.defaults.getData) {
settings.filterOptions.filterDelay = 0;
}
};
NgTableSettings.$inject = ['ngTableDefaults', 'ngTableDefaultGetData', 'ngTableDefaultGetGroups'];
return NgTableSettings;
}());
exports.NgTableSettings = NgTableSettings;
/***/ },
/* 11 */
/* unknown exports provided */
/* all exports used */
/*!**************************!*\
!*** ./src/core/util.ts ***!
\**************************/
/***/ function(module, exports) {
"use strict";
"use strict";
/**
* @private
*/
function convertSortToOrderBy(sorting) {
var result = [];
for (var column in sorting) {
result.push((sorting[column] === "asc" ? "+" : "-") + column);
}
return result;
}
exports.convertSortToOrderBy = convertSortToOrderBy;
/**
* @private
*/
function isGroupingFun(val) {
return typeof val === 'function';
}
exports.isGroupingFun = isGroupingFun;
/***/ },
/* 12 */,
/* 13 */
/* unknown exports provided */
/* all exports used */
/*!******************************************!*\
!*** ./src/browser/ngTable.directive.ts ***!
\******************************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
"use strict";
var ng1 = __webpack_require__(/*! angular */ 0);
ngTable.$inject = ['$q', '$parse'];
/**
* Directive that instantiates {@link NgTableController NgTableController}.
* @ngdoc directive
* @name ngTable
* @example
*
* ```html
* <table ng-table="$ctrl.tableParams" show-filter="true" class="table table-bordered">
* <tr ng-repeat="user in $data">
* <td data-title="'Name'" sortable="'name'" filter="{ 'name': 'text' }">
* {{user.name}}
* </td>
* <td data-title="'Age'" sortable="'age'" filter="{ 'age': 'text' }">
* {{user.age}}
* </td>
* </tr>
* </table>
* ```
*/
function ngTable($q, $parse) {
return {
restrict: 'A',
priority: 1001,
scope: true,
controller: 'ngTableController',
compile: function (element) {
var columns = [], i = 0, dataRow, groupRow;
var rows = [];
ng1.forEach(element.find('tr'), function (tr) {
rows.push(ng1.element(tr));
});
dataRow = rows.filter(function (tr) { return !tr.hasClass('ng-table-group'); })[0];
groupRow = rows.filter(function (tr) { return tr.hasClass('ng-table-group'); })[0];
if (!dataRow) {
return undefined;
}
ng1.forEach(dataRow.find('td'), function (item) {
var el = ng1.element(item);
if (el.attr('ignore-cell') && 'true' === el.attr('ignore-cell')) {
return;
}
var getAttrValue = function (attr) {
return el.attr('x-data-' + attr) || el.attr('data-' + attr) || el.attr(attr);
};
var setAttrValue = function (attr, value) {
if (el.attr('x-data-' + attr)) {
el.attr('x-data-' + attr, value);
}
else if (el.attr('data' + attr)) {
el.attr('data' + attr, value);
}
else {
el.attr(attr, value);
}
};
var parsedAttribute = function (attr) {
var expr = getAttrValue(attr);
if (!expr) {
return undefined;
}
var localValue;
var getter = function (context) {
if (localValue !== undefined) {
return localValue;
}
return $parse(expr)(context);
};
getter.assign = function ($scope, value) {
var parsedExpr = $parse(expr);
if (parsedExpr.assign) {
// we should be writing back to the parent scope as this is where the expression
// came from
parsedExpr.assign($scope.$parent, value);
}
else {
localValue = value;
}
};
return getter;
};
var titleExpr = getAttrValue('title-alt') || getAttrValue('title');
if (titleExpr) {
el.attr('data-title-text', '{{' + titleExpr + '}}'); // this used in responsive table
}
// NOTE TO MAINTAINERS: if you add extra fields to a $column be sure to extend ngTableColumn with
// a corresponding "safe" default
columns.push({
id: i++,
title: parsedAttribute('title'),
titleAlt: parsedAttribute('title-alt'),
headerTitle: parsedAttribute('header-title'),
sortable: parsedAttribute('sortable'),
'class': parsedAttribute('header-class'),
filter: parsedAttribute('filter'),
groupable: parsedAttribute('groupable'),
headerTemplateURL: parsedAttribute('header'),
filterData: parsedAttribute('filter-data'),
show: el.attr("ng-if") ? parsedAttribute('ng-if') : undefined
});
if (groupRow || el.attr("ng-if")) {
// change ng-if to bind to our column definition which we know will be writable
// because this will potentially increase the $watch count, only do so if we already have an
// ng-if or when we definitely need to change visibility of the columns.
// currently only ngTableGroupRow directive needs to change visibility
setAttrValue('ng-if', '$columns[' + (columns.length - 1) + '].show(this)');
}
});
return function (scope, element, attrs, controller) {
scope.$columns = columns = controller.buildColumns(columns);
controller.setupBindingsToInternalScope(attrs.ngTable);
controller.loadFilterData(columns);
controller.compileDirectiveTemplates();
};
}
};
}
exports.ngTable = ngTable;
/***/ },
/* 14 */
/* unknown exports provided */
/* all exports used */
/*!**************************************!*\
!*** ./src/browser/ngTableColumn.ts ***!
\**************************************/
/***/ function(module, exports, __webpack_require__) {
"use strict";
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
"use strict";
var ng1 = __webpack_require__(/*! angular */ 0);
/**
* @private
*/
function isScopeLike(object) {
return object != null && ng1.isFunction(object.$new);
}
/**
* @private
* Service to construct a $column definition used by {@link ngTable ngTable} directive
*/
var NgTableColumn = (function () {
function NgTableColumn() {
}
/**
* Creates a $column for use within a header template
*
* @param column the initial definition for $column to build
* @param defaultScope the $scope to supply to the $column getter methods when not supplied by caller
* @param columns a reference to the $columns array to make available on the context supplied to the
* $column getter methods
*/
NgTableColumn.prototype.buildColumn = function (column, defaultScope, columns) {
// note: we're not modifying the original column object. This helps to avoid unintended side affects
var extendedCol = Object.create(column);
var defaults = this.createDefaults();
var _loop_1 = function(prop) {
if (extendedCol[prop] === undefined) {
extendedCol[prop] = defaults[prop];
}
if (!ng1.isFunction(extendedCol[prop])) {
// wrap raw field values with "getter" functions
// - this is to ensure consistency with how ngTable.compile builds columns
// - note that the original column object is being "proxied"; this is important
// as it ensure that any changes to the original object will be returned by the "getter"
var getterSetter = function getterSetter() {
if (arguments.length === 1 && !isScopeLike(arguments[0])) {
getterSetter.assign(null, arguments[0]);
}
else {
return column[prop];
}
};
getterSetter.assign = function ($scope, value) {
column[prop] = value;
};
extendedCol[prop] = getterSetter;
}
// satisfy the arguments expected by the function returned by parsedAttribute in the ngTable directive
var getterFn = extendedCol[prop];
extendedCol[prop] = function () {
if (arguments.length === 1 && !isScopeLike(arguments[0])) {
getterFn.assign(defaultScope, arguments[0]);
}
else {
var scope = arguments[0] || defaultScope;
var context = Object.create(scope);
ng1.extend(context, {
$column: extendedCol,
$columns: columns
});
return getterFn.call(column, context);
}
};
if (getterFn.assign) {
extendedCol[prop].assign = getterFn.assign;
}
else {
var wrappedGetterFn_1 = extendedCol[prop];
var localValue_1;
var getterSetter = function getterSetter() {
if (arguments.length === 1 && !isScopeLike(arguments[0])) {
getterSetter.assign(null, arguments[0]);
}
else {
return localValue_1 != undefined ? localValue_1 : wrappedGetterFn_1.apply(extendedCol, arguments);
}
};
getterSetter.assign = function ($scope, value) {
localValue_1 = value;
};
extendedCol[prop] = getterSetter;
}
};
for (var prop in defaults) {
_loop_1(prop);
}
return extendedCol;
};
NgTableColumn.prototype.createDefaults = function () {
return {
'class': this.createGetterSetter(''),
filter: this.createGetterSetter(false),
groupable: this.createGetterSetter(false),
filterData: ng1.noop,
headerTemplateURL: this.createGetterSetter(false),
headerTitle: this.createGetterSetter(''),
sortable: this.createGetterSetter(false),
show: this.createGetterSetter(true),
title: this.createGetterSetter(''),
titleAlt: this.createGetterSetter('')
};
};
NgTableColumn.prototype.createGetterSetter = function (initialValue) {
var value = initialValue;
var getterSetter = function getterSetter() {
if (arguments.length === 1 && !isScopeLike(arguments[0])) {
getterSetter.assign(null, arguments[0]);
}
else {