chayns-api 1.0.0

package/dist/esm/wrapper/AppWrapper.js

@@ -0,0 +1,241 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import { Environment, Font, Gender, IconType, RuntimeEnviroment } from '../types/IChaynsReact';
+import invokeAppCall from "../util/appCall";
+import getDeviceInfo from "../util/deviceHelper";
+import { removeVisibilityChangeListener } from "../calls/visibilityChangeListener";
+import getUserInfo from "../calls/getUserInfo";
+export class AppWrapper {
+  mapOldApiToNew(_ref) {
+    var _window, _window2, _AppInfo$TappSelected;
+    let {
+      retVal
+    } = _ref;
+    const {
+      AppInfo,
+      AppUser
+    } = retVal;
+    this.accessToken = AppUser.TobitAccessToken;
+    return {
+      device: getDeviceInfo(navigator.userAgent, 'image/webp'),
+      environment: {
+        buildEnvironment: Environment.Production,
+        runtimeEnvironment: RuntimeEnviroment.Unknown
+      },
+      language: {
+        site: AppInfo.Language,
+        translation: null,
+        device: AppInfo.Language,
+        active: AppInfo.Language
+      },
+      // ToDo: Find better way to detect
+      site: {
+        id: AppInfo.SiteID,
+        locationId: AppInfo.LocationID,
+        url: (_window = window) === null || _window === void 0 ? void 0 : _window.location.href.split('#')[0],
+        layoutDisposition: {
+          contentWide: false,
+          barOnTop: false,
+          barWide: false,
+          coverDetached: false,
+          coverHidden: false,
+          coverWide: false,
+          docked: false
+        },
+        title: AppInfo.Title,
+        colorMode: AppInfo.colorMode,
+        color: AppInfo.color,
+        domain: AppInfo.domain,
+        font: {
+          id: Font.Roboto,
+          headlineFont: Font.Roboto,
+          dynamicFontSize: false
+        },
+        dynamicFontSize: false,
+        locationPersonId: AppInfo.LocationPersonId,
+        urlHash: (_window2 = window) === null || _window2 === void 0 ? void 0 : _window2.location.hash.replace('#', '')
+      },
+      parameters: [...new URLSearchParams(location.search)],
+      user: {
+        firstName: AppUser.FirstName,
+        lastName: AppUser.LastName,
+        gender: Gender.Unknown,
+        userId: AppUser.TobitUserID,
+        personId: AppUser.PersonID,
+        uacGroups: []
+      },
+      customData: null,
+      isAdminModeActive: AppUser.AdminMode,
+      currentPage: {
+        id: (_AppInfo$TappSelected = AppInfo.TappSelected) === null || _AppInfo$TappSelected === void 0 ? void 0 : _AppInfo$TappSelected.TappID,
+        siteId: AppInfo.SiteID
+      },
+      pages: AppInfo.Tapps.map(x => ({
+        id: x.TappID,
+        icon: '',
+        iconType: IconType.Font,
+        customUrl: '',
+        isExclusive: x.isExclusiveView,
+        isHiddenFromMenu: x.isHiddenFromMenu,
+        minAge: null,
+        name: x.ShowName,
+        sortId: x.SortUID
+      }))
+    };
+  }
+  constructor() {
+    _defineProperty(this, "values", null);
+    _defineProperty(this, "accessToken", "");
+    _defineProperty(this, "counter", 0);
+    _defineProperty(this, "functions", {
+      getAccessToken: async accessToken => {
+        return {
+          accessToken: this.accessToken
+        };
+      },
+      // addGeoLocationListener: async (value , callback) => {
+      //     return invokeAppCall({
+      //         'action': 14,
+      //         'value': {
+      //             'permanent': false,
+      //             callback: callback
+      //         }
+      //     });
+      // },
+      // addScrollListener: async (value, callback) => {
+      //
+      // },
+      //   addVisibilityChangeListener: async (callback) => addVisibilityChangeListener(callback),
+      // addWindowMetricsListener: async (callback) => {
+      //     const { id, shouldInitialize } = addApiListener('windowMetricsListener', callback);
+      //
+      //     if (shouldInitialize) {
+      //         window.addEventListener('resize', this.resizeListener = () => {
+      //             void (async() => {
+      //                 dispatchApiEvent('windowMetricsListener', {
+      //
+      //                 });
+      //             })();
+      //         })
+      //     }
+      //     return id;
+      // },
+      customCallbackFunction: async (type, data) => {},
+      // getAvailableSharingServices: async () => {
+      // },
+      // getGeoLocation: async (value) => {
+      // },
+      getUserInfo: async query => {
+        return getUserInfo(this, query);
+      },
+      // getScrollPosition: async () => {
+      // },
+      // getWindowMetrics: async () => {
+      // },
+      invokeCall: async (value, callback) => {},
+      invokeDialogCall: async (value, callback) => {
+        const callbackName = `chaynsApiV5Callback_${this.counter++}`;
+        window[callbackName] = _ref2 => {
+          let {
+            retVal
+          } = _ref2;
+          callback === null || callback === void 0 ? void 0 : callback(retVal);
+          delete window[callbackName];
+        };
+        const callObj = {
+          ...value,
+          value: {
+            ...value.value,
+            callback: callbackName
+          }
+        };
+        invokeAppCall(callObj);
+      },
+      // login: async(value, callback, closeCallback) => {
+      // },
+      logout: async () => {},
+      navigateBack: async () => {},
+      openImage: async value => {},
+      openUrl: async value => {},
+      openVideo: async value => {},
+      refreshAccessToken: async () => {},
+      refreshData: async value => {},
+      removeGeoLocationListener: async id => {},
+      removeScrollListener: async id => {},
+      removeVisibilityChangeListener(number) {
+        removeVisibilityChangeListener(number);
+        return Promise.resolve();
+      },
+      removeWindowMetricsListener: async id => {},
+      selectPage: async options => {},
+      scrollToY: async (position, duration) => {},
+      // sendMessageToGroup: async (groupId, message) => {
+      // },
+      // sendMessageToPage: async (message) => {
+      // },
+      // sendMessageToUser: async (userId, message) => {
+      // },
+      setAdminMode: async enabled => {},
+      // setDisplayTimeout: async (value) => {
+      // },
+      setFloatingButton: async (value, callback) => {},
+      setHeight: async value => {},
+      setOverlay: async (value, callback) => {},
+      setRefreshScrollEnabled: async isEnabled => {
+        invokeAppCall({
+          action: 0,
+          value: {
+            enabled: isEnabled
+          }
+        });
+        return {
+          isEnabled
+        };
+      },
+      // setScanQrCode: async (value) => {
+      // },
+      setTempDesignSettings: async value => {},
+      setWaitCursor: async value => {},
+      storageGetItem: async (key, accessMode) => {},
+      storageRemoveItem: async (key, accessMode) => {},
+      storageSetItem: async (key, value, accessMode, tappIds) => {},
+      vibrate: async value => {}
+    });
+  }
+  appCall(call) {
+    // generate uuid just in case multiple AppWrapper in one window
+    call.value.callback = `window.chaynsApiV5Callback_` + this.counter++;
+    invokeAppCall(call);
+  }
+
+  // @ts-ignore
+
+  async init() {
+    await new Promise(resolve => {
+      // @ts-ignore
+      window.globalDataCallback = data => {
+        this.values = this.mapOldApiToNew(data);
+        resolve(data);
+      };
+      invokeAppCall({
+        action: 18,
+        value: {
+          callback: 'window.globalDataCallback'
+        }
+      });
+    });
+    return undefined;
+  }
+  getSSRData() {
+    return null;
+  }
+  addDataListener(cb) {
+    const listener = ev => ev.detail && cb(ev.detail);
+    document.addEventListener('chayns_api_data', listener);
+    return () => {
+      document.removeEventListener('chayns_api_data', listener);
+    };
+  }
+  getInitialData() {
+    return this.values;
+  }
+}

