@universis/ngx-tables 0.6.0

package/esm2015/lib/i18n/tables.en.js

@@ -0,0 +1,103 @@
+export const TABLES_EN = {
+    "Tables": {
+        "Export": "Export",
+        "More": "More",
+        "Search": "Search",
+        "SearchPlaceholder": "Search...",
+        "GroupBy": "Group by",
+        "DataTable": {
+            "paginate": {
+                "first": "First",
+                "last": "Last",
+                "next": "Next",
+                "previous": "Previous"
+            },
+            "info": "Showing _START_ to _END_ of _TOTAL_ entries",
+            "infoEmpty": "Showing 0 to 0 of 0 entries",
+            "processing": "Processing data...",
+            "emptyTable": "There are no matching records."
+        },
+        "ColumnDisplay": "Column Display",
+        "ColumnDisplayInfo": "Επιλέξτε τις στήλες που θέλετε να εμφανίζονται.",
+        "Save": "Save",
+        "Apply": "Apply",
+        "Cancel": "Cancel",
+        "RecordsPerPage": "Items per page",
+        "PageInfo": "{{start}}-{{end}} of {{recordsTotal}}",
+        "SearchListPlaceHolder": "Search in list...",
+        "Filters": "Filters",
+        "All": "All",
+        "AddItem": "Add item",
+        "EmptyTableTitle": "There are no matching records.",
+        "EmptyTableMessage": "Please try to use other keywords or search parameters.",
+        "RemoveItem": "Remove item",
+        "Items": "items",
+        "Item": "item",
+        "AddItemMessage": {
+            "title": "Add item",
+            "one": "A new item has been added successfully.",
+            "many": "{{value}} new items have been added successfully."
+        },
+        "RemoveItemMessage": {
+            "title": "Remove items",
+            "one": "An item has been successfully removed.",
+            "many": "{{value}} items have been successfully removed."
+        },
+        "RemoveItemsTitle": "Remove items",
+        "RemoveItemsMessage": "You are going to remove one or more instructor courses. Do you want to proceed?",
+        "SelectAll": "Select all",
+        "ClearSelection": "Clear selection",
+        "Actions": {
+            "Label": "Edit",
+            "Start": "Start",
+            "ActionMessage": {
+                "None": "There is no selected item that meets action requirements.",
+                "One": "You have selected one item that meets action requirements.",
+                "Many": "You have selected {{length}} items that meet action requirements."
+            },
+            "CompletedWithErrors": {
+                "Title": "The operation was completed with errors.",
+                "Description": {
+                    "One": "One item has not been updated due to an error occurred while executing process.",
+                    "Many": "{{errors}} items have not been updated due to an error occurred while executing process."
+                }
+            },
+            "CompletedWithSuccess": {
+                "Title": "The operation was completed successfully."
+            }
+        }
+    },
+    "TrueFalse": {
+        "long": {
+            "Yes": "Yes",
+            "No": "No"
+        }
+    },
+    "AdvancedSearch": {
+        "Choose": "<Select a saved search>",
+        "ChooseDate": "Choose date",
+        "SavedSearches": "Saved searches",
+        "ToggleDropdown": "Toggle Dropdown",
+        "SaveCurrentSearch": "Save search",
+        "SaveAs": "Save as...",
+        "Save": "Save",
+        "Delete": "Remove",
+        "More": "More",
+        "Less": "Less",
+        "Modal": {
+            "Title": "Save current search criteria",
+            "Help": "Please add a title for the given search criteria. This title will help you to use those criteria again in the future.",
+            "TitleOnUserError": "Please use a valid name for your list",
+            "TitleOnListAlreadyCreated": "Name already in use. Please choose a different one",
+            "NoListDefined": "Cannot define user storage key.",
+            "EmptyCriteriaList": "Please define search criteria before save.",
+            "SaveNameLabel": "List name",
+            "SaveNamePlaceholder": "Type a title here...",
+            "Accept": "Save",
+            "Decline": "Decline",
+            "Close": "Close"
+        }
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tables.en.js","sourceRoot":"ng://@universis/ngx-tables/","sources":["lib/i18n/tables.en.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAG;IACrB,QAAQ,EAAE;QACR,QAAQ,EAAE,QAAQ;QAChB,MAAM,EAAE,MAAM;QACd,QAAQ,EAAE,QAAQ;QAClB,mBAAmB,EAAE,WAAW;QAChC,SAAS,EAAE,UAAU;QACrB,WAAW,EAAE;YACT,UAAU,EAAE;gBACR,OAAO,EAAE,OAAO;gBAChB,MAAM,EAAE,MAAM;gBACd,MAAM,EAAE,MAAM;gBACd,UAAU,EAAE,UAAU;aACzB;YACD,MAAM,EAAE,6CAA6C;YACrD,WAAW,EAAE,6BAA6B;YAC1C,YAAY,EAAE,oBAAoB;YAClC,YAAY,EAAE,gCAAgC;SACjD;QACH,eAAe,EAAE,gBAAgB;QACjC,mBAAmB,EAAE,iDAAiD;QACtE,MAAM,EAAE,MAAM;QACd,OAAO,EAAE,OAAO;QAChB,QAAQ,EAAE,QAAQ;QAClB,gBAAgB,EAAE,gBAAgB;QAClC,UAAU,EAAE,uCAAuC;QACnD,uBAAuB,EAAE,mBAAmB;QAC5C,SAAS,EAAE,SAAS;QACpB,KAAK,EAAE,KAAK;QACZ,SAAS,EAAE,UAAU;QACrB,iBAAiB,EAAE,gCAAgC;QACnD,mBAAmB,EAAE,wDAAwD;QAC7E,YAAY,EAAE,aAAa;QAC3B,OAAO,EAAE,OAAO;QAChB,MAAM,EAAE,MAAM;QAChB,gBAAgB,EAAE;YAChB,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,yCAAyC;YAChD,MAAM,EAAE,mDAAmD;SAC5D;QACD,mBAAmB,EAAE;YACnB,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,wCAAwC;YAC/C,MAAM,EAAE,iDAAiD;SAC1D;QACD,kBAAkB,EAAE,cAAc;QAClC,oBAAoB,EAAE,iFAAiF;QACrG,WAAW,EAAE,YAAY;QACzB,gBAAgB,EAAE,iBAAiB;QACnC,SAAS,EAAE;YACT,OAAO,EAAE,MAAM;YACf,OAAO,EAAE,OAAO;YAChB,eAAe,EAAE;gBACf,MAAM,EAAE,2DAA2D;gBACnE,KAAK,EAAE,4DAA4D;gBACnE,MAAM,EAAE,mEAAmE;aAC5E;YACD,qBAAqB,EAAE;gBACrB,OAAO,EAAE,0CAA0C;gBACnD,aAAa,EAAE;oBACb,KAAK,EAAE,iFAAiF;oBACxF,MAAM,EAAE,0FAA0F;iBACnG;aACF;YACD,sBAAsB,EAAE;gBACtB,OAAO,EAAE,2CAA2C;aACrD;SACF;KACF;IACD,WAAW,EAAE;QACT,MAAM,EAAE;YACJ,KAAK,EAAE,KAAK;YACZ,IAAI,EAAE,IAAI;SACb;KACJ;IACD,gBAAgB,EAAE;QACd,QAAQ,EAAE,yBAAyB;QACnC,YAAY,EAAE,aAAa;QAC3B,eAAe,EAAE,gBAAgB;QACjC,gBAAgB,EAAG,iBAAiB;QACpC,mBAAmB,EAAE,aAAa;QAClC,QAAQ,EAAG,YAAY;QACvB,MAAM,EAAG,MAAM;QACf,QAAQ,EAAG,QAAQ;QACnB,MAAM,EAAE,MAAM;QACd,MAAM,EAAE,MAAM;QACd,OAAO,EAAG;YACN,OAAO,EAAG,8BAA8B;YACxC,MAAM,EAAG,uHAAuH;YAChI,kBAAkB,EAAG,uCAAuC;YAC5D,2BAA2B,EAAG,oDAAoD;YAClF,eAAe,EAAG,iCAAiC;YACnD,mBAAmB,EAAG,4CAA4C;YAClE,eAAe,EAAG,WAAW;YAC7B,qBAAqB,EAAG,sBAAsB;YAC9C,QAAQ,EAAG,MAAM;YACjB,SAAS,EAAG,SAAS;YACrB,OAAO,EAAG,OAAO;SACpB;KACJ;CACJ,CAAA","sourcesContent":["export const TABLES_EN = {\n    \"Tables\": {\n      \"Export\": \"Export\",\n        \"More\": \"More\",\n        \"Search\": \"Search\",\n        \"SearchPlaceholder\": \"Search...\",\n        \"GroupBy\": \"Group by\",\n        \"DataTable\": {\n            \"paginate\": {\n                \"first\": \"First\",\n                \"last\": \"Last\",\n                \"next\": \"Next\",\n                \"previous\": \"Previous\"\n            },\n            \"info\": \"Showing _START_ to _END_ of _TOTAL_ entries\",\n            \"infoEmpty\": \"Showing 0 to 0 of 0 entries\",\n            \"processing\": \"Processing data...\",\n            \"emptyTable\": \"There are no matching records.\"\n        },\n      \"ColumnDisplay\": \"Column Display\",\n      \"ColumnDisplayInfo\": \"Επιλέξτε τις στήλες που θέλετε να εμφανίζονται.\",\n      \"Save\": \"Save\",\n      \"Apply\": \"Apply\",\n      \"Cancel\": \"Cancel\",\n      \"RecordsPerPage\": \"Items per page\",\n      \"PageInfo\": \"{{start}}-{{end}} of {{recordsTotal}}\",\n      \"SearchListPlaceHolder\": \"Search in list...\",\n      \"Filters\": \"Filters\",\n      \"All\": \"All\",\n      \"AddItem\": \"Add item\",\n      \"EmptyTableTitle\": \"There are no matching records.\",\n      \"EmptyTableMessage\": \"Please try to use other keywords or search parameters.\",\n      \"RemoveItem\": \"Remove item\",\n      \"Items\": \"items\",\n      \"Item\": \"item\",\n    \"AddItemMessage\": {\n      \"title\": \"Add item\",\n      \"one\": \"A new item has been added successfully.\",\n      \"many\": \"{{value}} new items have been added successfully.\"\n    },\n    \"RemoveItemMessage\": {\n      \"title\": \"Remove items\",\n      \"one\": \"An item has been successfully removed.\",\n      \"many\": \"{{value}} items have been successfully removed.\"\n    },\n    \"RemoveItemsTitle\": \"Remove items\",\n    \"RemoveItemsMessage\": \"You are going to remove one or more instructor courses. Do you want to proceed?\",\n      \"SelectAll\": \"Select all\",\n      \"ClearSelection\": \"Clear selection\",\n      \"Actions\": {\n        \"Label\": \"Edit\",\n        \"Start\": \"Start\",\n        \"ActionMessage\": {\n          \"None\": \"There is no selected item that meets action requirements.\",\n          \"One\": \"You have selected one item that meets action requirements.\",\n          \"Many\": \"You have selected {{length}} items that meet action requirements.\"\n        },\n        \"CompletedWithErrors\": {\n          \"Title\": \"The operation was completed with errors.\",\n          \"Description\": {\n            \"One\": \"One item has not been updated due to an error occurred while executing process.\",\n            \"Many\": \"{{errors}} items have not been updated due to an error occurred while executing process.\"\n          }\n        },\n        \"CompletedWithSuccess\": {\n          \"Title\": \"The operation was completed successfully.\"\n        }\n      }\n    },\n    \"TrueFalse\": {\n        \"long\": {\n            \"Yes\": \"Yes\",\n            \"No\": \"No\"\n        }\n    },\n    \"AdvancedSearch\": {\n        \"Choose\": \"<Select a saved search>\",\n        \"ChooseDate\": \"Choose date\",\n        \"SavedSearches\": \"Saved searches\",\n        \"ToggleDropdown\" : \"Toggle Dropdown\",\n        \"SaveCurrentSearch\": \"Save search\",\n        \"SaveAs\" : \"Save as...\",\n        \"Save\" : \"Save\",\n        \"Delete\" : \"Remove\",\n        \"More\": \"More\",\n        \"Less\": \"Less\",\n        \"Modal\" : {\n            \"Title\" : \"Save current search criteria\",\n            \"Help\" : \"Please add a title for the given search criteria. This title will help you to use those criteria again in the future.\",\n            \"TitleOnUserError\" : \"Please use a valid name for your list\",\n            \"TitleOnListAlreadyCreated\" : \"Name already in use. Please choose a different one\",\n            \"NoListDefined\" : \"Cannot define user storage key.\",\n            \"EmptyCriteriaList\" : \"Please define search criteria before save.\",\n            \"SaveNameLabel\" : \"List name\",\n            \"SaveNamePlaceholder\" : \"Type a title here...\",\n            \"Accept\" : \"Save\",\n            \"Decline\" : \"Decline\",\n            \"Close\" : \"Close\"\n        }\n    }\n}\n"]}

package/esm2015/lib/pipes/advanced-aggregator.pipe.js

@@ -0,0 +1,35 @@
+import { Pipe } from "@angular/core";
+/**
+ *
+ * @class AdvancedAggregatorPipe
+ * @classdesc Given a list of items runs a user defined function against that list
+ *
+ */
+export class AdvancedAggregatorPipe {
+    /**
+     *
+     * @override
+     *
+     * @param items The list of items to run the aggregator against
+     * @param functionPool The functions that are available from the list caller
+     * @param functionName The name of the function to be called
+     *
+     * @returns {string} The value to show at the UI
+     *
+     */
+    transform(items, functionPool, functionName) {
+        if (Array.isArray(items) && functionName && functionName in functionPool) {
+            return functionPool[functionName](items);
+        }
+        else {
+            return '-';
+        }
+    }
+}
+AdvancedAggregatorPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'callAggregator'
+            },] }
+];
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWR2YW5jZWQtYWdncmVnYXRvci5waXBlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHVuaXZlcnNpcy9uZ3gtdGFibGVzLyIsInNvdXJjZXMiOlsibGliL3BpcGVzL2FkdmFuY2VkLWFnZ3JlZ2F0b3IucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUVwRDs7Ozs7R0FLRztBQUtILE1BQU07SUFFSjs7Ozs7Ozs7OztPQVVHO0lBQ0gsU0FBUyxDQUFDLEtBQVksRUFBRSxZQUFpQixFQUFFLFlBQW9CO1FBQzdELElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxZQUFZLElBQUksWUFBWSxJQUFJLFlBQVksRUFBRTtZQUN4RSxPQUFPLFlBQVksQ0FBQyxZQUFZLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQztTQUMxQzthQUFNO1lBQ0wsT0FBTyxHQUFHLENBQUM7U0FDWjtJQUNILENBQUM7OztZQXRCRixJQUFJLFNBQUM7Z0JBQ0osSUFBSSxFQUFFLGdCQUFnQjthQUN2QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG4vKipcbiAqIFxuICogQGNsYXNzIEFkdmFuY2VkQWdncmVnYXRvclBpcGVcbiAqIEBjbGFzc2Rlc2MgR2l2ZW4gYSBsaXN0IG9mIGl0ZW1zIHJ1bnMgYSB1c2VyIGRlZmluZWQgZnVuY3Rpb24gYWdhaW5zdCB0aGF0IGxpc3RcbiAqIFxuICovXG5cbkBQaXBlKHtcbiAgbmFtZTogJ2NhbGxBZ2dyZWdhdG9yJ1xufSlcbmV4cG9ydCBjbGFzcyBBZHZhbmNlZEFnZ3JlZ2F0b3JQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgLyoqXG4gICAqIFxuICAgKiBAb3ZlcnJpZGVcbiAgICogXG4gICAqIEBwYXJhbSBpdGVtcyBUaGUgbGlzdCBvZiBpdGVtcyB0byBydW4gdGhlIGFnZ3JlZ2F0b3IgYWdhaW5zdFxuICAgKiBAcGFyYW0gZnVuY3Rpb25Qb29sIFRoZSBmdW5jdGlvbnMgdGhhdCBhcmUgYXZhaWxhYmxlIGZyb20gdGhlIGxpc3QgY2FsbGVyXG4gICAqIEBwYXJhbSBmdW5jdGlvbk5hbWUgVGhlIG5hbWUgb2YgdGhlIGZ1bmN0aW9uIHRvIGJlIGNhbGxlZFxuICAgKiBcbiAgICogQHJldHVybnMge3N0cmluZ30gVGhlIHZhbHVlIHRvIHNob3cgYXQgdGhlIFVJXG4gICAqIFxuICAgKi9cbiAgdHJhbnNmb3JtKGl0ZW1zOiBhbnlbXSwgZnVuY3Rpb25Qb29sOiBhbnksIGZ1bmN0aW9uTmFtZTogc3RyaW5nKTogYW55IHtcbiAgICBpZiAoQXJyYXkuaXNBcnJheShpdGVtcykgJiYgZnVuY3Rpb25OYW1lICYmIGZ1bmN0aW9uTmFtZSBpbiBmdW5jdGlvblBvb2wpIHtcbiAgICAgIHJldHVybiBmdW5jdGlvblBvb2xbZnVuY3Rpb25OYW1lXShpdGVtcyk7XG4gICAgfSBlbHNlIHtcbiAgICAgIHJldHVybiAnLSc7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2015/lib/pipes/advansed-aggregator-list-title-parse.pipe.js

