@elliemae/microfe-common 2.0.0-next.30

package/dist/cjs/tests/scriptingObjects/global.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var global_exports = {};
+__export(global_exports, {
+  Global: () => Global
+});
+module.exports = __toCommonJS(global_exports);
+var import_event = require("../../event.js");
+var import__ = require("../../index.js");
+var _data;
+class Global extends import__.ScriptingObject {
+  constructor() {
+    super("Global");
+    __privateAdd(this, _data, /* @__PURE__ */ new Map());
+    __publicField(this, "Change", new import_event.Event({
+      name: "Change",
+      requiresFeedback: false,
+      so: this
+    }));
+    __publicField(this, "set", (key, value) => {
+      __privateGet(this, _data).set(key, value);
+      return Promise.resolve();
+    });
+    __publicField(this, "get", (key) => Promise.resolve(__privateGet(this, _data).get(key)));
+  }
+}
+_data = new WeakMap();

package/dist/esm/app.config.json

@@ -0,0 +1,17 @@
+{
+  "appId": "lib-boilerplate",
+  "activeEnv": "localhost",
+  "serviceEndpoints": {
+    "api": "",
+    "idp": ""
+  },
+  "env": {
+    "localhost": {},
+    "dev2": {},
+    "qa2": {},
+    "qa3": {},
+    "int": {},
+    "stage": {},
+    "prod": {}
+  }
+}

package/dist/esm/event.js

@@ -0,0 +1,47 @@
+class Event {
+  /* eslint-enable indent */
+  /**
+   * scripting object that owns this event
+   */
+  scriptingObject;
+  /**
+   * name of the event
+   */
+  name;
+  /**
+   * scripting object id that owns this event
+   */
+  objectId;
+  /**
+   * flag indicating this event requires feedback from all of the listeners
+   */
+  requiresFeedback;
+  /**
+   * unique id of the event
+   */
+  id;
+  /**
+   * Create an event object
+   *
+   * @param {EventParam} param - parameters for creating an event
+   */
+  constructor(param) {
+    const { name, requiresFeedback = false, so } = param;
+    if (!name)
+      throw new Error("Event name is required");
+    if (!so)
+      throw new Error("Scripting object is required");
+    this.scriptingObject = so;
+    this.objectId = so.id;
+    this.name = name;
+    this.id = `${this.objectId}.${this.name}`.toLowerCase();
+    this.requiresFeedback = requiresFeedback;
+  }
+}
+const isEvent = (value) => value instanceof Event;
+const getEventId = (objectId, eventName) => `${objectId.toLowerCase()}.${eventName.toLowerCase()}`;
+export {
+  Event,
+  getEventId,
+  isEvent
+};

package/dist/esm/eventManager.js