package/dist/esm/wrapper/FrameWrapper.js

@@ -0,0 +1,279 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import * as comlink from 'comlink';
+import { addVisibilityChangeListener, removeVisibilityChangeListener } from '../calls/visibilityChangeListener';
+import { addApiListener, dispatchApiEvent, removeApiListener } from '../helper/apiListenerHelper';
+import getUserInfo from '../calls/getUserInfo';
+import { sendMessageToGroup, sendMessageToPage, sendMessageToUser } from '../calls/sendMessage';
+import { setTappHeight } from '../util/heightHelper';
+export class FrameWrapper {
+  constructor() {
+    _defineProperty(this, "resolve", null);
+    _defineProperty(this, "exposedFunctions", null);
+    _defineProperty(this, "resizeListener", null);
+    _defineProperty(this, "ready", new Promise(res => {
+      this.resolve = res;
+    }));
+    _defineProperty(this, "values", null);
+    _defineProperty(this, "functions", {
+      addGeoLocationListener: async (value, callback) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.addGeoLocationListener(value, callback && comlink.proxy(result => callback(result)));
+      },
+      addScrollListener: async (value, callback) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.addScrollListener(value, callback && comlink.proxy(result => callback(result)));
+      },
+      addVisibilityChangeListener: async callback => addVisibilityChangeListener(callback),
+      addWindowMetricsListener: async callback => {
+        if (!this.initialized) await this.ready;
+        const {
+          id,
+          shouldInitialize
+        } = addApiListener('windowMetricsListener', callback);
+        if (shouldInitialize) {
+          void this.exposedFunctions.addWindowMetricsListener(comlink.proxy(result => {
+            dispatchApiEvent('windowMetricsListener', result);
+          }));
+          window.addEventListener('resize', this.resizeListener = () => {
+            void (async () => {
+              const metrics = await this.exposedFunctions.getWindowMetrics();
+              dispatchApiEvent('windowMetricsListener', metrics);
+            })();
+          });
+        }
+        return id;
+      },
+      customCallbackFunction: async (type, data) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.customCallbackFunction(type, data);
+      },
+      getAvailableSharingServices: async () => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.getAvailableSharingServices();
+      },
+      getAccessToken: async accessToken => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.getAccessToken(accessToken);
+      },
+      getGeoLocation: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.getGeoLocation(value);
+      },
+      getUserInfo: async query => {
+        if (!this.initialized) await this.ready;
+        return getUserInfo(this, query);
+      },
+      getScrollPosition: async () => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.getScrollPosition();
+      },
+      getWindowMetrics: async () => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.getWindowMetrics();
+      },
+      invokeCall: async (value, callback) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.invokeCall(value, callback && comlink.proxy(result => callback(result)));
+      },
+      invokeDialogCall: async (value, callback) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.invokeDialogCall(value, callback && comlink.proxy(result => callback(result)));
+      },
+      login: async (value, callback, closeCallback) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.login(value, callback && comlink.proxy(result => callback(result)), closeCallback && comlink.proxy(() => closeCallback()));
+      },
+      logout: async () => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.logout();
+      },
+      navigateBack: async () => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.navigateBack();
+      },
+      openImage: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.openImage(value);
+      },
+      openUrl: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.openUrl(value);
+      },
+      openVideo: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.openVideo(value);
+      },
+      refreshAccessToken: async () => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.refreshAccessToken();
+      },
+      refreshData: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.refreshData(value);
+      },
+      removeGeoLocationListener: async id => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.removeGeoLocationListener(id);
+      },
+      removeScrollListener: async id => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.removeScrollListener(id);
+      },
+      removeVisibilityChangeListener(number) {
+        removeVisibilityChangeListener(number);
+        return Promise.resolve();
+      },
+      removeWindowMetricsListener: async id => {
+        if (!this.initialized) await this.ready;
+        const shouldRemove = removeApiListener('windowMetricsListener', id);
+        if (shouldRemove) {
+          void this.exposedFunctions.removeWindowMetricsListener(id);
+          if (this.resizeListener) window.removeEventListener('resize', this.resizeListener);
+          this.resizeListener = null;
+        }
+      },
+      selectPage: async options => {
+        if (!this.initialized) await this.ready;
+        await this.exposedFunctions.selectPage(options);
+      },
+      scrollToY: async (position, duration) => {
+        if (!this.initialized) await this.ready;
+        await this.exposedFunctions.scrollToY(position, duration);
+      },
+      sendMessageToGroup: async (groupId, message) => {
+        if (!this.initialized) await this.ready;
+        return sendMessageToGroup(this, message, groupId);
+      },
+      sendMessageToPage: async message => {
+        if (!this.initialized) await this.ready;
+        return sendMessageToPage(this, message);
+      },
+      sendMessageToUser: async (userId, message) => {
+        if (!this.initialized) await this.ready;
+        return sendMessageToUser(this, message, userId);
+      },
+      setAdminMode: async enabled => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setAdminMode(enabled);
+      },
+      setDisplayTimeout: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setDisplayTimeout(value);
+      },
+      setFloatingButton: async (value, callback) => {
+        var _value$items;
+        if (!this.initialized) await this.ready;
+        value.items = (_value$items = value.items) !== null && _value$items !== void 0 ? _value$items : [];
+        const itemClickFunctions = value.items.map(x => x.onClick);
+        value.items = value.items.map(x => ({
+          ...x,
+          onClick: undefined
+        }));
+        const cb = callback && comlink.proxy(data => {
+          if (data !== null && data !== void 0 && data.item && itemClickFunctions[data.index]) {
+            itemClickFunctions[data.index]();
+          } else {
+            callback();
+          }
+        });
+        // @ts-ignore
+        return this.exposedFunctions.setFloatingButton(value, cb);
+      },
+      setHeight: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setHeight(value);
+      },
+      setOverlay: async (value, callback) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setOverlay(value, callback && comlink.proxy(() => callback()));
+      },
+      setRefreshScrollEnabled: async enabled => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setRefreshScrollEnabled(enabled);
+      },
+      setScanQrCode: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setScanQrCode(value !== null && value !== void 0 ? value : {
+          cancel: false
+        });
+      },
+      setTempDesignSettings: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setTempDesignSettings(value);
+      },
+      setWaitCursor: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.setWaitCursor(value);
+      },
+      storageGetItem: async (key, accessMode) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.storageGetItem(key, accessMode);
+      },
+      storageRemoveItem: async (key, accessMode) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.storageRemoveItem(key, accessMode);
+      },
+      storageSetItem: async (key, value, accessMode, tappIds) => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.storageSetItem(key, value, accessMode, tappIds);
+      },
+      vibrate: async value => {
+        if (!this.initialized) await this.ready;
+        return this.exposedFunctions.vibrate(value);
+      }
+    });
+    _defineProperty(this, "initialized", false);
+    const initialDataTag = document.querySelector('#__CHAYNS_DATA__');
+    if (initialDataTag) {
+      this.values = JSON.parse(initialDataTag.innerHTML);
+    }
+  }
+  async init() {
+    if (this.initialized) return;
+    const exposed = comlink.wrap(comlink.windowEndpoint(window.parent))[window.name];
+    const dataListener = () => exposed.addDataListener(comlink.proxy(_ref => {
+      let {
+        type,
+        value
+      } = _ref;
+      if (this.initialized) {
+        this.values[type] = value;
+      }
+      this.values[type] = value;
+      document.dispatchEvent(new CustomEvent('chayns_api_data', {
+        detail: {
+          type,
+          value
+        }
+      }));
+    }));
+    let hostReadyCallback = null;
+    await Promise.race([dataListener(), new Promise(resolve => {
+      window.addEventListener('message', hostReadyCallback = ev => {
+        if (ev.data === 'chayns-api-host-ready') {
+          void dataListener().then(resolve);
+        }
+      });
+    })]);
+    if (hostReadyCallback) window.removeEventListener('message', hostReadyCallback);
+    this.values = await exposed.getInitialData();
+    this.exposedFunctions = exposed.functions;
+    this.initialized = true;
+    this.resolve(null);
+    setTappHeight(this.functions.setHeight);
+  }
+  addDataListener(cb) {
+    const listener = ev => ev.detail && cb(ev.detail);
+    document.addEventListener('chayns_api_data', listener);
+    return () => {
+      document.removeEventListener('chayns_api_data', listener);
+    };
+  }
+  getSSRData() {
+    return null;
+  }
+  getInitialData() {
+    return this.values;
+  }
+}

