@theseam/ui-common 0.3.10 → 0.4.0-beta.0

package/esm2020/dynamic/action/link/dynamic-action-link.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../dynamic-value-helper.service";
+/**
+ * Handles execution of link actions.
+ */
+export class DynamicActionLinkService {
+    constructor(_valueHandler) {
+        this._valueHandler = _valueHandler;
+        this.type = 'link';
+        this.label = 'Link Action';
+    }
+    // exec?: (args: IDynamicActionDef<T>, context: D) => Observable<R>
+    // execSync?: (args: IDynamicActionDef<T>, context: D) => R
+    async getUiProps(args, context) {
+        const link = await this._valueHandler.eval(args.link);
+        const external = !!(await this._valueHandler.eval(args.external));
+        const asset = !!(await this._valueHandler.eval(args.asset));
+        const target = await this._valueHandler.eval(args.target);
+        const queryParams = await this._valueHandler.eval(args.queryParams);
+        const def = {
+            _actionDef: args,
+            triggerType: asset ? 'link-asset' : external ? 'link-external' : 'link',
+            linkUrl: link,
+            // blockClickExpr: { type: 'jexl', expr: 'event.button == 0 && event.ctrlKey == true ? true : false' }
+        };
+        if (target) {
+            if (!def.linkExtras) {
+                def.linkExtras = {};
+            }
+            def.linkExtras.target = target;
+        }
+        if (queryParams) {
+            if (!def.linkExtras) {
+                def.linkExtras = {};
+            }
+            def.linkExtras.queryParams = queryParams;
+        }
+        return def;
+    }
+}
+DynamicActionLinkService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionLinkService, deps: [{ token: i1.DynamicValueHelperService }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicActionLinkService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionLinkService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionLinkService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DynamicValueHelperService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic/action/modal/dynamic-action-modal.service.mjs

@@ -0,0 +1,85 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { DynamicActionHelperService } from '../dynamic-action-helper.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../dynamic-value-helper.service";
+import * as i2 from "@theseam/ui-common/modal";
+/**
+ * Handles execution of modal actions.
+ */
+export class DynamicActionModalService {
+    constructor(_valueHelper, _modal, _injector) {
+        this._valueHelper = _valueHelper;
+        this._modal = _modal;
+        this._injector = _injector;
+        this.type = 'modal';
+        this.label = 'Modal Action';
+    }
+    async exec(args, context) {
+        const component = this._getComponent(args, context);
+        const data = this._getData(args, context);
+        return this._openModal(component, data).pipe(switchMap(modalRef => modalRef.afterClosed().pipe(switchMap(result => {
+            const resultAction = this._getModalResultAction(args, result);
+            // TODO: Come up with a way to pass data from previous action
+            if (resultAction) {
+                const dynamicActionHelper = this._getDynamicActionHelper();
+                return dynamicActionHelper.exec(resultAction, context);
+            }
+            return of(result);
+        })))).toPromise();
+    }
+    // execSync?: (args: IDynamicActionDef<T>, context: D) => R
+    async getUiProps(args, context) {
+        return {
+            _actionDef: args,
+            triggerType: 'click'
+        };
+    }
+    /**
+     * Get the dynamic action helper from the injector. The injector order causes
+     * the dynamic action helper to not be in the injector when the constructor is
+     * called.
+     */
+    _getDynamicActionHelper() {
+        return this._injector.get(DynamicActionHelperService);
+    }
+    _getComponent(args, context) {
+        let component = args && args.component;
+        if (component) {
+            component = this._valueHelper.evalSync(component, context);
+        }
+        return component;
+    }
+    _getData(args, context) {
+        let data = args && args.data;
+        if (data) {
+            data = this._valueHelper.evalSync(data, context);
+        }
+        return data;
+    }
+    _getModalResultAction(args, result) {
+        if (args.resultActions && args.resultActions[result]) {
+            return args.resultActions[result];
+        }
+    }
+    _openModal(modal, data) {
+        // TODO: Replace with JSON valid config from input def model
+        const config = {
+            data,
+            modalSize: 'lg'
+        };
+        if (typeof modal === 'string') {
+            return this._modal.openFromLazyComponent(modal, config);
+        }
+        else {
+            return of(this._modal.openFromComponent(modal, config));
+        }
+    }
+}
+DynamicActionModalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionModalService, deps: [{ token: i1.DynamicValueHelperService }, { token: i2.Modal }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicActionModalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionModalService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionModalService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DynamicValueHelperService }, { type: i2.Modal }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic/dynamic-value-helper.service.mjs

@@ -0,0 +1,102 @@
+import { Inject, Injectable, isDevMode } from '@angular/core';
+import { THESEAM_DYNAMIC_VALUE_EVALUATOR } from './tokens/dynamic-value-evaluator';
+import * as i0 from "@angular/core";
+/**
+ *
+ */
+export class DynamicValueHelperService {
+    constructor(evaluators) {
+        this._evaluatorMap = new Map();
+        // Only one evaluator should exist for a type, so map them for faster lookup.
+        for (const e of evaluators) {
+            if (isDevMode()) {
+                if (this._evaluatorMap.has(e.type)) {
+                    console.warn(`[DynamicValueHelperService] Multiple evaluators found for type '${e.type}'`);
+                }
+            }
+            this._evaluatorMap.set(e.type, e);
+        }
+    }
+    /**
+     * Evaluate a dynamic value to its actual value.
+     *
+     * TODO: Improve context and return typing.
+     */
+    eval(value, context) {
+        if (this.isEvaluatableType(value, true)) {
+            return this._evalEvaluatable(value, context);
+        }
+        // Use `evalSync` if `eval` isn't provided and `evalSync` is.
+        if (this.isEvaluatableType(value, false)) {
+            return Promise.resolve(this._evalEvaluatableSync(value, context));
+        }
+        return Promise.resolve(value);
+    }
+    /**
+     * Evaluate a dynamic value to its actual value.
+     *
+     * TODO: Improve context and return typing.
+     */
+    evalSync(value, context) {
+        if (this.isEvaluatableType(value, false)) {
+            return this._evalEvaluatableSync(value, context);
+        }
+        return value;
+    }
+    /**
+     * Checks if a DynamicValue is a type that can be evaluated.
+     */
+    isEvaluatableType(value, isAsync) {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return false;
+        }
+        if (!value.type) {
+            return false;
+        }
+        if (this._evaluatorMap.has(value.type)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     *
+     */
+    _evalEvaluatable(value, context) {
+        const evaluator = this._evaluatorMap.get(value.type);
+        if (!evaluator) {
+            throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' not found.`);
+        }
+        if (!evaluator.eval) {
+            throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' does not implement 'eval()'.`);
+        }
+        return evaluator.eval(value, context);
+    }
+    /**
+     *
+     */
+    _evalEvaluatableSync(value, context) {
+        const evaluator = this._evaluatorMap.get(value.type);
+        if (!evaluator) {
+            throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' not found.`);
+        }
+        if (!evaluator.evalSync) {
+            throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' does not implement 'evalSync()'.`);
+        }
+        return evaluator.evalSync(value, context);
+    }
+}
+DynamicValueHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicValueHelperService, deps: [{ token: THESEAM_DYNAMIC_VALUE_EVALUATOR }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicValueHelperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicValueHelperService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicValueHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_DYNAMIC_VALUE_EVALUATOR]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-value-helper.service.js","sourceRoot":"","sources":["../../../../projects/ui-common/dynamic/dynamic-value-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, isDevMode } from '@angular/core'\n\nimport { DynamicValue } from './models/dynamic-value'\nimport { DynamicValueBaseType } from './models/dynamic-value-base-type'\nimport { DynamicValueEvaluatableType } from './models/dynamic-value-evaluatable-type'\nimport { IDynamicValueEvaluator } from './models/dynamic-value-evaluator'\nimport { IDynamicValueType } from './models/dynamic-value-type'\nimport { THESEAM_DYNAMIC_VALUE_EVALUATOR } from './tokens/dynamic-value-evaluator'\n\n/**\n *\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class DynamicValueHelperService {\n\n  private _evaluatorMap = new Map<string, IDynamicValueEvaluator>()\n\n  constructor(\n    @Inject(THESEAM_DYNAMIC_VALUE_EVALUATOR) evaluators: IDynamicValueEvaluator[]\n  ) {\n    // Only one evaluator should exist for a type, so map them for faster lookup.\n    for (const e of evaluators) {\n      if (isDevMode()) {\n        if (this._evaluatorMap.has(e.type)) {\n          console.warn(`[DynamicValueHelperService] Multiple evaluators found for type '${e.type}'`)\n        }\n      }\n      this._evaluatorMap.set(e.type, e)\n    }\n  }\n\n  /**\n   * Evaluate a dynamic value to its actual value.\n   *\n   * TODO: Improve context and return typing.\n   */\n  public eval<R extends DynamicValueBaseType>(value: DynamicValue<R>, context?: any): Promise<R> {\n    if (this.isEvaluatableType(value, true)) {\n      return this._evalEvaluatable(value, context)\n    }\n\n    // Use `evalSync` if `eval` isn't provided and `evalSync` is.\n    if (this.isEvaluatableType(value, false)) {\n      return Promise.resolve<R>(this._evalEvaluatableSync(value, context))\n    }\n\n    return Promise.resolve<R>(value)\n  }\n\n  /**\n   * Evaluate a dynamic value to its actual value.\n   *\n   * TODO: Improve context and return typing.\n   */\n  public evalSync<R extends DynamicValueBaseType>(value: DynamicValue<R>, context?: any): R {\n    if (this.isEvaluatableType(value, false)) {\n      return this._evalEvaluatableSync(value, context)\n    }\n\n    return value\n  }\n\n  /**\n   * Checks if a DynamicValue is a type that can be evaluated.\n   */\n  public isEvaluatableType<R extends DynamicValueBaseType>(value: DynamicValue<R>, isAsync: boolean): value is DynamicValueEvaluatableType<R> {\n    if (value === undefined || value === null) {\n      return false\n    }\n\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n      return false\n    }\n\n    if (!(<DynamicValueEvaluatableType<R>>value).type) {\n      return false\n    }\n\n    if (this._evaluatorMap.has((<DynamicValueEvaluatableType<R>>value).type)) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   *\n   */\n  private _evalEvaluatable<R extends DynamicValueBaseType>(value: DynamicValueEvaluatableType<R>, context?: any): Promise<R> {\n    const evaluator = this._evaluatorMap.get(value.type)\n    if (!evaluator) {\n      throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' not found.`)\n    }\n    if (!evaluator.eval) {\n      throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' does not implement 'eval()'.`)\n    }\n    return evaluator.eval(value, context)\n  }\n\n  /**\n   *\n   */\n  private _evalEvaluatableSync<R extends DynamicValueBaseType>(value: DynamicValueEvaluatableType<R>, context?: any): R {\n    const evaluator = this._evaluatorMap.get(value.type)\n    if (!evaluator) {\n      throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' not found.`)\n    }\n    if (!evaluator.evalSync) {\n      throw Error(`[DynamicValueHelperService] Evaluator '${value ? value.type : undefined}' does not implement 'evalSync()'.`)\n    }\n    return evaluator.evalSync(value, context)\n  }\n\n}\n"]}

package/esm2020/dynamic/evaluators/exporters-data-evaluator/exporters-data-evaluator.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { THESEAM_DATA_EXPORTER } from '@theseam/ui-common/data-exporter';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+export class ExportersDataEvaluator {
+    constructor(_injector) {
+        this._injector = _injector;
+        this.type = 'exporters-data';
+    }
+    async eval(value, context) {
+        return this.evalSync(value, context);
+    }
+    evalSync(value, context) {
+        return {
+            exporters: this._exporters(value.exporters || [])
+        };
+    }
+    _exporters(exporters) {
+        const dataExporters = (this._injector.get(THESEAM_DATA_EXPORTER) || []);
+        return exporters
+            .map(e => dataExporters.find(de => de.name === e))
+            .filter(notNullOrUndefined);
+    }
+}
+ExportersDataEvaluator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ExportersDataEvaluator, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ExportersDataEvaluator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ExportersDataEvaluator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ExportersDataEvaluator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic/evaluators/jexl-evaluator/jexl-evaluator.mjs

@@ -0,0 +1,32 @@
+// NOTE: ng-packagr ignores the "types" and "typeRoots" settings in tsconfig.
+// Unless there is a way to make it stop ignoring those settings, tripple slash
+// reference to a `.d.ts` file was the only way I could stop the missing types
+// error.
+// tslint:disable-next-line: no-reference
+// /// <reference path="./jexl.d.ts" />
+// /// <reference path="../../../../../custom_types/jexl/index.d.ts" />
+import { DatePipe } from '@angular/common';
+import { Injectable } from '@angular/core';
+// @ts-ignore: Missing types
+import jexl from 'jexl';
+import * as i0 from "@angular/core";
+export class JexlEvaluator {
+    constructor() {
+        this.type = 'jexl';
+        this._jexl = new jexl.Jexl();
+        this._jexl.addTransform('date', (val, row) => new DatePipe('en-US').transform(val, 'yyyy-MM-dd h:mm aaa'));
+        this._jexl.addTransform('length', (val) => val !== null && val !== undefined ? val.length : 0);
+    }
+    eval(value, context) {
+        return this._jexl.eval(value.expr, context);
+    }
+    evalSync(value, context) {
+        return this._jexl.evalSync(value.expr, context);
+    }
+}
+JexlEvaluator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: JexlEvaluator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+JexlEvaluator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: JexlEvaluator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: JexlEvaluator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic/models/dynamic-value-evaluatable-type.mjs

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

package/esm2020/dynamic-component-loader/dynamic-component-loader.module.mjs

@@ -0,0 +1,50 @@
+import { ANALYZE_FOR_ENTRY_COMPONENTS, NgModule, } from '@angular/core';
+import { ROUTES } from '@angular/router';
+import { TheSeamDynamicComponentLoader } from './dynamic-component-loader.service';
+import { DYNAMIC_COMPONENT, DYNAMIC_COMPONENT_MANIFESTS, DYNAMIC_MODULE } from './dynamic-component-tokens';
+import * as i0 from "@angular/core";
+export class TheSeamDynamicComponentLoaderModule {
+    static forRoot(manifests) {
+        return {
+            ngModule: TheSeamDynamicComponentLoaderModule,
+            providers: [
+                TheSeamDynamicComponentLoader,
+                // provider for Angular CLI to analyze
+                { provide: ROUTES, useValue: manifests, multi: true },
+                // provider for TheSeamDynamicComponentLoader to analyze
+                { provide: DYNAMIC_COMPONENT_MANIFESTS, useValue: manifests },
+            ],
+        };
+    }
+    static forModule(manifest) {
+        return {
+            ngModule: TheSeamDynamicComponentLoaderModule,
+            providers: [
+                { provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: manifest, multi: true },
+                // provider for @angular/router to parse
+                { provide: ROUTES, useValue: manifest, multi: true },
+                // provider for TheSeamDynamicComponentLoader to analyze
+                { provide: DYNAMIC_MODULE, useValue: manifest }
+            ],
+        };
+    }
+    static forChild(component) {
+        return {
+            ngModule: TheSeamDynamicComponentLoaderModule,
+            providers: [
+                { provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: component, multi: true },
+                // provider for @angular/router to parse
+                { provide: ROUTES, useValue: [], multi: true },
+                // provider for TheSeamDynamicComponentLoader to analyze
+                { provide: DYNAMIC_COMPONENT, useValue: component },
+            ],
+        };
+    }
+}
+TheSeamDynamicComponentLoaderModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamDynamicComponentLoaderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamDynamicComponentLoaderModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.3", ngImport: i0, type: TheSeamDynamicComponentLoaderModule });
+TheSeamDynamicComponentLoaderModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamDynamicComponentLoaderModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamDynamicComponentLoaderModule, decorators: [{
+            type: NgModule
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic-component-loader/dynamic-component-loader.service.mjs

@@ -0,0 +1,78 @@
+import { Inject, Injectable, NgModuleFactory, Optional } from '@angular/core';
+import { of } from 'rxjs';
+import { from, throwError } from 'rxjs';
+import { mergeMap, switchMap } from 'rxjs/operators';
+import { DYNAMIC_COMPONENT, DYNAMIC_COMPONENT_MANIFESTS, DYNAMIC_MODULE } from './dynamic-component-tokens';
+import { wrapIntoObservable } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+export class TheSeamDynamicComponentLoader {
+    constructor(compiler, injector, manifests) {
+        this.compiler = compiler;
+        this.injector = injector;
+        this._manifests = manifests || [];
+    }
+    /** Retrieve a ComponentFactory, based on the specified componentId (defined in the DynamicComponentManifest array). */
+    getComponentFactory(componentId, injector) {
+        const manifest = this._manifests
+            .find(m => m.componentId === componentId);
+        if (!manifest) {
+            return throwError(`TheSeamDynamicComponentLoader: Unknown componentId "${componentId}"`);
+        }
+        // const path = manifest.loadChildren
+        // const p = this.load<T>(path, componentId, injector)
+        // return from(p)
+        const moduleFactory$ = this.loadModuleFactory(manifest.loadChildren);
+        return moduleFactory$
+            .pipe(switchMap(m => from(this.loadFactory(m, componentId, injector))));
+    }
+    loadModuleFactory(loadChildren) {
+        return wrapIntoObservable(loadChildren()).pipe(mergeMap((t) => {
+            if (t instanceof NgModuleFactory) {
+                return of(t);
+            }
+            else {
+                return from(this.compiler.compileModuleAsync(t));
+            }
+        }));
+    }
+    loadFactory(ngModuleFactory, componentId, injector) {
+        const moduleRef = ngModuleFactory.create(injector || this.injector);
+        const dynamicComponentType = moduleRef.injector.get(DYNAMIC_COMPONENT, null);
+        if (!dynamicComponentType) {
+            const dynamicModule = moduleRef.injector.get(DYNAMIC_MODULE, null);
+            if (!dynamicModule) {
+                throw new Error('TheSeamDynamicComponentLoader: Dynamic module for'
+                    + ` componentId "${componentId}" does not contain`
+                    + ' DYNAMIC_COMPONENT or DYNAMIC_MODULE as a provider.');
+            }
+            if (dynamicModule.componentId !== componentId) {
+                throw new Error('TheSeamDynamicComponentLoader: Dynamic module for'
+                    + `${componentId} does not match manifest.`);
+            }
+            const path = dynamicModule.loadChildren;
+            if (!path) {
+                throw new Error(`${componentId} unknown!`);
+            }
+            // return this.load<T>(path, componentId, injector)
+            const moduleFactory$ = this.loadModuleFactory(dynamicModule.loadChildren);
+            return moduleFactory$
+                .pipe(switchMap(m => from(this.loadFactory(m, componentId, injector))))
+                .toPromise();
+        }
+        return Promise.resolve(moduleRef.componentFactoryResolver.resolveComponentFactory(dynamicComponentType));
+    }
+}
+TheSeamDynamicComponentLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamDynamicComponentLoader, deps: [{ token: i0.Compiler }, { token: i0.Injector }, { token: DYNAMIC_COMPONENT_MANIFESTS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TheSeamDynamicComponentLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamDynamicComponentLoader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamDynamicComponentLoader, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Compiler }, { type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DYNAMIC_COMPONENT_MANIFESTS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-component-loader.service.js","sourceRoot":"","sources":["../../../../projects/ui-common/dynamic-component-loader/dynamic-component-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Compiler, ComponentFactory, Inject, Injectable, Injector, NgModuleFactory, Optional } from '@angular/core'\nimport { Observable, of } from 'rxjs'\nimport { from, throwError } from 'rxjs'\nimport { mergeMap, switchMap } from 'rxjs/operators'\n\nimport { LoadChildren } from '@angular/router'\nimport { DynamicComponentManifest } from './dynamic-component-manifest'\nimport {\n  DYNAMIC_COMPONENT,\n  DYNAMIC_COMPONENT_MANIFESTS,\n  DYNAMIC_MODULE\n} from './dynamic-component-tokens'\n\nimport { wrapIntoObservable } from '@theseam/ui-common/utils'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class TheSeamDynamicComponentLoader {\n\n  private _manifests: DynamicComponentManifest[]\n\n  constructor(\n    private compiler: Compiler,\n    private injector: Injector,\n    @Optional() @Inject(DYNAMIC_COMPONENT_MANIFESTS) manifests: DynamicComponentManifest[],\n  ) { this._manifests = manifests || [] }\n\n  /** Retrieve a ComponentFactory, based on the specified componentId (defined in the DynamicComponentManifest array). */\n  getComponentFactory<T>(componentId: string, injector?: Injector): Observable<ComponentFactory<T>> {\n    const manifest = this._manifests\n      .find(m => m.componentId === componentId)\n    if (!manifest) {\n      return throwError(`TheSeamDynamicComponentLoader: Unknown componentId \"${componentId}\"`)\n    }\n\n    // const path = manifest.loadChildren\n\n    // const p = this.load<T>(path, componentId, injector)\n    // return from(p)\n\n    const moduleFactory$ = this.loadModuleFactory(manifest.loadChildren)\n\n    return moduleFactory$\n      .pipe(switchMap(m => from(this.loadFactory<any>(m, componentId, injector))))\n  }\n\n  private loadModuleFactory(loadChildren: LoadChildren): Observable<NgModuleFactory<any>> {\n    return wrapIntoObservable(loadChildren()).pipe(mergeMap((t: any) => {\n      if (t instanceof NgModuleFactory) {\n        return of(t)\n      } else {\n        return from(this.compiler.compileModuleAsync(t))\n      }\n    }))\n  }\n\n  private loadFactory<T>(ngModuleFactory: NgModuleFactory<any>, componentId: string, injector?: Injector): Promise<ComponentFactory<T>> {\n    const moduleRef = ngModuleFactory.create(injector || this.injector)\n    const dynamicComponentType = moduleRef.injector.get(DYNAMIC_COMPONENT, null)\n    if (!dynamicComponentType) {\n      const dynamicModule: DynamicComponentManifest = moduleRef.injector.get(DYNAMIC_MODULE, null)\n\n      if (!dynamicModule) {\n        throw new Error(\n          'TheSeamDynamicComponentLoader: Dynamic module for'\n          + ` componentId \"${componentId}\" does not contain`\n          + ' DYNAMIC_COMPONENT or DYNAMIC_MODULE as a provider.',\n        )\n      }\n      if (dynamicModule.componentId !== componentId) {\n        throw new Error(\n          'TheSeamDynamicComponentLoader: Dynamic module for'\n          + `${componentId} does not match manifest.`,\n        )\n      }\n\n      const path = dynamicModule.loadChildren\n\n      if (!path) {\n        throw new Error(`${componentId} unknown!`)\n      }\n\n      // return this.load<T>(path, componentId, injector)\n      const moduleFactory$ = this.loadModuleFactory(dynamicModule.loadChildren)\n\n      return moduleFactory$\n        .pipe(switchMap(m => from(this.loadFactory<any>(m, componentId, injector))))\n        .toPromise() as Promise<ComponentFactory<T>>\n    }\n\n    return Promise.resolve(moduleRef.componentFactoryResolver.resolveComponentFactory<T>(dynamicComponentType))\n  }\n}\n"]}

package/esm2020/dynamic-component-loader/dynamic-component-manifest.mjs

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

package/esm2020/footer-bar/footer-bar/footer-bar.component.mjs

@@ -0,0 +1,14 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FooterBarComponent {
+    constructor() { }
+    ngOnInit() {
+    }
+}
+FooterBarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FooterBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FooterBarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: FooterBarComponent, selector: "seam-footer-bar", ngImport: i0, template: "<p>footer-bar works!</p>\n", styles: [""], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FooterBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-footer-bar', changeDetection: ChangeDetectionStrategy.OnPush, template: "<p>footer-bar works!</p>\n" }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9vdGVyLWJhci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZm9vdGVyLWJhci9mb290ZXItYmFyL2Zvb3Rlci1iYXIuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL2Zvb3Rlci1iYXIvZm9vdGVyLWJhci9mb290ZXItYmFyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUE7O0FBUTFFLE1BQU0sT0FBTyxrQkFBa0I7SUFFN0IsZ0JBQWdCLENBQUM7SUFFakIsUUFBUTtJQUNSLENBQUM7OytHQUxVLGtCQUFrQjttR0FBbEIsa0JBQWtCLHVEQ1IvQiw0QkFDQTsyRkRPYSxrQkFBa0I7a0JBTjlCLFNBQVM7K0JBQ0UsaUJBQWlCLG1CQUdWLHVCQUF1QixDQUFDLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdzZWFtLWZvb3Rlci1iYXInLFxuICB0ZW1wbGF0ZVVybDogJy4vZm9vdGVyLWJhci5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2Zvb3Rlci1iYXIuY29tcG9uZW50LnNjc3MnXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgRm9vdGVyQmFyQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcblxuICBjb25zdHJ1Y3RvcigpIHsgfVxuXG4gIG5nT25Jbml0KCkge1xuICB9XG5cbn1cbiIsIjxwPmZvb3Rlci1iYXIgd29ya3MhPC9wPlxuIl19

package/esm2020/footer-bar/footer-bar.module.mjs

@@ -0,0 +1,20 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FooterBarComponent } from './footer-bar/footer-bar.component';
+import * as i0 from "@angular/core";
+export class FooterBarModule {
+}
+FooterBarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FooterBarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FooterBarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.3", ngImport: i0, type: FooterBarModule, declarations: [FooterBarComponent], imports: [CommonModule], exports: [FooterBarComponent] });
+FooterBarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FooterBarModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FooterBarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [FooterBarComponent],
+                    imports: [
+                        CommonModule
+                    ],
+                    exports: [FooterBarComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9vdGVyLWJhci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZm9vdGVyLWJhci9mb290ZXItYmFyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDOUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUN4QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQTs7QUFVdEUsTUFBTSxPQUFPLGVBQWU7OzRHQUFmLGVBQWU7NkdBQWYsZUFBZSxpQkFOWCxrQkFBa0IsYUFFL0IsWUFBWSxhQUVKLGtCQUFrQjs2R0FFakIsZUFBZSxZQUp4QixZQUFZOzJGQUlILGVBQWU7a0JBUDNCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsa0JBQWtCLENBQUM7b0JBQ2xDLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3FCQUNiO29CQUNELE9BQU8sRUFBRSxDQUFDLGtCQUFrQixDQUFDO2lCQUM5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbidcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcbmltcG9ydCB7IEZvb3RlckJhckNvbXBvbmVudCB9IGZyb20gJy4vZm9vdGVyLWJhci9mb290ZXItYmFyLmNvbXBvbmVudCdcblxuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtGb290ZXJCYXJDb21wb25lbnRdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6IFtGb290ZXJCYXJDb21wb25lbnRdXG59KVxuZXhwb3J0IGNsYXNzIEZvb3RlckJhck1vZHVsZSB7IH1cbiJdfQ==

package/esm2020/form-field/form-field-error.directive.mjs

@@ -0,0 +1,30 @@
+import { __decorate } from "tslib";
+import { Directive, Input } from '@angular/core';
+import { InputBoolean } from '@theseam/ui-common/core';
+import * as i0 from "@angular/core";
+export class FormFieldErrorDirective {
+    constructor(template) {
+        this.template = template;
+        this.external = false;
+    }
+    get validatorName() { return this._validatorName || this.seamFormFieldError; }
+    set validatorName(value) { this._validatorName = value; }
+}
+FormFieldErrorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FormFieldErrorDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+FormFieldErrorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: FormFieldErrorDirective, selector: "[seamFormFieldError]", inputs: { validatorName: "validatorName", seamFormFieldError: "seamFormFieldError", external: "external" }, ngImport: i0 });
+__decorate([
+    InputBoolean()
+], FormFieldErrorDirective.prototype, "external", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FormFieldErrorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamFormFieldError]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { validatorName: [{
+                type: Input
+            }], seamFormFieldError: [{
+                type: Input
+            }], external: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/form-field/form-field-help-text.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormFieldHelpTextDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+FormFieldHelpTextDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FormFieldHelpTextDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+FormFieldHelpTextDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: FormFieldHelpTextDirective, selector: "[seamFormFieldHelpText]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: FormFieldHelpTextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamFormFieldHelpText]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1maWVsZC1oZWxwLXRleHQuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL2Zvcm0tZmllbGQvZm9ybS1maWVsZC1oZWxwLXRleHQuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWUsTUFBTSxlQUFlLENBQUE7O0FBS3RELE1BQU0sT0FBTywwQkFBMEI7SUFFckMsWUFBbUIsUUFBMEI7UUFBMUIsYUFBUSxHQUFSLFFBQVEsQ0FBa0I7SUFBSSxDQUFDOzt1SEFGdkMsMEJBQTBCOzJHQUExQiwwQkFBMEI7MkZBQTFCLDBCQUEwQjtrQkFIdEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUseUJBQXlCO2lCQUNwQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbc2VhbUZvcm1GaWVsZEhlbHBUZXh0XSdcbn0pXG5leHBvcnQgY2xhc3MgRm9ybUZpZWxkSGVscFRleHREaXJlY3RpdmUge1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8YW55PikgeyB9XG5cbn1cbiJdfQ==