@@ -0,0 +1,182 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _listeners, _asyncCallwithTimeout, _emitEvent, _emitEventWithFeedback;
+import { v4 as uuidv4 } from "uuid";
+const flatten = (source, target = []) => {
+  const retVal = target || [];
+  if (source && source.forEach) {
+    source.forEach((item) => {
+      flatten(item, retVal);
+    });
+  } else if (typeof source !== "undefined") {
+    retVal.push(source);
+  }
+  return retVal;
+};
+class EventManager {
+  constructor() {
+    /**
+     * event listeners
+     */
+    __privateAdd(this, _listeners, /* @__PURE__ */ new Map());
+    /**
+     * call an async function with a timeout
+     *
+     * @param promise async function to call
+     * @param feedbackWaitTime timeout in milliseconds
+     * @returns result of the async function or undefined if timeout
+     */
+    __privateAdd(this, _asyncCallwithTimeout, (promise, feedbackWaitTime) => {
+      const timeout = new Promise((resolve) => {
+        setTimeout(() => {
+          resolve();
+        }, feedbackWaitTime);
+      });
+      return Promise.race([promise, timeout]);
+    });
+    /**
+     * emit an event to set of listeners
+     *
+     * @param {EmitEventParam} param - parameters for emitting an event
+     */
+    __privateAdd(this, _emitEvent, (param) => {
+      const { eventName, scriptingObject, eventParams, listeners } = param;
+      listeners.map(async (listener) => {
+        try {
+          await listener.callback({
+            obj: scriptingObject,
+            eventName,
+            eventParams
+          });
+        } catch (e) {
+        }
+      });
+    });
+    __privateAdd(this, _emitEventWithFeedback, async ({
+      eventId,
+      eventName,
+      scriptingObject,
+      eventParams,
+      feedbackWaitTime
+    }) => {
+      const listeners = __privateGet(this, _listeners).get(eventId) || [];
+      const promises = listeners.map(
+        (listener) => __privateGet(this, _asyncCallwithTimeout).call(
+          this,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          listener.callback({
+            obj: scriptingObject,
+            eventName,
+            eventParams
+          }),
+          feedbackWaitTime
+        )
+      );
+      const retValues = await Promise.all(promises);
+      return flatten(retValues);
+    });
+    /**
+     * dispatch an event
+     *
+     * @param {DispatchEventParam<EventId, Params>} param - parameters for dispatching an event
+     */
+    __publicField(this, "dispatchEvent", async (param) => {
+      const {
+        event: { id, name, requiresFeedback, scriptingObject },
+        eventParams,
+        feedbackWaitTime = 1e3
+      } = param;
+      if (!id)
+        throw new Error("Event Id is required");
+      const listeners = __privateGet(this, _listeners).get(id) || [];
+      if (!requiresFeedback) {
+        __privateGet(this, _emitEvent).call(this, {
+          eventName: name,
+          scriptingObject,
+          eventParams,
+          listeners
+        });
+        return Promise.resolve();
+      }
+      return __privateGet(this, _emitEventWithFeedback).call(this, {
+        eventId: id,
+        eventName: name,
+        scriptingObject,
+        eventParams,
+        feedbackWaitTime
+      });
+    });
+    /**
+     * Subscribe to an event
+     *
+     * @param {SubscribeParam<EventId, AppEvents[EventId]>} param - parameters for subscribing to an event
+     */
+    __publicField(this, "subscribe", (param) => {
+      const { eventId, listener } = param;
+      if (!eventId)
+        throw new Error("eventId is required");
+      if (!listener)
+        throw new Error("Listener is required");
+      const listeners = __privateGet(this, _listeners).get(eventId) || [];
+      const subscriptionId = uuidv4();
+      listeners.push({
+        subscriptionId,
+        callback: listener
+      });
+      __privateGet(this, _listeners).set(eventId, listeners);
+      return subscriptionId;
+    });
+    /**
+     * Unsubscribe from an event
+     *
+     * @param {UnsubscribeParam<EventId>} param - parameters for unsubscribing from an event
+     */
+    __publicField(this, "unsubscribe", (param) => {
+      const { eventId, subscriptionId } = param;
+      if (!eventId)
+        throw new Error("eventId id is required");
+      if (subscriptionId) {
+        const listeners = __privateGet(this, _listeners).get(eventId) || [];
+        const index = listeners.findIndex(
+          (listener) => listener.subscriptionId === subscriptionId
+        );
+        if (index > -1) {
+          listeners.splice(index, 1);
+          __privateGet(this, _listeners).set(eventId, listeners);
+        }
+      } else {
+        __privateGet(this, _listeners).delete(eventId);
+      }
+    });
+    /**
+     * Unsubscribe from all events
+     */
+    __publicField(this, "unsubscribeAll", () => {
+      __privateGet(this, _listeners).clear();
+    });
+  }
+}
+_listeners = new WeakMap();
+_asyncCallwithTimeout = new WeakMap();
+_emitEvent = new WeakMap();
+_emitEventWithFeedback = new WeakMap();
+export {
+  EventManager
+};

package/dist/esm/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Common</title>
+</head>
+<body>
+  
+</body>
+</html>

package/dist/esm/index.js

@@ -0,0 +1,15 @@
+import { Remoting, sendMessage } from "./remoting.js";
+import { EventManager } from "./eventManager.js";
+import { getEventId } from "./event.js";
+import { Event } from "./event.js";
+import { ScriptingObject } from "./scriptingObject.js";
+import { MessageType } from "./messageType.js";
+export {
+  Event,
+  EventManager,
+  MessageType,
+  Remoting,
+  ScriptingObject,
+  getEventId,
+  sendMessage
+};

package/dist/esm/messageType.js

@@ -0,0 +1,17 @@
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["GuestReady"] = "guest:ready";
+  MessageType2["GuestClose"] = "guest:close";
+  MessageType2["GuestReadyComplete"] = "guest:readyComplete";
+  MessageType2["GuestResize"] = "guest:resize";
+  MessageType2["GuestFocus"] = "guest:focus";
+  MessageType2["HandShake"] = "handshake";
+  MessageType2["HandShakeAck"] = "handshake:ack";
+  MessageType2["ObjectInvoke"] = "object:invoke";
+  MessageType2["ObjectGet"] = "object:get";
+  MessageType2["ObjectEvent"] = "object:event";
+  MessageType2["HostConfig"] = "host:config";
+  return MessageType2;
+})(MessageType || {});
+export {
+  MessageType
+};

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": false
+}