@trackunit/iris-app-runtime-core 0.3.49 → 0.3.51

package/index.js

@@ -1,6 +1,5 @@
 import { CustomFieldType } from '@trackunit/iris-app-runtime-core-api';
 export * from '@trackunit/iris-app-runtime-core-api';
-import { connectToParent } from 'penpal';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -27,324 +26,759 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-/**
- * Setup using the subscribedMethods to subscribe to events from the host.
- *
- * @param subscribedMethods the methods to subscribe to
- * @returns { Connection<HostConnectorApi> } the connection to the host
- */
-const setupHostConnector = (subscribedMethods) => {
-    var _a;
-    const methods = Object.assign({ onGlobalSelectionChanged: () => { }, onTokenChanged: () => { }, onAssetSortingStateChanged: () => { } }, subscribedMethods);
-    const connection = connectToParent({ methods });
-    (_a = connection.promise) === null || _a === void 0 ? void 0 : _a.catch(err => {
-        // TODO consider how to handle this catch
-        // eslint-disable-next-line no-console
-        console.log(err);
-    });
-    return connection;
-};
-const hostConnector = setupHostConnector({});
-/**
- * Gets the host connector.
- *
- * @returns { Promise<HostConnectorApi> } the connection to the host
- */
-const getHostConnector = () => {
-    return hostConnector.promise;
+var MessageType;
+(function (MessageType) {
+    MessageType["Call"] = "call";
+    MessageType["Reply"] = "reply";
+    MessageType["Syn"] = "syn";
+    MessageType["SynAck"] = "synAck";
+    MessageType["Ack"] = "ack";
+})(MessageType || (MessageType = {}));
+var Resolution;
+(function (Resolution) {
+    Resolution["Fulfilled"] = "fulfilled";
+    Resolution["Rejected"] = "rejected";
+})(Resolution || (Resolution = {}));
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["ConnectionDestroyed"] = "ConnectionDestroyed";
+    ErrorCode["ConnectionTimeout"] = "ConnectionTimeout";
+    ErrorCode["NoIframeSrc"] = "NoIframeSrc";
+})(ErrorCode || (ErrorCode = {}));
+var NativeErrorName;
+(function (NativeErrorName) {
+    NativeErrorName["DataCloneError"] = "DataCloneError";
+})(NativeErrorName || (NativeErrorName = {}));
+var NativeEventType;
+(function (NativeEventType) {
+    NativeEventType["Message"] = "message";
+})(NativeEventType || (NativeEventType = {}));
+
+var createDestructor = (localName, log) => {
+    const callbacks = [];
+    let destroyed = false;
+    return {
+        destroy(error) {
+            if (!destroyed) {
+                destroyed = true;
+                log(`${localName}: Destroying connection`);
+                callbacks.forEach((callback) => {
+                    callback(error);
+                });
+            }
+        },
+        onDestroy(callback) {
+            destroyed ? callback() : callbacks.push(callback);
+        },
+    };
+};
+
+var createLogger = (debug) => {
+    /**
+     * Logs a message if debug is enabled.
+     */
+    return (...args) => {
+        if (debug) {
+            console.log('[Penpal]', ...args); // eslint-disable-line no-console
+        }
+    };
 };
 
-const AnalyticsContextRuntime = {
-    logPageView: (details) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        api.logPageView(details);
-    }),
-    logError: (details) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        api.logError(details);
-    }),
-    logEvent: (eventName, details, nameSupplement) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        api.logEvent(eventName, details, nameSupplement);
-    }),
-    setUserProperty: (name, data) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        api.setUserProperty(name, data);
-    }),
+/**
+ * Converts an error object into a plain object.
+ */
+const serializeError = ({ name, message, stack, }) => ({
+    name,
+    message,
+    stack,
+});
+/**
+ * Converts a plain object into an error object.
+ */
+const deserializeError = (obj) => {
+    const deserializedError = new Error();
+    // @ts-ignore
+    Object.keys(obj).forEach((key) => (deserializedError[key] = obj[key]));
+    return deserializedError;
 };
 