@@ -0,0 +1,46 @@
+import { Pipe } from "@angular/core";
+import { TranslateService } from "@ngx-translate/core";
+/**
+ *
+ * @class ParseTitlePipe
+ * @classdesc Given a title of an aggregator list, translates and evaluates the parameter if any
+ *
+ */
+export class ParseTitlePipe {
+    constructor(_translateService) {
+        this._translateService = _translateService;
+    }
+    /**
+     *
+     * @override
+     *
+     * @param {string} title The title of the list
+     * @param {string} key The current list key that is being used
+     *
+     */
+    transform(title, key) {
+        if (!title) {
+            return '';
+        }
+        else {
+            if (key === undefined || key === null || key === 'undefined' || key === 'null') {
+                key = this._translateService.instant('Tables.NotDefined');
+            }
+            return title.split(' ')
+                .map((part) => this._translateService.instant(part))
+                .map((part) => part.replace('${param}', key))
+                .join(' ');
+        }
+    }
+}
+ParseTitlePipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'aggregatorListTitle'
+            },] }
+];
+/** @nocollapse */
+ParseTitlePipe.ctorParameters = () => [
+    { type: TranslateService }
+];
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/advanced-aggregator/advanced-aggregator.service.js

@@ -0,0 +1,117 @@
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { AngularDataContext } from '@themost/angular';
+import { TemplatePipe } from '@universis/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@themost/angular";
+import * as i2 from "@universis/common";
+export class AdvancedAggregatorService {
+    constructor(_context, _template) {
+        this._context = _context;
+        this._template = _template;
+    }
+    /**
+     *
+     * Formats and executes the data query
+     *
+     * @param {string} model The target model
+     * @param {object} fixedParams Pairs of parameters to always be applied
+     * @param {string} queryStatement The default query to use for fetching the data (e.g. expands etc)
+     * @param {Array<string>} filters A list of filter expressions to append at the query
+     * @param {string} searchTemplate The template to use for searching expressions
+     * @param {string} searchValue The value of the user search
+     *
+     * @returns {Promise<any>} The response of the query execution
+     */
+    fetchData(model, fixedParams, queryStatement = '', filters, searchTemplate, searchValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const query = this._context.model(model).asQueryable();
+            if (!fixedParams || typeof fixedParams !== 'object') {
+                fixedParams = {};
+            }
+            let filterExpressions = [];
+            if (fixedParams) {
+                for (let param of Object.keys(fixedParams)) {
+                    filterExpressions.push(`${param} eq ${fixedParams[param]}`);
+                }
+            }
+            if (filters && Array.isArray(filters)) {
+                filterExpressions = [
+                    ...filterExpressions,
+                    ...filters
+                ];
+            }
+            if (searchTemplate && searchValue) {
+                let evaluatedSearch;
+                if (/^"(.*?)"$/.test(searchValue)) { // validate search text in double quotes
+                    evaluatedSearch = this._template.transform(searchTemplate, Object.assign({}, fixedParams, { text: searchValue.replace(/^"|"$/g, '') }));
+                }
+                else {
+                    // try to split words
+                    const words = searchValue.split(' ');
+                    // join words to a single filter
+                    evaluatedSearch = words.map(word => {
+                        return this._template.transform(searchTemplate, Object.assign({}, fixedParams, { text: word }));
+                    }).join(' and ');
+                }
+                filterExpressions.push(evaluatedSearch);
+            }
+            query.setParam('$filter', filterExpressions.join(' and '));
+            return query.expand(queryStatement).take(-1).getItems();
+        });
+    }
+    /**
+     *
+     * Formats the received data to use flat keys
+     *
+     * @param config The applied configuration
+     * @param data The raw data
+     *
+     * @returns {Array<any>} The flat-key object list
+     *
+     */
+    formatData(config, data) {
+        try {
+            return data.map((entry) => {
+                let entryObject = {};
+                for (let i = 0; i < config.columns.length; i++) {
+                    const keys = config.columns[i].name.split('/');
+                    let helperObject = entry[keys[0]];
+                    if (helperObject && keys.length > 1) {
+                        for (let i = 1; i < keys.length; i++) {
+                            if (helperObject === undefined || helperObject === null) {
+                                break;
+                            }
+                            else {
+                                helperObject = helperObject[keys[i]] !== undefined && helperObject[keys[i]] !== null
+                                    ? helperObject[keys[i]]
+                                    : undefined;
+                            }
+                        }
+                    }
+                    entryObject[config.columns[i].name] = helperObject;
+                }
+                if (entry.subitems) {
+                    entryObject.subitems = entry.subitems;
+                }
+                return entryObject;
+            });
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+}
+AdvancedAggregatorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+AdvancedAggregatorService.ctorParameters = () => [
+    { type: AngularDataContext },
+    { type: TemplatePipe }
+];
+AdvancedAggregatorService.ngInjectableDef = i0.defineInjectable({ factory: function AdvancedAggregatorService_Factory() { return new AdvancedAggregatorService(i0.inject(i1.AngularDataContext), i0.inject(i2.TemplatePipe)); }, token: AdvancedAggregatorService, providedIn: "root" });
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced-aggregator.service.js","sourceRoot":"ng://@universis/ngx-tables/","sources":["lib/services/advanced-aggregator/advanced-aggregator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AngularDataContext } from '@themost/angular';\nimport { TemplatePipe } from '@universis/common';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AdvancedAggregatorService {\n\n  constructor(\n    private _context: AngularDataContext,\n    private _template: TemplatePipe\n  ) { }\n\n  /**\n   *\n   * Formats and executes the data query\n   *\n   * @param {string} model The target model\n   * @param {object} fixedParams Pairs of parameters to always be applied\n   * @param {string} queryStatement The default query to use for fetching the data (e.g. expands etc)\n   * @param {Array<string>} filters A list of filter expressions to append at the query\n   * @param {string} searchTemplate The template to use for searching expressions\n   * @param {string} searchValue The value of the user search\n   *\n   * @returns {Promise<any>} The response of the query execution\n   */\n  async fetchData(model: string, fixedParams: object, queryStatement: string = '', filters: string[], searchTemplate?: string, searchValue?: string): Promise<any> {\n    const query = this._context.model(model).asQueryable();\n\n    if (!fixedParams || typeof fixedParams !== 'object') {\n      fixedParams = {};\n    }\n\n    let filterExpressions = [];\n\n    if (fixedParams) {\n      for (let param of Object.keys(fixedParams)) {\n        filterExpressions.push(`${param} eq ${fixedParams[param]}`);\n      }\n    }\n\n    if (filters && Array.isArray(filters)) {\n      filterExpressions = [\n        ...filterExpressions,\n        ...filters\n      ]\n    }\n\n    if (searchTemplate && searchValue) {\n      let evaluatedSearch;\n      if (/^\"(.*?)\"$/.test(searchValue)) { // validate search text in double quotes\n        evaluatedSearch = this._template.transform(searchTemplate, {\n          ...fixedParams,\n          text: searchValue.replace(/^\"|\"$/g, '')\n        });\n      } else {\n        // try to split words\n        const words = searchValue.split(' ');\n        // join words to a single filter\n        evaluatedSearch = words.map(word => {\n          return this._template.transform(searchTemplate, {\n            ...fixedParams,\n            text: word\n          });\n        }).join(' and ');\n      }\n      filterExpressions.push(evaluatedSearch);\n    }\n    query.setParam('$filter', filterExpressions.join(' and '));\n    return query.expand(queryStatement).take(-1).getItems();\n  }\n\n  /**\n   *\n   * Formats the received data to use flat keys\n   *\n   * @param config The applied configuration\n   * @param data The raw data\n   *\n   * @returns {Array<any>} The flat-key object list\n   *\n   */\n  formatData(config, data) {\n    try {\n      return data.map((entry) => {\n        let entryObject = {} as any;\n        for (let i = 0; i < config.columns.length; i++) {\n          const keys = config.columns[i].name.split('/');\n          let helperObject = entry[keys[0]];\n\n          if (helperObject && keys.length > 1) {\n            for (let i = 1; i < keys.length; i++) {\n              if (helperObject === undefined || helperObject === null) {\n                break;\n              } else {\n                helperObject = helperObject[keys[i]] !== undefined && helperObject[keys[i]] !== null\n                  ? helperObject[keys[i]]\n                  : undefined;\n              }\n            }\n          }\n\n          entryObject[config.columns[i].name] = helperObject;\n        }\n\n        if (entry.subitems) {\n          entryObject.subitems = entry.subitems;\n        }\n\n        return entryObject;\n      });\n    } catch (err) {\n      console.error(err);\n    }\n  }\n}\n"]}

package/esm2015/lib/tables.activated-table.service.js

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, NavigationStart, Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class ActivatedTableService {
+    constructor(_router, _activatedRoute) {
+        this._router = _router;
+        this._activatedRoute = _activatedRoute;
+        _router.events.forEach((event) => {
+            if (event instanceof NavigationStart) {
+                if (this._activeTable) {
+                    this._activeTable = null;
+                }
+            }
+        });
+    }
+    get activeTable() {
+        return this._activeTable;
+    }
+    set activeTable(tableComponent) {
+        this._activeTable = tableComponent;
+    }
+}
+ActivatedTableService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+ActivatedTableService.ctorParameters = () => [
+    { type: Router },
+    { type: ActivatedRoute }
+];
+ActivatedTableService.ngInjectableDef = i0.defineInjectable({ factory: function ActivatedTableService_Factory() { return new ActivatedTableService(i0.inject(i1.Router), i0.inject(i1.ActivatedRoute)); }, token: ActivatedTableService, providedIn: "root" });
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/tables.module.js

@@ -0,0 +1,134 @@
+import * as tslib_1 from "tslib";
+import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AdvancedTableComponent, COLUMN_FORMATTERS } from './components/advanced-table/advanced-table.component';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
+import { AdvancedTableSearchComponent } from './components/advanced-table/advanced-table-search.component';
+import { DatePipe } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { BtnExpDirective } from './directives/btnexp.directive';
+import { AdvancedTableSettingsComponent } from './components/advanced-table/advanced-table-settings.component';
+import { SharedModule, TemplatePipe } from '@universis/common';
+import { AdvancedTableModalBaseComponent } from './components/advanced-table-modal/advanced-table-modal-base.component';
+import { RouterModalModule } from '@universis/common/routing';
+import { AdvancedSearchFormComponent } from './components/advanced-search-form/advanced-search-form.component';
+import { AdvancedFormsModule } from '@universis/forms';
+import { FormioModule } from 'angular-formio';
+import { AdvancedListComponent } from './components/advanced-list/advanced-list.component';
+import { RouterModule } from '@angular/router';
+import { AdvancedSearchConfigurationResolver, AdvancedTableConfigurationResolver } from './components/advanced-table/advanced-table-resolvers';
+import { AdvancedRowActionComponent } from './components/advanced-row-action/advanced-row-action.component';
+import { FORMATTERS } from './components/advanced-table/advanced-table.formatters.interface';
+import { TABLES_EL } from './i18n/tables.el';
+import { TABLES_EN } from './i18n/tables.en';
+import { TableSimpleHeaderComponent, SimpleHeaderToolsComponent } from './components/table-simple-header/table-simple-header.component';
+import { ModalModule } from 'ngx-bootstrap/modal';
+import { BsDropdownModule } from 'ngx-bootstrap/dropdown';
+import { ProgressbarModule } from 'ngx-bootstrap/progressbar';
+import { AdvancedSelectComponent } from './components/advanced-select/advanced-select.component';
+import { AdvancedSelectService } from './components/advanced-select/advanced-select.service';
+import { AdvancedTableEditorDirective } from './directives/advanced-table-editor.directive';
+import { AdvancedAggregatorComponent } from "./components/advanced-aggregator/advanced-aggregator.component";
+import { AdvancedAggregatorListComponent } from "./components/advanced-aggregator-list/advanced-aggregator-list.component";
+import { AdvancedAggregatorService } from './services/advanced-aggregator/advanced-aggregator.service';
+import { AdvancedAggregatorPipe } from './pipes/advanced-aggregator.pipe';
+import { GroupByPipe, NgPipesModule } from 'ngx-pipes';
+import { ParseTitlePipe } from './pipes/advansed-aggregator-list-title-parse.pipe';
+import { AddItemsComponent } from "./components/add-items/add-items.component";
+const ɵ0 = FORMATTERS;
+export class TablesModule {
+    constructor(_translateService) {
+        this._translateService = _translateService;
+        this.ngOnInit().catch(err => {
+            console.error('An error occurred while loading tables module');
+            console.error(err);
+        });
+    }
+    ngOnInit() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this._translateService.setTranslation('en', TABLES_EN, true);
+            this._translateService.setTranslation('el', TABLES_EL, true);
+        });
+    }
+}
+TablesModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    SharedModule,
+                    TranslateModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    RouterModule,
+                    RouterModalModule,
+                    FormioModule,
+                    AdvancedFormsModule,
+                    SharedModule,
+                    ModalModule,
+                    BsDropdownModule,
+                    ProgressbarModule,
+                    NgPipesModule
+                ],
+                providers: [DatePipe, TemplatePipe,
+                    {
+                        provide: COLUMN_FORMATTERS,
+                        useValue: ɵ0
+                    },
+                    AdvancedTableConfigurationResolver,
+                    AdvancedSearchConfigurationResolver,
+                    AdvancedSelectService,
+                    AdvancedAggregatorService,
+                    GroupByPipe
+                ],
+                declarations: [
+                    AdvancedTableComponent,
+                    AdvancedTableSearchComponent,
+                    BtnExpDirective,
+                    AdvancedTableSettingsComponent,
+                    AdvancedTableModalBaseComponent,
+                    AdvancedSearchFormComponent,
+                    AdvancedListComponent,
+                    AdvancedRowActionComponent,
+                    TableSimpleHeaderComponent,
+                    SimpleHeaderToolsComponent,
+                    AdvancedSelectComponent,
+                    AdvancedTableEditorDirective,
+                    AdvancedAggregatorComponent,
+                    AdvancedAggregatorListComponent,
+                    AdvancedAggregatorPipe,
+                    ParseTitlePipe,
+                    AddItemsComponent
+                ],
+                exports: [
+                    AdvancedTableComponent,
+                    AdvancedTableSearchComponent,
+                    BtnExpDirective,
+                    AdvancedTableSettingsComponent,
+                    AdvancedSearchFormComponent,
+                    AdvancedListComponent,
+                    AdvancedRowActionComponent,
+                    TableSimpleHeaderComponent,
+                    SimpleHeaderToolsComponent,
+                    AdvancedSelectComponent,
+                    AdvancedTableEditorDirective,
+                    AdvancedAggregatorComponent,
+                    AdvancedAggregatorListComponent,
+                    AddItemsComponent
+                ],
+                entryComponents: [
+                    AdvancedTableModalBaseComponent,
+                    AdvancedTableSettingsComponent,
+                    AdvancedRowActionComponent,
+                    AdvancedSelectComponent,
+                    AddItemsComponent
+                ],
+                schemas: [CUSTOM_ELEMENTS_SCHEMA]
+            },] }
+];
+/** @nocollapse */
+TablesModule.ctorParameters = () => [
+    { type: TranslateService }
+];
+export { ɵ0 };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tables.module.js","sourceRoot":"ng://@universis/ngx-tables/","sources":["lib/tables.module.ts"],"names":[],"mappings":"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","sourcesContent":["import {InjectionToken, NgModule, OnInit, CUSTOM_ELEMENTS_SCHEMA} from '@angular/core';\nimport {CommonModule} from '@angular/common';\nimport {AdvancedTableComponent, COLUMN_FORMATTERS} from './components/advanced-table/advanced-table.component';\nimport {TranslateModule, TranslateService} from '@ngx-translate/core';\nimport {AdvancedTableSearchComponent} from './components/advanced-table/advanced-table-search.component';\nimport { DatePipe } from '@angular/common';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\n\nimport {BtnExpDirective} from './directives/btnexp.directive';\nimport {AdvancedTableSettingsComponent} from './components/advanced-table/advanced-table-settings.component';\nimport {SharedModule, TemplatePipe} from '@universis/common';\nimport {AdvancedFilterValueProvider} from './components/advanced-table/advanced-filter-value-provider.service';\nimport { AdvancedTableModalBaseComponent } from './components/advanced-table-modal/advanced-table-modal-base.component';\nimport {RouterModalModule} from '@universis/common/routing';\nimport { AdvancedSearchFormComponent } from './components/advanced-search-form/advanced-search-form.component';\nimport {AdvancedFormsModule} from '@universis/forms';\nimport {FormioModule} from 'angular-formio';\nimport { AdvancedListComponent } from './components/advanced-list/advanced-list.component';\nimport {RouterModule} from '@angular/router';\nimport {\n    AdvancedSearchConfigurationResolver,\n    AdvancedTableConfigurationResolver\n} from './components/advanced-table/advanced-table-resolvers';\nimport {AdvancedRowActionComponent} from './components/advanced-row-action/advanced-row-action.component';\nimport {FORMATTERS} from './components/advanced-table/advanced-table.formatters.interface';\n\nimport {TABLES_EL} from './i18n/tables.el';\nimport {TABLES_EN} from './i18n/tables.en';\nimport { TableSimpleHeaderComponent, SimpleHeaderToolsComponent } from './components/table-simple-header/table-simple-header.component';\nimport { ModalModule } from 'ngx-bootstrap/modal';\nimport { BsDropdownModule } from 'ngx-bootstrap/dropdown';\nimport { ProgressbarModule } from 'ngx-bootstrap/progressbar';\nimport { AdvancedSelectComponent } from './components/advanced-select/advanced-select.component';\nimport { AdvancedSelectService } from './components/advanced-select/advanced-select.service';\nimport { AdvancedTableEditorDirective } from './directives/advanced-table-editor.directive';\nimport {AdvancedAggregatorComponent} from \"./components/advanced-aggregator/advanced-aggregator.component\";\nimport {AdvancedAggregatorListComponent} from \"./components/advanced-aggregator-list/advanced-aggregator-list.component\";\nimport {AdvancedAggregatorService} from './services/advanced-aggregator/advanced-aggregator.service';\nimport {AdvancedAggregatorPipe} from './pipes/advanced-aggregator.pipe';\nimport {GroupByPipe, NgPipesModule} from 'ngx-pipes';\nimport {ParseTitlePipe} from './pipes/advansed-aggregator-list-title-parse.pipe';\nimport {AddItemsComponent} from \"./components/add-items/add-items.component\";\n\n@NgModule({\n    imports: [\n        CommonModule,\n        SharedModule,\n        TranslateModule,\n        FormsModule,\n        ReactiveFormsModule,\n        RouterModule,\n        RouterModalModule,\n        FormioModule,\n        AdvancedFormsModule,\n        SharedModule,\n        ModalModule,\n        BsDropdownModule,\n        ProgressbarModule,\n        NgPipesModule\n    ],\n    providers: [DatePipe, TemplatePipe,\n      {\n        provide: COLUMN_FORMATTERS,\n        useValue: FORMATTERS\n      },\n\n      AdvancedTableConfigurationResolver,\n        AdvancedSearchConfigurationResolver,\n        AdvancedSelectService,\n        AdvancedAggregatorService,\n        GroupByPipe\n      ],\n    declarations: [\n        AdvancedTableComponent,\n        AdvancedTableSearchComponent,\n        BtnExpDirective,\n        AdvancedTableSettingsComponent,\n        AdvancedTableModalBaseComponent,\n        AdvancedSearchFormComponent,\n        AdvancedListComponent,\n        AdvancedRowActionComponent,\n        TableSimpleHeaderComponent,\n        SimpleHeaderToolsComponent,\n        AdvancedSelectComponent,\n        AdvancedTableEditorDirective,\n        AdvancedAggregatorComponent,\n        AdvancedAggregatorListComponent,\n        AdvancedAggregatorPipe,\n        ParseTitlePipe,\n        AddItemsComponent\n    ],\n    exports: [\n        AdvancedTableComponent,\n        AdvancedTableSearchComponent,\n        BtnExpDirective,\n        AdvancedTableSettingsComponent,\n        AdvancedSearchFormComponent,\n        AdvancedListComponent,\n        AdvancedRowActionComponent,\n        TableSimpleHeaderComponent,\n        SimpleHeaderToolsComponent,\n        AdvancedSelectComponent,\n        AdvancedTableEditorDirective,\n        AdvancedAggregatorComponent,\n        AdvancedAggregatorListComponent,\n        AddItemsComponent\n    ],\n    entryComponents: [\n        AdvancedTableModalBaseComponent,\n        AdvancedTableSettingsComponent,\n        AdvancedRowActionComponent,\n        AdvancedSelectComponent,\n        AddItemsComponent\n    ],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA]\n})\nexport class TablesModule implements OnInit {\n    constructor(private _translateService: TranslateService) {\n        this.ngOnInit().catch(err => {\n            console.error('An error occurred while loading tables module');\n            console.error(err);\n        });\n    }\n\n    async ngOnInit() {\n        this._translateService.setTranslation('en', TABLES_EN, true);\n        this._translateService.setTranslation('el', TABLES_EL, true);\n    }\n\n}\n"]}

