@reltio/components 1.4.1102 → 1.4.1103

package/esm/hooks/useAPI/API.js

@@ -0,0 +1,197 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { sendRequestFromCustomSandbox, sendWorkflowRequest, startProcessFromQuery } from '@reltio/mdm-sdk';
+import { RequestAction } from './types';
+var processFromQuery = function (params, permissions, workflowPath, tenant, environment) {
+    if (!params.processDefinitionId) {
+        return new Promise(function (resolve) { return resolve({ errorMessage: 'processDefinitionId is empty' }); });
+    }
+    if (!params.searchString) {
+        return new Promise(function (resolve) { return resolve({ errorMessage: 'searchString is empty' }); });
+    }
+    if (!workflowPath) {
+        return new Promise(function (resolve) { return resolve({ errorMessage: 'Workflow path is not defined' }); });
+    }
+    var errors = validateParams(__assign({ url: '/processInstances/_generateFromQuery' }, params), permissions);
+    if (errors) {
+        return new Promise(function (resolve) { return resolve(errors); });
+    }
+    return startProcessFromQuery({
+        workflowPath: workflowPath,
+        processType: params.processDefinitionId,
+        searchString: params.searchString,
+        tenant: tenant,
+        environment: environment
+    });
+};
+var workflowRequest = function (params, permissions, workflowPath, tenant) {
+    var url = params.url;
+    var errors = validateParams(params, permissions);
+    if (errors) {
+        return new Promise(function (resolve) { return resolve(errors); });
+    }
+    var isExternalUrl = url.includes('http:') || url.includes('https:');
+    if (!workflowPath && !isExternalUrl) {
+        return new Promise(function (resolve) { return resolve({ errorMessage: 'Workflow path is not defined' }); });
+    }
+    return sendWorkflowRequest({
+        url: url,
+        method: params.method || 'GET',
+        data: params.data,
+        tenant: tenant,
+        headers: params.headers,
+        workflowPath: workflowPath
+    });
+};
+var sendApiRequest = function (params, permissions) {
+    var errors = validateParams(params, permissions);
+    if (errors) {
+        return new Promise(function (resolve) { return resolve(errors); });
+    }
+    return sendRequestFromCustomSandbox({
+        url: params.url,
+        method: params.method,
+        data: params.data,
+        headers: params.headers
+    });
+};
+var validateParams = function (params, permissions) {
+    var url = params.url;
+    if (!url)
+        return { errorMessage: 'URL is empty' };
+    var allowed = permissions === null || permissions === void 0 ? void 0 : permissions.some(function (perm) {
+        var parsed = perm.match(/^(?:([^:?#]+):)?(?:\/\/((?:(([^:@?]*)(?::([^:@?]*))?)?@)?((?:\[[0-9A-Fa-f:]+)|(?:[^:?#]*))(?::(\d*))?))?((((?:[^?#]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/);
+        var protocol = parsed[1];
+        var host = parsed[6];
+        var protocolAndHost = protocol + "://" + host;
+        var re = new RegExp('^' + perm + '$');
+        var formattedPerm = perm.replace(/\/*$/, '');
+        return (formattedPerm === url ||
+            (host && host === formattedPerm) ||
+            (host && protocolAndHost === formattedPerm) ||
+            (formattedPerm && formattedPerm.indexOf('/') === 0 && url && url.indexOf(formattedPerm) === 0) ||
+            (formattedPerm && re.test(url)));
+    });
+    if (!allowed || ((permissions === null || permissions === void 0 ? void 0 : permissions.length) || 0) === 0) {
+        return { errorMessage: 'Not enough permissions' };
+    }
+    return false;
+};
+export var processRequest = function (_a) {
+    var name = _a.name, paramObject = _a.paramObject, permissions = _a.permissions, worker = _a.worker, metadata = _a.metadata, config = _a.config, apiPath = _a.apiPath, user = _a.user, workflowPath = _a.workflowPath, entity = _a.entity, tenant = _a.tenant, entityUri = _a.entityUri, query = _a.query, openSearch = _a.openSearch, environment = _a.environment, getCurrentPerspectiveId = _a.getCurrentPerspectiveId, showPerspective = _a.showPerspective, workflowCheckPermission = _a.workflowCheckPermission, setEntityUri = _a.setEntityUri;
+    var handleRequest = function (request) {
+        request
+            .then(function (data) {
+            worker.postMessage(__assign({ action: 'response', result: { data: data } }, paramObject.params));
+        })
+            .catch(function () {
+            worker.postMessage(__assign({ action: 'response', result: { data: {}, headers: '', status: 0 } }, paramObject.params));
+        });
+    };
+    switch (name) {
+        case RequestAction.API: {
+            var request = sendApiRequest(paramObject.params, permissions);
+            handleRequest(request);
+            break;
+        }
+        case RequestAction.WORKFLOW: {
+            var request = workflowRequest(paramObject.params, permissions, workflowPath, tenant);
+            handleRequest(request);
+            break;
+        }
+        case RequestAction.WORKFLOW_START_PROCESS_FROM_QUERY: {
+            var request = processFromQuery(paramObject.params, permissions, workflowPath, tenant, environment);
+            handleRequest(request);
+            break;
+        }
+        case RequestAction.GET_CONFIGURATION: {
+            worker.postMessage(__assign({ action: 'response', result: metadata }, paramObject.params));
+            break;
+        }
+        case RequestAction.GET_UI_CONFIGURATION: {
+            var response = __assign(__assign({}, config), { action: __assign({}, config.action) });
+            if (response.action.permissions) {
+                delete response.action.permissions;
+            }
+            worker.postMessage(__assign({ action: 'response', result: response }, paramObject.params));
+            break;
+        }
+        case RequestAction.SET_ENTITY_URI: {
+            var listener = function () { return worker.postMessage(__assign({ action: 'response', result: entity }, paramObject.params)); };
+            setEntityUri(entityUri, listener);
+            break;
+        }
+        case RequestAction.SET_PERSPECTIVE: {
+            showPerspective(paramObject.params.perspective);
+            worker.postMessage(__assign({ action: 'response', result: getCurrentPerspectiveId() }, paramObject.params));
+            break;
+        }
+        case RequestAction.GET_PERSPECTIVE: {
+            if (getCurrentPerspectiveId) {
+                worker.postMessage(__assign({ action: 'response', result: getCurrentPerspectiveId() }, paramObject.params));
+            }
+            break;
+        }
+        case RequestAction.WORKFLOW_CHECK_PERMISSION: {
+            worker.postMessage(__assign({ action: 'response', result: workflowCheckPermission(paramObject.params.permission) }, paramObject.params));
+            break;
+        }
+        case RequestAction.GET_SEARCH_QUERY: {
+            worker.postMessage(__assign({ action: 'response', result: query }, paramObject.params));
+            break;
+        }
+        case RequestAction.OPEN_SEARCH: {
+            openSearch({ viewId: config.id, searchState: paramObject.params.searchState });
+            break;
+        }
+        case RequestAction.GET_ENTITY_URI: {
+            worker.postMessage(__assign({ action: 'response', result: entityUri }, paramObject.params));
+            break;
+        }
+        case RequestAction.GET_ENTITY: {
+            worker.postMessage(__assign({ action: 'response', result: entity }, paramObject.params));
+            break;
+        }
+        case RequestAction.GET_API_PATH: {
+            worker.postMessage(__assign({ action: 'response', result: apiPath }, paramObject.params));
+            break;
+        }
+        case RequestAction.WORKFLOW_GET_WORKFLOW_PATH: {
+            worker.postMessage(__assign({ action: 'response', result: workflowPath }, paramObject.params));
+            break;
+        }
+        case RequestAction.GET_TENANT: {
+            worker.postMessage(__assign({ action: 'response', result: tenant }, paramObject.params));
+            break;
+        }
+        case RequestAction.GET_USER: {
+            worker.postMessage(__assign({ action: 'response', result: user }, paramObject.params));
+            break;
+        }
+        case RequestAction.ALERT: {
+            window.alert(paramObject.params.text);
+            break;
+        }
+        case RequestAction.CONFIRM: {
+            window.confirm(paramObject.params.text);
+            break;
+        }
+        case RequestAction.PROMPT: {
+            window.prompt(paramObject.params.text, paramObject.params.defaultText || '');
+            break;
+        }
+        case RequestAction.OPEN_WINDOW: {
+            window.open(paramObject.params.url, '_blank');
+            break;
+        }
+    }
+};

package/esm/hooks/useAPI/helpers.d.ts

@@ -0,0 +1 @@
+export declare const getWorkerURL: (uiPath: string, tenant: string) => string;

package/esm/hooks/useAPI/helpers.js

@@ -0,0 +1,8 @@
+export var getWorkerURL = function (uiPath, tenant) {
+    if (uiPath === null || uiPath === void 0 ? void 0 : uiPath.includes('nui')) {
+        return uiPath.replace(tenant + "/", '') + "worker_api.js";
+    }
+    else {
+        return uiPath + "worker_api.js";
+    }
+};

package/esm/hooks/useAPI/index.d.ts

@@ -0,0 +1,5 @@
+export { useAPI } from './useAPI';
+export { CustomAction } from './types';
+export { processRequest } from './API';
+export { getWorkerURL } from './helpers';
+export type { CustomActionTask, Params, Request } from './types';

package/esm/hooks/useAPI/index.js

@@ -0,0 +1,4 @@
+export { useAPI } from './useAPI';
+export { CustomAction } from './types';
+export { processRequest } from './API';
+export { getWorkerURL } from './helpers';

package/esm/hooks/useAPI/types.d.ts

@@ -0,0 +1,90 @@
+import { CustomScript, CustomViewConfig, PrimitiveValue } from '@reltio/mdm-sdk';
+export declare enum RequestAction {
+    WORKFLOW = "workflow",
+    WORKFLOW_START_PROCESS_FROM_QUERY = "workflow/startProcessFromQuery",
+    API = "api",
+    GET_ENTITY_URI = "getEntityUri",
+    GET_ENTITY = "getEntity",
+    GET_API_PATH = "getApiPath",
+    WORKFLOW_GET_WORKFLOW_PATH = "workflow/getWorkflowPath",
+    GET_SEARCH_QUERY = "getSearchQuery",
+    GET_TENANT = "getTenant",
+    GET_USER = "getUser",
+    GET_PERSPECTIVE = "getPerspective",
+    SET_PERSPECTIVE = "setPerspective",
+    SET_ENTITY_URI = "setEntityUri",
+    ALERT = "alert",
+    CONFIRM = "confirm",
+    PROMPT = "prompt",
+    OPEN_WINDOW = "openWindow",
+    GET_CONFIGURATION = "getConfiguration",
+    GET_UI_CONFIGURATION = "getUiConfiguration",
+    OPEN_SEARCH = "openSearch",
+    WORKFLOW_CHECK_PERMISSION = "workflow/checkPermission"
+}
+export declare type Params = {
+    url?: string;
+    name?: RequestAction;
+    id?: string | number;
+    method?: 'PUT' | 'DELETE' | 'GET' | 'POST';
+    data?: {
+        [key: string]: unknown;
+    };
+    headers?: {
+        [key: string]: string;
+    };
+    processDefinitionId?: string;
+    searchString?: string;
+    perspective?: string;
+    permission?: string;
+    searchState?: unknown;
+    defaultText?: string;
+    text?: string;
+    html?: string;
+};
+export declare type ProcessRequestParams = {
+    name: RequestAction;
+    paramObject: {
+        params: Params;
+    };
+    permissions?: string[];
+    worker: Worker;
+    metadata: any;
+    config: CustomViewConfig | {
+        action: CustomScript;
+    };
+    user: any;
+    apiPath: string;
+    workflowPath: string;
+    environment: string;
+    entity: any;
+    tenant: any;
+    entityUri: string;
+    query: any;
+    openSearch: (search: any) => void;
+    workflowCheckPermission: (permission?: string) => boolean;
+    getCurrentPerspectiveId: () => string;
+    showPerspective: (perspective: any) => void;
+    setEntityUri: (entityUri: string, listener: () => void) => void;
+};
+export declare enum CustomAction {
+    SET_HTML = "setHtml",
+    LOG = "log",
+    SET_VISIBILITY = "setVisibility",
+    MESSAGE = "message",
+    SET_ENABLED = "setEnabled",
+    SET_TOOLTIP = "setToolTip",
+    SET_LABEL = "setLabel",
+    SET_HEIGHT = "setHeight",
+    SET_WIDTH = "setWidth",
+    RETURN_PROCESSED_API_RESPONSE = "returnProcessedApiResponse",
+    RETURN_PROCESSED_API_REQUEST = "returnProcessedApiRequest",
+    REQUEST = "request"
+}
+export declare type CustomActionTask = {
+    action: CustomAction;
+    params: Params | PrimitiveValue;
+};
+export declare type Request = Omit<CustomActionTask, 'params'> & {
+    params: Params;
+};

package/esm/hooks/useAPI/types.js

@@ -0,0 +1,39 @@
+export var RequestAction;
+(function (RequestAction) {
+    RequestAction["WORKFLOW"] = "workflow";
+    RequestAction["WORKFLOW_START_PROCESS_FROM_QUERY"] = "workflow/startProcessFromQuery";
+    RequestAction["API"] = "api";
+    RequestAction["GET_ENTITY_URI"] = "getEntityUri";
+    RequestAction["GET_ENTITY"] = "getEntity";
+    RequestAction["GET_API_PATH"] = "getApiPath";
+    RequestAction["WORKFLOW_GET_WORKFLOW_PATH"] = "workflow/getWorkflowPath";
+    RequestAction["GET_SEARCH_QUERY"] = "getSearchQuery";
+    RequestAction["GET_TENANT"] = "getTenant";
+    RequestAction["GET_USER"] = "getUser";
+    RequestAction["GET_PERSPECTIVE"] = "getPerspective";
+    RequestAction["SET_PERSPECTIVE"] = "setPerspective";
+    RequestAction["SET_ENTITY_URI"] = "setEntityUri";
+    RequestAction["ALERT"] = "alert";
+    RequestAction["CONFIRM"] = "confirm";
+    RequestAction["PROMPT"] = "prompt";
+    RequestAction["OPEN_WINDOW"] = "openWindow";
+    RequestAction["GET_CONFIGURATION"] = "getConfiguration";
+    RequestAction["GET_UI_CONFIGURATION"] = "getUiConfiguration";
+    RequestAction["OPEN_SEARCH"] = "openSearch";
+    RequestAction["WORKFLOW_CHECK_PERMISSION"] = "workflow/checkPermission";
+})(RequestAction || (RequestAction = {}));
+export var CustomAction;
+(function (CustomAction) {
+    CustomAction["SET_HTML"] = "setHtml";
+    CustomAction["LOG"] = "log";
+    CustomAction["SET_VISIBILITY"] = "setVisibility";
+    CustomAction["MESSAGE"] = "message";
+    CustomAction["SET_ENABLED"] = "setEnabled";
+    CustomAction["SET_TOOLTIP"] = "setToolTip";
+    CustomAction["SET_LABEL"] = "setLabel";
+    CustomAction["SET_HEIGHT"] = "setHeight";
+    CustomAction["SET_WIDTH"] = "setWidth";
+    CustomAction["RETURN_PROCESSED_API_RESPONSE"] = "returnProcessedApiResponse";
+    CustomAction["RETURN_PROCESSED_API_REQUEST"] = "returnProcessedApiRequest";
+    CustomAction["REQUEST"] = "request";
+})(CustomAction || (CustomAction = {}));

package/esm/hooks/useAPI/useAPI.d.ts

@@ -0,0 +1,13 @@
+import { CustomViewConfig } from '@reltio/mdm-sdk';
+export declare const useAPI: (config: CustomViewConfig) => {
+    html: HTMLElement;
+    visible: boolean;
+    tooltip: string;
+    customStyles: {
+        height?: number | string;
+        width?: number | string;
+        'pointer-events'?: string;
+    };
+    message: string;
+    onClosePopup: () => void;
+};

package/esm/hooks/useAPI/useAPI.js

@@ -0,0 +1,169 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { useContext, useEffect, useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import mdmModule, { ui } from '@reltio/mdm-module';
+import { initializeWebWorker } from '@reltio/mdm-sdk';
+import { useWorkflowCheckPermission } from '../../components/workflow';
+import { SandboxAPIContext } from '../../contexts';
+import { processRequest } from './API';
+import { getWorkerURL } from './helpers';
+import { CustomAction } from './types';
+export var useAPI = function (config) {
+    var _a = config.action, files = _a.files, permissions = _a.permissions;
+    var _b = useState(), html = _b[0], setHtml = _b[1];
+    var _c = useState([]), listenersToReset = _c[0], setListenersToReset = _c[1];
+    var _d = useState(true), visible = _d[0], setVisible = _d[1];
+    var _e = useState(null), tooltip = _e[0], setTooltip = _e[1];
+    var _f = useState(null), customStyles = _f[0], setCustomStyles = _f[1];
+    var _g = useState(''), message = _g[0], setMessage = _g[1];
+    var dispatch = useDispatch();
+    var metadata = useSelector(mdmModule.selectors.getMetadata) || {};
+    var entity = useSelector(mdmModule.selectors.getEntity) || {};
+    var uiPath = useSelector(mdmModule.selectors.getUIPath);
+    var tenant = useSelector(mdmModule.selectors.getTenant);
+    var workerUrl = getWorkerURL(uiPath, tenant);
+    var apiPath = useSelector(mdmModule.selectors.getApiPath);
+    var workflowPath = useSelector(mdmModule.selectors.getWorkflowPath);
+    var user = useSelector(mdmModule.selectors.getUser);
+    var entityUri = useSelector(mdmModule.selectors.getEntityUri);
+    var environment = useSelector(mdmModule.selectors.getWorkflowEnvironmentUrl);
+    var qxApi = useContext(SandboxAPIContext);
+    var workflowCheckPermission = useWorkflowCheckPermission();
+    var _h = useSelector(mdmModule.selectors.getSearchProviderData) || {}, typeSearch = _h.type, search = _h.data;
+    var openSearch = function (search) { return dispatch(ui.actions.openSearch(search)); };
+    var process = function (task, worker, innerText) {
+        if (task) {
+            var handlersToReset_1 = [];
+            var processInnerHtml_1 = function (parent) {
+                var uiActions = parent.getAttribute('ui-actions');
+                var uiTooltip = parent.getAttribute('ui-tooltip');
+                var id = parent.getAttribute('id') || parent.getAttribute('name');
+                if (uiActions) {
+                    uiActions.split(',').forEach(function (uiAction) {
+                        var handler = function () {
+                            var data = {
+                                action: 'event',
+                                type: 'uiAction',
+                                data: {
+                                    type: uiAction,
+                                    id: id
+                                }
+                            };
+                            worker.postMessage(data);
+                        };
+                        parent.addEventListener(uiAction, handler);
+                        handlersToReset_1.push(function () {
+                            parent.removeEventListener(uiAction, handler);
+                        });
+                    });
+                    parent.removeAttribute('ui-actions');
+                }
+                if (uiTooltip) {
+                    setTooltip(uiTooltip);
+                }
+                parent.childNodes.forEach(function (child) {
+                    if (child.nodeType === 1) {
+                        //Node.ELEMENT_NODE
+                        processInnerHtml_1(child);
+                    }
+                });
+            };
+            var resetHtml = function (html) {
+                var docBlock = document.createElement('div');
+                docBlock.innerHTML = html || innerText;
+                processInnerHtml_1(docBlock);
+                setListenersToReset(handlersToReset_1);
+                setHtml(docBlock);
+            };
+            if (task.action === CustomAction.SET_HTML && innerText !== task.params.html) {
+                resetHtml(task.params.html);
+            }
+            switch (task.action) {
+                case CustomAction.LOG: {
+                    console.log(task.params); //eslint-disable-line no-console
+                    break;
+                }
+                case CustomAction.SET_VISIBILITY: {
+                    if (task.params === 'visible') {
+                        setVisible(true);
+                        resetHtml();
+                    }
+                    else {
+                        setVisible(false);
+                    }
+                    break;
+                }
+                case CustomAction.SET_TOOLTIP: {
+                    setTooltip(task.params);
+                    resetHtml();
+                    break;
+                }
+                case CustomAction.SET_HEIGHT: {
+                    setCustomStyles(function (prev) { return (__assign(__assign({}, (prev || {})), { height: task.params })); });
+                    break;
+                }
+                case CustomAction.SET_WIDTH: {
+                    setCustomStyles(function (prev) { return (__assign(__assign({}, (prev || {})), { width: task.params })); });
+                    break;
+                }
+                case CustomAction.SET_ENABLED: {
+                    setCustomStyles(function (prev) {
+                        var newStyles = __assign({}, (prev || {}));
+                        if (!task.params) {
+                            newStyles['pointer-events'] = 'none';
+                        }
+                        else {
+                            delete newStyles['pointer-events'];
+                        }
+                        return newStyles;
+                    });
+                    break;
+                }
+                case CustomAction.MESSAGE: {
+                    setMessage(task.params);
+                    break;
+                }
+                case CustomAction.REQUEST: {
+                    processRequest(__assign({ name: task.params.name, paramObject: task, permissions: permissions,
+                        worker: worker,
+                        metadata: metadata, config: config, user: user,
+                        apiPath: apiPath,
+                        tenant: tenant,
+                        workflowPath: workflowPath,
+                        entity: entity,
+                        entityUri: entityUri,
+                        environment: environment, query: typeSearch === 'search' ? search === null || search === void 0 ? void 0 : search.query : null, openSearch: openSearch,
+                        workflowCheckPermission: workflowCheckPermission }, qxApi));
+                    break;
+                }
+            }
+        }
+    };
+    useEffect(function () {
+        var worker = initializeWebWorker(workerUrl, files, process);
+        return function () {
+            worker.terminate();
+        };
+    }, []);
+    useEffect(function () { return function () {
+        listenersToReset.forEach(function (listener) { return listener(); });
+    }; }, [listenersToReset]);
+    return {
+        html: html,
+        visible: visible,
+        tooltip: tooltip,
+        customStyles: customStyles,
+        message: message,
+        onClosePopup: function () { return setMessage(''); }
+    };
+};

package/esm/hooks/useCustomScripts.d.ts

@@ -0,0 +1,9 @@
+import { createRequestProvider, CustomScript } from '@reltio/mdm-sdk';
+declare type InterceptHandlers = {
+    addInternalRequestInterceptor: ReturnType<typeof createRequestProvider>['addRequestInterceptor'];
+    addInternalResponseInterceptor: ReturnType<typeof createRequestProvider>['addResponseInterceptor'];
+    removeInternalRequestInterceptor: ReturnType<typeof createRequestProvider>['removeRequestInterceptor'];
+    removeInternalResponseInterceptor: ReturnType<typeof createRequestProvider>['removeResponseInterceptor'];
+};
+export declare const useCustomScripts: (config: CustomScript[], { addInternalRequestInterceptor, addInternalResponseInterceptor, removeInternalRequestInterceptor, removeInternalResponseInterceptor }: InterceptHandlers) => void;
+export {};