-const AssetRuntime = {
-    getAssetInfo: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getAssetInfo();
-    }),
+/**
+ * Listens for "call" messages coming from the remote, executes the corresponding method, and
+ * responds with the return value.
+ */
+var connectCallReceiver = (info, serializedMethods, log) => {
+    const { localName, local, remote, originForSending, originForReceiving, } = info;
+    let destroyed = false;
+    const handleMessageEvent = (event) => {
+        if (event.source !== remote || event.data.penpal !== MessageType.Call) {
+            return;
+        }
+        if (originForReceiving !== '*' && event.origin !== originForReceiving) {
+            log(`${localName} received message from origin ${event.origin} which did not match expected origin ${originForReceiving}`);
+            return;
+        }
+        const callMessage = event.data;
+        const { methodName, args, id } = callMessage;
+        log(`${localName}: Received ${methodName}() call`);
+        const createPromiseHandler = (resolution) => {
+            return (returnValue) => {
+                log(`${localName}: Sending ${methodName}() reply`);
+                if (destroyed) {
+                    // It's possible to throw an error here, but it would need to be thrown asynchronously
+                    // and would only be catchable using window.onerror. This is because the consumer
+                    // is merely returning a value from their method and not calling any function
+                    // that they could wrap in a try-catch. Even if the consumer were to catch the error,
+                    // the value of doing so is questionable. Instead, we'll just log a message.
+                    log(`${localName}: Unable to send ${methodName}() reply due to destroyed connection`);
+                    return;
+                }
+                const message = {
+                    penpal: MessageType.Reply,
+                    id,
+                    resolution,
+                    returnValue,
+                };
+                if (resolution === Resolution.Rejected &&
+                    returnValue instanceof Error) {
+                    message.returnValue = serializeError(returnValue);
+                    message.returnValueIsError = true;
+                }
+                try {
+                    remote.postMessage(message, originForSending);
+                }
+                catch (err) {
+                    // If a consumer attempts to send an object that's not cloneable (e.g., window),
+                    // we want to ensure the receiver's promise gets rejected.
+                    if (err.name === NativeErrorName.DataCloneError) {
+                        const errorReplyMessage = {
+                            penpal: MessageType.Reply,
+                            id,
+                            resolution: Resolution.Rejected,
+                            returnValue: serializeError(err),
+                            returnValueIsError: true,
+                        };
+                        remote.postMessage(errorReplyMessage, originForSending);
+                    }
+                    throw err;
+                }
+            };
+        };
+        new Promise((resolve) => resolve(serializedMethods[methodName].apply(serializedMethods, args))).then(createPromiseHandler(Resolution.Fulfilled), createPromiseHandler(Resolution.Rejected));
+    };
+    local.addEventListener(NativeEventType.Message, handleMessageEvent);
+    return () => {
+        destroyed = true;
+        local.removeEventListener(NativeEventType.Message, handleMessageEvent);
+    };
 };
 
-const AssetSortingRuntime = {
-    getAssetSortingState: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getAssetSortingState();
-    }),
-    setAssetSortingState: (...args) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.setAssetSortingState(...args);
-    }),
+let id = 0;
+/**
+ * @return {number} A unique ID (not universally unique)
+ */
+var generateId = () => ++id;
+
+const KEY_PATH_DELIMITER = '.';
+const keyPathToSegments = (keyPath) => keyPath ? keyPath.split(KEY_PATH_DELIMITER) : [];
+const segmentsToKeyPath = (segments) => segments.join(KEY_PATH_DELIMITER);
+const createKeyPath = (key, prefix) => {
+    const segments = keyPathToSegments(prefix || '');
+    segments.push(key);
+    return segmentsToKeyPath(segments);
+};
+/**
+ * Given a `keyPath`, set it to be `value` on `subject`, creating any intermediate
+ * objects along the way.
+ *
+ * @param {Object} subject The object on which to set value.
+ * @param {string} keyPath The key path at which to set value.
+ * @param {Object} value The value to store at the given key path.
+ * @returns {Object} Updated subject.
+ */
+const setAtKeyPath = (subject, keyPath, value) => {
+    const segments = keyPathToSegments(keyPath);
+    segments.reduce((prevSubject, key, idx) => {
+        if (typeof prevSubject[key] === 'undefined') {
+            prevSubject[key] = {};
+        }
+        if (idx === segments.length - 1) {
+            prevSubject[key] = value;
+        }
+        return prevSubject[key];
+    }, subject);
+    return subject;
+};
+/**
+ * Given a dictionary of (nested) keys to function, flatten them to a map
+ * from key path to function.
+ *
+ * @param {Object} methods The (potentially nested) object to serialize.
+ * @param {string} prefix A string with which to prefix entries. Typically not intended to be used by consumers.
+ * @returns {Object} An map from key path in `methods` to functions.
+ */
+const serializeMethods = (methods, prefix) => {
+    const flattenedMethods = {};
+    Object.keys(methods).forEach((key) => {
+        const value = methods[key];
+        const keyPath = createKeyPath(key, prefix);
+        if (typeof value === 'object') {
+            // Recurse into any nested children.
+            Object.assign(flattenedMethods, serializeMethods(value, keyPath));
+        }
+        if (typeof value === 'function') {
+            // If we've found a method, expose it.
+            flattenedMethods[keyPath] = value;
+        }
+    });
+    return flattenedMethods;
+};
+/**
+ * Given a map of key paths to functions, unpack the key paths to an object.
+ *
+ * @param {Object} flattenedMethods A map of key paths to functions to unpack.
+ * @returns {Object} A (potentially nested) map of functions.
+ */
+const deserializeMethods = (flattenedMethods) => {
+    const methods = {};
+    for (const keyPath in flattenedMethods) {
+        setAtKeyPath(methods, keyPath, flattenedMethods[keyPath]);
+    }
+    return methods;
 };
 