package/dist/esm/wrapper/ModuleFederationWrapper.js

@@ -0,0 +1,56 @@
+import { addVisibilityChangeListener, removeVisibilityChangeListener } from '../calls/visibilityChangeListener';
+import { addApiListener, dispatchApiEvent, removeApiListener } from '../helper/apiListenerHelper';
+import getUserInfo from '../calls/getUserInfo';
+import { sendMessageToGroup, sendMessageToPage, sendMessageToUser } from '../calls/sendMessage';
+export class ModuleFederationWrapper {
+  constructor(values, functions) {
+    this.values = values;
+    this.functions = {};
+    this.functions.addVisibilityChangeListener = async callback => addVisibilityChangeListener(callback);
+    this.functions.removeVisibilityChangeListener = async id => removeVisibilityChangeListener(id);
+    this.functions.getUserInfo = async query => getUserInfo(this, query);
+    this.functions.sendMessageToGroup = async (groupId, object) => sendMessageToGroup(this, object, groupId);
+    this.functions.sendMessageToPage = async object => sendMessageToPage(this, object);
+    this.functions.sendMessageToUser = async (userId, object) => sendMessageToUser(this, object, userId);
+    // make all functions async to be consistent with frame wrapper
+    Object.entries(functions).forEach(_ref => {
+      let [k, fn] = _ref;
+      // eslint-disable-next-line
+      this.functions[k] = async function () {
+        return fn(...arguments);
+      };
+    });
+    this.functions.addWindowMetricsListener = async callback => {
+      const {
+        id,
+        shouldInitialize
+      } = addApiListener('windowMetrics', callback);
+      if (shouldInitialize) {
+        void functions.addWindowMetricsListener(value => dispatchApiEvent('windowMetrics', value));
+      }
+      return id;
+    };
+    this.functions.removeWindowMetricsListener = async id => {
+      const shouldRemove = removeApiListener('windowMetrics', id);
+      if (shouldRemove) {
+        void functions.removeWindowMetricsListener(id);
+      }
+    };
+  }
+  async init() {
+    return undefined;
+  }
+  addDataListener(cb) {
+    const listener = ev => ev.detail && cb(ev.detail);
+    document.addEventListener('chayns_api_data', listener);
+    return () => {
+      document.removeEventListener('chayns_api_data', listener);
+    };
+  }
+  getSSRData() {
+    return null;
+  }
+  getInitialData() {
+    return this.values;
+  }
+}

