@esolve/ng-esolve-connect 0.19.0 → 0.20.2

package/esm2020/media/components/media-section/esolve-media-section.component.mjs

@@ -0,0 +1,46 @@
+import { Component, Input, Injector } from '@angular/core';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ESOLVE_SECTION_DATA } from '../../esolve-section-data.token';
+import { EsolveMediaLayoutService } from '../../services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/cdk/portal";
+export class EsolveMediaSectionComponent {
+    constructor(layoutService) {
+        this.layoutService = layoutService;
+        this.portals = [];
+    }
+    ngOnChanges() {
+        const sections = this.layoutService.getSectionContent(this.key);
+        this.processPortals(sections);
+    }
+    processPortals(sections) {
+        for (const section of sections) {
+            const injector = Injector.create({
+                providers: [
+                    {
+                        provide: ESOLVE_SECTION_DATA,
+                        useValue: section,
+                    },
+                    {
+                        provide: EsolveMediaLayoutService,
+                        useValue: this.layoutService,
+                    },
+                ],
+            });
+            const component = this.layoutService.getSectionComponent(this.key, section);
+            const portal = new ComponentPortal(component, null, injector);
+            this.portals.push(portal);
+        }
+    }
+}
+EsolveMediaSectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaSectionComponent, deps: [{ token: i1.EsolveMediaLayoutService }], target: i0.ɵɵFactoryTarget.Component });
+EsolveMediaSectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: EsolveMediaSectionComponent, selector: "eslv-media-section", inputs: { key: "key" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"portals.length > 0\">\r\n    <ng-container *ngFor=\"let portal of portals\">\r\n        <ng-template [cdkPortalOutlet]=\"portal\"></ng-template>\r\n    </ng-container>\r\n</ng-container>\r\n", directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaSectionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'eslv-media-section', template: "<ng-container *ngIf=\"portals.length > 0\">\r\n    <ng-container *ngFor=\"let portal of portals\">\r\n        <ng-template [cdkPortalOutlet]=\"portal\"></ng-template>\r\n    </ng-container>\r\n</ng-container>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.EsolveMediaLayoutService }]; }, propDecorators: { key: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/media/esolve-connect-media-config.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const ESOLVE_CONNECT_MEDIA_CONFIG = new InjectionToken('esolve.connect.media.config');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWNvbm5lY3QtbWVkaWEtY29uZmlnLnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctZXNvbHZlLWNvbm5lY3QvbWVkaWEvc3JjL2Vzb2x2ZS1jb25uZWN0LW1lZGlhLWNvbmZpZy50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSS9DLE1BQU0sQ0FBQyxNQUFNLDJCQUEyQixHQUNwQyxJQUFJLGNBQWMsQ0FDZCw2QkFBNkIsQ0FDaEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5pbXBvcnQgeyBFc29sdmVDb25uZWN0TWVkaWFDb25maWcgfSBmcm9tICcuL2Vzb2x2ZS1jb25uZWN0LW1lZGlhLmNvbmZpZyc7XHJcblxyXG5leHBvcnQgY29uc3QgRVNPTFZFX0NPTk5FQ1RfTUVESUFfQ09ORklHID1cclxuICAgIG5ldyBJbmplY3Rpb25Ub2tlbjxFc29sdmVDb25uZWN0TWVkaWFDb25maWc+KFxyXG4gICAgICAgICdlc29sdmUuY29ubmVjdC5tZWRpYS5jb25maWcnLFxyXG4gICAgKTtcclxuIl19

package/esm2020/media/esolve-connect-media.config.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWNvbm5lY3QtbWVkaWEuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctZXNvbHZlLWNvbm5lY3QvbWVkaWEvc3JjL2Vzb2x2ZS1jb25uZWN0LW1lZGlhLmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXNvbHZlTGF5b3V0Q29uZmlnLCBFc29sdmVMYXlvdXRTZWN0aW9uQ29uZmlnIH0gZnJvbSAnLi9pbnRlcmZhY2VzJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgRXNvbHZlQ29ubmVjdE1lZGlhQ29uZmlnIHtcclxuICAgIGxheW91dHM6IEVzb2x2ZUxheW91dENvbmZpZ1tdO1xyXG4gICAgZGVmYXVsdF9sYXlvdXQ/OiBzdHJpbmc7XHJcbiAgICBzZWN0aW9uczogRXNvbHZlTGF5b3V0U2VjdGlvbkNvbmZpZ1tdO1xyXG59XHJcbiJdfQ==

package/esm2020/media/esolve-ng-esolve-connect-media.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLW5nLWVzb2x2ZS1jb25uZWN0LW1lZGlhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctZXNvbHZlLWNvbm5lY3QvbWVkaWEvc3JjL2Vzb2x2ZS1uZy1lc29sdmUtY29ubmVjdC1tZWRpYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/esm2020/media/esolve-section-data.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const ESOLVE_SECTION_DATA = new InjectionToken('esolve.media.layout.section');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLXNlY3Rpb24tZGF0YS50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWVzb2x2ZS1jb25uZWN0L21lZGlhL3NyYy9lc29sdmUtc2VjdGlvbi1kYXRhLnRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFJL0MsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQzVCLElBQUksY0FBYyxDQUNkLDZCQUE2QixDQUNoQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IEVzb2x2ZU1lZGlhTGF5b3V0U2VjdGlvbiB9IGZyb20gJy4vY2xhc3Nlcyc7XHJcblxyXG5leHBvcnQgY29uc3QgRVNPTFZFX1NFQ1RJT05fREFUQSA9XHJcbiAgICBuZXcgSW5qZWN0aW9uVG9rZW48RXNvbHZlTWVkaWFMYXlvdXRTZWN0aW9uPihcclxuICAgICAgICAnZXNvbHZlLm1lZGlhLmxheW91dC5zZWN0aW9uJ1xyXG4gICAgKTtcclxuIl19

package/esm2020/media/interfaces/esolve-heading-record.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWhlYWRpbmctcmVjb3JkLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWVzb2x2ZS1jb25uZWN0L21lZGlhL3NyYy9pbnRlcmZhY2VzL2Vzb2x2ZS1oZWFkaW5nLXJlY29yZC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRXNvbHZlSGVhZGluZ1JlY29yZCB7XHJcbiAgICBpZDogbnVtYmVyO1xyXG4gICAgaWRlbnRpZmllcjogc3RyaW5nO1xyXG4gICAgdmFsdWU6IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2020/media/interfaces/esolve-layout-config.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWxheW91dC1jb25maWcuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctZXNvbHZlLWNvbm5lY3QvbWVkaWEvc3JjL2ludGVyZmFjZXMvZXNvbHZlLWxheW91dC1jb25maWcuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnRUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL3BvcnRhbCc7XHJcblxyXG5pbXBvcnQgeyBFc29sdmVMYXlvdXRTZWN0aW9uQ29uZmlnIH0gZnJvbSAnLi9lc29sdmUtbGF5b3V0LXNlY3Rpb24tY29uZmlnLmludGVyZmFjZSc7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEVzb2x2ZUxheW91dENvbmZpZyB7XHJcbiAgICBrZXk6IHN0cmluZztcclxuICAgIGNvbXBvbmVudDogQ29tcG9uZW50VHlwZTxhbnk+O1xyXG4gICAgc2VjdGlvbnM/OiB7XHJcbiAgICAgICAgW2tleTogc3RyaW5nXTogRXNvbHZlTGF5b3V0U2VjdGlvbkNvbmZpZ1tdO1xyXG4gICAgfTtcclxufVxyXG4iXX0=

package/esm2020/media/interfaces/esolve-layout-section-config.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWxheW91dC1zZWN0aW9uLWNvbmZpZy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lc29sdmUtY29ubmVjdC9tZWRpYS9zcmMvaW50ZXJmYWNlcy9lc29sdmUtbGF5b3V0LXNlY3Rpb24tY29uZmlnLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50VHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9wb3J0YWwnO1xyXG5cclxuaW1wb3J0IHsgRXNvbHZlTWVkaWFMYXlvdXRTZWN0aW9uVHlwZSB9IGZyb20gJy4uL3R5cGVzJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgRXNvbHZlTGF5b3V0U2VjdGlvbkNvbmZpZyB7XHJcbiAgICBrZXk6IEVzb2x2ZU1lZGlhTGF5b3V0U2VjdGlvblR5cGU7XHJcbiAgICBzdWJfa2V5Pzogc3RyaW5nO1xyXG4gICAgY29tcG9uZW50OiBDb21wb25lbnRUeXBlPGFueT47XHJcbn1cclxuIl19

package/esm2020/media/interfaces/esolve-media-group-record.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLW1lZGlhLWdyb3VwLXJlY29yZC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lc29sdmUtY29ubmVjdC9tZWRpYS9zcmMvaW50ZXJmYWNlcy9lc29sdmUtbWVkaWEtZ3JvdXAtcmVjb3JkLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBFc29sdmVNZWRpYUdyb3VwUmVjb3JkIHtcclxuICAgIGlkPzogbnVtYmVyO1xyXG4gICAgbmFtZT86IHN0cmluZztcclxuICAgIHNlZl9uYW1lPzogc3RyaW5nO1xyXG4gICAgZGVzY3JpcHRpb24/OiBzdHJpbmc7XHJcbn1cclxuIl19

package/esm2020/media/interfaces/esolve-media-layout-section-record.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLW1lZGlhLWxheW91dC1zZWN0aW9uLXJlY29yZC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lc29sdmUtY29ubmVjdC9tZWRpYS9zcmMvaW50ZXJmYWNlcy9lc29sdmUtbWVkaWEtbGF5b3V0LXNlY3Rpb24tcmVjb3JkLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXNvbHZlTWVkaWFMYXlvdXRTZWN0aW9uVHlwZSB9IGZyb20gJy4uL3R5cGVzJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgRXNvbHZlTWVkaWFMYXlvdXRTZWN0aW9uUmVjb3JkIHtcclxuICAgIHR5cGU6IEVzb2x2ZU1lZGlhTGF5b3V0U2VjdGlvblR5cGU7XHJcbiAgICBzdWJfdHlwZT86IHN0cmluZztcclxuICAgIGlkZW50aWZpZXI6IHN0cmluZztcclxuICAgIGRhdGE/OiBhbnk7XHJcbn1cclxuIl19

package/esm2020/media/interfaces/esolve-media-record.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/media/interfaces/index.mjs

@@ -0,0 +1,7 @@
+export * from './esolve-layout-config.interface';
+export * from './esolve-layout-section-config.interface';
+export * from './esolve-heading-record.interface';
+export * from './esolve-media-record.interface';
+export * from './esolve-media-group-record.interface';
+export * from './esolve-media-layout-section-record.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lc29sdmUtY29ubmVjdC9tZWRpYS9zcmMvaW50ZXJmYWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxnREFBZ0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXNvbHZlLWxheW91dC1jb25maWcuaW50ZXJmYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtbGF5b3V0LXNlY3Rpb24tY29uZmlnLmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZXNvbHZlLWhlYWRpbmctcmVjb3JkLmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZXNvbHZlLW1lZGlhLXJlY29yZC5pbnRlcmZhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2Vzb2x2ZS1tZWRpYS1ncm91cC1yZWNvcmQuaW50ZXJmYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtbWVkaWEtbGF5b3V0LXNlY3Rpb24tcmVjb3JkLmludGVyZmFjZSc7XHJcbiJdfQ==

package/esm2020/media/ng-esolve-connect-media.module.mjs

@@ -0,0 +1,54 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { PortalModule } from '@angular/cdk/portal';
+import { NgEsolveConnectModule } from '@esolve/ng-esolve-connect';
+import { EsolveMediaLayoutComponent, EsolveMediaSectionComponent } from './components';
+import { ESOLVE_CONNECT_MEDIA_CONFIG } from './esolve-connect-media-config.token';
+import * as i0 from "@angular/core";
+export class NgEsolveConnectMediaModule {
+    static withConfig(config) {
+        return {
+            ngModule: NgEsolveConnectMediaModule,
+            providers: [
+                {
+                    provide: ESOLVE_CONNECT_MEDIA_CONFIG,
+                    useValue: config,
+                },
+            ],
+        };
+    }
+}
+NgEsolveConnectMediaModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgEsolveConnectMediaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgEsolveConnectMediaModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgEsolveConnectMediaModule, declarations: [EsolveMediaLayoutComponent,
+        EsolveMediaSectionComponent], imports: [CommonModule,
+        HttpClientModule,
+        PortalModule,
+        NgEsolveConnectModule], exports: [EsolveMediaLayoutComponent,
+        EsolveMediaSectionComponent] });
+NgEsolveConnectMediaModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgEsolveConnectMediaModule, imports: [[
+            CommonModule,
+            HttpClientModule,
+            PortalModule,
+            NgEsolveConnectModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NgEsolveConnectMediaModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        EsolveMediaLayoutComponent,
+                        EsolveMediaSectionComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        PortalModule,
+                        NgEsolveConnectModule,
+                    ],
+                    exports: [
+                        EsolveMediaLayoutComponent,
+                        EsolveMediaSectionComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/media/public_api.mjs

@@ -0,0 +1,10 @@
+export * from './ng-esolve-connect-media.module';
+export * from './esolve-connect-media.config';
+export * from './esolve-connect-media-config.token';
+export * from './esolve-section-data.token';
+export * from './components';
+export * from './classes';
+export * from './types';
+export * from './interfaces';
+export * from './services';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWVzb2x2ZS1jb25uZWN0L21lZGlhL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsNkJBQTZCLENBQUM7QUFFNUMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL25nLWVzb2x2ZS1jb25uZWN0LW1lZGlhLm1vZHVsZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZXNvbHZlLWNvbm5lY3QtbWVkaWEuY29uZmlnJztcclxuZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtY29ubmVjdC1tZWRpYS1jb25maWcudG9rZW4nO1xyXG5leHBvcnQgKiBmcm9tICcuL2Vzb2x2ZS1zZWN0aW9uLWRhdGEudG9rZW4nO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9jbGFzc2VzJztcclxuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMnO1xyXG4iXX0=

package/esm2020/media/services/esolve-media-layout.service.mjs

@@ -0,0 +1,145 @@
+import { Inject, Injectable } from '@angular/core';
+import { ESOLVE_CONNECT_MEDIA_CONFIG } from '../esolve-connect-media-config.token';
+import * as i0 from "@angular/core";
+export class EsolveMediaLayoutService {
+    constructor(config) {
+        this.section_key_delimiter = '>>>';
+        this.layout_map = new Map();
+        this.section_map = new Map();
+        if (config.layouts.length === 0) {
+            throw new Error('No layouts have been defined');
+        }
+        for (const layout of config.layouts) {
+            this.setLayout(layout.key, layout.component);
+            if (layout.sections) {
+                for (const section_group_key in layout.sections) {
+                    const sections = layout.sections[section_group_key];
+                    for (const section of sections) {
+                        const key_options = {
+                            type: section.key,
+                            sub_type: section.sub_key,
+                            layout: layout.key,
+                        };
+                        if (section_group_key !== '__default') {
+                            key_options.group = section_group_key;
+                        }
+                        this.setSection(section.component, key_options);
+                    }
+                }
+            }
+        }
+        const default_layout = config.default_layout;
+        if (default_layout) {
+            this.default_layout = default_layout;
+        }
+        else {
+            this.default_layout = config.layouts[0].key;
+        }
+        if (config.sections.length > 0) {
+            for (const section of config.sections) {
+                const key_options = {
+                    type: section.key,
+                    sub_type: section.sub_key,
+                };
+                this.setSection(section.component, key_options);
+            }
+        }
+    }
+    getMedia() {
+        if (!this.media) {
+            throw new Error('Media not declared');
+        }
+        return this.media;
+    }
+    setMedia(media) {
+        this.media = media;
+    }
+    getLayout() {
+        const media = this.getMedia();
+        let layout_key = media.layout;
+        if (layout_key === '') {
+            layout_key = this.default_layout;
+        }
+        return this.searchLayout(layout_key);
+    }
+    getSectionContent(key) {
+        const media = this.getMedia();
+        if (media.sections) {
+            const section = media.sections.get(key);
+            if (section) {
+                return section;
+            }
+        }
+        return [];
+    }
+    getSectionComponent(key, section) {
+        const type = section.type;
+        const sub_type = section.sub_type;
+        const { layout } = this.getMedia();
+        const section_key = this.createSectionMapKey({
+            type,
+            sub_type,
+            layout,
+            group: key,
+        });
+        let component = this.section_map.get(section_key);
+        if (component) {
+            return component;
+        }
+        const layout_key = this.createSectionMapKey({
+            type,
+            sub_type,
+            layout,
+        });
+        component = this.section_map.get(layout_key);
+        if (component) {
+            return component;
+        }
+        const base_key = this.createSectionMapKey({
+            type,
+            sub_type,
+        });
+        component = this.section_map.get(base_key);
+        if (component) {
+            return component;
+        }
+        throw new Error('Section component not defined');
+    }
+    searchLayout(layout_key) {
+        const component = this.layout_map.get(layout_key);
+        if (!component) {
+            throw new Error('Layout not declared');
+        }
+        return component;
+    }
+    setLayout(key, component) {
+        this.layout_map.set(key, component);
+    }
+    setSection(component, key_options) {
+        const key = this.createSectionMapKey(key_options);
+        this.section_map.set(key, component);
+    }
+    createSectionMapKey(key_options) {
+        const { type, sub_type, layout, group } = key_options;
+        const key_array = [type];
+        if (sub_type) {
+            key_array.push(sub_type);
+        }
+        if (layout) {
+            key_array.push(layout);
+            if (group) {
+                key_array.push(group);
+            }
+        }
+        return key_array.join(this.section_key_delimiter);
+    }
+}
+EsolveMediaLayoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaLayoutService, deps: [{ token: ESOLVE_CONNECT_MEDIA_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveMediaLayoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaLayoutService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaLayoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ESOLVE_CONNECT_MEDIA_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esolve-media-layout.service.js","sourceRoot":"","sources":["../../../../../projects/ng-esolve-connect/media/src/services/esolve-media-layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\r\nimport { Inject, Injectable } from '@angular/core';\r\n\r\nimport { EsolveMediaArticle, EsolveMediaLayoutSection } from '../classes';\r\nimport { EsolveMediaLayoutSectionType } from '../types';\r\n\r\nimport { ESOLVE_CONNECT_MEDIA_CONFIG } from '../esolve-connect-media-config.token';\r\nimport { EsolveConnectMediaConfig } from '../esolve-connect-media.config';\r\n\r\ntype ComponentMap = Map<string, ComponentType<any>>;\r\n\r\ntype SectionKeyOptions = {\r\n    type: EsolveMediaLayoutSectionType;\r\n    sub_type?: string;\r\n    layout?: string;\r\n    group?: string;\r\n};\r\n\r\n@Injectable()\r\nexport class EsolveMediaLayoutService {\r\n    private readonly section_key_delimiter = '>>>';\r\n\r\n    private media?: EsolveMediaArticle;\r\n    private layout_map: ComponentMap = new Map();\r\n    private section_map: ComponentMap = new Map();\r\n    private default_layout: string;\r\n\r\n    constructor(\r\n        @Inject(ESOLVE_CONNECT_MEDIA_CONFIG)\r\n        config: EsolveConnectMediaConfig,\r\n    ) {\r\n        if (config.layouts.length === 0) {\r\n            throw new Error('No layouts have been defined');\r\n        }\r\n\r\n        for (const layout of config.layouts) {\r\n            this.setLayout(layout.key, layout.component);\r\n\r\n            if (layout.sections) {\r\n                for (const section_group_key in layout.sections) {\r\n                    const sections = layout.sections[section_group_key];\r\n\r\n                    for (const section of sections) {\r\n                        const key_options: SectionKeyOptions = {\r\n                            type: section.key,\r\n                            sub_type: section.sub_key,\r\n                            layout: layout.key,\r\n                        };\r\n\r\n                        if (section_group_key !== '__default') {\r\n                            key_options.group = section_group_key;\r\n                        }\r\n\r\n                        this.setSection(section.component, key_options);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        const default_layout = config.default_layout;\r\n\r\n        if (default_layout) {\r\n            this.default_layout = default_layout;\r\n        } else {\r\n            this.default_layout = config.layouts[0].key;\r\n        }\r\n\r\n        if (config.sections.length > 0) {\r\n            for (const section of config.sections) {\r\n                const key_options: SectionKeyOptions = {\r\n                    type: section.key,\r\n                    sub_type: section.sub_key,\r\n                };\r\n\r\n                this.setSection(section.component, key_options);\r\n            }\r\n        }\r\n    }\r\n\r\n    public getMedia() {\r\n        if (!this.media) {\r\n            throw new Error('Media not declared');\r\n        }\r\n\r\n        return this.media;\r\n    }\r\n\r\n    public setMedia(media: EsolveMediaArticle) {\r\n        this.media = media;\r\n    }\r\n\r\n    public getLayout() {\r\n        const media = this.getMedia();\r\n\r\n        let layout_key = media.layout;\r\n\r\n        if (layout_key === '') {\r\n            layout_key = this.default_layout;\r\n        }\r\n\r\n        return this.searchLayout(layout_key);\r\n    }\r\n\r\n    public getSectionContent(key: string) {\r\n        const media = this.getMedia();\r\n\r\n        if (media.sections) {\r\n            const section = media.sections.get(key);\r\n\r\n            if (section) {\r\n                return section;\r\n            }\r\n        }\r\n\r\n        return [];\r\n    }\r\n\r\n    public getSectionComponent(key: string, section: EsolveMediaLayoutSection) {\r\n        const type = section.type;\r\n        const sub_type = section.sub_type;\r\n        const { layout } = this.getMedia();\r\n\r\n        const section_key = this.createSectionMapKey({\r\n            type,\r\n            sub_type,\r\n            layout,\r\n            group: key,\r\n        });\r\n\r\n        let component = this.section_map.get(section_key);\r\n\r\n        if (component) {\r\n            return component;\r\n        }\r\n\r\n        const layout_key = this.createSectionMapKey({\r\n            type,\r\n            sub_type,\r\n            layout,\r\n        });\r\n\r\n        component = this.section_map.get(layout_key);\r\n\r\n        if (component) {\r\n            return component;\r\n        }\r\n\r\n        const base_key = this.createSectionMapKey({\r\n            type,\r\n            sub_type,\r\n        });\r\n\r\n        component = this.section_map.get(base_key);\r\n\r\n        if (component) {\r\n            return component;\r\n        }\r\n\r\n        throw new Error('Section component not defined');\r\n    }\r\n\r\n    private searchLayout(layout_key: string) {\r\n        const component = this.layout_map.get(layout_key);\r\n\r\n        if (!component) {\r\n            throw new Error('Layout not declared');\r\n        }\r\n\r\n        return component;\r\n    }\r\n\r\n    private setLayout(key: string, component: ComponentType<any>) {\r\n        this.layout_map.set(key, component);\r\n    }\r\n\r\n    private setSection(\r\n        component: ComponentType<any>,\r\n        key_options: SectionKeyOptions,\r\n    ) {\r\n        const key = this.createSectionMapKey(key_options);\r\n\r\n        this.section_map.set(key, component);\r\n    }\r\n\r\n    private createSectionMapKey(key_options: SectionKeyOptions) {\r\n        const { type, sub_type, layout, group } = key_options;\r\n\r\n        const key_array: string[] = [type];\r\n\r\n        if (sub_type) {\r\n            key_array.push(sub_type);\r\n        }\r\n\r\n        if (layout) {\r\n            key_array.push(layout);\r\n\r\n            if (group) {\r\n                key_array.push(group);\r\n            }\r\n        }\r\n\r\n        return key_array.join(this.section_key_delimiter);\r\n    }\r\n}\r\n"]}

package/esm2020/media/services/esolve-media.service.mjs

@@ -0,0 +1,114 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { ESOLVE_CONNECT_CONFIG, } from '@esolve/ng-esolve-connect';
+import { EsolveMediaArticle, EsolveHeading } from '../classes';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class EsolveMediaService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    /**
+     * Retrieves the media record from the eSolve instance using the identifier
+     *
+     * @param identifier String representing the eSolve media identifier
+     */
+    getMediaArticle(identifier) {
+        const params = new HttpParams({ fromObject: { identifier } });
+        // TODO: Error Handling
+        return this.getMediaRecords(params).pipe(map((response) => {
+            if ((response.records === undefined) ||
+                (response.records.length <= 0)) {
+                throw response;
+            }
+            const mediaRecord = response.records[0];
+            if (!mediaRecord.active) {
+                throw response;
+            }
+            return this.processMediaRecord(mediaRecord);
+        }));
+    }
+    /**
+     * Retrieves a group of media records from the eSolve instance linked to a group
+     *
+     * @param media_group String representing the eSolve media group
+     */
+    getGroupedMediaArticles(media_group) {
+        const params = new HttpParams({
+            fromObject: { media_group_sef: media_group }
+        });
+        return this.getMediaRecords(params).pipe(map((response) => {
+            const mediaArticles = [];
+            if ((response.records !== undefined) &&
+                (response.records.length > 0)) {
+                for (const mediaRecord of response.records) {
+                    if (mediaRecord.active) {
+                        mediaArticles.push(this.processMediaRecord(mediaRecord));
+                    }
+                }
+            }
+            return mediaArticles;
+        }));
+    }
+    /**
+     * Retrieves the media heading records from the eSolve instance using the identifiers
+     *
+     * @param identifiers Array of strings representing the eSolve heading identifiers
+     */
+    getHeadings(identifiers) {
+        return this.http
+            .get(`${this.config.api_url}/get-headings.php`, {
+            params: {
+                identifier: identifiers.join(','),
+            },
+        })
+            .pipe(map((response) => {
+            const headings = [];
+            if ((response.records !== undefined) &&
+                (response.records.length > 0)) {
+                for (const heading_record of response.records) {
+                    headings.push(this.processHeadingRecord(heading_record));
+                }
+            }
+            return headings;
+        }));
+    }
+    /**
+     * Processes media article record
+     *
+     * @param record Record from eSolve instance
+     */
+    processMediaRecord(record) {
+        return new EsolveMediaArticle(record);
+    }
+    /**
+     * Processes media heading record
+     *
+     * @param record Record from eSolve instance
+     */
+    processHeadingRecord(record) {
+        return new EsolveHeading(record.identifier, record.value);
+    }
+    /**
+     * Retrieves media records from eSolve instance.
+     *
+     * @param params HTTP params
+     */
+    getMediaRecords(params) {
+        return this.http.get(`${this.config.api_url}/get-media.php`, { params });
+    }
+}
+EsolveMediaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaService, deps: [{ token: ESOLVE_CONNECT_CONFIG }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+EsolveMediaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: EsolveMediaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ESOLVE_CONNECT_CONFIG]
+                }] }, { type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esolve-media.service.js","sourceRoot":"","sources":["../../../../../projects/ng-esolve-connect/media/src/services/esolve-media.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { HttpClient, HttpParams } from '@angular/common/http';\r\n\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\n\r\nimport {\r\n    EsolveConnectConfig,\r\n    EsolveGetResponse,\r\n    ESOLVE_CONNECT_CONFIG,\r\n} from '@esolve/ng-esolve-connect';\r\n\r\nimport { EsolveMediaArticle, EsolveHeading } from '../classes';\r\nimport { EsolveMediaRecord, EsolveHeadingRecord } from '../interfaces';\r\n\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class EsolveMediaService {\r\n    constructor(\r\n        @Inject(ESOLVE_CONNECT_CONFIG) private config: EsolveConnectConfig,\r\n        private http: HttpClient,\r\n    ) { }\r\n\r\n    /**\r\n     * Retrieves the media record from the eSolve instance using the identifier\r\n     *\r\n     * @param identifier String representing the eSolve media identifier\r\n     */\r\n    public getMediaArticle(identifier: string): Observable<EsolveMediaArticle> {\r\n        const params = new HttpParams({ fromObject: { identifier } });\r\n\r\n        // TODO: Error Handling\r\n        return this.getMediaRecords(params).pipe(\r\n            map((response) => {\r\n                if (\r\n                    (response.records === undefined) ||\r\n                    (response.records.length <= 0)\r\n                ) {\r\n                    throw response;\r\n                }\r\n\r\n                const mediaRecord = response.records[0];\r\n\r\n                if (!mediaRecord.active) {\r\n                    throw response;\r\n                }\r\n\r\n                return this.processMediaRecord(mediaRecord);\r\n            })\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Retrieves a group of media records from the eSolve instance linked to a group\r\n     *\r\n     * @param media_group String representing the eSolve media group\r\n     */\r\n    public getGroupedMediaArticles(media_group: string): Observable<EsolveMediaArticle[]> {\r\n        const params = new HttpParams({\r\n            fromObject: { media_group_sef: media_group }\r\n        });\r\n\r\n        return this.getMediaRecords(params).pipe(\r\n            map((response) => {\r\n                const mediaArticles: EsolveMediaArticle[] = [];\r\n\r\n                if (\r\n                    (response.records !== undefined) &&\r\n                    (response.records.length > 0)\r\n                ) {\r\n                    for (const mediaRecord of response.records) {\r\n                        if (mediaRecord.active) {\r\n                            mediaArticles.push(this.processMediaRecord(mediaRecord));\r\n                        }\r\n                    }\r\n                }\r\n\r\n                return mediaArticles;\r\n            })\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Retrieves the media heading records from the eSolve instance using the identifiers\r\n     *\r\n     * @param identifiers Array of strings representing the eSolve heading identifiers\r\n     */\r\n    public getHeadings(identifiers: string[]): Observable<EsolveHeading[]> {\r\n        return this.http\r\n            .get<EsolveGetResponse<EsolveHeadingRecord[]>>(\r\n                `${this.config.api_url}/get-headings.php`,\r\n                {\r\n                    params: {\r\n                        identifier: identifiers.join(','),\r\n                    },\r\n                }\r\n            )\r\n            .pipe(\r\n                map((response) => {\r\n                    const headings: EsolveHeading[] = [];\r\n\r\n                    if (\r\n                        (response.records !== undefined) &&\r\n                        (response.records.length > 0)\r\n                    ) {\r\n                        for (const heading_record of response.records) {\r\n                            headings.push(this.processHeadingRecord(heading_record));\r\n                        }\r\n                    }\r\n\r\n                    return headings;\r\n                })\r\n            );\r\n    }\r\n\r\n    /**\r\n     * Processes media article record\r\n     *\r\n     * @param record Record from eSolve instance\r\n     */\r\n    private processMediaRecord(record: EsolveMediaRecord): EsolveMediaArticle {\r\n        return new EsolveMediaArticle(record);\r\n    }\r\n\r\n    /**\r\n     * Processes media heading record\r\n     *\r\n     * @param record Record from eSolve instance\r\n     */\r\n    private processHeadingRecord(record: EsolveHeadingRecord): EsolveHeading {\r\n        return new EsolveHeading(\r\n            record.identifier,\r\n            record.value\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Retrieves media records from eSolve instance.\r\n     *\r\n     * @param params HTTP params\r\n     */\r\n    private getMediaRecords(params: HttpParams): Observable<EsolveGetResponse<EsolveMediaRecord[]>> {\r\n        return this.http.get<EsolveGetResponse<EsolveMediaRecord[]>>(\r\n            `${this.config.api_url}/get-media.php`,\r\n            { params }\r\n        );\r\n    }\r\n}\r\n"]}

package/esm2020/media/services/index.mjs

@@ -0,0 +1,3 @@
+export * from './esolve-media.service';
+export * from './esolve-media-layout.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lc29sdmUtY29ubmVjdC9tZWRpYS9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtbWVkaWEuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZXNvbHZlLW1lZGlhLWxheW91dC5zZXJ2aWNlJztcclxuIl19

package/esm2020/media/types/esolve-media-layout-section-type.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLW1lZGlhLWxheW91dC1zZWN0aW9uLXR5cGUudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWVzb2x2ZS1jb25uZWN0L21lZGlhL3NyYy90eXBlcy9lc29sdmUtbWVkaWEtbGF5b3V0LXNlY3Rpb24tdHlwZS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBFc29sdmVNZWRpYUxheW91dFNlY3Rpb25UeXBlID1cclxuICAgICdtZWRpYScgfFxyXG4gICAgJ2Jhbm5lcicgfFxyXG4gICAgJ2xpbmtlZF9zdG9jaycgfFxyXG4gICAgJ2N1c3RvbSc7XHJcbiJdfQ==

package/esm2020/media/types/index.mjs

@@ -0,0 +1,2 @@
+export * from './esolve-media-layout-section-type.type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lc29sdmUtY29ubmVjdC9tZWRpYS9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5Q0FBeUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXNvbHZlLW1lZGlhLWxheW91dC1zZWN0aW9uLXR5cGUudHlwZSc7XHJcbiJdfQ==

package/esm2020/public-api.mjs

@@ -2,6 +2,8 @@
  * Public API Surface of ng-esolve-connect
  */
 export * from './lib/ng-esolve-connect.module';
+export * from './lib/esolve-connect.config';
+export * from './lib/esolve-connect-config.constant';
 export * from './lib/shared/esolve-list.model';
 export * from './lib/shared/esolve-result.model';
 export * from './lib/shared/response';
@@ -22,8 +24,6 @@ export * from './lib/auth';
 export * from './lib/account';
 // Banners
 export * from './lib/banners';
-// Media
-export * from './lib/media';
 // Menu
 export * from './lib/menu';
 // News
@@ -52,4 +52,4 @@ export * from './lib/shipping';
 export * from './lib/locations';
 // Enquiry
 export * from './lib/enquiry';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esolve-ng-esolve-connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esolve-ng-esolve-connect.d.ts","sourceRoot":"","sources":["../../projects/ng-esolve-connect/src/esolve-ng-esolve-connect.ts"],"names":[],"mappings":"AAAA;;GAEG;;AAEH,cAAc,cAAc,CAAC"}