@netgrif/components-core 6.0.1

package/esm2015/lib/view/workflow-view/models/injection-token-workflow-service.js

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * An InjectionToken that can be used to set the process filter in workflow view
+ */
+export const NAE_WORKFLOW_SERVICE_FILTER = new InjectionToken('NaeWorkflowServiceFilter');
+/**
+ * An InjectionToken that can be used to enable/disable process delete confirmation dialog
+ */
+export const NAE_WORKFLOW_SERVICE_CONFIRM_DELETE = new InjectionToken('NaeWorkflowServiceConfirmDelete');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0aW9uLXRva2VuLXdvcmtmbG93LXNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy93b3JrZmxvdy12aWV3L21vZGVscy9pbmplY3Rpb24tdG9rZW4td29ya2Zsb3ctc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRzdDOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQUcsSUFBSSxjQUFjLENBQXNCLDBCQUEwQixDQUFDLENBQUM7QUFFL0c7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxtQ0FBbUMsR0FBRyxJQUFJLGNBQWMsQ0FBVSxpQ0FBaUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1BldHJpTmV0UmVxdWVzdEJvZHl9IGZyb20gJy4uLy4uLy4uL3Jlc291cmNlcy9pbnRlcmZhY2UvcGV0cmktbmV0LXJlcXVlc3QtYm9keSc7XG5cbi8qKlxuICogQW4gSW5qZWN0aW9uVG9rZW4gdGhhdCBjYW4gYmUgdXNlZCB0byBzZXQgdGhlIHByb2Nlc3MgZmlsdGVyIGluIHdvcmtmbG93IHZpZXdcbiAqL1xuZXhwb3J0IGNvbnN0IE5BRV9XT1JLRkxPV19TRVJWSUNFX0ZJTFRFUiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxQZXRyaU5ldFJlcXVlc3RCb2R5PignTmFlV29ya2Zsb3dTZXJ2aWNlRmlsdGVyJyk7XG5cbi8qKlxuICogQW4gSW5qZWN0aW9uVG9rZW4gdGhhdCBjYW4gYmUgdXNlZCB0byBlbmFibGUvZGlzYWJsZSBwcm9jZXNzIGRlbGV0ZSBjb25maXJtYXRpb24gZGlhbG9nXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfV09SS0ZMT1dfU0VSVklDRV9DT05GSVJNX0RFTEVURSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxib29sZWFuPignTmFlV29ya2Zsb3dTZXJ2aWNlQ29uZmlybURlbGV0ZScpO1xuIl19

package/esm2015/lib/view/workflow-view/workflow-view.service.js