package/dist/esm/wrapper/SsrWrapper.js

@@ -0,0 +1,23 @@
+export class SsrWrapper {
+  constructor(values, functions) {
+    this.initialData = values;
+    this.values = values;
+    this.functions = functions;
+  }
+  async init() {
+    return undefined;
+  }
+  addDataListener(cb) {
+    const listener = ev => ev.detail && cb(ev.detail);
+    document.addEventListener('chayns_api_data', listener);
+    return () => {
+      document.removeEventListener('chayns_api_data', listener);
+    };
+  }
+  getSSRData() {
+    return this.initialData;
+  }
+  getInitialData() {
+    return this.values;
+  }
+}

package/dist/types/calls/dialogs/alert.d.ts

@@ -0,0 +1 @@
+export declare function alert(title?: string, message?: string): Promise<any> | "unsupported";

package/dist/types/calls/dialogs/chaynsDialog.d.ts

@@ -0,0 +1,24 @@
+export declare const buttonText: {
+    YES: string;
+    NO: string;
+    OK: string;
+    CANCEL: string;
+};
+export declare const buttonType: {
+    CANCEL: number;
+    NEGATIVE: number;
+    POSITIVE: number;
+};
+export declare const dialogAction: {
+    ALERT_CONFIRM: number;
+    INPUT: number;
+    SELECT: number;
+    DATE: number;
+    ADVANCED_DATE: number;
+    DROP_UP_ALERT: number;
+    MEDIA_SELECT: number;
+    FILE_SELECT: number;
+    SIGNATURE: number;
+    IFRAME: number;
+};
+export declare function chaynsDialog(config: any): Promise<any> | "unsupported";

package/dist/types/calls/dialogs/close.d.ts

@@ -0,0 +1 @@
+export declare function close(): Promise<any>;

package/dist/types/calls/dialogs/communication.d.ts

@@ -0,0 +1,3 @@
+export declare function sendData(data: any, isApiEvent: any): Promise<any>;
+export declare function addDialogDataListener(callback: any, getApiEvents?: boolean): boolean;
+export declare function removeDialogDataListener(callback: any, getApiEvents?: boolean): boolean;

package/dist/types/calls/dialogs/confirm.d.ts

@@ -0,0 +1,13 @@
+import { DialogButton } from "../../types/dialog";
+type Confirm = {
+    headline?: string;
+    text?: string;
+    buttons?: DialogButton[] | {
+        buttons?: DialogButton[];
+        links?: DialogButton[];
+    };
+    links?: unknown;
+    select?: unknown;
+};
+export declare function confirm(title?: string, message?: string, config?: Confirm): Promise<any> | "unsupported";
+export {};