-const CurrentUserRuntime = {
-    getCurrentUserContext: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getCurrentUserContext();
-    }),
-    getCurrentUserRole: (userIds) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getCurrentUserRole(userIds);
-    }),
+/**
+ * Augments an object with methods that match those defined by the remote. When these methods are
+ * called, a "call" message will be sent to the remote, the remote's corresponding method will be
+ * executed, and the method's return value will be returned via a message.
+ * @param {Object} callSender Sender object that should be augmented with methods.
+ * @param {Object} info Information about the local and remote windows.
+ * @param {Array} methodKeyPaths Key paths of methods available to be called on the remote.
+ * @param {Promise} destructionPromise A promise resolved when destroy() is called on the penpal
+ * connection.
+ * @returns {Object} The call sender object with methods that may be called.
+ */
+var connectCallSender = (callSender, info, methodKeyPaths, destroyConnection, log) => {
+    const { localName, local, remote, originForSending, originForReceiving, } = info;
+    let destroyed = false;
+    log(`${localName}: Connecting call sender`);
+    const createMethodProxy = (methodName) => {
+        return (...args) => {
+            log(`${localName}: Sending ${methodName}() call`);
+            // This handles the case where the iframe has been removed from the DOM
+            // (and therefore its window closed), the consumer has not yet
+            // called destroy(), and the user calls a method exposed by
+            // the remote. We detect the iframe has been removed and force
+            // a destroy() immediately so that the consumer sees the error saying
+            // the connection has been destroyed. We wrap this check in a try catch
+            // because Edge throws an "Object expected" error when accessing
+            // contentWindow.closed on a contentWindow from an iframe that's been
+            // removed from the DOM.
+            let iframeRemoved;
+            try {
+                if (remote.closed) {
+                    iframeRemoved = true;
+                }
+            }
+            catch (e) {
+                iframeRemoved = true;
+            }
+            if (iframeRemoved) {
+                destroyConnection();
+            }
+            if (destroyed) {
+                const error = new Error(`Unable to send ${methodName}() call due ` + `to destroyed connection`);
+                error.code = ErrorCode.ConnectionDestroyed;
+                throw error;
+            }
+            return new Promise((resolve, reject) => {
+                const id = generateId();
+                const handleMessageEvent = (event) => {
+                    if (event.source !== remote ||
+                        event.data.penpal !== MessageType.Reply ||
+                        event.data.id !== id) {
+                        return;
+                    }
+                    if (originForReceiving !== '*' &&
+                        event.origin !== originForReceiving) {
+                        log(`${localName} received message from origin ${event.origin} which did not match expected origin ${originForReceiving}`);
+                        return;
+                    }
+                    const replyMessage = event.data;
+                    log(`${localName}: Received ${methodName}() reply`);
+                    local.removeEventListener(NativeEventType.Message, handleMessageEvent);
+                    let returnValue = replyMessage.returnValue;
+                    if (replyMessage.returnValueIsError) {
+                        returnValue = deserializeError(returnValue);
+                    }
+                    (replyMessage.resolution === Resolution.Fulfilled ? resolve : reject)(returnValue);
+                };
+                local.addEventListener(NativeEventType.Message, handleMessageEvent);
+                const callMessage = {
+                    penpal: MessageType.Call,
+                    id,
+                    methodName,
+                    args,
+                };
+                remote.postMessage(callMessage, originForSending);
+            });
+        };
+    };
+    // Wrap each method in a proxy which sends it to the corresponding receiver.
+    const flattenedMethods = methodKeyPaths.reduce((api, name) => {
+        api[name] = createMethodProxy(name);
+        return api;
+    }, {});
+    // Unpack the structure of the provided methods object onto the CallSender, exposing
+    // the methods in the same shape they were provided.
+    Object.assign(callSender, deserializeMethods(flattenedMethods));
+    return () => {
+        destroyed = true;
+    };
+};
+
+/**
+ * Starts a timeout and calls the callback with an error
+ * if the timeout completes before the stop function is called.
+ */
+var startConnectionTimeout = (timeout, callback) => {
+    let timeoutId;
+    if (timeout !== undefined) {
+        timeoutId = window.setTimeout(() => {
+            const error = new Error(`Connection timed out after ${timeout}ms`);
+            error.code = ErrorCode.ConnectionTimeout;
+            callback(error);
+        }, timeout);
+    }
+    return () => {
+        clearTimeout(timeoutId);
+    };
+};
+
+/**
+ * Handles a SYN-ACK handshake message.
+ */
+var handleSynAckMessageFactory = (parentOrigin, serializedMethods, destructor, log) => {
+    const { destroy, onDestroy } = destructor;
+    return (event) => {
+        let originQualifies = parentOrigin instanceof RegExp
+            ? parentOrigin.test(event.origin)
+            : parentOrigin === '*' || parentOrigin === event.origin;
+        if (!originQualifies) {
+            log(`Child: Handshake - Received SYN-ACK from origin ${event.origin} which did not match expected origin ${parentOrigin}`);
+            return;
+        }
+        log('Child: Handshake - Received SYN-ACK, responding with ACK');
+        // If event.origin is "null", the remote protocol is file: or data: and we
+        // must post messages with "*" as targetOrigin when sending messages.
+        // https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage#Using_window.postMessage_in_extensions
+        const originForSending = event.origin === 'null' ? '*' : event.origin;
+        const ackMessage = {
+            penpal: MessageType.Ack,
+            methodNames: Object.keys(serializedMethods),
+        };
+        window.parent.postMessage(ackMessage, originForSending);
+        const info = {
+            localName: 'Child',
+            local: window,
+            remote: window.parent,
+            originForSending,
+            originForReceiving: event.origin,
+        };
+        const destroyCallReceiver = connectCallReceiver(info, serializedMethods, log);
+        onDestroy(destroyCallReceiver);
+        const callSender = {};
+        const destroyCallSender = connectCallSender(callSender, info, event.data.methodNames, destroy, log);
+        onDestroy(destroyCallSender);
+        return callSender;
+    };
+};
+
+const areGlobalsAccessible = () => {
+    try {
+        clearTimeout();
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Attempts to establish communication with the parent window.
+ */
+var connectToParent = (options = {}) => {
+    const { parentOrigin = '*', methods = {}, timeout, debug = false } = options;
+    const log = createLogger(debug);
+    const destructor = createDestructor('Child', log);
+    const { destroy, onDestroy } = destructor;
+    const serializedMethods = serializeMethods(methods);
+    const handleSynAckMessage = handleSynAckMessageFactory(parentOrigin, serializedMethods, destructor, log);
+    const sendSynMessage = () => {
+        log('Child: Handshake - Sending SYN');
+        const synMessage = { penpal: MessageType.Syn };
+        const parentOriginForSyn = parentOrigin instanceof RegExp ? '*' : parentOrigin;
+        window.parent.postMessage(synMessage, parentOriginForSyn);
+    };
+    const promise = new Promise((resolve, reject) => {
+        const stopConnectionTimeout = startConnectionTimeout(timeout, destroy);
+        const handleMessage = (event) => {
+            // Under niche scenarios, we get into this function after
+            // the iframe has been removed from the DOM. In Edge, this
+            // results in "Object expected" errors being thrown when we
+            // try to access properties on window (global properties).
+            // For this reason, we try to access a global up front (clearTimeout)
+            // and if it fails we can assume the iframe has been removed
+            // and we ignore the message event.
+            if (!areGlobalsAccessible()) {
+                return;
+            }
+            if (event.source !== parent || !event.data) {
+                return;
+            }
+            if (event.data.penpal === MessageType.SynAck) {
+                const callSender = handleSynAckMessage(event);
+                if (callSender) {
+                    window.removeEventListener(NativeEventType.Message, handleMessage);
+                    stopConnectionTimeout();
+                    resolve(callSender);
+                }
+            }
+        };
+        window.addEventListener(NativeEventType.Message, handleMessage);
+        sendSynMessage();
+        onDestroy((error) => {
+            window.removeEventListener(NativeEventType.Message, handleMessage);
+            if (error) {
+                reject(error);
+            }
+        });
+    });
+    return {
+        promise,
+        destroy() {
+            // Don't allow consumer to pass an error into destroy.
+            destroy();
+        },
+    };
 };
 
-/**
- * Get the value of a custom field from a raw value.
- *
- * @param customFieldDefinition the definition of the custom field
- * @param newValue the new value to set
- * @returns { CustomFieldValue } an updated CustomFieldValue
- */
-const getCustomFieldValueFromRawValue = (customFieldDefinition, newValue) => {
-    if (customFieldDefinition.type === CustomFieldType.BOOLEAN) {
-        return {
-            booleanValue: newValue ? true : false,
-            type: CustomFieldType.BOOLEAN,
-        };
-    }
-    else if (customFieldDefinition.type === CustomFieldType.DATE) {
-        return {
-            dateValue: getDateValue(newValue),
-            type: CustomFieldType.DATE,
-        };
-    }
-    else if (customFieldDefinition.type === CustomFieldType.DROPDOWN) {
-        const stringArrayValue = [];
-        if (Array.isArray(newValue)) {
-            newValue.forEach(item => {
-                if (typeof item === "string") {
-                    stringArrayValue.push(item);
-                }
-                else {
-                    stringArrayValue.push(item === null || item === void 0 ? void 0 : item.value);
-                }
-            });
-        }
-        else {
-            if (typeof newValue === "string") {
-                stringArrayValue.push(newValue);
-            }
-            else if (typeof newValue === "object") {
-                stringArrayValue.push(newValue === null || newValue === void 0 ? void 0 : newValue.value);
-            }
-        }
-        return {
-            stringArrayValue: stringArrayValue,
-            type: CustomFieldType.DROPDOWN,
-        };
-    }
-    else if (customFieldDefinition.type === CustomFieldType.EMAIL) {
-        return {
-            stringValue: getStringValue(newValue),
-            type: CustomFieldType.EMAIL,
-        };
-    }
-    else if (customFieldDefinition.type === CustomFieldType.NUMBER) {
-        let value = customFieldDefinition.isInteger
-            ? parseInt(newValue)
-            : parseFloat(newValue);
-        if (isNaN(value)) {
-            value = null;
-        }
-        return {
-            numberValue: value,
-            type: CustomFieldType.NUMBER,
-        };
-    }
-    else if (customFieldDefinition.type === CustomFieldType.PHONE_NUMBER) {
-        return {
-            stringValue: getStringValue(newValue),
-            type: CustomFieldType.PHONE_NUMBER,
-        };
-    }
-    else if (customFieldDefinition.type === CustomFieldType.STRING) {
-        return {
-            stringValue: getStringValue(newValue),
-            type: CustomFieldType.STRING,
-        };
-    }
-    else if (customFieldDefinition.type === CustomFieldType.WEB_ADDRESS) {
-        return {
-            stringValue: getStringValue(newValue),
-            type: CustomFieldType.WEB_ADDRESS,
-        };
-    }
-    throw new Error("Unsupported custom field type");
-};
-/**
- *  Convert the received value to a string
- */
-const getStringValue = (value) => {
-    const stringValue = value;
-    if (stringValue === null || stringValue === undefined) {
-        return null;
-    }
-    else if (stringValue.trim().length === 0) {
-        return null;
-    }
-    else {
-        return stringValue.trim();
-    }
-};
-/**
- *  Format the received value to a date string
- *  yyyy-mm-dd
- */
-const getDateValue = (value) => {
-    const date = new Date(value);
-    const day = date.toLocaleString("en-US", { day: "2-digit" });
-    const month = date.toLocaleString("en-US", { month: "2-digit" });
-    const year = date.toLocaleString("en-US", { year: "numeric" });
-    return `${year}-${month}-${day}`;
-};
-const CustomFieldRuntime = {
-    getCustomFieldsFor: (entity) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getCustomFieldsFor(entity);
-    }),
-    setCustomFieldsFor: (entity, values) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.setCustomFieldsFor(entity, values);
-    }),
-    setCustomFieldsFromFormData: (entity, formData, originalDefinitions) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        const values = [];
-        Object.keys(formData).forEach(key => {
-            var _a;
-            const found = (_a = originalDefinitions.find(originalDefinition => originalDefinition.definition.key === key)) === null || _a === void 0 ? void 0 : _a.definition;
-            if (found) {
-                values.push({
-                    definitionKey: key,
-                    value: getCustomFieldValueFromRawValue(found, formData[key]),
-                });
-            }
-            else {
-                throw new Error("Unsupported custom field type: " + key);
-            }
-        });
-        return api.setCustomFieldsFor(entity, values);
-    }),
+/**
+ * Setup using the subscribedMethods to subscribe to events from the host.
+ *
+ * @param subscribedMethods the methods to subscribe to
+ * @returns { Connection<HostConnectorApi> } the connection to the host
+ */
+const setupHostConnector = (subscribedMethods) => {
+    var _a;
+    const methods = Object.assign({ onGlobalSelectionChanged: () => { }, onTokenChanged: () => { }, onAssetSortingStateChanged: () => { } }, subscribedMethods);
+    const connection = connectToParent({ methods });
+    (_a = connection.promise) === null || _a === void 0 ? void 0 : _a.catch(err => {
+        // TODO consider how to handle this catch
+        // eslint-disable-next-line no-console
+        console.log(err);
+    });
+    return connection;
+};
+const hostConnector = setupHostConnector({});
+/**
+ * Gets the host connector.
+ *
+ * @returns { Promise<HostConnectorApi> } the connection to the host
+ */
+const getHostConnector = () => {
+    return hostConnector.promise;
+};
+
+const AnalyticsContextRuntime = {
+    logPageView: (details) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        api.logPageView(details);
+    }),
+    logError: (details) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        api.logError(details);
+    }),
+    logEvent: (eventName, details, nameSupplement) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        api.logEvent(eventName, details, nameSupplement);
+    }),
+    setUserProperty: (name, data) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        api.setUserProperty(name, data);
+    }),
+};
+
+const AssetRuntime = {
+    getAssetInfo: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getAssetInfo();
+    }),
+};
+
+const AssetSortingRuntime = {
+    getAssetSortingState: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getAssetSortingState();
+    }),
+    setAssetSortingState: (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.setAssetSortingState(...args);
+    }),
+};
+
+const CurrentUserRuntime = {
+    getCurrentUserContext: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getCurrentUserContext();
+    }),
+    getCurrentUserRole: (userIds) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getCurrentUserRole(userIds);
+    }),
+};
+
+/**
+ * Get the value of a custom field from a raw value.
+ *
+ * @param customFieldDefinition the definition of the custom field
+ * @param newValue the new value to set
+ * @returns { CustomFieldValue } an updated CustomFieldValue
+ */
+const getCustomFieldValueFromRawValue = (customFieldDefinition, newValue) => {
+    if (customFieldDefinition.type === CustomFieldType.BOOLEAN) {
+        return {
+            booleanValue: newValue ? true : false,
+            type: CustomFieldType.BOOLEAN,
+        };
+    }
+    else if (customFieldDefinition.type === CustomFieldType.DATE) {
+        return {
+            dateValue: getDateValue(newValue),
+            type: CustomFieldType.DATE,
+        };
+    }
+    else if (customFieldDefinition.type === CustomFieldType.DROPDOWN) {
+        const stringArrayValue = [];
+        if (Array.isArray(newValue)) {
+            newValue.forEach(item => {
+                if (typeof item === "string") {
+                    stringArrayValue.push(item);
+                }
+                else {
+                    stringArrayValue.push(item === null || item === void 0 ? void 0 : item.value);
+                }
+            });
+        }
+        else {
+            if (typeof newValue === "string") {
+                stringArrayValue.push(newValue);
+            }
+            else if (typeof newValue === "object") {
+                stringArrayValue.push(newValue === null || newValue === void 0 ? void 0 : newValue.value);
+            }
+        }
+        return {
+            stringArrayValue: stringArrayValue,
+            type: CustomFieldType.DROPDOWN,
+        };
+    }
+    else if (customFieldDefinition.type === CustomFieldType.EMAIL) {
+        return {
+            stringValue: getStringValue(newValue),
+            type: CustomFieldType.EMAIL,
+        };
+    }
+    else if (customFieldDefinition.type === CustomFieldType.NUMBER) {
+        let value = customFieldDefinition.isInteger
+            ? parseInt(newValue)
+            : parseFloat(newValue);
+        if (isNaN(value)) {
+            value = null;
+        }
+        return {
+            numberValue: value,
+            type: CustomFieldType.NUMBER,
+        };
+    }
+    else if (customFieldDefinition.type === CustomFieldType.PHONE_NUMBER) {
+        return {
+            stringValue: getStringValue(newValue),
+            type: CustomFieldType.PHONE_NUMBER,
+        };
+    }
+    else if (customFieldDefinition.type === CustomFieldType.STRING) {
+        return {
+            stringValue: getStringValue(newValue),
+            type: CustomFieldType.STRING,
+        };
+    }
+    else if (customFieldDefinition.type === CustomFieldType.WEB_ADDRESS) {
+        return {
+            stringValue: getStringValue(newValue),
+            type: CustomFieldType.WEB_ADDRESS,
+        };
+    }
+    throw new Error("Unsupported custom field type");
+};
+/**
+ *  Convert the received value to a string
+ */
+const getStringValue = (value) => {
+    const stringValue = value;
+    if (stringValue === null || stringValue === undefined) {
+        return null;
+    }
+    else if (stringValue.trim().length === 0) {
+        return null;
+    }
+    else {
+        return stringValue.trim();
+    }
+};
+/**
+ *  Format the received value to a date string
+ *  yyyy-mm-dd
+ */
+const getDateValue = (value) => {
+    const date = new Date(value);
+    const day = date.toLocaleString("en-US", { day: "2-digit" });
+    const month = date.toLocaleString("en-US", { month: "2-digit" });
+    const year = date.toLocaleString("en-US", { year: "numeric" });
+    return `${year}-${month}-${day}`;
+};
+const CustomFieldRuntime = {
+    getCustomFieldsFor: (entity) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getCustomFieldsFor(entity);
+    }),
+    setCustomFieldsFor: (entity, values) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.setCustomFieldsFor(entity, values);
+    }),
+    setCustomFieldsFromFormData: (entity, formData, originalDefinitions) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        const values = [];
+        Object.keys(formData).forEach(key => {
+            var _a;
+            const found = (_a = originalDefinitions.find(originalDefinition => originalDefinition.definition.key === key)) === null || _a === void 0 ? void 0 : _a.definition;
+            if (found) {
+                values.push({
+                    definitionKey: key,
+                    value: getCustomFieldValueFromRawValue(found, formData[key]),
+                });
+            }
+            else {
+                throw new Error("Unsupported custom field type: " + key);
+            }
+        });
+        return api.setCustomFieldsFor(entity, values);
+    }),
 };
 
