ornamentum
Version:
Angular Toolkit
1,144 lines (1,116 loc) • 398 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('@angular/forms'), require('rxjs'), require('rxjs/operators'), require('@angular/common/http'), require('rxjs/webSocket')) :
typeof define === 'function' && define.amd ? define('ornamentum', ['exports', '@angular/core', '@angular/common', '@angular/forms', 'rxjs', 'rxjs/operators', '@angular/common/http', 'rxjs/webSocket'], factory) :
(global = global || self, factory(global.ornamentum = {}, global.ng.core, global.ng.common, global.ng.forms, global.Rx, global.rxjs.operators, global.ng.common.http, global.rxjs.webSocket));
}(this, function (exports, core, common, forms, rxjs, operators, http, webSocket) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __exportStar(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result.default = mod;
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var DATA_TABLE_CONFIG = new core.InjectionToken('dataTableConfig');
/**
* Data table config service
* Manage all the global configurations of grid which can be overridden while importing the module.
*/
var DataTableConfigService = /** @class */ (function () {
function DataTableConfigService(dataTableConfig) {
this.dataTableConfig = dataTableConfig;
// Table base config
this.persistTableState = false;
this.storageMode = 'session';
this.multiColumnSortable = false;
this.showHeader = false;
this.title = '';
this.width = undefined;
this.minContentHeight = 200;
this.minContentWidth = undefined;
this.contentHeight = undefined;
this.pageable = false;
this.loadOnScroll = false;
this.loadViewDistanceRatio = 1;
this.showIndexColumn = false;
this.indexColumnTitle = '#';
this.rowSelectable = false;
this.selectMode = 'single';
this.showRowSelectCheckbox = true;
this.showRowSelectAllCheckbox = false;
this.showSubstituteRows = false;
this.expandableRows = false;
this.selectOnRowClick = false;
this.expandOnRowClick = false;
this.autoFetch = true;
this.showLoadingSpinner = true;
this.selectTrackBy = 'id';
this.filterDebounceTime = 500;
this.filterDebounce = true;
this.showRefreshButton = false;
this.showColumnSelector = false;
this.columnSelectorWidth = 240;
this.expanderColumnWidth = 30;
this.indexColumnWidth = 30;
this.selectionColumnWidth = 30;
this.showRowExpandLoadingSpinner = false;
this.offset = 0;
this.limit = 10;
this.maxLimit = 100;
this.stateKeyPrefix = 'grid_state_';
this.baseTranslations = {
noDataMessage: {
header: 'Whoops!',
body: 'No data to display. Added data will appear here.',
},
pagination: {
limit: 'Limit:',
rangeKey: 'Results:',
rangeSeparator: 'of',
nextTooltip: 'Next',
previousTooltip: 'Previous',
lastTooltip: 'Last',
firstTooltip: 'First'
},
columnSelector: {
header: 'Show/Hide Column'
},
dropdownFilter: {
noDataMessage: 'No Results Available',
filterPlaceholder: 'Search',
selectedOptionWrapPlaceholder: 'Options',
selectPlaceholder: 'Select'
}
};
// Table column config
this.sortable = false;
this.sortOrder = '';
this.filterable = false;
this.filterPlaceholder = 'Search';
this.columnResizable = false;
this.columnVisible = true;
this.showDropdownFilter = false;
this.showFilterClearButton = true;
// Column dropdown filter options
this.dropdownFilterMenuPosition = 'bottom-left';
this.dropdownFilterSelectMode = 'multi';
this.dropdownFilterSearchable = true;
this.dropdownFilterSearchDebounceTime = 500;
this.dropdownFilterSearchDebounce = true;
this.dropdownFilterWrapDisplaySelectLimit = 1;
this.dropdownFilterGroupByField = undefined;
this.dropdownFilterShowSelectedOptionRemoveButton = false;
this.dropdownFilterShowClearSelectionButton = true;
this.dropdownFilterMenuWidth = 320;
this.dropdownFilterMenuHeight = 250;
this.dropdownFilterMultiSelectOptionMaxWidth = 135;
this.dropdownFilterCloseMenuOnSelect = true;
this.dropdownFilterDynamicDimensionCalculation = true;
this.dropdownFilterDynamicWidthRatio = 1.25;
this.dropdownFilterDynamicHeightRatio = 1.25;
if (dataTableConfig) {
Object.assign(this, dataTableConfig);
}
}
Object.defineProperty(DataTableConfigService.prototype, "translations", {
/**
* Returns translations.
*/
get: /**
* Returns translations.
* @return {?}
*/
function () {
return this.baseTranslations;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
var e_1, _a;
if (!value) {
return;
}
try {
// all keys are object type.
for (var _b = __values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), key = _d[0], val = _d[1];
this.baseTranslations[key] = __assign({}, this.baseTranslations[key], val);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DataTableConfigService.prototype, "showRowSelectCheckboxColumn", {
/**
* Get row select checkbox column.
*/
get: /**
* Get row select checkbox column.
* @return {?}
*/
function () {
return this.rowSelectable && this.showRowSelectCheckbox;
},
enumerable: true,
configurable: true
});
DataTableConfigService.decorators = [
{ type: core.Injectable }
];
/** @nocollapse */
DataTableConfigService.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: core.Inject, args: [DATA_TABLE_CONFIG,] }] }
]; };
return DataTableConfigService;
}());
if (false) {
/** @type {?} */
DataTableConfigService.prototype.persistTableState;
/** @type {?} */
DataTableConfigService.prototype.storageMode;
/** @type {?} */
DataTableConfigService.prototype.multiColumnSortable;
/** @type {?} */
DataTableConfigService.prototype.showHeader;
/** @type {?} */
DataTableConfigService.prototype.title;
/** @type {?} */
DataTableConfigService.prototype.width;
/** @type {?} */
DataTableConfigService.prototype.minContentHeight;
/** @type {?} */
DataTableConfigService.prototype.minContentWidth;
/** @type {?} */
DataTableConfigService.prototype.contentHeight;
/** @type {?} */
DataTableConfigService.prototype.pageable;
/** @type {?} */
DataTableConfigService.prototype.loadOnScroll;
/** @type {?} */
DataTableConfigService.prototype.loadViewDistanceRatio;
/** @type {?} */
DataTableConfigService.prototype.showIndexColumn;
/** @type {?} */
DataTableConfigService.prototype.indexColumnTitle;
/** @type {?} */
DataTableConfigService.prototype.rowSelectable;
/** @type {?} */
DataTableConfigService.prototype.selectMode;
/** @type {?} */
DataTableConfigService.prototype.showRowSelectCheckbox;
/** @type {?} */
DataTableConfigService.prototype.showRowSelectAllCheckbox;
/** @type {?} */
DataTableConfigService.prototype.showSubstituteRows;
/** @type {?} */
DataTableConfigService.prototype.expandableRows;
/** @type {?} */
DataTableConfigService.prototype.selectOnRowClick;
/** @type {?} */
DataTableConfigService.prototype.expandOnRowClick;
/** @type {?} */
DataTableConfigService.prototype.autoFetch;
/** @type {?} */
DataTableConfigService.prototype.showLoadingSpinner;
/** @type {?} */
DataTableConfigService.prototype.selectTrackBy;
/** @type {?} */
DataTableConfigService.prototype.filterDebounceTime;
/** @type {?} */
DataTableConfigService.prototype.filterDebounce;
/** @type {?} */
DataTableConfigService.prototype.showRefreshButton;
/** @type {?} */
DataTableConfigService.prototype.showColumnSelector;
/** @type {?} */
DataTableConfigService.prototype.columnSelectorWidth;
/** @type {?} */
DataTableConfigService.prototype.expanderColumnWidth;
/** @type {?} */
DataTableConfigService.prototype.indexColumnWidth;
/** @type {?} */
DataTableConfigService.prototype.selectionColumnWidth;
/** @type {?} */
DataTableConfigService.prototype.showRowExpandLoadingSpinner;
/** @type {?} */
DataTableConfigService.prototype.offset;
/** @type {?} */
DataTableConfigService.prototype.limit;
/** @type {?} */
DataTableConfigService.prototype.maxLimit;
/** @type {?} */
DataTableConfigService.prototype.stateKeyPrefix;
/** @type {?} */
DataTableConfigService.prototype.baseTranslations;
/** @type {?} */
DataTableConfigService.prototype.sortable;
/** @type {?} */
DataTableConfigService.prototype.sortOrder;
/** @type {?} */
DataTableConfigService.prototype.filterable;
/** @type {?} */
DataTableConfigService.prototype.filterPlaceholder;
/** @type {?} */
DataTableConfigService.prototype.columnResizable;
/** @type {?} */
DataTableConfigService.prototype.columnVisible;
/** @type {?} */
DataTableConfigService.prototype.showDropdownFilter;
/** @type {?} */
DataTableConfigService.prototype.showFilterClearButton;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterMenuPosition;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterSelectMode;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterSearchable;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterSearchDebounceTime;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterSearchDebounce;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterWrapDisplaySelectLimit;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterGroupByField;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterShowSelectedOptionRemoveButton;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterShowClearSelectionButton;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterMenuWidth;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterMenuHeight;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterMultiSelectOptionMaxWidth;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterCloseMenuOnSelect;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterDynamicDimensionCalculation;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterDynamicWidthRatio;
/** @type {?} */
DataTableConfigService.prototype.dropdownFilterDynamicHeightRatio;
/**
* @type {?}
* @private
*/
DataTableConfigService.prototype.dataTableConfig;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Data table event state service; Manage all internal data tale event streams.
*/
var DataTableEventStateService = /** @class */ (function () {
function DataTableEventStateService() {
this.allRowSelectChangeStream = new core.EventEmitter();
this.dataFetchStream = new core.EventEmitter();
this.headerClickStream = new core.EventEmitter();
this.rowBindStream = new core.EventEmitter();
this.rowClickStream = new core.EventEmitter();
this.rowDoubleClickStream = new core.EventEmitter();
this.rowSelectChangeStream = new core.EventEmitter();
this.cellBindStream = new core.EventEmitter();
this.cellClickStream = new core.EventEmitter();
this.initStream = new core.EventEmitter();
this.dataBoundStream = new core.EventEmitter();
this.columnBind = new core.EventEmitter();
this.fetchFilterOptionsStream = new rxjs.ReplaySubject(1);
this.staticDataSourceStream = new rxjs.ReplaySubject(1);
}
DataTableEventStateService.decorators = [
{ type: core.Injectable }
];
return DataTableEventStateService;
}());
if (false) {
/** @type {?} */
DataTableEventStateService.prototype.allRowSelectChangeStream;
/** @type {?} */
DataTableEventStateService.prototype.dataFetchStream;
/** @type {?} */
DataTableEventStateService.prototype.headerClickStream;
/** @type {?} */
DataTableEventStateService.prototype.rowBindStream;
/** @type {?} */
DataTableEventStateService.prototype.rowClickStream;
/** @type {?} */
DataTableEventStateService.prototype.rowDoubleClickStream;
/** @type {?} */
DataTableEventStateService.prototype.rowSelectChangeStream;
/** @type {?} */
DataTableEventStateService.prototype.cellBindStream;
/** @type {?} */
DataTableEventStateService.prototype.cellClickStream;
/** @type {?} */
DataTableEventStateService.prototype.initStream;
/** @type {?} */
DataTableEventStateService.prototype.dataBoundStream;
/** @type {?} */
DataTableEventStateService.prototype.columnBind;
/** @type {?} */
DataTableEventStateService.prototype.fetchFilterOptionsStream;
/** @type {?} */
DataTableEventStateService.prototype.staticDataSourceStream;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Data table state manager service; Manage current data table state snapshot.
*/
var DataTableDataStateService = /** @class */ (function () {
function DataTableDataStateService() {
this.allRowSelected = false;
this.selectedRows = [];
this.dataRows = [];
this.dataLoading = true;
this.substituteRows = [];
this.heardReload = false;
this.currentSortPriority = 0;
this.onDynamicRowSpanExtract = (/**
* @return {?}
*/
function () { return 1; });
}
Object.defineProperty(DataTableDataStateService.prototype, "showNoDataOverlay", {
/**
* Get show no data overlay status.
* @return True if no data overlay should be shown.
*/
get: /**
* Get show no data overlay status.
* @return {?} True if no data overlay should be shown.
*/
function () {
return !this.dataRows.length && !this.dataLoading;
},
enumerable: true,
configurable: true
});
/**
* Get data table row unique id.
* @param append Target identifier.
* @param index Target index.
*/
/**
* Get data table row unique id.
* @param {?} append Target identifier.
* @param {?} index Target index.
* @return {?}
*/
DataTableDataStateService.prototype.getUniqueId = /**
* Get data table row unique id.
* @param {?} append Target identifier.
* @param {?} index Target index.
* @return {?}
*/
function (append, index) {
return this.id + "-dt-" + append + "-" + index;
};
DataTableDataStateService.decorators = [
{ type: core.Injectable }
];
return DataTableDataStateService;
}());
if (false) {
/** @type {?} */
DataTableDataStateService.prototype.id;
/** @type {?} */
DataTableDataStateService.prototype.allRowSelected;
/** @type {?} */
DataTableDataStateService.prototype.selectedRow;
/** @type {?} */
DataTableDataStateService.prototype.selectedRows;
/** @type {?} */
DataTableDataStateService.prototype.dataRows;
/** @type {?} */
DataTableDataStateService.prototype.itemCount;
/** @type {?} */
DataTableDataStateService.prototype.tableWidth;
/** @type {?} */
DataTableDataStateService.prototype.dataLoading;
/** @type {?} */
DataTableDataStateService.prototype.substituteRows;
/** @type {?} */
DataTableDataStateService.prototype.heardReload;
/** @type {?} */
DataTableDataStateService.prototype.currentSortPriority;
/** @type {?} */
DataTableDataStateService.prototype.relativeParentElement;
/** @type {?} */
DataTableDataStateService.prototype.onFilterValueExtract;
/** @type {?} */
DataTableDataStateService.prototype.onDataBind;
/** @type {?} */
DataTableDataStateService.prototype.onDynamicRowSpanExtract;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Data table column component. Data table columns associated data is captured via this component.
*/
var DataTableColumnComponent = /** @class */ (function () {
function DataTableColumnComponent(dataTableConfigService, eventStateService, dataStateService) {
this.dataTableConfigService = dataTableConfigService;
this.eventStateService = eventStateService;
this.dataStateService = dataStateService;
this.currentSortOrder = '';
this.baseSortOrder = '';
/**
* Show filed in column selector popup if true.
*/
this.showInColumnSelector = true; // TODO: move to base conf
// Table column config
this.sortable = dataTableConfigService.sortable;
this.currentSortOrder = dataTableConfigService.sortOrder;
this.filterable = dataTableConfigService.filterable;
this.filterPlaceholder = dataTableConfigService.filterPlaceholder;
this.resizable = dataTableConfigService.columnResizable;
this.visible = dataTableConfigService.columnVisible;
this.showDropdownFilter = dataTableConfigService.showDropdownFilter;
this.showFilterClearButton = dataTableConfigService.showFilterClearButton;
// Dropdown filter config
this.dropdownFilterMenuPosition = dataTableConfigService.dropdownFilterMenuPosition;
this.dropdownFilterSelectMode = dataTableConfigService.dropdownFilterSelectMode;
this.dropdownFilterSearchable = dataTableConfigService.dropdownFilterSearchable;
this.dropdownFilterSearchDebounceTime = dataTableConfigService.dropdownFilterSearchDebounceTime;
this.dropdownFilterSearchDebounce = dataTableConfigService.dropdownFilterSearchDebounce;
this.dropdownFilterWrapDisplaySelectLimit = dataTableConfigService.dropdownFilterWrapDisplaySelectLimit;
this.dropdownFilterGroupByField = dataTableConfigService.dropdownFilterGroupByField;
this.dropdownFilterShowSelectedOptionRemoveButton = dataTableConfigService.dropdownFilterShowSelectedOptionRemoveButton;
this.dropdownFilterShowClearSelectionButton = dataTableConfigService.dropdownFilterShowClearSelectionButton;
this.dropdownFilterMenuWidth = dataTableConfigService.dropdownFilterMenuWidth;
this.dropdownFilterMenuHeight = dataTableConfigService.dropdownFilterMenuHeight;
this.dropdownFilterMultiSelectOptionMaxWidth = dataTableConfigService.dropdownFilterMultiSelectOptionMaxWidth;
this.dropdownFilterCloseMenuOnSelect = dataTableConfigService.dropdownFilterCloseMenuOnSelect;
this.dropdownFilterDynamicDimensionCalculation = dataTableConfigService.dropdownFilterDynamicDimensionCalculation;
this.dropdownFilterDynamicWidthRatio = dataTableConfigService.dropdownFilterDynamicWidthRatio;
this.dropdownFilterDynamicHeightRatio = dataTableConfigService.dropdownFilterDynamicHeightRatio;
}
Object.defineProperty(DataTableColumnComponent.prototype, "sortOrder", {
/**
* Get initial column sort order.
*/
get: /**
* Get initial column sort order.
* @return {?}
*/
function () {
return this.currentSortOrder;
},
/**
* Set initial column sort order.
*/
set: /**
* Set initial column sort order.
* @param {?} value
* @return {?}
*/
function (value) {
this.currentSortOrder = value;
this.baseSortOrder = value;
},
enumerable: true,
configurable: true
});
/**
* Reset data sort order.
*/
/**
* Reset data sort order.
* @return {?}
*/
DataTableColumnComponent.prototype.resetSortOrder = /**
* Reset data sort order.
* @return {?}
*/
function () {
this.currentSortOrder = this.baseSortOrder;
};
/**
* Get dynamic cell color.
* @param row Data row object.
* @return Cell color string.
*/
/**
* Get dynamic cell color.
* @param {?} row Data row object.
* @return {?} Cell color string.
*/
DataTableColumnComponent.prototype.getCellColor = /**
* Get dynamic cell color.
* @param {?} row Data row object.
* @return {?} Cell color string.
*/
function (row) {
if (this.onCellColorRender !== undefined) {
return this.onCellColorRender(row, this);
}
};
/**
* Get new sort order upon sort click.
* @return New sort order enum value.
*/
/**
* Get new sort order upon sort click.
* @return {?} New sort order enum value.
*/
DataTableColumnComponent.prototype.getNewSortOrder = /**
* Get new sort order upon sort click.
* @return {?} New sort order enum value.
*/
function () {
/** @type {?} */
var newSortOrder;
switch (this.sortOrder) {
case 'asc':
newSortOrder = 'desc';
break;
case 'desc':
newSortOrder = '';
break;
case '':
newSortOrder = 'asc';
break;
}
return newSortOrder;
};
/**
* Get current sort state icon css class enabled state.
* @return Sort order icon css class collection object.
*/
/**
* Get current sort state icon css class enabled state.
* @return {?} Sort order icon css class collection object.
*/
DataTableColumnComponent.prototype.getSortIconClass = /**
* Get current sort state icon css class enabled state.
* @return {?} Sort order icon css class collection object.
*/
function () {
return {
'sort-asc': this.sortOrder === 'asc',
'sort-dsc': this.sortOrder === 'desc',
'sort-reset': !this.sortOrder
};
};
/**
* Component destroy lifecycle event handler.
*/
/**
* Component destroy lifecycle event handler.
* @return {?}
*/
DataTableColumnComponent.prototype.ngOnDestroy = /**
* Component destroy lifecycle event handler.
* @return {?}
*/
function () {
if (this.filterValueExtractorSubscription) {
this.filterValueExtractorSubscription.unsubscribe();
}
};
/**
* Component initialize lifecycle event handler.
*/
/**
* Component initialize lifecycle event handler.
* @return {?}
*/
DataTableColumnComponent.prototype.ngOnInit = /**
* Component initialize lifecycle event handler.
* @return {?}
*/
function () {
if (!this.cssClass && this.field) {
if (/^[a-zA-Z0-9_]+$/.test(this.field)) {
this.cssClass = 'column-' + this.field;
}
else {
this.cssClass = 'column-' + this.field.replace(/[^a-zA-Z0-9_]/g, '');
}
}
this.eventStateService.columnBind.emit(this);
if (this.dataTableConfigService.multiColumnSortable && this.sortable) {
if (this.sortOrder === '') {
if (this.sortPriority !== undefined) {
throw Error('[sortPriority] should be ignored when multi column sorting is enabled with natural sort order.');
}
}
else {
if (this.sortPriority === undefined) {
throw Error('[sortPriority] is required when multi column sorting is enabled with an explicit sort order.');
}
}
if (this.sortPriority < 1) {
throw Error('[sortPriority] must be greater than 1.');
}
if (this.dataStateService.currentSortPriority < this.sortPriority) {
this.dataStateService.currentSortPriority = this.sortPriority;
}
}
};
DataTableColumnComponent.decorators = [
{ type: core.Component, args: [{
selector: 'ng-data-table-column',
template: ''
}] }
];
/** @nocollapse */
DataTableColumnComponent.ctorParameters = function () { return [
{ type: DataTableConfigService },
{ type: DataTableEventStateService },
{ type: DataTableDataStateService }
]; };
DataTableColumnComponent.propDecorators = {
cellTemplate: [{ type: core.ContentChild, args: ['ngDataTableCell', { static: true },] }],
headerTemplate: [{ type: core.ContentChild, args: ['ngDataTableHeader', { static: true },] }],
filterTemplate: [{ type: core.ContentChild, args: ['ngDataTableFilter', { static: true },] }],
dropdownFilterLoadingSpinnerTemplate: [{ type: core.ContentChild, args: ['ngFilterDropdownLoadingSpinner', { static: true },] }],
dropdownFilterOptionTemplate: [{ type: core.ContentChild, args: ['ngFilterDropdownOption', { static: true },] }],
dropdownFilterOptionGroupHeaderTemplate: [{ type: core.ContentChild, args: ['ngFilterDropdownOptionGroupHeader', { static: true },] }],
filterExpression: [{ type: core.Input }],
filterFieldMapper: [{ type: core.Input }],
onCellColorRender: [{ type: core.Input }],
title: [{ type: core.Input }],
sortable: [{ type: core.Input }],
sortPriority: [{ type: core.Input }],
sortOrder: [{ type: core.Input }],
filterable: [{ type: core.Input }],
resizable: [{ type: core.Input }],
field: [{ type: core.Input }],
filterField: [{ type: core.Input }],
sortField: [{ type: core.Input }],
cssClass: [{ type: core.Input }],
width: [{ type: core.Input }],
visible: [{ type: core.Input }],
showInColumnSelector: [{ type: core.Input }],
filterPlaceholder: [{ type: core.Input }],
filter: [{ type: core.Input }],
showFilterClearButton: [{ type: core.Input }],
resizeMinLimit: [{ type: core.Input }],
showDropdownFilter: [{ type: core.Input }],
dropdownFilterMenuPosition: [{ type: core.Input }],
dropdownFilterSelectMode: [{ type: core.Input }],
dropdownFilterSearchable: [{ type: core.Input }],
dropdownFilterSearchDebounceTime: [{ type: core.Input }],
dropdownFilterSearchDebounce: [{ type: core.Input }],
dropDownFilterShowOptionSelectCheckbox: [{ type: core.Input }],
dropdownFilterWrapDisplaySelectLimit: [{ type: core.Input }],
dropdownFilterGroupByField: [{ type: core.Input }],
dropdownFilterShowSelectedOptionRemoveButton: [{ type: core.Input }],
dropdownFilterShowClearSelectionButton: [{ type: core.Input }],
dropdownFilterMenuWidth: [{ type: core.Input }],
dropdownFilterMenuHeight: [{ type: core.Input }],
dropdownFilterMultiSelectOptionMaxWidth: [{ type: core.Input }],
dropdownFilterCloseMenuOnSelect: [{ type: core.Input }],
dropdownFilterDynamicDimensionCalculation: [{ type: core.Input }],
dropdownFilterDynamicWidthRatio: [{ type: core.Input }],
dropdownFilterDynamicHeightRatio: [{ type: core.Input }]
};
return DataTableColumnComponent;
}());
if (false) {
/**
* @type {?}
* @private
*/
DataTableColumnComponent.prototype.filterValueExtractorSubscription;
/**
* @type {?}
* @private
*/
DataTableColumnComponent.prototype.currentSortOrder;
/**
* @type {?}
* @private
*/
DataTableColumnComponent.prototype.baseSortOrder;
/** @type {?} */
DataTableColumnComponent.prototype.actualWidth;
/** @type {?} */
DataTableColumnComponent.prototype.cellTemplate;
/** @type {?} */
DataTableColumnComponent.prototype.headerTemplate;
/** @type {?} */
DataTableColumnComponent.prototype.filterTemplate;
/** @type {?} */
DataTableColumnComponent.prototype.dropdownFilterLoadingSpinnerTemplate;
/** @type {?} */
DataTableColumnComponent.prototype.dropdownFilterOptionTemplate;
/** @type {?} */
DataTableColumnComponent.prototype.dropdownFilterOptionGroupHeaderTemplate;
/**
* Filter expression event handler callback. Used to apply custom data filter expression logic.
* @type {?}
*/
DataTableColumnComponent.prototype.filterExpression;
/**
* Custom filter field map event handler callback. Used to extract filter field when showDropdownFilter option is true.
* @type {?}
*/
DataTableColumnComponent.prototype.filterFieldMapper;
/**
* Cell color render event handler callback.
* @type {?}
*/
DataTableColumnComponent.prototype.onCellColorRender;
/**
* Column display title.
* @type {?}
*/
DataTableColumnComponent.prototype.title;
/**
* Columns sortable if true. Show sort indicator on column title.
* @type {?}
*/
DataTableColumnComponent.prototype.sortable;
/**
* Multi column sort priority. Lowest number will get the height precedence. Usage of same precedence number in
* multiple columns may lead to unexpected behaviors. This priority number will be displayed in the column header
* when multi column sorting is enabled hence, consider indexing accordingly.
* @type {?}
*/
DataTableColumnComponent.prototype.sortPriority;
/**
* Column filterable if true. Show filter options on filter header row when enabled.
* @type {?}
*/
DataTableColumnComponent.prototype.filterable;
/**
* Column resizeable if true. Show column resize indicator on column right corner.
* @type {?}
*/
DataTableColumnComponent.prototype.resizable;
/**
* Data item mapping field name.
* @type {?}
*/
DataTableColumnComponent.prototype.field;
/**
* Filter field identifier. Fallback to field if not provided.
* @type {?}
*/
DataTableColumnComponent.prototype.filterField;
/**
* Sort field identifier. Fallback to field if not provided.
* @type {?}
*/
DataTableColumnComponent.prototype.sortField;
/**
* Column title CSS class names. Use space delimiter to separate class names.
* @type {?}
*/
DataTableColumnComponent.prototype.cssClass;
/**
* Static column width in pixels or percentage.
* @type {?}
*/
DataTableColumnComponent.prototype.width;
/**
* Render column if true. Else include in column selector but not rendered.
* @type {?}
*/
DataTableColumnComponent.prototype.visible;
/**
* Show filed in column selector popup if true.
* @type {?}
*/
DataTableColumnComponent.prototype.showInColumnSelector;
/**
* Filter placeholder value. Placeholder text to show on filter text box. Applicable only for none dropdown filter mode.
* @type {?}
*/
DataTableColumnComponent.prototype.filterPlaceholder;
/**
* Applied filter value on initialize.
* @type {?}
*/
DataTableColumnComponent.prototype.filter;
/**
* Show filter clear button if true. Applicable only for none dropdown filter mode.
* @type {?}
*/
DataTableColumnComponent.prototype.showFilterClearButton;
/**
* Resize minimum limit. Column cannot be resized to fit less than the number of pixels specified here.
* @type {?}
*/
DataTableColumnComponent.prototype.resizeMinLimit;
/**
* Show dropdown filter if true. Filter data using dropdown filter.
* @type {?}
*/
DataTableColumnComponent.prototype.showDropdownFilter;
/**
* Dropdown filter menu position. Placement of filter popup menu.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterMenuPosition;
/**
* Dropdown select mode. Filter option select mode.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterSelectMode;
/**
* Dropdown filter searchable if true. Display search box within filter option menu.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterSearchable;
/**
* Dropdown filter search debounce time in milliseconds. Applicable only when dropdownFilterSearchDebounce is true.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterSearchDebounceTime;
/**
* Enable dropdown filter data search debounce with provided dropdownFilterSearchDebounceTime if true.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterSearchDebounce;
/**
* Dropdown filter show option select checkbox.
* @type {?}
*/
DataTableColumnComponent.prototype.dropDownFilterShowOptionSelectCheckbox;
/**
* Dropdown filter selected items display limit.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterWrapDisplaySelectLimit;
/**
* Dropdown filter group by field name in item schema.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterGroupByField;
/**
* Dropdown filter show selected option remove button if true.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterShowSelectedOptionRemoveButton;
/**
* Dropdown filter show all select options clear button if true.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterShowClearSelectionButton;
/**
* Dropdown filter menu width in pixels.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterMenuWidth;
/**
* Dropdown filter menu height in pixels.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterMenuHeight;
/**
* Dropdown filter multi select option max width.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterMultiSelectOptionMaxWidth;
/**
* Dropdown filter close menu on select if true.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterCloseMenuOnSelect;
/**
* Dynamically calculate Dropdown filter menu dimensions relative to column width; dropdownFilterMenuWidth and
* dropdownFilterMenuHeight configuration are ignored when true.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterDynamicDimensionCalculation;
/**
* Dynamic dropdown view width ratio. Used for dynamic dimension calculation.
* @type {?}
*/
DataTableColumnComponent.prototype.dropdownFilterDynamicWidthRatio;
/**
* Dynamic dropdown view height ratio. Used for dynamic dimension calculation.
* @type {?}
*/
D