@@ -0,0 +1,211 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { SortableView } from '../abstract/sortable-view';
+import { PetriNetResourceService } from '../../resources/engine-endpoint/petri-net-resource.service';
+import { BehaviorSubject, of } from 'rxjs';
+import { Net } from '../../process/net';
+import { catchError, concatMap, map, mergeMap, scan, tap } from 'rxjs/operators';
+import { LoggerService } from '../../logger/services/logger.service';
+import { HttpParams } from '@angular/common/http';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { hasContent } from '../../utility/pagination/page-has-content';
+import { NAE_WORKFLOW_SERVICE_CONFIRM_DELETE, NAE_WORKFLOW_SERVICE_FILTER } from './models/injection-token-workflow-service';
+import { DialogService } from '../../dialog/services/dialog.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { arrayToObservable } from '../../utility/array-to-observable';
+import { SearchIndexResolverService } from '../../search/search-keyword-resolver-service/search-index-resolver.service';
+export class WorkflowViewService extends SortableView {
+    constructor(_petriNetResource, _log, _dialogService, _snackBarService, _translate, resolver, injectedBaseFilter, confirmDelete) {
+        super(resolver);
+        this._petriNetResource = _petriNetResource;
+        this._log = _log;
+        this._dialogService = _dialogService;
+        this._snackBarService = _snackBarService;
+        this._translate = _translate;
+        this._loading$ = new LoadingEmitter();
+        this._clear = false;
+        this._endOfData = false;
+        this._pagination = {
+            size: 25,
+            totalElements: undefined,
+            totalPages: undefined,
+            number: -1
+        };
+        this._nextPage$ = new BehaviorSubject(Object.assign({}, this._pagination, { number: 0 }));
+        this._baseFilter = injectedBaseFilter !== null ? injectedBaseFilter : {};
+        this._showDeleteConfirmationDialog = confirmDelete === null || confirmDelete;
+        const workflowsMap = this._nextPage$.pipe(mergeMap(p => this.loadPage(p)), map(petriNets => {
+            if (this._clear) {
+                // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content
+                const results = [{ content: [], stopLoading: false }, { content: petriNets, stopLoading: true }];
+                return arrayToObservable(results);
+            }
+            else {
+                return of({ content: petriNets, stopLoading: true });
+            }
+        }), concatMap(o => o), map(o => {
+            if (o.stopLoading) {
+                this._loading$.off();
+            }
+            return o.content;
+        }), map(petriNets => {
+            return petriNets.reduce((acc, cur) => {
+                return Object.assign(Object.assign({}, acc), { [cur.stringId]: cur });
+            }, {});
+        }), scan((acc, petriNetsMap) => {
+            if (this._clear) {
+                this._clear = false;
+                return Object.assign({}, petriNetsMap);
+            }
+            return Object.assign(Object.assign({}, acc), petriNetsMap);
+        }, {}));
+        this._workflows$ = workflowsMap.pipe(map(v => Object.values(v)));
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._loading$.complete();
+        this._nextPage$.complete();
+    }
+    get loading() {
+        return this._loading$.isActive;
+    }
+    get loading$() {
+        return this._loading$.asObservable();
+    }
+    get workflows$() {
+        return this._workflows$;
+    }
+    loadPage(pageRequest) {
+        if (pageRequest.number < 0) {
+            return of([]);
+        }
+        let params = new HttpParams();
+        params = this.addSortParams(params);
+        params = this.addPageParams(params, pageRequest);
+        this._loading$.on();
+        return this._petriNetResource.searchPetriNets(this._baseFilter, params).pipe(catchError(err => {
+            this._log.error('Loading Petri nets has failed!', err);
+            return of({ content: [], pagination: Object.assign({}, this._pagination) });
+        }), tap(res => {
+            Object.assign(this._pagination, res.pagination);
+        }), tap(res => {
+            this._endOfData = !hasContent(res)
+                || res.pagination.number === res.pagination.totalPages - 1;
+        }), map((netsPage) => {
+            if (hasContent(netsPage)) {
+                const array = [];
+                netsPage.content.forEach(net => {
+                    array.push(new Net(net));
+                });
+                return array;
+            }
+            return [];
+        }));
+    }
+    nextPage(renderedRange, totalLoaded, pagination) {
+        if (this._endOfData) {
+            return;
+        }
+        if (renderedRange.end === totalLoaded) {
+            let p = pagination;
+            if (p === undefined) {
+                p = Object.assign({}, this._pagination);
+                p.number += 1;
+            }
+            this._nextPage$.next(p);
+        }
+    }
+    reload() {
+        if (!this._workflows$ || !this._pagination) {
+            return;
+        }
+        this._endOfData = false;
+        this._clear = true;
+        const p = Object.assign({}, this._pagination);
+        p.number = 0;
+        const range = {
+            start: -1,
+            end: 0
+        };
+        this.nextPage(range, 0, p);
+    }
+    /**
+     * Opens a dialog (if configured) and then asks the service to delete the selected workflow.
+     * @param workflow the workflow that should be deleted
+     */
+    deleteWorkflow(workflow) {
+        if (this._showDeleteConfirmationDialog) {
+            const confirmationText = this._translate.instant('workflow.delete').toUpperCase();
+            this._dialogService.openPromptDialog(this._translate.instant('workflow.dialog.header', { name: workflow.title, version: workflow.version }), this._translate.instant('workflow.dialog.content'), this._translate.instant('workflow.dialog.typeToConfirm', { delete: confirmationText }))
+                .afterClosed().subscribe(result => {
+                if (result !== undefined && result.prompt === confirmationText) {
+                    this._deleteWorkflow(workflow);
+                }
+                else {
+                    this._snackBarService.openGenericSnackBar(this._translate.instant('workflow.snackBar.deleteCanceled'), 'info');
+                }
+            });
+        }
+        else {
+            this._deleteWorkflow(workflow);
+        }
+    }
+    /**
+     * Sends the workflow delete to backend and processes the result.
+     * @param workflow the workflow that should be deleted
+     */
+    _deleteWorkflow(workflow) {
+        this._petriNetResource.deletePetriNet(workflow.stringId).subscribe(response => {
+            this._snackBarService.openSuccessSnackBar(this._translate.instant('workflow.snackBar.deleteSuccess'));
+            this._log.info('Process delete success. Server response: ' + response.success);
+            this.reload();
+        }, error => {
+            this._snackBarService.openErrorSnackBar(this._translate.instant('workflow.snackBar.deleteError'));
+            this._log.error('Process delete failed. Server response: ' + error);
+        });
+    }
+    getMetaFieldSortId() {
+        return this._lastHeaderSearchState.fieldIdentifier;
+    }
+    getDefaultSortParam() {
+        // TODO 7.4.2020 - workflow sorting and searching
+        return '';
+    }
+    addSortParams(params) {
+        if (this._lastHeaderSearchState.sortDirection !== '') {
+            return params.set('sort', `${this.getSortId()},${this._lastHeaderSearchState.sortDirection}`);
+        }
+        else {
+            return params.set('sort', this.getDefaultSortParam());
+        }
+    }
+    addPageParams(params, pagination) {
+        params = params.set('size', pagination.size + '');
+        params = params.set('page', pagination.number + '');
+        return params;
+    }
+}
+WorkflowViewService.ctorParameters = () => [
+    { type: PetriNetResourceService },
+    { type: LoggerService },
+    { type: DialogService },
+    { type: SnackBarService },
+    { type: TranslateService },
+    { type: SearchIndexResolverService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_FILTER,] }] },
+    { type: Boolean, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_CONFIRM_DELETE,] }] }
+];
+WorkflowViewService.decorators = [
+    { type: Injectable }
+];
+WorkflowViewService.ctorParameters = () => [
+    { type: PetriNetResourceService },
+    { type: LoggerService },
+    { type: DialogService },
+    { type: SnackBarService },
+    { type: TranslateService },
+    { type: SearchIndexResolverService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_FILTER,] }] },
+    { type: Boolean, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_CONFIRM_DELETE,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-view.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/workflow-view/workflow-view.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {SortableView} from '../abstract/sortable-view';\nimport {PetriNetResourceService} from '../../resources/engine-endpoint/petri-net-resource.service';\nimport {BehaviorSubject, Observable, of} from 'rxjs';\nimport {Net} from '../../process/net';\nimport {catchError, concatMap, map, mergeMap, scan, tap} from 'rxjs/operators';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {PetriNetReference} from '../../resources/interface/petri-net-reference';\nimport {HttpParams} from '@angular/common/http';\nimport {Pagination} from '../../resources/interface/pagination';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {Page} from '../../resources/interface/page';\nimport {ListRange} from '@angular/cdk/collections';\nimport {hasContent} from '../../utility/pagination/page-has-content';\nimport {PetriNetRequestBody} from '../../resources/interface/petri-net-request-body';\nimport {NAE_WORKFLOW_SERVICE_CONFIRM_DELETE, NAE_WORKFLOW_SERVICE_FILTER} from './models/injection-token-workflow-service';\nimport {DialogService} from '../../dialog/services/dialog.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {arrayToObservable} from '../../utility/array-to-observable';\nimport {SearchIndexResolverService} from '../../search/search-keyword-resolver-service/search-index-resolver.service';\n\n\n@Injectable()\nexport class WorkflowViewService extends SortableView implements OnDestroy {\n\n    // TODO 19.10.2020 - Add support for requests with context (filter), same as Case- and TaskViewServices\n    protected _loading$: LoadingEmitter;\n    protected _workflows$: Observable<Array<Net>>;\n    protected _clear: boolean;\n    protected _nextPage$: BehaviorSubject<Pagination>;\n    protected _endOfData: boolean;\n    protected _pagination: Pagination;\n    protected _baseFilter: PetriNetRequestBody;\n    protected _showDeleteConfirmationDialog: boolean;\n\n    constructor(protected _petriNetResource: PetriNetResourceService,\n                protected _log: LoggerService,\n                protected _dialogService: DialogService,\n                protected _snackBarService: SnackBarService,\n                protected _translate: TranslateService,\n                resolver: SearchIndexResolverService,\n                @Optional() @Inject(NAE_WORKFLOW_SERVICE_FILTER) injectedBaseFilter: PetriNetRequestBody,\n                @Optional() @Inject(NAE_WORKFLOW_SERVICE_CONFIRM_DELETE) confirmDelete: boolean) {\n        super(resolver);\n        this._loading$ = new LoadingEmitter();\n        this._clear = false;\n        this._endOfData = false;\n        this._pagination = {\n            size: 25,\n            totalElements: undefined,\n            totalPages: undefined,\n            number: -1\n        };\n        this._nextPage$ = new BehaviorSubject<Pagination>(\n            Object.assign({}, this._pagination, {number: 0})\n        );\n\n        this._baseFilter = injectedBaseFilter !== null ? injectedBaseFilter : {};\n        this._showDeleteConfirmationDialog = confirmDelete === null || confirmDelete;\n\n        const workflowsMap = this._nextPage$.pipe(\n            mergeMap(p => this.loadPage(p)),\n            map(petriNets => {\n                if (this._clear) {\n                    // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content\n                    const results = [{content: [], stopLoading: false}, {content: petriNets, stopLoading: true}];\n                    return arrayToObservable(results);\n                } else {\n                    return of({content: petriNets, stopLoading: true});\n                }\n            }),\n            concatMap(o => o),\n            map(o => {\n                if (o.stopLoading) {\n                    this._loading$.off();\n                }\n                return o.content;\n            }),\n            map(petriNets => {\n                return petriNets.reduce((acc, cur) => {\n                    return {...acc, [cur.stringId]: cur};\n                }, {});\n            }),\n            scan((acc, petriNetsMap) => {\n                if (this._clear) {\n                    this._clear = false;\n                    return {...petriNetsMap};\n                }\n                return {...acc, ...petriNetsMap};\n            }, {})\n        );\n\n        this._workflows$ = workflowsMap.pipe(\n            map(v => Object.values(v))\n        );\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._loading$.complete();\n        this._nextPage$.complete();\n    }\n\n    public get loading(): boolean {\n        return this._loading$.isActive;\n    }\n\n    public get loading$(): Observable<boolean> {\n        return this._loading$.asObservable();\n    }\n\n    public get workflows$(): Observable<Array<Net>> {\n        return this._workflows$;\n    }\n\n    public loadPage(pageRequest: Pagination): Observable<Array<Net>> {\n        if (pageRequest.number < 0) {\n            return of([]);\n        }\n        let params: HttpParams = new HttpParams();\n        params = this.addSortParams(params);\n        params = this.addPageParams(params, pageRequest);\n        this._loading$.on();\n\n        return this._petriNetResource.searchPetriNets(this._baseFilter, params).pipe(\n            catchError(err => {\n                this._log.error('Loading Petri nets has failed!', err);\n                return of({content: [], pagination: {...this._pagination}});\n            }),\n            tap(res => {\n                Object.assign(this._pagination, res.pagination);\n            }),\n            tap(res => {\n                this._endOfData = !hasContent(res)\n                    || res.pagination.number === res.pagination.totalPages - 1;\n            }),\n            map((netsPage: Page<PetriNetReference>) => {\n                if (hasContent(netsPage)) {\n                    const array: Array<Net> = [];\n                    netsPage.content.forEach(net => {\n                        array.push(new Net(net));\n                    });\n                    return array;\n                }\n                return [];\n            })\n        );\n    }\n\n    public nextPage(renderedRange: ListRange, totalLoaded: number, pagination?: Pagination) {\n        if (this._endOfData) {\n            return;\n        }\n\n        if (renderedRange.end === totalLoaded) {\n            let p = pagination;\n            if (p === undefined) {\n                p = Object.assign({}, this._pagination);\n                p.number += 1;\n            }\n            this._nextPage$.next(p);\n        }\n    }\n\n    public reload(): void {\n        if (!this._workflows$ || !this._pagination) {\n            return;\n        }\n\n        this._endOfData = false;\n        this._clear = true;\n        const p = Object.assign({}, this._pagination);\n        p.number = 0;\n        const range = {\n            start: -1,\n            end: 0\n        };\n        this.nextPage(range, 0, p);\n    }\n\n    /**\n     * Opens a dialog (if configured) and then asks the service to delete the selected workflow.\n     * @param workflow the workflow that should be deleted\n     */\n    public deleteWorkflow(workflow: Net): void {\n        if (this._showDeleteConfirmationDialog) {\n            const confirmationText = this._translate.instant('workflow.delete').toUpperCase();\n\n            this._dialogService.openPromptDialog(\n                this._translate.instant('workflow.dialog.header', {name: workflow.title, version: workflow.version}),\n                this._translate.instant('workflow.dialog.content'),\n                this._translate.instant('workflow.dialog.typeToConfirm', {delete: confirmationText}))\n                .afterClosed().subscribe(result => {\n                if (result !== undefined && result.prompt === confirmationText) {\n                    this._deleteWorkflow(workflow);\n                } else {\n                    this._snackBarService.openGenericSnackBar(this._translate.instant('workflow.snackBar.deleteCanceled'), 'info');\n                }\n            });\n        } else {\n            this._deleteWorkflow(workflow);\n        }\n    }\n\n    /**\n     * Sends the workflow delete to backend and processes the result.\n     * @param workflow the workflow that should be deleted\n     */\n    protected _deleteWorkflow(workflow: Net): void {\n        this._petriNetResource.deletePetriNet(workflow.stringId).subscribe(response => {\n                this._snackBarService.openSuccessSnackBar(this._translate.instant('workflow.snackBar.deleteSuccess'));\n                this._log.info('Process delete success. Server response: ' + response.success);\n                this.reload();\n            },\n            error => {\n                this._snackBarService.openErrorSnackBar(this._translate.instant('workflow.snackBar.deleteError'));\n                this._log.error('Process delete failed. Server response: ' + error);\n            }\n        );\n    }\n\n    protected getMetaFieldSortId(): string {\n        return this._lastHeaderSearchState.fieldIdentifier;\n    }\n\n    protected getDefaultSortParam(): string {\n        // TODO 7.4.2020 - workflow sorting and searching\n        return '';\n    }\n\n    protected addSortParams(params: HttpParams): HttpParams {\n        if (this._lastHeaderSearchState.sortDirection !== '') {\n            return params.set('sort', `${this.getSortId()},${this._lastHeaderSearchState.sortDirection}`);\n        } else {\n            return params.set('sort', this.getDefaultSortParam());\n        }\n    }\n\n    protected addPageParams(params: HttpParams, pagination: Pagination): HttpParams {\n        params = params.set('size', pagination.size + '');\n        params = params.set('page', pagination.number + '');\n        return params;\n    }\n\n}\n"]}

package/esm2015/netgrif-components-core.js

@@ -0,0 +1,20 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+export { AnonymousAuthenticationInterceptor as ɵj } from './lib/authentication/services/anonymous-authentication-interceptor';
+export { AuthenticationInterceptor as ɵi } from './lib/authentication/services/authentication-interceptor';
+export { AbstractDataFieldComponent as ɵb } from './lib/data-fields/models/abstract-data-field-component';
+export { AbstractTimeInstanceFieldComponent as ɵc } from './lib/data-fields/time-instance-abstract-field/abstract-time-instance-field.component';
+export { AbstractTimeInstanceField as ɵe } from './lib/data-fields/time-instance-abstract-field/models/abstract-time-instance-field';
+export { AlertDialogModule as ɵq } from './lib/dialog/components/alert-dialog/alert-dialog.module';
+export { ConfirmDialogModule as ɵr } from './lib/dialog/components/confirm-dialog/confirm-dialog.module';
+export { PromptDialogModule as ɵs } from './lib/dialog/components/prompt-dialog/prompt-dialog.module';
+export { AbstractDialog as ɵn } from './lib/dialog/models/abstract-dialog';
+export { AbstractHeaderModeComponent as ɵt } from './lib/header/header-modes/abstract-header-mode.component';
+export { AbstractNavigationResizableDrawerComponent as ɵk } from './lib/navigation/navigation-drawer/abstract-navigation-resizable-drawer.component';
+export { PanelWithHeaderBinding as ɵm } from './lib/panel/abstract/panel-with-header-binding';
+export { PanelWithImmediateData as ɵl } from './lib/panel/abstract/panel-with-immediate-data';
+export { DataGroupLayoutType as ɵu } from './lib/resources/interface/data-group-layout';
+export { TranslateInterceptor as ɵa } from './lib/translate/translate-interceptor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0Z3JpZi1jb21wb25lbnRzLWNvcmUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJuZXRncmlmLWNvbXBvbmVudHMtY29yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDO0FBRTdCLE9BQU8sRUFBQyxrQ0FBa0MsSUFBSSxFQUFFLEVBQUMsTUFBTSxvRUFBb0UsQ0FBQztBQUM1SCxPQUFPLEVBQUMseUJBQXlCLElBQUksRUFBRSxFQUFDLE1BQU0sMERBQTBELENBQUM7QUFJekcsT0FBTyxFQUFDLDBCQUEwQixJQUFJLEVBQUUsRUFBQyxNQUFNLHdEQUF3RCxDQUFDO0FBRXhHLE9BQU8sRUFBQyxrQ0FBa0MsSUFBSSxFQUFFLEVBQUMsTUFBTSx1RkFBdUYsQ0FBQztBQUMvSSxPQUFPLEVBQUMseUJBQXlCLElBQUksRUFBRSxFQUFDLE1BQU0sb0ZBQW9GLENBQUM7QUFDbkksT0FBTyxFQUFDLGlCQUFpQixJQUFJLEVBQUUsRUFBQyxNQUFNLDBEQUEwRCxDQUFDO0FBQ2pHLE9BQU8sRUFBQyxtQkFBbUIsSUFBSSxFQUFFLEVBQUMsTUFBTSw4REFBOEQsQ0FBQztBQUN2RyxPQUFPLEVBQUMsa0JBQWtCLElBQUksRUFBRSxFQUFDLE1BQU0sNERBQTRELENBQUM7QUFHcEcsT0FBTyxFQUFDLGNBQWMsSUFBSSxFQUFFLEVBQUMsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RSxPQUFPLEVBQUMsMkJBQTJCLElBQUksRUFBRSxFQUFDLE1BQU0sMERBQTBELENBQUM7QUFDM0csT0FBTyxFQUFDLDBDQUEwQyxJQUFJLEVBQUUsRUFBQyxNQUFNLG1GQUFtRixDQUFDO0FBQ25KLE9BQU8sRUFBQyxzQkFBc0IsSUFBSSxFQUFFLEVBQUMsTUFBTSxnREFBZ0QsQ0FBQztBQUM1RixPQUFPLEVBQUMsc0JBQXNCLElBQUksRUFBRSxFQUFDLE1BQU0sZ0RBQWdELENBQUM7QUFDNUYsT0FBTyxFQUFDLG1CQUFtQixJQUFJLEVBQUUsRUFBQyxNQUFNLDZDQUE2QyxDQUFDO0FBQ3RGLE9BQU8sRUFBQyxvQkFBb0IsSUFBSSxFQUFFLEVBQUMsTUFBTSx1Q0FBdUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcblxuZXhwb3J0IHtBbm9ueW1vdXNBdXRoZW50aWNhdGlvbkludGVyY2VwdG9yIGFzIMm1an0gZnJvbSAnLi9saWIvYXV0aGVudGljYXRpb24vc2VydmljZXMvYW5vbnltb3VzLWF1dGhlbnRpY2F0aW9uLWludGVyY2VwdG9yJztcbmV4cG9ydCB7QXV0aGVudGljYXRpb25JbnRlcmNlcHRvciBhcyDJtWl9IGZyb20gJy4vbGliL2F1dGhlbnRpY2F0aW9uL3NlcnZpY2VzL2F1dGhlbnRpY2F0aW9uLWludGVyY2VwdG9yJztcbmV4cG9ydCB7RmlsZUZpZWxkVmFsdWUgYXMgybVmfSBmcm9tICcuL2xpYi9kYXRhLWZpZWxkcy9maWxlLWZpZWxkL21vZGVscy9maWxlLWZpZWxkLXZhbHVlJztcbmV4cG9ydCB7RmlsZUxpc3RGaWVsZFZhbHVlIGFzIMm1Z30gZnJvbSAnLi9saWIvZGF0YS1maWVsZHMvZmlsZS1saXN0LWZpZWxkL21vZGVscy9maWxlLWxpc3QtZmllbGQtdmFsdWUnO1xuZXhwb3J0IHtJMThuRmllbGRWYWx1ZSBhcyDJtWh9IGZyb20gJy4vbGliL2RhdGEtZmllbGRzL2kxOG4tZmllbGQvbW9kZWxzL2kxOG4tZmllbGQtdmFsdWUnO1xuZXhwb3J0IHtBYnN0cmFjdERhdGFGaWVsZENvbXBvbmVudCBhcyDJtWJ9IGZyb20gJy4vbGliL2RhdGEtZmllbGRzL21vZGVscy9hYnN0cmFjdC1kYXRhLWZpZWxkLWNvbXBvbmVudCc7XG5leHBvcnQge0JlaGF2aW9yIGFzIMm1ZH0gZnJvbSAnLi9saWIvZGF0YS1maWVsZHMvbW9kZWxzL2JlaGF2aW9yJztcbmV4cG9ydCB7QWJzdHJhY3RUaW1lSW5zdGFuY2VGaWVsZENvbXBvbmVudCBhcyDJtWN9IGZyb20gJy4vbGliL2RhdGEtZmllbGRzL3RpbWUtaW5zdGFuY2UtYWJzdHJhY3QtZmllbGQvYWJzdHJhY3QtdGltZS1pbnN0YW5jZS1maWVsZC5jb21wb25lbnQnO1xuZXhwb3J0IHtBYnN0cmFjdFRpbWVJbnN0YW5jZUZpZWxkIGFzIMm1ZX0gZnJvbSAnLi9saWIvZGF0YS1maWVsZHMvdGltZS1pbnN0YW5jZS1hYnN0cmFjdC1maWVsZC9tb2RlbHMvYWJzdHJhY3QtdGltZS1pbnN0YW5jZS1maWVsZCc7XG5leHBvcnQge0FsZXJ0RGlhbG9nTW9kdWxlIGFzIMm1cX0gZnJvbSAnLi9saWIvZGlhbG9nL2NvbXBvbmVudHMvYWxlcnQtZGlhbG9nL2FsZXJ0LWRpYWxvZy5tb2R1bGUnO1xuZXhwb3J0IHtDb25maXJtRGlhbG9nTW9kdWxlIGFzIMm1cn0gZnJvbSAnLi9saWIvZGlhbG9nL2NvbXBvbmVudHMvY29uZmlybS1kaWFsb2cvY29uZmlybS1kaWFsb2cubW9kdWxlJztcbmV4cG9ydCB7UHJvbXB0RGlhbG9nTW9kdWxlIGFzIMm1c30gZnJvbSAnLi9saWIvZGlhbG9nL2NvbXBvbmVudHMvcHJvbXB0LWRpYWxvZy9wcm9tcHQtZGlhbG9nLm1vZHVsZSc7XG5leHBvcnQge0RpYWxvZ0RhdGEgYXMgybVwfSBmcm9tICcuL2xpYi9kaWFsb2cvbW9kZWxzL0RpYWxvZ0RhdGEnO1xuZXhwb3J0IHtEaWFsb2dSZXN1bHQgYXMgybVvfSBmcm9tICcuL2xpYi9kaWFsb2cvbW9kZWxzL0RpYWxvZ1Jlc3VsdCc7XG5leHBvcnQge0Fic3RyYWN0RGlhbG9nIGFzIMm1bn0gZnJvbSAnLi9saWIvZGlhbG9nL21vZGVscy9hYnN0cmFjdC1kaWFsb2cnO1xuZXhwb3J0IHtBYnN0cmFjdEhlYWRlck1vZGVDb21wb25lbnQgYXMgybV0fSBmcm9tICcuL2xpYi9oZWFkZXIvaGVhZGVyLW1vZGVzL2Fic3RyYWN0LWhlYWRlci1tb2RlLmNvbXBvbmVudCc7XG5leHBvcnQge0Fic3RyYWN0TmF2aWdhdGlvblJlc2l6YWJsZURyYXdlckNvbXBvbmVudCBhcyDJtWt9IGZyb20gJy4vbGliL25hdmlnYXRpb24vbmF2aWdhdGlvbi1kcmF3ZXIvYWJzdHJhY3QtbmF2aWdhdGlvbi1yZXNpemFibGUtZHJhd2VyLmNvbXBvbmVudCc7XG5leHBvcnQge1BhbmVsV2l0aEhlYWRlckJpbmRpbmcgYXMgybVtfSBmcm9tICcuL2xpYi9wYW5lbC9hYnN0cmFjdC9wYW5lbC13aXRoLWhlYWRlci1iaW5kaW5nJztcbmV4cG9ydCB7UGFuZWxXaXRoSW1tZWRpYXRlRGF0YSBhcyDJtWx9IGZyb20gJy4vbGliL3BhbmVsL2Fic3RyYWN0L3BhbmVsLXdpdGgtaW1tZWRpYXRlLWRhdGEnO1xuZXhwb3J0IHtEYXRhR3JvdXBMYXlvdXRUeXBlIGFzIMm1dX0gZnJvbSAnLi9saWIvcmVzb3VyY2VzL2ludGVyZmFjZS9kYXRhLWdyb3VwLWxheW91dCc7XG5leHBvcnQge1RyYW5zbGF0ZUludGVyY2VwdG9yIGFzIMm1YX0gZnJvbSAnLi9saWIvdHJhbnNsYXRlL3RyYW5zbGF0ZS1pbnRlcmNlcHRvcic7Il19

package/esm2015/public-api.js

@@ -0,0 +1,45 @@
+/*
+ * Public API Surface of netgrif-components-core
+ */
+export * from './commons/schema';
+/* MODULES */
+export * from './lib/material/material.module';
+export * from './lib/covalent/covalent.module';
+export * from './lib/currency/currency.module';
+/* APIS */
+export * from './lib/logger/public-api';
+export * from './lib/data-fields/public-api';
+export * from './lib/authentication/public-api';
+export * from './lib/user/public-api';
+export * from './lib/panel/public-api';
+export * from './lib/configuration/public-api';
+export * from './lib/forms/public-api';
+export * from './lib/toolbar/public-api';
+export * from './lib/tabs/public-api';
+export * from './lib/side-menu/public-api';
+export * from './lib/dialog/public-api';
+export * from './lib/header/public-api';
+export * from './lib/resources/public-api';
+export * from './lib/navigation/public-api';
+export * from './lib/view/public-api';
+export * from './lib/process/public-api';
+export * from './lib/dashboard/public-api';
+export * from './lib/filter/public-api';
+export * from './lib/snack-bar/public-api';
+export * from './lib/search/public-api';
+export * from './lib/translate/public-api';
+export * from './lib/admin/public-api';
+export * from './lib/utility/public-api';
+export * from './lib/routing/public-api';
+export * from './lib/task-content/public-api';
+export * from './lib/task/public-api';
+export * from './lib/moment/public-api';
+export * from './lib/authorization/public-api';
+export * from './lib/public/public-api';
+export * from './lib/groups/public-api';
+export * from './lib/legal/public-api';
+export * from './lib/allowed-nets/public-api';
+export * from './lib/event-queue/public-api';
+export * from './lib/changed-fields/public-api';
+export * from './lib/event/public-api';
+//# sourceMappingURL=data:application/json;base64,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