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

package/esm2020/datatable-dynamic/dynamic-datatable-def.service.mjs

@@ -0,0 +1,88 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, of } from 'rxjs';
+import { map, shareReplay, switchMap } from 'rxjs/operators';
+import { THESEAM_DATA_EXPORTER } from '@theseam/ui-common/data-exporter';
+import { THESEAM_DATA_FILTER_DEF } from '@theseam/ui-common/data-filters';
+import { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { setDynamicDatatableDefDefaults } from './utils/index';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/dynamic";
+/**
+ * Manages the data defined in the `DatatableDynamicDef`. Simplifies accessing
+ * and observing the needed data based on the `DatatableDynamicDef`.
+ */
+export class DynamicDatatableDefService {
+    constructor(dataExporters, dataFilters, _valueHelper) {
+        this._valueHelper = _valueHelper;
+        /** @ignore */
+        this._defSubject = new BehaviorSubject(undefined);
+        this._dataExporters = (dataExporters || []);
+        this._dataFilters = (dataFilters || []);
+        this.def$ = this._defSubject.asObservable();
+        this.exporters$ = this.def$.pipe(map(def => !!def ? this._mapExporters(def) : []), shareReplay({ bufferSize: 1, refCount: true }));
+        this.filterMenuItems$ = this.def$.pipe(map(def => !!def ? this._mapFilterMenuItems(def) : []), shareReplay({ bufferSize: 1, refCount: true }));
+        this.hasFilterMenu$ = this.def$.pipe(switchMap(def => {
+            if (!def) {
+                return of(false);
+            }
+            // Check if the visibility can be determined by the state value only.
+            if (def.filterMenu && def.filterMenu.state) {
+                switch (def.filterMenu.state) {
+                    case 'always-visible': return of(true);
+                    case 'hidden': return of(false);
+                }
+            }
+            // Check if there is anything to put in the filter menu.
+            return combineLatest([
+                this.exporters$.pipe(map(e => e.length > 0)),
+                this.filterMenuItems$.pipe(map(f => f.length > 0))
+            ]).pipe(map(v => v.indexOf(true) !== -1));
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this.options$ = this.def$.pipe(map(def => !!def ? def.options : undefined), shareReplay({ bufferSize: 1, refCount: true }));
+        this.menuBar$ = this.def$.pipe(map(def => (notNullOrUndefined(def) && hasProperty(def, 'menuBar')) ? def.menuBar : undefined), 
+        // tap(v => console.log('menubar', v)),
+        shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    /** Sets the `DatatableDynamicDef` that defines the datatable.  */
+    setDef(def) {
+        if (def) {
+            setDynamicDatatableDefDefaults(def);
+        }
+        this._defSubject.next(def || undefined);
+    }
+    /** Map the def exporters to the provided `IDataExporter` objects. */
+    _mapExporters(def) {
+        if (!def.filterMenu || !Array.isArray(def.filterMenu.exporters)) {
+            return [];
+        }
+        return def.filterMenu.exporters
+            .map(e => this._dataExporters.find(de => de.name === e))
+            .filter(notNullOrUndefined);
+    }
+    /** Map the def filter menu items to provided components. */
+    _mapFilterMenuItems(def) {
+        if (!def.filterMenu || !def.filterMenu.filters || !Array.isArray(def.filterMenu.filters)) {
+            return [];
+        }
+        return def.filterMenu.filters
+            .map(f => {
+            const _df = this._dataFilters.find(df => df.name === f.name);
+            if (_df) {
+                return { ...f, component: _df.component };
+            }
+        })
+            .filter(notNullOrUndefined);
+    }
+}
+DynamicDatatableDefService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicDatatableDefService, deps: [{ token: THESEAM_DATA_EXPORTER }, { token: THESEAM_DATA_FILTER_DEF }, { token: i1.DynamicValueHelperService }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicDatatableDefService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicDatatableDefService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicDatatableDefService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_DATA_EXPORTER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_DATA_FILTER_DEF]
+                }] }, { type: i1.DynamicValueHelperService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-datatable-def.service.js","sourceRoot":"","sources":["../../../../projects/ui-common/datatable-dynamic/dynamic-datatable-def.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal'\nimport { Inject, Injectable } from '@angular/core'\nimport { BehaviorSubject, combineLatest, Observable, of } from 'rxjs'\nimport { map, shareReplay, switchMap } from 'rxjs/operators'\n\nimport { IDataExporter, THESEAM_DATA_EXPORTER } from '@theseam/ui-common/data-exporter'\nimport { IDataFilter, THESEAM_DATA_FILTER_DEF } from '@theseam/ui-common/data-filters'\nimport { DynamicValueHelperService } from '@theseam/ui-common/dynamic'\nimport { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { DynamicDatatableOptions } from './datatable-dynamic-def'\nimport { DatatableDynamicDef } from './datatable-dynamic-def'\nimport { DynamicDatatableMenuBar } from './models/dynamic-datatable-menu-bar'\nimport { DynamicDatatableFilterMenuItem } from './models/index'\nimport { setDynamicDatatableDefDefaults } from './utils/index'\n\n/**\n * Manages the data defined in the `DatatableDynamicDef`. Simplifies accessing\n * and observing the needed data based on the `DatatableDynamicDef`.\n */\n@Injectable()\nexport class DynamicDatatableDefService {\n\n  /**\n   * @deprecated\n   * @ignore\n   */\n  private _dataExporters: IDataExporter[]\n\n  /**\n   * @deprecated\n   * @ignore\n   */\n  private _dataFilters: { name: string, component: ComponentType<IDataFilter> }[]\n\n  /** @ignore */\n  private readonly _defSubject = new BehaviorSubject<DatatableDynamicDef | undefined>(undefined)\n\n  /** Dynamic datatable definition. */\n  public readonly def$: Observable<DatatableDynamicDef | undefined>\n\n  /**\n   * Exporters in the def that are available.\n   * @deprecated\n   */\n  public readonly exporters$: Observable<IDataExporter[]>\n\n  /**\n   * Filter menu items in the def that are available.\n   * @deprecated\n   */\n  public readonly filterMenuItems$: Observable<DynamicDatatableFilterMenuItem[]>\n\n  /**\n   * Observes whether the datatable has a filter menu.\n   * @deprecated\n   */\n  public readonly hasFilterMenu$: Observable<boolean>\n\n  /** Observes datatable options. */\n  public readonly options$: Observable<DynamicDatatableOptions | undefined>\n\n  /** Observes the datatable def menu bar. */\n  public readonly menuBar$: Observable<DynamicDatatableMenuBar | undefined>\n\n  constructor(\n    @Inject(THESEAM_DATA_EXPORTER) dataExporters: IDataExporter[],\n    @Inject(THESEAM_DATA_FILTER_DEF) dataFilters: { name: string, component: ComponentType<IDataFilter> }[],\n    private _valueHelper: DynamicValueHelperService,\n  ) {\n    this._dataExporters = (dataExporters || [])\n    this._dataFilters = (dataFilters || [])\n\n    this.def$ = this._defSubject.asObservable()\n\n    this.exporters$ = this.def$.pipe(\n      map(def => !!def ? this._mapExporters(def) : []),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.filterMenuItems$ = this.def$.pipe(\n      map(def => !!def ? this._mapFilterMenuItems(def) : []),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.hasFilterMenu$ = this.def$.pipe(\n      switchMap(def => {\n        if (!def) { return of(false) }\n\n        // Check if the visibility can be determined by the state value only.\n        if (def.filterMenu && def.filterMenu.state) {\n          switch (def.filterMenu.state) {\n            case 'always-visible': return of(true)\n            case 'hidden': return of(false)\n          }\n        }\n\n        // Check if there is anything to put in the filter menu.\n        return combineLatest([\n          this.exporters$.pipe(map(e => e.length > 0)),\n          this.filterMenuItems$.pipe(map(f => f.length > 0))\n        ]).pipe(map(v => v.indexOf(true) !== -1))\n      }),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.options$ = this.def$.pipe(\n      map(def => !!def ? def.options : undefined),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.menuBar$ = this.def$.pipe(\n      map(def => (notNullOrUndefined(def) && hasProperty(def, 'menuBar')) ? def.menuBar : undefined),\n      // tap(v => console.log('menubar', v)),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n  }\n\n  /** Sets the `DatatableDynamicDef` that defines the datatable.  */\n  public setDef(def: DatatableDynamicDef | undefined): void {\n    if (def) { setDynamicDatatableDefDefaults(def) }\n    this._defSubject.next(def || undefined)\n  }\n\n  /** Map the def exporters to the provided `IDataExporter` objects. */\n  private _mapExporters(def: DatatableDynamicDef): IDataExporter[] {\n    if (!def.filterMenu || !Array.isArray(def.filterMenu.exporters)) {\n      return []\n    }\n\n    return def.filterMenu.exporters\n      .map(e => this._dataExporters.find(de => de.name === e))\n      .filter(notNullOrUndefined)\n  }\n\n  /** Map the def filter menu items to provided components. */\n  private _mapFilterMenuItems(def: DatatableDynamicDef): DynamicDatatableFilterMenuItem[] {\n    if (!def.filterMenu || !def.filterMenu.filters || !Array.isArray(def.filterMenu.filters)) {\n      return []\n    }\n\n    return def.filterMenu.filters\n      .map(f => {\n        const _df = this._dataFilters.find(df => df.name === f.name)\n        if (_df) { return { ...f, component: _df.component } }\n      })\n      .filter(notNullOrUndefined)\n  }\n\n}\n"]}

package/esm2020/datatable-dynamic/dynamic-datatable-row-actions.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { from, of } from 'rxjs';
+import { map, switchMap, toArray } from 'rxjs/operators';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/dynamic";
+import * as i2 from "./dynamic-datatable-def.service";
+export class DynamicDatatableRowActionsService {
+    constructor(_valueHelper, _dynamicDef) {
+        this._valueHelper = _valueHelper;
+        this._dynamicDef = _dynamicDef;
+    }
+    /**
+     * Observe actions for specified row
+     */
+    rowActions(row) {
+        return this._dynamicDef.def$.pipe(map(def => (def && def.rowActions) ? def.rowActions || [] : []), switchMap(rowActions => !!rowActions
+            ? from(rowActions).pipe(map(rowAction => {
+                if (rowAction.hasOwnProperty('hidden')) {
+                    if (typeof rowAction.hidden === 'boolean') {
+                        return rowAction.hidden ? undefined : rowAction;
+                    }
+                    else {
+                        const context = this._getRowActionContext(row, rowAction);
+                        // TODO: Fix async eval
+                        const isHidden = this._valueHelper.evalSync(rowAction.hidden, context);
+                        return isHidden ? undefined : rowAction;
+                    }
+                }
+                return rowAction;
+            }), toArray(), map(v => v.filter(notNullOrUndefined)))
+            : of([])));
+    }
+    /** @ignore */
+    _getRowActionContext(row, rowActionDef) {
+        return {
+            row
+        };
+    }
+}
+DynamicDatatableRowActionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicDatatableRowActionsService, deps: [{ token: i1.DynamicValueHelperService }, { token: i2.DynamicDatatableDefService }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicDatatableRowActionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicDatatableRowActionsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicDatatableRowActionsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DynamicValueHelperService }, { type: i2.DynamicDatatableDefService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/datatable-dynamic/models/dynamic-datatable-menu-bar.mjs

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

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

@@ -0,0 +1,206 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable, isDevMode, Optional } from '@angular/core';
+import { from } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { isAbsoluteUrl } from '@theseam/ui-common/utils';
+import { isValidRequestMethod, THESEAM_API_CONFIG, VALID_REQUEST_METHODS } from '../../tokens/api-config';
+import { dynamicActionApiNotSupportedError } from './dynamic-action-api-errors';
+import * as i0 from "@angular/core";
+import * as i1 from "../../dynamic-value-helper.service";
+import * as i2 from "@angular/common/http";
+/**
+ * Handles execution of api call actions.
+ *
+ * This action service should be generic enough to
+ * work with any url endpoint, but will be biased towards our api where needed.
+ */
+export class DynamicActionApiService {
+    constructor(_valueHelper, _http, _configs) {
+        this._valueHelper = _valueHelper;
+        this._http = _http;
+        this._configs = _configs;
+        this.type = 'api';
+        this.label = 'Api Action';
+    }
+    exec(args, context) {
+        if (!this._isSupported()) {
+            throw dynamicActionApiNotSupportedError();
+        }
+        return from(this._getExecInfo(args, context)).pipe(switchMap(x => this._http.request(x.method, x.url, x.options))).toPromise();
+    }
+    async getUiProps(args, context) {
+        return {
+            _actionDef: args,
+            triggerType: 'click'
+        };
+    }
+    async _getExecInfo(args, context) {
+        const method = args.method || 'GET';
+        const url = await this._getUrl(args, context);
+        if (url === null) {
+            throw new Error('[DynamicActionApiService] Unable to determine url.');
+        }
+        const body = await this._getBody(args, context);
+        const params = await this._getParams(args, context);
+        const headers = await this._getHeaders(args, context);
+        const result = {
+            url,
+            method,
+            options: { body, params, headers }
+        };
+        return result;
+    }
+    async _getUrl(args, context) {
+        const config = this._getApiConfig(args);
+        let endpoint = '';
+        if (args.endpoint) {
+            endpoint = await this._valueHelper.eval(args.endpoint, context);
+        }
+        if (isAbsoluteUrl(endpoint)) {
+            return endpoint;
+        }
+        if (config && config.url !== undefined && config.url !== null) {
+            const url = await this._valueHelper.eval(config.url, context);
+            if (typeof url === 'string') {
+                const addSlash = endpoint.length > 0 && endpoint.indexOf('/') !== 0 &&
+                    url.length > 0 && url.indexOf('/') !== 0;
+                return `${config.url}${addSlash ? '/' : ''}${endpoint}`;
+            }
+        }
+        return null;
+    }
+    _getApiConfig(args) {
+        const configs = this._configs || [];
+        if (args.id === undefined || args.id === null) {
+            return configs.length > 0 ? configs[0] : null;
+        }
+        for (const config of configs) {
+            if (config.id && config.id === args.id) {
+                return config;
+            }
+        }
+        return null;
+    }
+    async _getBody(args, context) {
+        if (args.body !== undefined && args.body !== null) {
+            return await this._valueHelper.eval(args.body, context);
+        }
+        return undefined;
+    }
+    async _getParams(args, context) {
+        if (args.params !== undefined && args.params !== null) {
+            return await this._valueHelper.eval(args.params, context);
+        }
+        return undefined;
+    }
+    async _getHeaders(args, context) {
+        let headers = {};
+        const config = this._getApiConfig(args);
+        // TODO: Make sure I am handling these values correctly. This could be
+        // much cleaner. Tests with all the js primitives, null, undefined, and
+        // dynamic action types should be written.
+        if (config && config.methodHeaders) {
+            const method = typeof args.method === 'string'
+                ? args.method.trim().toUpperCase()
+                : 'GET'; // Default method type
+            if (!isValidRequestMethod(method)) {
+                throw Error(`API request method must be one of ${VALID_REQUEST_METHODS}`);
+            }
+            const h = method && config.methodHeaders[method];
+            if (h !== undefined && h !== null) {
+                headers = await this._evalHeaders(h, context);
+            }
+        }
+        // TODO: Cleanup messing multiple level logic
+        const argHeaders = args.headers;
+        if (argHeaders !== undefined && argHeaders !== null) {
+            if (typeof argHeaders === 'string') {
+                headers = argHeaders;
+            }
+            else {
+                const _val = this._valueHelper.eval(argHeaders, context); // TODO: Fix argHeaders type
+                if (typeof _val === 'string') {
+                    headers = _val;
+                }
+                else {
+                    const keys = Object.keys(argHeaders);
+                    for (const key of keys) {
+                        if (!isValidRequestMethod(key)) {
+                            throw Error(`API request method must be one of ${VALID_REQUEST_METHODS}`);
+                        }
+                        // TODO: Fix types
+                        const value = argHeaders[key];
+                        if (typeof value === 'string') {
+                            headers[key] = value;
+                        }
+                        else if (Array.isArray(value)) {
+                            headers[key] = await Promise.all(value.map(async (v) => await this._valueHelper.eval(v, context)));
+                        }
+                        else {
+                            headers[key] = await this._valueHelper.eval(value, context);
+                        }
+                    }
+                }
+            }
+        }
+        return new HttpHeaders(headers);
+    }
+    async _evalHeaders(headers, context) {
+        let res = {};
+        // TODO: Cleanup messing multiple level logic
+        if (typeof headers === 'string') {
+            res = headers;
+        }
+        else {
+            const _val = this._valueHelper.eval(headers, context); // TODO: Fix argHeaders type
+            if (typeof _val === 'string') {
+                res = _val;
+            }
+            else {
+                const keys = Object.keys(headers);
+                for (const key of keys) {
+                    const value = headers[key];
+                    if (typeof value === 'string') {
+                        res[key] = value;
+                    }
+                    else if (Array.isArray(value)) {
+                        res[key] = await Promise.all(value.map(async (v) => await this._valueHelper.eval(v, context)));
+                    }
+                    else {
+                        res[key] = await this._valueHelper.eval(value, context);
+                    }
+                }
+            }
+        }
+        return res;
+    }
+    _isSupported() {
+        if (isDevMode()) {
+            console.warn(`[DynamicActionApiService] Action is not ready for production yet.`);
+        }
+        else {
+            // I don't expect this to be attempted in prod before completed, so I am just adding a console warning.
+            console.warn(`Unable to complete request. Contact support for assistance.`);
+        }
+        if (!this._http) {
+            if (isDevMode()) {
+                console.warn(`[DynamicActionApiService] Endpoint actions require \`HttpClientModule\` to be imported.`);
+            }
+            return false;
+        }
+        return true;
+    }
+}
+DynamicActionApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionApiService, deps: [{ token: i1.DynamicValueHelperService }, { token: i2.HttpClient, optional: true }, { token: THESEAM_API_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicActionApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DynamicValueHelperService }, { type: i2.HttpClient, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [THESEAM_API_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-action-api.service.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/dynamic/action/api/dynamic-action-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http'\nimport { Inject, Injectable, isDevMode, Optional } from '@angular/core'\nimport { from } from 'rxjs'\nimport { switchMap } from 'rxjs/operators'\n\nimport { isAbsoluteUrl } from '@theseam/ui-common/utils'\n\nimport { DynamicValueHelperService } from '../../dynamic-value-helper.service'\nimport { DynamicActionUiButtonDef } from '../../models/dynamic-action-ui-button-def'\nimport { DynamicValue } from '../../models/dynamic-value'\nimport { ApiRequestMethodHeader, ApiRequestMethodHeaders, IApiConfig, isValidRequestMethod, THESEAM_API_CONFIG, VALID_REQUEST_METHODS } from '../../tokens/api-config'\n\nimport { DynamicActionApi } from './dynamic-action-api'\nimport { DynamicActionApiDef } from './dynamic-action-api-def'\nimport { dynamicActionApiNotSupportedError } from './dynamic-action-api-errors'\n\n/**\n * Handles execution of api call actions.\n *\n * This action service should be generic enough to\n * work with any url endpoint, but will be biased towards our api where needed.\n */\n@Injectable()\nexport class DynamicActionApiService implements DynamicActionApi {\n\n  readonly type = 'api'\n\n  label = 'Api Action'\n\n  constructor(\n    private _valueHelper: DynamicValueHelperService,\n    @Optional() private _http: HttpClient,\n    @Optional() @Inject(THESEAM_API_CONFIG) private _configs: IApiConfig[]\n  ) { }\n\n  public exec(args: DynamicActionApiDef, context: any): Promise<any> {\n    if (!this._isSupported()) {\n      throw dynamicActionApiNotSupportedError()\n    }\n\n    return from(this._getExecInfo(args, context)).pipe(\n      switchMap(x => this._http.request<any>(x.method, x.url, x.options)),\n    ).toPromise()\n  }\n\n  public async getUiProps(args: DynamicActionApiDef, context: any): Promise<DynamicActionUiButtonDef> {\n    return {\n      _actionDef: args,\n      triggerType: 'click'\n    }\n  }\n\n  private async _getExecInfo(args: DynamicActionApiDef, context?: any) {\n    const method = args.method || 'GET'\n\n    const url = await this._getUrl(args, context)\n    if (url === null) {\n      throw new Error('[DynamicActionApiService] Unable to determine url.')\n    }\n\n    const body = await this._getBody(args, context)\n    const params = await this._getParams(args, context)\n\n    const headers = await this._getHeaders(args, context)\n\n    const result = {\n      url,\n      method,\n      options: { body, params, headers }\n    }\n\n    return result\n  }\n\n  private async _getUrl(args: DynamicActionApiDef, context?: any): Promise<string | null> {\n    const config = this._getApiConfig(args)\n\n    let endpoint = ''\n    if (args.endpoint) {\n      endpoint = await this._valueHelper.eval(args.endpoint, context)\n    }\n\n    if (isAbsoluteUrl(endpoint)) {\n      return endpoint\n    }\n\n    if (config && config.url !== undefined && config.url !== null) {\n      const url = await this._valueHelper.eval(config.url, context)\n      if (typeof url === 'string') {\n        const addSlash = endpoint.length > 0 && endpoint.indexOf('/') !== 0 &&\n          url.length > 0 && url.indexOf('/') !== 0\n        return `${config.url}${addSlash ? '/' : ''}${endpoint}`\n      }\n    }\n\n    return null\n  }\n\n  private _getApiConfig(args: DynamicActionApiDef): IApiConfig | null {\n    const configs = this._configs || []\n\n    if (args.id === undefined || args.id === null) {\n      return configs.length > 0 ? configs[0] : null\n    }\n\n    for (const config of configs) {\n      if (config.id && config.id === args.id) {\n        return config\n      }\n    }\n\n    return null\n  }\n\n  private async _getBody(args: DynamicActionApiDef, context?: any) {\n    if (args.body !== undefined && args.body !== null) {\n      return await this._valueHelper.eval(args.body, context)\n    }\n\n    return undefined\n  }\n\n  private async _getParams(args: DynamicActionApiDef, context?: any) {\n    if (args.params !== undefined && args.params !== null) {\n      return await this._valueHelper.eval(args.params, context)\n    }\n\n    return undefined\n  }\n\n  private async _getHeaders(args: DynamicActionApiDef, context?: any): Promise<HttpHeaders> {\n    let headers: ApiRequestMethodHeaders = {}\n\n    const config = this._getApiConfig(args)\n\n    // TODO: Make sure I am handling these values correctly. This could be\n    // much cleaner. Tests with all the js primitives, null, undefined, and\n    // dynamic action types should be written.\n\n    if (config && config.methodHeaders) {\n      const method = typeof args.method === 'string'\n        ? args.method.trim().toUpperCase()\n        : 'GET' // Default method type\n\n      if (!isValidRequestMethod(method)) {\n        throw Error(`API request method must be one of ${VALID_REQUEST_METHODS}`)\n      }\n\n      const h = method && config.methodHeaders[method]\n      if (h !== undefined && h !== null) {\n        headers = await this._evalHeaders(h, context) as any\n      }\n    }\n\n    // TODO: Cleanup messing multiple level logic\n    const argHeaders = args.headers\n    if (argHeaders !== undefined && argHeaders !== null) {\n      if (typeof argHeaders === 'string') {\n        headers = argHeaders as any\n      } else {\n        const _val = this._valueHelper.eval(argHeaders as any, context) // TODO: Fix argHeaders type\n        if (typeof _val === 'string') {\n          headers = _val\n        } else {\n          const keys = Object.keys(argHeaders)\n          for (const key of keys) {\n            if (!isValidRequestMethod(key)) {\n              throw Error(`API request method must be one of ${VALID_REQUEST_METHODS}`)\n            }\n\n            // TODO: Fix types\n            const value = (argHeaders as any)[key]\n            if (typeof value === 'string') {\n              headers[key] = value\n            } else if (Array.isArray(value)) {\n              headers[key] = await Promise.all(value.map(async v => await this._valueHelper.eval(v, context))) as any\n            } else {\n              headers[key] = await this._valueHelper.eval(value, context)\n            }\n          }\n        }\n      }\n    }\n\n    return new HttpHeaders(headers as any)\n  }\n\n  private async _evalHeaders(\n    headers: string | DynamicValue<string> | { [name: string]: DynamicValue<string> | DynamicValue<string>[] },\n    context?: any\n  ) {\n    let res: string | { [name: string]: string | string[] } = {}\n\n    // TODO: Cleanup messing multiple level logic\n    if (typeof headers === 'string') {\n      res = headers\n    } else {\n      const _val = this._valueHelper.eval(headers as any, context) // TODO: Fix argHeaders type\n      if (typeof _val === 'string') {\n        res = _val\n      } else {\n        const keys = Object.keys(headers)\n        for (const key of keys) {\n          const value = (headers as any)[key]\n          if (typeof value === 'string') {\n            res[key] = value\n          } else if (Array.isArray(value)) {\n            res[key] = await Promise.all(value.map(async v => await this._valueHelper.eval(v, context)))\n          } else {\n            res[key] = await this._valueHelper.eval(value, context)\n          }\n        }\n      }\n    }\n    return res\n  }\n\n  private _isSupported(): boolean {\n    if (isDevMode()) {\n      console.warn(`[DynamicActionApiService] Action is not ready for production yet.`)\n    } else {\n      // I don't expect this to be attempted in prod before completed, so I am just adding a console warning.\n      console.warn(`Unable to complete request. Contact support for assistance.`)\n    }\n\n    if (!this._http) {\n      if (isDevMode()) {\n        console.warn(`[DynamicActionApiService] Endpoint actions require \\`HttpClientModule\\` to be imported.`)\n      }\n      return false\n    }\n    return true\n  }\n}\n"]}

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

@@ -0,0 +1,157 @@
+import { Inject, Injectable, isDevMode, Optional } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { hasProperty } from '@theseam/ui-common/utils';
+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";
+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.
+     */
+    async exec(actionDef, context) {
+        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 (await this.requiresConfirmation(actionDef, context)) {
+            const confirmed = await this.promptConfirmation(actionDef, context);
+            if (!confirmed) {
+                // TODO: Decide a good way to handle a rejected confirm.
+                return 'rejected';
+            }
+        }
+        return await 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;
+    }
+    async requiresConfirmation(actionDef, context) {
+        if (!hasProperty(actionDef, 'confirmDef')) {
+            return false;
+        }
+        if (hasProperty(actionDef.confirmDef, 'disabled')) {
+            return !(await 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.`);
+    }
+    async promptConfirmation(actionDef, context) {
+        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 = await this._valueHelper.eval(confirmDef.message, context);
+        }
+        let alert;
+        if (hasProperty(confirmDef, 'alert')) {
+            alert = await this._valueHelper.eval(confirmDef.alert, context);
+        }
+        const modalDef = this._confirmDialog.open(message, alert);
+        return modalDef.afterClosed().pipe(map(v => v === 'confirm')).toPromise().then(x => x ?? false);
+    }
+}
+DynamicActionHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionHelperService, deps: [{ token: i1.DynamicValueHelperService }, { token: i2.SeamConfirmDialogService, optional: true }, { token: THESEAM_DYNAMIC_ACTION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicActionHelperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionHelperService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DynamicActionHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicValueHelperService }, { type: i2.SeamConfirmDialogService, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, 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().then(x => x ?? false)\n  }\n\n}\n"]}