@theseam/ui-common 0.2.9

package/esm2015/dynamic/action/dynamic-action-helper.service.js

@@ -0,0 +1,163 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable, isDevMode, Optional } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { SeamConfirmDialogService } from '@theseam/ui-common/confirm-dialog';
+import { hasProperty } from '@theseam/ui-common/utils';
+import { DynamicValueHelperService } from '../dynamic-value-helper.service';
+import { THESEAM_DYNAMIC_ACTION } from '../tokens/dynamic-action';
+import * as i0 from "@angular/core";
+import * as i1 from "../dynamic-value-helper.service";
+import * as i2 from "@theseam/ui-common/confirm-dialog";
+import * as i3 from "../tokens/dynamic-action";
+export class DynamicActionHelperService {
+    constructor(_valueHelper, 
+    // TODO: Consider making the action confirm more generic
+    _confirmDialog, actions) {
+        this._valueHelper = _valueHelper;
+        this._confirmDialog = _confirmDialog;
+        this._actionMap = new Map();
+        // Only one evaluator should exist for a type, so map them for faster lookup.
+        for (const e of (actions || [])) {
+            if (isDevMode()) {
+                if (this._actionMap.has(e.type)) {
+                    console.warn(`[DynamicActionHelperService] Multiple actions found for type '${e.type}'`);
+                }
+            }
+            this._actionMap.set(e.type, e);
+        }
+    }
+    /**
+     * Execute an async action.
+     *
+     * TODO: Improve context and return typing.
+     */
+    exec(actionDef, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const action = this._actionMap.get(actionDef.type);
+            if (!action) {
+                throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' not found.`);
+            }
+            if (!action.exec) {
+                throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' does not implement 'exec()'.`);
+            }
+            if (yield this.requiresConfirmation(actionDef, context)) {
+                const confirmed = yield this.promptConfirmation(actionDef, context);
+                if (!confirmed) {
+                    // TODO: Decide a good way to handle a rejected confirm.
+                    return 'rejected';
+                }
+            }
+            return yield action.exec(actionDef, context);
+        });
+    }
+    /**
+     * Execute an action.
+     *
+     * TODO: Improve context and return typing.
+     */
+    execSync(actionDef, context) {
+        const action = this._actionMap.get(actionDef.type);
+        if (!action) {
+            throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' not found.`);
+        }
+        if (!action.execSync) {
+            throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' does not implement 'execSync()'.`);
+        }
+        return action.execSync(actionDef, context);
+    }
+    /**
+     * Get UI props for action.
+     *
+     * TODO: Improve context and return typing.
+     */
+    getUiProps(actionDef, context) {
+        const action = this._actionMap.get(actionDef.type);
+        if (!action) {
+            throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' not found.`);
+        }
+        if (!action.getUiProps) {
+            throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' does not implement 'getUiProps()'.`);
+        }
+        return action.getUiProps(actionDef, context);
+    }
+    /**
+     * Checks if a DynamicActionDef is a type that can be executed.
+     */
+    isExecutableType(value, isAsync) {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        const action = this._actionMap.get(value.type);
+        if (!action) {
+            return false;
+        }
+        if (isAsync && !action.exec) {
+            return false;
+        }
+        if (!isAsync && !action.execSync) {
+            return false;
+        }
+        return true;
+    }
+    requiresConfirmation(actionDef, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!hasProperty(actionDef, 'confirmDef')) {
+                return false;
+            }
+            if (hasProperty(actionDef.confirmDef, 'disabled')) {
+                return !(yield this._valueHelper.eval(actionDef.confirmDef.disabled, context));
+            }
+            return true;
+        });
+    }
+    requiresConfirmationSync(actionDef, context) {
+        if (!hasProperty(actionDef, 'confirmDef')) {
+            return false;
+        }
+        if (hasProperty(actionDef.confirmDef, 'disabled')) {
+            const disabled = !this._valueHelper.evalSync(actionDef.confirmDef.disabled, context);
+            if (!disabled) {
+                throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +
+                    `confirm dialog. Only async actions support confirm dialog.`);
+            }
+            return false;
+        }
+        throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +
+            `confirm dialog. Only async actions support confirm dialog.`);
+    }
+    promptConfirmation(actionDef, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._confirmDialog) {
+                throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +
+                    `confirm dialog. Confirm dialog service is not injected.`);
+            }
+            const confirmDef = actionDef.confirmDef;
+            if (!confirmDef) {
+                throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +
+                    `confirm dialog. Confirm def is not defined.`);
+            }
+            let message;
+            if (hasProperty(confirmDef, 'message')) {
+                message = yield this._valueHelper.eval(confirmDef.message, context);
+            }
+            let alert;
+            if (hasProperty(confirmDef, 'alert')) {
+                alert = yield this._valueHelper.eval(confirmDef.alert, context);
+            }
+            const modalDef = this._confirmDialog.open(message, alert);
+            return modalDef.afterClosed().pipe(map(v => v === 'confirm')).toPromise();
+        });
+    }
+}
+DynamicActionHelperService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DynamicActionHelperService_Factory() { return new DynamicActionHelperService(i0.ɵɵinject(i1.DynamicValueHelperService), i0.ɵɵinject(i2.SeamConfirmDialogService, 8), i0.ɵɵinject(i3.THESEAM_DYNAMIC_ACTION, 8)); }, token: DynamicActionHelperService, providedIn: "root" });
+DynamicActionHelperService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+DynamicActionHelperService.ctorParameters = () => [
+    { type: DynamicValueHelperService },
+    { type: SeamConfirmDialogService, decorators: [{ type: Optional }] },
+    { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [THESEAM_DYNAMIC_ACTION,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-action-helper.service.js","sourceRoot":"","sources":["../../../../../projects/ui-common/dynamic/action/dynamic-action-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, isDevMode, Optional } from '@angular/core'\nimport { map } from 'rxjs/operators'\n\nimport { SeamConfirmDialogService } from '@theseam/ui-common/confirm-dialog'\nimport { ThemeTypes } from '@theseam/ui-common/models'\nimport { hasProperty } from '@theseam/ui-common/utils'\n\nimport { DynamicValueHelperService } from '../dynamic-value-helper.service'\nimport { DynamicAction } from '../models/dynamic-action'\nimport { DynamicActionDef } from '../models/dynamic-action-def'\nimport { DynamicActionUiDef } from '../models/dynamic-action-ui-def'\nimport { THESEAM_DYNAMIC_ACTION } from '../tokens/dynamic-action'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DynamicActionHelperService {\n\n  private _actionMap = new Map<string, DynamicAction<string>>()\n\n  constructor(\n    private _valueHelper: DynamicValueHelperService,\n    // TODO: Consider making the action confirm more generic\n    @Optional() private _confirmDialog?: SeamConfirmDialogService,\n    @Optional() @Inject(THESEAM_DYNAMIC_ACTION) actions?: DynamicAction<string>[]\n  ) {\n    // Only one evaluator should exist for a type, so map them for faster lookup.\n    for (const e of (actions || [])) {\n      if (isDevMode()) {\n        if (this._actionMap.has(e.type)) {\n          console.warn(`[DynamicActionHelperService] Multiple actions found for type '${e.type}'`)\n        }\n      }\n      this._actionMap.set(e.type, e)\n    }\n  }\n\n  /**\n   * Execute an async action.\n   *\n   * TODO: Improve context and return typing.\n   */\n  public async exec<T extends string>(actionDef: DynamicActionDef<T>, context?: any): Promise<DynamicActionDef<T>> {\n    const action = this._actionMap.get(actionDef.type)\n    if (!action) {\n      throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' not found.`)\n    }\n    if (!action.exec) {\n      throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' does not implement 'exec()'.`)\n    }\n\n    if (await this.requiresConfirmation(actionDef, context)) {\n      const confirmed = await this.promptConfirmation(actionDef, context)\n      if (!confirmed) {\n        // TODO: Decide a good way to handle a rejected confirm.\n        return 'rejected' as any\n      }\n    }\n\n    return await action.exec(actionDef, context)\n  }\n\n  /**\n   * Execute an action.\n   *\n   * TODO: Improve context and return typing.\n   */\n  public execSync<T extends string>(actionDef: DynamicActionDef<T>, context?: any): DynamicActionDef<T> {\n    const action = this._actionMap.get(actionDef.type)\n    if (!action) {\n      throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' not found.`)\n    }\n    if (!action.execSync) {\n      throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' does not implement 'execSync()'.`)\n    }\n\n    return action.execSync(actionDef, context)\n  }\n\n  /**\n   * Get UI props for action.\n   *\n   * TODO: Improve context and return typing.\n   */\n  public getUiProps<T extends string>(actionDef: DynamicActionDef<T>, context?: any): Promise<DynamicActionUiDef> {\n    const action = this._actionMap.get(actionDef.type)\n    if (!action) {\n      throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' not found.`)\n    }\n    if (!action.getUiProps) {\n      throw Error(`[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' does not implement 'getUiProps()'.`)\n    }\n\n    return action.getUiProps(actionDef, context)\n  }\n\n  /**\n   * Checks if a DynamicActionDef is a type that can be executed.\n   */\n  public isExecutableType<T extends string>(value: DynamicActionDef<T>, isAsync: boolean): boolean {\n    if (value === undefined || value === null) {\n      return false\n    }\n\n    const action  = this._actionMap.get(value.type)\n    if (!action) {\n      return false\n    }\n\n    if (isAsync && !action.exec) {\n      return false\n    }\n    if (!isAsync && !action.execSync) {\n      return false\n    }\n\n    return true\n  }\n\n  public async requiresConfirmation<T extends string>(actionDef: DynamicActionDef<T>, context?: any): Promise<boolean> {\n    if (!hasProperty(actionDef, 'confirmDef')) {\n      return false\n    }\n\n    if (hasProperty(actionDef.confirmDef, 'disabled')) {\n      return !(await this._valueHelper.eval(actionDef.confirmDef.disabled, context))\n    }\n\n    return true\n  }\n\n  public requiresConfirmationSync<T extends string>(actionDef: DynamicActionDef<T>, context?: any): boolean {\n    if (!hasProperty(actionDef, 'confirmDef')) {\n      return false\n    }\n\n    if (hasProperty(actionDef.confirmDef, 'disabled')) {\n      const disabled = !this._valueHelper.evalSync(actionDef.confirmDef.disabled, context)\n      if (!disabled) {\n        throw Error(\n          `[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +\n          `confirm dialog. Only async actions support confirm dialog.`\n        )\n      }\n      return false\n    }\n\n    throw Error(\n      `[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +\n      `confirm dialog. Only async actions support confirm dialog.`\n    )\n  }\n\n  public async promptConfirmation<T extends string>(actionDef: DynamicActionDef<T>, context?: any): Promise<boolean> {\n    if (!this._confirmDialog) {\n      throw Error(\n        `[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +\n        `confirm dialog. Confirm dialog service is not injected.`\n      )\n    }\n\n    const confirmDef = actionDef.confirmDef\n    if (!confirmDef) {\n      throw Error(\n        `[DynamicActionHelperService] Action '${actionDef ? actionDef.type : undefined}' can't open ` +\n        `confirm dialog. Confirm def is not defined.`\n      )\n    }\n\n    let message: string | undefined\n    if (hasProperty(confirmDef, 'message')) {\n      message = await this._valueHelper.eval(confirmDef.message, context)\n    }\n    let alert: string | { message: string, type: ThemeTypes } | undefined\n    if (hasProperty(confirmDef, 'alert')) {\n      alert = await this._valueHelper.eval(confirmDef.alert, context)\n    }\n\n    const modalDef = this._confirmDialog.open(message, alert)\n    return modalDef.afterClosed().pipe(\n      map(v => v === 'confirm')\n    ).toPromise()\n  }\n\n}\n"]}

package/esm2015/dynamic/action/index.js

@@ -0,0 +1,11 @@
+export * from './api/dynamic-action-api-def';
+export * from './api/dynamic-action-api.service';
+export * from './api/dynamic-action-api';
+export * from './link/dynamic-action-link-def';
+export * from './link/dynamic-action-link.service';
+export * from './link/dynamic-action-link';
+export * from './modal/dynamic-action-modal-def';
+export * from './modal/dynamic-action-modal.service';
+export * from './modal/dynamic-action-modal';
+export * from './dynamic-action-helper.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZHluYW1pYy9hY3Rpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQTtBQUM1QyxjQUFjLGtDQUFrQyxDQUFBO0FBQ2hELGNBQWMsMEJBQTBCLENBQUE7QUFFeEMsY0FBYyxnQ0FBZ0MsQ0FBQTtBQUM5QyxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsNEJBQTRCLENBQUE7QUFFMUMsY0FBYyxrQ0FBa0MsQ0FBQTtBQUNoRCxjQUFjLHNDQUFzQyxDQUFBO0FBQ3BELGNBQWMsOEJBQThCLENBQUE7QUFFNUMsY0FBYyxpQ0FBaUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXBpL2R5bmFtaWMtYWN0aW9uLWFwaS1kZWYnXG5leHBvcnQgKiBmcm9tICcuL2FwaS9keW5hbWljLWFjdGlvbi1hcGkuc2VydmljZSdcbmV4cG9ydCAqIGZyb20gJy4vYXBpL2R5bmFtaWMtYWN0aW9uLWFwaSdcblxuZXhwb3J0ICogZnJvbSAnLi9saW5rL2R5bmFtaWMtYWN0aW9uLWxpbmstZGVmJ1xuZXhwb3J0ICogZnJvbSAnLi9saW5rL2R5bmFtaWMtYWN0aW9uLWxpbmsuc2VydmljZSdcbmV4cG9ydCAqIGZyb20gJy4vbGluay9keW5hbWljLWFjdGlvbi1saW5rJ1xuXG5leHBvcnQgKiBmcm9tICcuL21vZGFsL2R5bmFtaWMtYWN0aW9uLW1vZGFsLWRlZidcbmV4cG9ydCAqIGZyb20gJy4vbW9kYWwvZHluYW1pYy1hY3Rpb24tbW9kYWwuc2VydmljZSdcbmV4cG9ydCAqIGZyb20gJy4vbW9kYWwvZHluYW1pYy1hY3Rpb24tbW9kYWwnXG5cbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1hY3Rpb24taGVscGVyLnNlcnZpY2UnXG4iXX0=

package/esm2015/dynamic/action/link/dynamic-action-link-def.js

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

package/esm2015/dynamic/action/link/dynamic-action-link.js

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

package/esm2015/dynamic/action/link/dynamic-action-link.service.js

@@ -0,0 +1,50 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { DynamicValueHelperService } 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
+    getUiProps(args, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = yield this._valueHandler.eval(args.link);
+            const external = !!(yield this._valueHandler.eval(args.external));
+            const asset = !!(yield this._valueHandler.eval(args.asset));
+            const target = yield this._valueHandler.eval(args.target);
+            const queryParams = yield 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.decorators = [
+    { type: Injectable }
+];
+DynamicActionLinkService.ctorParameters = () => [
+    { type: DynamicValueHelperService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/dynamic/action/modal/dynamic-action-modal-def.js

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

package/esm2015/dynamic/action/modal/dynamic-action-modal.js

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

package/esm2015/dynamic/action/modal/dynamic-action-modal.service.js

@@ -0,0 +1,92 @@
+import { __awaiter } from "tslib";
+import { Injectable, Injector } from '@angular/core';
+import { of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { Modal } from '@theseam/ui-common/modal';
+import { DynamicValueHelperService } from '../../dynamic-value-helper.service';
+import { DynamicActionHelperService } from '../dynamic-action-helper.service';
+/**
+ * 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';
+    }
+    exec(args, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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
+    getUiProps(args, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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.decorators = [
+    { type: Injectable }
+];
+DynamicActionModalService.ctorParameters = () => [
+    { type: DynamicValueHelperService },
+    { type: Modal },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/dynamic/dynamic-value-helper.service.js

@@ -0,0 +1,101 @@
+import { Inject, Injectable, isDevMode } from '@angular/core';
+import { THESEAM_DYNAMIC_VALUE_EVALUATOR } from './tokens/dynamic-value-evaluator';
+import * as i0 from "@angular/core";
+import * as i1 from "./tokens/dynamic-value-evaluator";
+/**
+ *
+ */
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function DynamicValueHelperService_Factory() { return new DynamicValueHelperService(i0.ɵɵinject(i1.THESEAM_DYNAMIC_VALUE_EVALUATOR)); }, token: DynamicValueHelperService, providedIn: "root" });
+DynamicValueHelperService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+DynamicValueHelperService.ctorParameters = () => [
+    { type: Array, 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 { 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>(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>(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>(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>(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>(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/esm2015/dynamic/evaluators/exporters-data-evaluator/exporters-data-evaluator.js

@@ -0,0 +1,33 @@
+import { __awaiter } from "tslib";
+import { Injectable, Injector } from '@angular/core';
+import { THESEAM_DATA_EXPORTER } from '@theseam/ui-common/data-exporter';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+export class ExportersDataEvaluator {
+    constructor(_injector) {
+        this._injector = _injector;
+        this.type = 'exporters-data';
+    }
+    eval(value, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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.decorators = [
+    { type: Injectable }
+];
+ExportersDataEvaluator.ctorParameters = () => [
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,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