-const EnvironmentRuntime = {
-    getEnvironmentContext: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getEnvironmentContext();
-    }),
+const EnvironmentRuntime = {
+    getEnvironmentContext: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getEnvironmentContext();
+    }),
 };
 
-const GlobalSelectionRuntime = {
-    getGlobalSelection: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getGlobalSelectionContext();
-    }),
+const GlobalSelectionRuntime = {
+    getGlobalSelection: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getGlobalSelectionContext();
+    }),
 };
 
-const OemBrandingContextRuntime = {
-    getOemBrandingContextRuntime: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return {
-            getOemImage: api.getOemImage,
-            getOemBranding: api.getOemBranding,
-        };
-    }),
+const OemBrandingContextRuntime = {
+    getOemBrandingContextRuntime: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return {
+            getOemImage: api.getOemImage,
+            getOemBranding: api.getOemBranding,
+        };
+    }),
 };
 
-const NavigationRuntime = {
-    setDeepLink: (props) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.setDeepLink(props);
-    }),
-    gotoAssetHome: (assetId, options) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.gotoAssetHome(assetId, options);
-    }),
-    gotoSiteHome: (siteId, options) => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.gotoSiteHome(siteId, options);
-    }),
+const NavigationRuntime = {
+    setDeepLink: (props) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.setDeepLink(props);
+    }),
+    gotoAssetHome: (assetId, options) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.gotoAssetHome(assetId, options);
+    }),
+    gotoSiteHome: (siteId, options) => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.gotoSiteHome(siteId, options);
+    }),
 };
 