package/esm2015/public_api.js

@@ -0,0 +1,22 @@
+/*
+ * Public API Surface of tables
+ */
+export * from './lib/components/advanced-list/advanced-list.component';
+export * from './lib/components/advanced-row-action/advanced-row-action.component';
+export * from './lib/components/advanced-search-form/advanced-search-form.component';
+export * from './lib/components/advanced-table/advanced-table-resolvers';
+export * from './lib/components/advanced-table/advanced-table.formatters';
+export * from './lib/components/advanced-table/advanced-table.component';
+export * from './lib/components/advanced-table/advanced-table-search.component';
+export * from './lib/components/advanced-table/advanced-table.formatters.interface';
+export * from './lib/components/advanced-table-modal/advanced-table-modal-base.component';
+export * from './lib/components/advanced-select/advanced-select.component';
+export * from './lib/components/advanced-select/advanced-select.service';
+export * from './lib/tables.module';
+export * from './lib/tables.activated-table.service';
+export * from './lib/directives/advanced-table-editor.directive';
+export * from './lib/components/advanced-aggregator/advanced-aggregator.component';
+export * from './lib/components/advanced-aggregator-list/advanced-aggregator-list.component';
+export * from './lib/components/add-items/add-items.component';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0B1bml2ZXJzaXMvbmd4LXRhYmxlcy8iLCJzb3VyY2VzIjpbInB1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLHdEQUF3RCxDQUFDO0FBQ3ZFLGNBQWMsb0VBQW9FLENBQUM7QUFDbkYsY0FBYyxzRUFBc0UsQ0FBQztBQUVyRixjQUFjLDBEQUEwRCxDQUFDO0FBQ3pFLGNBQWMsMkRBQTJELENBQUM7QUFDMUUsY0FBYywwREFBMEQsQ0FBQztBQUN6RSxjQUFjLGlFQUFpRSxDQUFDO0FBQ2hGLGNBQWMscUVBQXFFLENBQUM7QUFDcEYsY0FBYywyRUFBMkUsQ0FBQztBQUMxRixjQUFjLDREQUE0RCxDQUFDO0FBQzNFLGNBQWMsMERBQTBELENBQUM7QUFDekUsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsa0RBQWtELENBQUM7QUFDakUsY0FBYyxvRUFBb0UsQ0FBQztBQUNuRixjQUFjLDhFQUE4RSxDQUFBO0FBQzVGLGNBQWMsZ0RBQWdELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHRhYmxlc1xuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2FkdmFuY2VkLWxpc3QvYWR2YW5jZWQtbGlzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9hZHZhbmNlZC1yb3ctYWN0aW9uL2FkdmFuY2VkLXJvdy1hY3Rpb24uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvYWR2YW5jZWQtc2VhcmNoLWZvcm0vYWR2YW5jZWQtc2VhcmNoLWZvcm0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvYWR2YW5jZWQtdGFibGUvYWR2YW5jZWQtdGFibGUuaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2FkdmFuY2VkLXRhYmxlL2FkdmFuY2VkLXRhYmxlLXJlc29sdmVycyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2FkdmFuY2VkLXRhYmxlL2FkdmFuY2VkLXRhYmxlLmZvcm1hdHRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9hZHZhbmNlZC10YWJsZS9hZHZhbmNlZC10YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9hZHZhbmNlZC10YWJsZS9hZHZhbmNlZC10YWJsZS1zZWFyY2guY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvYWR2YW5jZWQtdGFibGUvYWR2YW5jZWQtdGFibGUuZm9ybWF0dGVycy5pbnRlcmZhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9hZHZhbmNlZC10YWJsZS1tb2RhbC9hZHZhbmNlZC10YWJsZS1tb2RhbC1iYXNlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2FkdmFuY2VkLXNlbGVjdC9hZHZhbmNlZC1zZWxlY3QuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvYWR2YW5jZWQtc2VsZWN0L2FkdmFuY2VkLXNlbGVjdC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RhYmxlcy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGFibGVzLmFjdGl2YXRlZC10YWJsZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RpcmVjdGl2ZXMvYWR2YW5jZWQtdGFibGUtZWRpdG9yLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2FkdmFuY2VkLWFnZ3JlZ2F0b3IvYWR2YW5jZWQtYWdncmVnYXRvci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9hZHZhbmNlZC1hZ2dyZWdhdG9yLWxpc3QvYWR2YW5jZWQtYWdncmVnYXRvci1saXN0LmNvbXBvbmVudCdcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvYWRkLWl0ZW1zL2FkZC1pdGVtcy5jb21wb25lbnQnO1xuIl19

package/esm2015/universis-ngx-tables.js

@@ -0,0 +1,14 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+export { AdvancedFilterValueProvider as ɵb } from './lib/components/advanced-table/advanced-filter-value-provider.service';
+export { AdvancedTableSearchBaseComponent as ɵa } from './lib/components/advanced-table/advanced-table-search-base';
+export { AdvancedTableSettingsComponent as ɵe } from './lib/components/advanced-table/advanced-table-settings.component';
+export { SimpleHeaderToolsComponent as ɵf, TableSimpleHeaderComponent as ɵg } from './lib/components/table-simple-header/table-simple-header.component';
+export { BtnExpDirective as ɵd } from './lib/directives/btnexp.directive';
+export { AdvancedAggregatorPipe as ɵh } from './lib/pipes/advanced-aggregator.pipe';
+export { ParseTitlePipe as ɵi } from './lib/pipes/advansed-aggregator-list-title-parse.pipe';
+export { AdvancedAggregatorService as ɵc } from './lib/services/advanced-aggregator/advanced-aggregator.service';
+
+//# sourceMappingURL=data:application/json;base64,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