@smartsoft001-mobilems/angular 1.0.63 → 2.1.0

package/fesm2022/smartsoft001-mobilems-angular.mjs

@@ -0,0 +1,709 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, signal, Component, Directive, effect, contentChild, APP_INITIALIZER, NgModule } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { StyleService as StyleService$1, AppBaseComponent, PageBaseComponent, BaseComponent, SharedModule as SharedModule$1 } from '@smartsoft001/angular';
+import { HttpClient } from '@angular/common/http';
+import * as moment from 'moment';
+import { lastValueFrom, combineLatest, firstValueFrom, of, throwError } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import { CrudService, CrudFacade } from '@smartsoft001/crud-shell-angular';
+import { RouterOutlet, RouterModule } from '@angular/router';
+import { __decorate, __metadata } from 'tslib';
+import * as _ from 'lodash';
+import { Debounce } from 'lodash-decorators';
+
+function setTranslationsAndLang(service) {
+    const map = {
+        pl: TRANSLATE_DATA_PL,
+    };
+    Object.keys(map).forEach((key) => {
+        service.setTranslation(key, map[key], true);
+    });
+    if (!service.currentLang) {
+        const lang = service.getBrowserLang();
+        service.use(lang ?? 'en');
+    }
+}
+const TRANSLATE_DATA_PL = {
+    MODEL: {
+    //..
+    },
+    //..
+};
+
+const environment = {
+    production: false,
+    apiUrl: '',
+};
+
+const variables = {};
+
+class StyleService {
+    constructor() {
+        this.styleService = inject(StyleService$1);
+    }
+    init(elementRef) {
+        const customVariables = {
+            ...variables,
+        };
+        this.styleService.init(elementRef, customVariables);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: StyleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: StyleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: StyleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class SharedConfig {
+    constructor() {
+        this.apiUrl = '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedConfig }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedConfig, decorators: [{
+            type: Injectable
+        }] });
+
+class ConfigsService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.config = inject(SharedConfig);
+    }
+    get() {
+        const date = moment().format('YYYY-MM-DD');
+        return lastValueFrom(combineLatest([
+            this.httpClient.post(this.config.apiUrl + 'object/object-of-the-week', {
+                dateStart: date,
+                dateEnd: date,
+            }),
+            this.httpClient.get(this.config.apiUrl + 'setting/theme'),
+        ]).pipe(map(([r1, r2]) => {
+            return {
+                id: '',
+                objectOfTheDay: {
+                    id: Number(r1?.data?.current?.objectId),
+                    title: r1?.data?.current?.title,
+                },
+                theme: r2.data,
+            };
+        })));
+    }
+    getPage(id) {
+        return firstValueFrom(this.httpClient
+            .get(this.config.apiUrl + 'page/' + id)
+            .pipe(map((r) => r.data)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ConfigsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ConfigsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ConfigsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CrudBaseService extends CrudService {
+    downloadPdf(name, id) {
+        return fetch(this.config.apiUrl + this.getUrlNameForDetails() + '/' + id + '/pdf')
+            .then((resp) => resp.arrayBuffer())
+            .then((resp) => {
+            const file = new Blob([resp], { type: 'application/pdf' });
+            const fileURL = URL.createObjectURL(file);
+            const link = document.createElement('a');
+            link.href = fileURL;
+            link.download = name + '.pdf';
+            link.click();
+        });
+    }
+    getById(id) {
+        return firstValueFrom(this.http
+            .get(this.config.apiUrl + this.getUrlNameForDetails() + '/' + id)
+            .pipe(map((r) => r?.data)));
+    }
+    getList(filter) {
+        let page = 1;
+        if (filter?.offset && filter?.limit) {
+            page = filter.offset / filter.limit;
+        }
+        let url = this.getBaseListUrl(page, filter);
+        if (filter?.searchText) {
+            url += `&filter[phrase]=${filter.searchText}`;
+        }
+        if (filter?.sortBy) {
+            url += `&sort=${filter.sortBy}-${filter.sortDesc ? 'desc' : 'asc'}`;
+        }
+        else {
+            url += `&sort=random`;
+        }
+        filter?.query?.forEach((q) => {
+            const isArray = Array.isArray(q.value);
+            if (isArray) {
+                q.value.forEach((value) => {
+                    url += `&filter[${q.key}]${this.getQueryType(q.type, true)}=${value.id}`;
+                });
+            }
+            else {
+                url += `&filter[${q.key}]${this.getQueryType(q.type, false)}=${q.value}`;
+            }
+        });
+        return firstValueFrom(this.http
+            .get(url)
+            .pipe(map((r) => {
+            const response = r;
+            return {
+                data: response.data?.items ?? [],
+                totalCount: response.data?.paginatorDetails?.totalItemsCount ?? 0,
+                links: {},
+            };
+        }), catchError(this.handleError)));
+    }
+    getBaseListUrl(page, filter) {
+        return `${this.config.apiUrl}${this.getUrlNameForList() !== 'public-collections'
+            ? 'search/' + this.getUrlNameForList()
+            : 'public-collections'}/page/${page}?maxPerPage=${filter?.limit}`;
+    }
+    handleError(err) {
+        if (err.status === 404 || err.status === 406) {
+            return of({
+                data: [],
+                totalCount: 0,
+                links: {},
+            });
+        }
+        return throwError(() => new Error(`There was an error: ${err.status}`));
+    }
+    getQueryType(type, isArray) {
+        switch (type) {
+            case '>=':
+                return '[from]';
+            case '<=':
+                return '[to]';
+            case '=':
+                return isArray ? '[]' : '';
+            default:
+                throw 'Type not supported!';
+        }
+    }
+}
+
+class DictionaryService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.config = inject(SharedConfig);
+    }
+    get(type, query = { page: 1 }) {
+        let url = this.config.apiUrl +
+            `${query.context ? query.context : 'dictionary'}/${type}/search/page/${query.page}?sort=random`;
+        if (query.pageSize) {
+            url += `&maxPerPage=${query.pageSize}`;
+        }
+        if (query.searchText) {
+            url += `&q=${query.searchText}`;
+        }
+        return this.httpClient
+            .get(url)
+            .pipe(map((r) => r.data.items));
+    }
+    getNode(type, query = {}) {
+        let url = this.config.apiUrl +
+            `${query.context ? query.context : 'dictionary'}/${type}/tree`;
+        if (query.nodeId !== null && query.nodeId !== undefined) {
+            //In case the nodeId is 0 or is cast to false
+            url += `?id=${query.nodeId}`;
+        }
+        return this.httpClient
+            .get(url)
+            .pipe(map((r) => r.data));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: DictionaryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: DictionaryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: DictionaryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const SERVICES = [
+    DictionaryService,
+    StyleService,
+    ConfigsService,
+    ConfigsFacade,
+    CrudBaseService,
+];
+
+class ConfigsFacade {
+    constructor() {
+        this.service = inject(ConfigsService);
+        this.sanitizer = inject(DomSanitizer);
+    }
+    static { this._source = signal(null, ...(ngDevMode ? [{ debugName: "_source" }] : [])); }
+    get data() {
+        return ConfigsFacade._source();
+    }
+    getPage(id) {
+        return this.service.getPage(id).then((page) => {
+            if (!page)
+                return page;
+            return {
+                ...page,
+                content: this.sanitizer.bypassSecurityTrustHtml(page.content),
+            };
+        });
+    }
+    init() {
+        return this.service.get().then((config) => {
+            ConfigsFacade._source.set(config);
+            return config;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ConfigsFacade, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ConfigsFacade }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ConfigsFacade, decorators: [{
+            type: Injectable
+        }] });
+
+class AppComponent extends AppBaseComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: AppComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.0", type: AppComponent, isStandalone: true, selector: "smart-mobilems-app", usesInheritance: true, ngImport: i0, template: `
+    <ng-content select="header"></ng-content>
+
+    <main>
+      <router-outlet></router-outlet>
+    </main>
+
+    <ng-content select="footer"></ng-content>
+  `, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name", "routerOutletData"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: AppComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'smart-mobilems-app',
+                    imports: [RouterOutlet],
+                    template: `
+    <ng-content select="header"></ng-content>
+
+    <main>
+      <router-outlet></router-outlet>
+    </main>
+
+    <ng-content select="footer"></ng-content>
+  `,
+                }]
+        }] });
+
+class PageComponent extends PageBaseComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: PageComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.0", type: PageComponent, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: PageComponent, decorators: [{
+            type: Directive
+        }] });
+
+class FiltersContext extends BaseComponent {
+    set searchText(val) {
+        if (this._filter && this._filter.searchText === val)
+            return;
+        this.refresh({
+            searchText: val,
+            offset: 0,
+        });
+    }
+    get searchText() {
+        return this._filter?.searchText;
+    }
+    set page(val) {
+        const offset = this._filter?.limit ? this._filter?.limit * val : 0;
+        if (this._filter && this._filter.offset === offset)
+            return;
+        this.refresh({
+            offset: offset,
+        });
+    }
+    get page() {
+        if (!this._filter)
+            return 1;
+        if (!this._filter.offset || !this._filter.limit)
+            return 1;
+        return this._filter.offset / this._filter.limit;
+    }
+    set limit(val) {
+        if (this._filter && this._filter.limit === val)
+            return;
+        this.refresh({
+            limit: val,
+            offset: 0,
+        });
+    }
+    get limit() {
+        if (!this._filter)
+            return 20;
+        if (!this._filter.limit)
+            return 20;
+        return this._filter.limit;
+    }
+    set sortBy(val) {
+        if (this._filter && this._filter.sortBy === val)
+            return;
+        this.refresh({
+            sortBy: val,
+        });
+    }
+    get sortBy() {
+        return this._filter?.sortBy;
+    }
+    set query(val) {
+        if (this._filter && this._filter.query === val)
+            return;
+        this.refresh({
+            query: val,
+        });
+    }
+    get query() {
+        return this._filter?.query;
+    }
+    set sortDesc(val) {
+        if (this._filter && this._filter.sortDesc === val)
+            return;
+        this.refresh({
+            sortDesc: val,
+        });
+    }
+    get sortDesc() {
+        return this._filter?.sortDesc;
+    }
+    set sort(val) {
+        if (this._filter && this._filter.sortBy === val)
+            return;
+        this.refresh({
+            sortBy: val?.by,
+            sortDesc: val?.desc,
+        });
+    }
+    get sort() {
+        return {
+            by: this._filter?.sortBy,
+            desc: this._filter?.sortDesc,
+        };
+    }
+    set onlyImage(val) {
+        if (!val && this.onlyImage && this._filter) {
+            const result = this._filter.query
+                ? this._filter.query?.filter((q) => !(q.type === '=' && q.key === 'onlyImage'))
+                : [];
+            this.refresh({
+                query: [...result],
+            });
+        }
+        if (val && !this.onlyImage && this._filter) {
+            const result = this._filter.query
+                ? this._filter.query.filter((q) => !(q.type === '=' && q.key === 'onlyImage'))
+                : [];
+            this.refresh({
+                offset: 0,
+                query: [
+                    ...result,
+                    {
+                        type: '=',
+                        key: 'onlyImage',
+                        value: 1,
+                        hidden: true,
+                    },
+                ],
+            });
+        }
+    }
+    get onlyImage() {
+        return this._filter?.query?.some((q) => q.type === '=' && q.key === 'onlyImage' && q.value === 1);
+    }
+    set exposure(val) {
+        if (!val && this.exposure && this._filter) {
+            const result = this._filter.query
+                ? this._filter.query?.filter((q) => !(q.type === '=' &&
+                    q.key === 'locationType' &&
+                    q.value === 'Ekspozycja'))
+                : [];
+            this.refresh({
+                query: [...result],
+            });
+        }
+        if (val && !this.exposure && this._filter) {
+            const result = this._filter.query
+                ? this._filter.query?.filter((q) => !(q.type === '=' &&
+                    q.key === 'locationType' &&
+                    q.value === 'Ekspozycja'))
+                : [];
+            this.refresh({
+                offset: 0,
+                query: [
+                    ...result,
+                    {
+                        type: '=',
+                        key: 'locationType',
+                        value: 'Ekspozycja',
+                        hidden: true,
+                    },
+                ],
+            });
+        }
+    }
+    get exposure() {
+        return this._filter?.query?.some((q) => q.type === '=' && q.key === 'locationType' && q.value === 'Ekspozycja');
+    }
+    set creators(val) {
+        this.filterSet(this.creators, val, 'creators', '=');
+    }
+    get creators() {
+        return this.filterGet('=', 'creators');
+    }
+    set createDatesFrom(val) {
+        this.filterSet(this.createDatesFrom, val, 'createDates', '>=');
+    }
+    get createDatesFrom() {
+        return this.filterGet('>=', 'createDates');
+    }
+    set createDatesTo(val) {
+        this.filterSet(this.createDatesTo, val, 'createDates', '<=');
+    }
+    get createDatesTo() {
+        return this.filterGet('<=', 'createDates');
+    }
+    set publicationDateFrom(val) {
+        this.filterSet(this.publicationDateFrom, val, 'publicationDate', '>=');
+    }
+    get publicationDateFrom() {
+        return this.filterGet('>=', 'publicationDate');
+    }
+    set publicationDateTo(val) {
+        this.filterSet(this.publicationDateTo, val, 'publicationDate', '<=');
+    }
+    get publicationDateTo() {
+        return this.filterGet('<=', 'publicationDate');
+    }
+    set createPlaces(val) {
+        this.filterSet(this.createPlaces, val, 'createPlaces', '=');
+    }
+    get createPlaces() {
+        return this.filterGet('=', 'createPlaces');
+    }
+    set keywords(val) {
+        this.filterSet(this.keywords, val, 'keywords', '=');
+    }
+    get keywords() {
+        return this.filterGet('=', 'keywords');
+    }
+    set techniques(val) {
+        this.filterSet(this.techniques, val, 'techniques', '=');
+    }
+    get techniques() {
+        return this.filterGet('=', 'techniques');
+    }
+    set materials(val) {
+        this.filterSet(this.materials, val, 'materials', '=');
+    }
+    get materials() {
+        return this.filterGet('=', 'materials');
+    }
+    set category(val) {
+        this.filterSet(this.category, val, 'category', '=');
+    }
+    get category() {
+        return this.filterGet('=', 'category');
+    }
+    set department(val) {
+        this.filterSet(this.department, val, 'department', '=');
+    }
+    get department() {
+        return this.filterGet('=', 'department');
+    }
+    set location(val) {
+        this.filterSet(this.category, val, 'location', '=');
+    }
+    get location() {
+        return this.filterGet('=', 'location');
+    }
+    set locationType(val) {
+        this.filterSet(this.category, val, 'locationType', '=');
+    }
+    get locationType() {
+        return this.filterGet('=', 'locationType');
+    }
+    set cycles(val) {
+        this.filterSet(this.cycles, val, 'cycles', '=');
+    }
+    get cycles() {
+        return this.filterGet('=', 'cycles');
+    }
+    set authors(val) {
+        this.filterSet(this.authors, val, 'authors', '=');
+    }
+    get authors() {
+        return this.filterGet('=', 'authors');
+    }
+    set targetGroups(val) {
+        this.filterSet(this.targetGroups, val, 'targetGroups', '=');
+    }
+    get targetGroups() {
+        return this.filterGet('=', 'targetGroups');
+    }
+    set template(val) {
+        this.filterSet(this.template, val, 'template', '=');
+    }
+    get template() {
+        return this.filterGet('=', 'template');
+    }
+    set types(val) {
+        this.filterSet(this.types, val, 'types', '=');
+    }
+    get types() {
+        return this.filterGet('=', 'types');
+    }
+    set extraNumbersValue(val) {
+        this.filterSet(this.creators, val, 'extraNumbersValue', '=');
+    }
+    get extraNumbersValue() {
+        return this.filterGet('=', 'extraNumbersValue');
+    }
+    constructor() {
+        super();
+        this.facade = inject((CrudFacade));
+        this.totalCount = this.facade.totalCount;
+        effect(() => {
+            this._filter = this.facade.filter();
+        });
+    }
+    refresh(filter) {
+        let change = false;
+        Object.keys(filter).forEach((key) => {
+            if (!_.isEqual(this._filter[key], filter[key]))
+                change = true;
+        });
+        if (!change)
+            return;
+        this.facade.read({
+            ...this.facade.filter,
+            ...filter,
+        });
+    }
+    filterGet(key, type) {
+        return this._filter?.query?.find((q) => q.type === key && q.key === type)?.value;
+    }
+    filterSet(currentValue, val, key, type) {
+        if (!val && this._filter) {
+            const result = this._filter?.query
+                ? this._filter?.query?.filter((q) => !(q.type === type && q.key === key))
+                : [];
+            this.refresh({
+                offset: 0,
+                query: [...result],
+            });
+        }
+        if (val && currentValue !== val && this._filter) {
+            const result = this._filter?.query
+                ? this._filter?.query?.filter((q) => !(q.type === type && q.key === key))
+                : [];
+            this.refresh({
+                offset: 0,
+                query: [
+                    ...result,
+                    {
+                        type: type,
+                        key: key,
+                        value: val,
+                        hidden: true,
+                    },
+                ],
+            });
+        }
+    }
+}
+__decorate([
+    Debounce(500),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], FiltersContext.prototype, "refresh", null);
+class FiltersBaseComponent {
+    constructor() {
+        this.contentTpl = contentChild('contentTpl', ...(ngDevMode ? [{ debugName: "contentTpl" }] : []));
+    }
+    ngAfterContentInit() {
+        this.context = new FiltersContext();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: FiltersBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "20.1.0", type: FiltersBaseComponent, isStandalone: true, selector: "smart-mobilems-filters", queries: [{ propertyName: "contentTpl", first: true, predicate: ["contentTpl"], descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: FiltersBaseComponent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'smart-mobilems-filters',
+                }]
+        }] });
+
+const COMPONENTS = [AppComponent];
+
+const DIRECTIVES = [];
+
+function initializeApp(configsFacade) {
+    return () => {
+        setTimeout(() => {
+            configsFacade.init();
+        });
+    };
+}
+class SharedModule {
+    static forFeature(config) {
+        return {
+            ngModule: SharedModule,
+            providers: [
+                {
+                    provide: SharedConfig,
+                    useValue: config,
+                },
+            ],
+        };
+    }
+    static forRoot(config) {
+        return {
+            ngModule: SharedModule,
+            providers: [
+                {
+                    provide: SharedConfig,
+                    useValue: config,
+                },
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: initializeApp,
+                    multi: true,
+                    deps: [ConfigsFacade],
+                },
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.0", ngImport: i0, type: SharedModule, imports: [RouterModule, AppComponent], exports: [SharedModule$1] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedModule, imports: [RouterModule, SharedModule$1] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [...DIRECTIVES],
+                    imports: [RouterModule, COMPONENTS],
+                    exports: [SharedModule$1, ...DIRECTIVES],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AppComponent, COMPONENTS, ConfigsFacade, ConfigsService, CrudBaseService, DictionaryService, FiltersBaseComponent, FiltersContext, PageComponent, SERVICES, SharedConfig, SharedModule, StyleService, TRANSLATE_DATA_PL, environment, setTranslationsAndLang };
+//# sourceMappingURL=smartsoft001-mobilems-angular.mjs.map