-const ParamsRuntime = {
-    getAppName: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getAppName();
-    }),
-    getOrgName: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getOrgName();
-    }),
-    getExtensionName: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getExtensionName();
-    }),
+const ParamsRuntime = {
+    getAppName: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getAppName();
+    }),
+    getOrgName: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getOrgName();
+    }),
+    getExtensionName: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getExtensionName();
+    }),
 };
 
-const RestRuntime = {
-    apiHost: "https://API_HOST",
-    request(path, method, requestParams, body, bodyType, secureByDefault) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const api = yield getHostConnector();
-            return api.requestTrackunitRestApi(path, method, requestParams, body, bodyType, secureByDefault);
-        });
-    },
+const RestRuntime = {
+    apiHost: "https://API_HOST",
+    request(path, method, requestParams, body, bodyType, secureByDefault) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield getHostConnector();
+            return api.requestTrackunitRestApi(path, method, requestParams, body, bodyType, secureByDefault);
+        });
+    },
 };
 
-const SiteRuntime = {
-    getSiteInfo: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getSiteInfo();
-    }),
+const SiteRuntime = {
+    getSiteInfo: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getSiteInfo();
+    }),
 };
 
-const ToastRuntime = {
-    addToast(toast) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const api = yield getHostConnector();
-            return api
-                .addToast(Object.assign(Object.assign({}, toast), { primaryAction: (_a = toast.primaryAction) === null || _a === void 0 ? void 0 : _a.label, secondaryAction: (_b = toast.secondaryAction) === null || _b === void 0 ? void 0 : _b.label }))
-                .then(res => {
-                var _a, _b, _c, _d;
-                switch (res) {
-                    case "primaryAction":
-                        (_b = (_a = toast.primaryAction) === null || _a === void 0 ? void 0 : _a.onClick) === null || _b === void 0 ? void 0 : _b.call(_a);
-                        break;
-                    case "secondaryAction":
-                        (_d = (_c = toast.secondaryAction) === null || _c === void 0 ? void 0 : _c.onClick) === null || _d === void 0 ? void 0 : _d.call(_c);
-                        break;
-                }
-            });
-        });
-    },
+const ToastRuntime = {
+    addToast(toast) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield getHostConnector();
+            return api
+                .addToast(Object.assign(Object.assign({}, toast), { primaryAction: (_a = toast.primaryAction) === null || _a === void 0 ? void 0 : _a.label, secondaryAction: (_b = toast.secondaryAction) === null || _b === void 0 ? void 0 : _b.label }))
+                .then(res => {
+                var _a, _b, _c, _d;
+                switch (res) {
+                    case "primaryAction":
+                        (_b = (_a = toast.primaryAction) === null || _a === void 0 ? void 0 : _a.onClick) === null || _b === void 0 ? void 0 : _b.call(_a);
+                        break;
+                    case "secondaryAction":
+                        (_d = (_c = toast.secondaryAction) === null || _c === void 0 ? void 0 : _c.onClick) === null || _d === void 0 ? void 0 : _d.call(_c);
+                        break;
+                }
+            });
+        });
+    },
 };
 
-const TokenRuntime = {
-    getTokenContext: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getTokenContext();
-    }),
+const TokenRuntime = {
+    getTokenContext: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getTokenContext();
+    }),
 };
 
-const UserSubscriptionRuntime = {
-    getUserSubscriptionContext: () => __awaiter(void 0, void 0, void 0, function* () {
-        const api = yield getHostConnector();
-        return api.getUserSubscriptionContext();
-    }),
+const UserSubscriptionRuntime = {
+    getUserSubscriptionContext: () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = yield getHostConnector();
+        return api.getUserSubscriptionContext();
+    }),
 };
 
 export { AnalyticsContextRuntime, AssetRuntime, AssetSortingRuntime, CurrentUserRuntime, CustomFieldRuntime, EnvironmentRuntime, GlobalSelectionRuntime, NavigationRuntime, OemBrandingContextRuntime, ParamsRuntime, RestRuntime, SiteRuntime, ToastRuntime, TokenRuntime, UserSubscriptionRuntime, getCustomFieldValueFromRawValue, getDateValue, getHostConnector, getStringValue, setupHostConnector };