@myop/sdk 0.1.45 → 0.1.47

package/dist/module/helpers/index.js

@@ -17,6 +17,10 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -46,8 +50,84 @@ var uuidv4 = () => {
     (c) => (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
   );
 };
+var bytesToUuid = (bytes) => {
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20)
+  ].join("-");
+};
+var base64UrlDecode = (str) => {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4) base64 += "=";
+  const binary = atob(base64);
+  return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+};
+var decompressUUIDs = (encoded) => {
+  const bytes = base64UrlDecode(encoded);
+  if (bytes.length % 16 !== 0) throw new Error("Invalid input length");
+  const uuids = [];
+  for (let i = 0; i < bytes.length; i += 16) {
+    uuids.push(bytesToUuid(bytes.slice(i, i + 16)));
+  }
+  return uuids;
+};
+
+// src/utils/utils.ts
+var wait = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+// src/messages/index.ts
+var messages_exports = {};
+__export(messages_exports, {
+  AddEventListenerMessage: () => AddEventListenerMessage,
+  BaseMyopMessage: () => BaseMyopMessage,
+  BindClickMessage: () => BindClickMessage,
+  ChangeTextMessage: () => ChangeTextMessage,
+  CleanupMessage: () => CleanupMessage,
+  CleanupReplayMessage: () => CleanupReplayMessage,
+  ClickReplayMessage: () => ClickReplayMessage,
+  CreateRefComponentMessage: () => CreateRefComponentMessage,
+  CustomRefMessage: () => CustomRefMessage,
+  DetectMyopRefsMessage: () => DetectMyopRefsMessage,
+  DetectedMyopRefsMessage: () => DetectedMyopRefsMessage,
+  DisposeMessage: () => DisposeMessage,
+  ElementValueReplayMessage: () => ElementValueReplayMessage,
+  EnvelopedMessage: () => EnvelopedMessage,
+  EventListenerCallbackMessage: () => EventListenerCallbackMessage,
+  ExecuteComponentMethod: () => ExecuteComponentMethod,
+  ExecuteScriptMessage: () => ExecuteScriptMessage,
+  ExecuteScriptReplyMessage: () => ExecuteScriptReplyMessage,
+  GetAttributeMessage: () => GetAttributeMessage,
+  GetAttributeReplayMessage: () => GetAttributeReplayMessage,
+  GetElementValueMessage: () => GetElementValueMessage,
+  InitMessage: () => InitMessage,
+  InitRequest: () => InitRequest,
+  InitResponse: () => InitResponse,
+  MessageDirection: () => MessageDirection,
+  MutationObserverMessage: () => MutationObserverMessage,
+  MyopBindMessage: () => MyopBindMessage,
+  MyopBindReplayMessage: () => MyopBindReplayMessage,
+  MyopElementMessage: () => MyopElementMessage,
+  Ref: () => Ref,
+  RefComponentCreatedMessage: () => RefComponentCreatedMessage,
+  ResizeObserverMessage: () => ResizeObserverMessage,
+  SetAttributeMessage: () => SetAttributeMessage,
+  SetInnerHtml: () => SetInnerHtml,
+  SetMutationObserverMessage: () => SetMutationObserverMessage,
+  SetResizeObserverMessage: () => SetResizeObserverMessage,
+  stripFunction: () => stripFunction
+});
 
 // src/messages/BaseMessage.ts
+var MessageDirection = class {
+};
+__publicField(MessageDirection, "down", "down");
+__publicField(MessageDirection, "up", "up");
 var BaseMyopMessage = class {
   constructor() {
     __publicField(this, "id", uuidv4());
@@ -68,6 +148,18 @@ var BaseMyopMessage = class {
     return msg.messageType === this.messageType;
   }
 };
+var MyopElementMessage = class extends BaseMyopMessage {
+  constructor(ref) {
+    super();
+    this.ref = ref;
+  }
+};
+var MyopBindReplayMessage = class extends BaseMyopMessage {
+  constructor(replayToHandler) {
+    super();
+    this.replayToHandler = replayToHandler;
+  }
+};
 var MyopBindMessage = class extends BaseMyopMessage {
   constructor(handler) {
     super();
@@ -75,9 +167,65 @@ var MyopBindMessage = class extends BaseMyopMessage {
     __publicField(this, "handlerUniqueId", uuidv4());
   }
 };
+var Ref = class _Ref {
+  constructor(refConfig, component) {
+    this.refConfig = refConfig;
+    this.component = component;
+    __publicField(this, "myop", true);
+    __publicField(this, "__nonProxied");
+    this.__nonProxied = __spreadProps(__spreadValues({}, this), {
+      component: null
+      // in order to be serializable
+    });
+  }
+  static create(selector, refConfig, component) {
+    let _refConfig = refConfig;
+    if (!_refConfig) {
+      _refConfig = {
+        id: "",
+        name: "",
+        description: "",
+        selectorType: "id-attribute",
+        selector,
+        behavior: {
+          type: "code"
+        }
+      };
+    }
+    return new _Ref(_refConfig, component);
+  }
+};
+
+// src/messages/BindClickMessage.ts
+var ReplayMessageKey = "ClickReplayMessage";
+var BindClickMessage = class extends MyopBindMessage {
+  constructor(ref, handler) {
+    super(handler);
+    this.ref = ref;
+    __publicField(this, "replyMessageKey", ReplayMessageKey);
+    __publicField(this, "messageType", "BindClickMessage");
+    __publicField(this, "cleanable", true);
+  }
+};
+var ClickReplayMessage = class extends MyopBindReplayMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", ReplayMessageKey);
+  }
+};
+
+// src/messages/ChangeTextMessage.ts
+var ChangeTextMessage = class extends BaseMyopMessage {
+  constructor(ref, text) {
+    super();
+    this.ref = ref;
+    __publicField(this, "messageType", "ChangeTextMessage");
+    this.content = text;
+  }
+};
 
 // src/messages/ExecuteScriptMessage.ts
-var ReplayMessageKey = "ExecuteScriptReplyMessage";
+var ReplayMessageKey2 = "ExecuteScriptReplyMessage";
 var functionBodyRegex = /(?:function\s*\w*\s*\([^)]*\)\s*\{([\s\S]*?)\}|(\([^)]*\)\s*=>\s*\{([\s\S]*?)\}))\s*$/;
 var expressionBodyRegex = /\(\s*[^)]+\s*\)\s*=>\s*(.+)/;
 var stripFunction = (content) => {
@@ -95,7 +243,7 @@ var ExecuteScriptMessage = class extends MyopBindMessage {
   }, scriptInputs2) {
     super(handler);
     this.scriptInputs = scriptInputs2;
-    __publicField(this, "replyMessageKey", ReplayMessageKey);
+    __publicField(this, "replyMessageKey", ReplayMessageKey2);
     __publicField(this, "messageType", "ExecuteScriptMessage");
     __publicField(this, "script", "");
     this.script = script.toString();
@@ -105,6 +253,14 @@ var ExecuteScriptMessage = class extends MyopBindMessage {
 };
 __publicField(ExecuteScriptMessage, "replierKey", "send");
 __publicField(ExecuteScriptMessage, "completeStreamKey", "completeStream");
+var ExecuteScriptReplyMessage = class extends MyopBindReplayMessage {
+  constructor(replayToHandler, content) {
+    super(replayToHandler);
+    this.replayToHandler = replayToHandler;
+    this.content = content;
+    __publicField(this, "messageType", ReplayMessageKey2);
+  }
+};
 
 // src/messages/CustomRefMessage.ts
 var CustomRefMessage = class extends ExecuteScriptMessage {
@@ -127,6 +283,238 @@ var CustomRefMessage = class extends ExecuteScriptMessage {
   }
 };
 
+// src/messages/AddEventListenerMessage.ts
+var ReplayMessageKey3 = "EventListenerCallbackMessage";
+var AddEventListenerMessage = class extends MyopBindMessage {
+  // {} // empty
+  constructor(ref, type, handler) {
+    super(handler);
+    this.ref = ref;
+    this.type = type;
+    this.handler = handler;
+    __publicField(this, "replyMessageKey", ReplayMessageKey3);
+    __publicField(this, "messageType", "AddEventListenerMessage");
+    __publicField(this, "cleanable", true);
+    __publicField(this, "serializableSkeleton", false);
+  }
+  withSerializableSkeleton(serializableSkeleton) {
+    this.serializableSkeleton = serializableSkeleton;
+    return this;
+  }
+};
+var EventListenerCallbackMessage = class extends MyopBindReplayMessage {
+  constructor(replayToHandler, e) {
+    super(replayToHandler);
+    this.replayToHandler = replayToHandler;
+    this.e = e;
+    __publicField(this, "messageType", ReplayMessageKey3);
+    this.content = {
+      e
+    };
+  }
+};
+
+// src/messages/SetAttributeMessage.ts
+var SetAttributeMessage = class extends BaseMyopMessage {
+  constructor(ref, name, value) {
+    super();
+    this.ref = ref;
+    this.name = name;
+    this.value = value;
+    __publicField(this, "messageType", "SetAttributeMessage");
+  }
+};
+
+// src/messages/GetElementValueMessage.ts
+var ReplayMessageKey4 = "ElementValueReplayMessage";
+var GetElementValueMessage = class extends MyopBindMessage {
+  constructor(ref, handler) {
+    super(handler);
+    this.ref = ref;
+    __publicField(this, "replyMessageKey", ReplayMessageKey4);
+    __publicField(this, "messageType", "GetElementValueMessage");
+  }
+};
+var ElementValueReplayMessage = class extends MyopBindReplayMessage {
+  constructor(content) {
+    super();
+    this.content = content;
+    __publicField(this, "messageType", ReplayMessageKey4);
+  }
+};
+
+// src/messages/SetInnerHtml.ts
+var SetInnerHtml = class extends BaseMyopMessage {
+  constructor(ref, innerHtml) {
+    super();
+    this.ref = ref;
+    __publicField(this, "messageType", "SetInnerHtml");
+    this.content = innerHtml;
+  }
+};
+
+// src/messages/InitMessage.ts
+var InitMessage = class extends BaseMyopMessage {
+  constructor(id) {
+    super();
+    __publicField(this, "messageType", "InitMessage");
+    this.content = { id };
+  }
+  isTypeof(msg) {
+    return msg.messageType === this.messageType;
+  }
+};
+var InitResponse = class extends InitMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", "InitResponse");
+  }
+};
+var InitRequest = class extends BaseMyopMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", "InitRequest");
+  }
+};
+
+// src/messages/CreateRefComponentMessage.ts
+var ReplayMessageKey5 = "RefComponentCreatedMessage";
+var CreateRefComponentMessage = class extends MyopBindMessage {
+  constructor(refConfig, nestedComponentConfig, options, handler) {
+    super(handler);
+    this.refConfig = refConfig;
+    this.nestedComponentConfig = nestedComponentConfig;
+    this.options = options;
+    __publicField(this, "replyMessageKey", ReplayMessageKey5);
+    __publicField(this, "messageType", "CreateRefComponentMessage");
+  }
+};
+var RefComponentCreatedMessage = class extends MyopBindReplayMessage {
+  constructor(replayToHandler, nestedRefs, failed) {
+    super(replayToHandler);
+    this.replayToHandler = replayToHandler;
+    this.nestedRefs = nestedRefs;
+    this.failed = failed;
+    __publicField(this, "messageType", ReplayMessageKey5);
+  }
+};
+
+// src/messages/EnvelopedMessage.ts
+var EnvelopedMessage = class extends BaseMyopMessage {
+  constructor(destination, message) {
+    super();
+    this.destination = destination;
+    this.message = message;
+    __publicField(this, "messageType", "EnvelopedMessage");
+    const innerEnvelopedMessage = message;
+    this.route = [destination, ...innerEnvelopedMessage.route ? innerEnvelopedMessage.route : []];
+  }
+};
+
+// src/messages/DetectMyopRefsMessage.ts
+var ReplayMessageKey6 = "DetectedMyopRefsMessage";
+var DetectMyopRefsMessage = class extends MyopBindMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", "DetectMyopRefsMessage");
+    __publicField(this, "replyMessageKey", ReplayMessageKey6);
+  }
+};
+var DetectedMyopRefsMessage = class extends MyopBindReplayMessage {
+  constructor(replayToHandler, myopElementRefs) {
+    super(replayToHandler);
+    this.replayToHandler = replayToHandler;
+    __publicField(this, "messageType", ReplayMessageKey6);
+    this.content = myopElementRefs;
+  }
+  isTypeof(msg) {
+    return msg.messageType === this.messageType;
+  }
+};
+
+// src/messages/GetAttributeMessage.ts
+var ReplayMessageKey7 = "GetAttributeReplayMessage";
+var GetAttributeMessage = class extends MyopBindMessage {
+  constructor(ref, name, handler) {
+    super(handler);
+    this.ref = ref;
+    this.name = name;
+    __publicField(this, "replyMessageKey", ReplayMessageKey7);
+    __publicField(this, "messageType", "GetAttributeMessage");
+  }
+};
+var GetAttributeReplayMessage = class extends MyopBindReplayMessage {
+  constructor(content) {
+    super();
+    this.content = content;
+    __publicField(this, "messageType", ReplayMessageKey7);
+  }
+};
+
+// src/messages/componentMessages/ExecuteComponentMethod.ts
+var ExecuteComponentMethod = class extends BaseMyopMessage {
+  constructor(method) {
+    super();
+    this.method = method;
+    __publicField(this, "messageType", "ExecuteComponentMethod");
+  }
+};
+
+// src/messages/componentMessages/SetMutationObserverMessage.ts
+var SetMutationObserverMessage = class extends BaseMyopMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", "SetMutationObserverMessage");
+  }
+};
+var MutationObserverMessage = class extends BaseMyopMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", "MutationObserverMessage");
+  }
+};
+
+// src/messages/CleanupMessage.ts
+var ReplayMessageKey8 = "CleanupReplayMessage";
+var CleanupMessage = class extends MyopBindMessage {
+  constructor(cleanupForMessageId, handler) {
+    super(handler);
+    this.cleanupForMessageId = cleanupForMessageId;
+    __publicField(this, "replyMessageKey", ReplayMessageKey8);
+    __publicField(this, "messageType", "CleanupMessage");
+  }
+};
+var CleanupReplayMessage = class extends MyopBindReplayMessage {
+  constructor(customCleanup) {
+    super();
+    this.customCleanup = customCleanup;
+    __publicField(this, "messageType", ReplayMessageKey8);
+  }
+};
+
+// src/messages/DisposeMessage.ts
+var DisposeMessage = class extends BaseMyopMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", "DisposeMessage");
+  }
+};
+
+// src/messages/componentMessages/SetResizeObserverMessage.ts
+var SetResizeObserverMessage = class extends BaseMyopMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "cleanable", true);
+    __publicField(this, "messageType", "SetResizeObserverMessage");
+  }
+};
+var ResizeObserverMessage = class extends BaseMyopMessage {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", "ResizeObserverMessage");
+  }
+};
+
 // src/helpers/applyStylesheet.ts
 var applyStylesheet = (component, stylesheet, css) => {
   const tagId = `myop-css-${uuidv4()}`;
@@ -396,6 +784,2132 @@ var CloudRepository = _CloudRepository;
 var exec = (getter) => __async(void 0, null, function* () {
   return yield getter();
 });
+
+// src/dynamicImport/defineDynamicImport.ts
+var __federation__ = "__federation__";
+var onLoadKey = "onLoad";
+var defineDynamicImport = (globalName, module) => {
+  if (window[__federation__] && window[__federation__][globalName] && window[__federation__][globalName][onLoadKey]) {
+    window[__federation__][globalName][onLoadKey]({ [globalName]: module });
+  } else {
+  }
+};
+
+// src/common/MyopMessages.ts
+var MyopMessages = {
+  //host to component
+  "InitRequest": "InitRequest",
+  "InitResponse": "InitResponse",
+  "InitMessage": "InitMessage",
+  "DisposeMessage": "DisposeMessage",
+  "ChangeTextMessage": "ChangeTextMessage",
+  "BindClickMessage": "BindClickMessage",
+  "DetectMyopRefsMessage": "DetectMyopRefsMessage",
+  "ExecuteScriptMessage": "ExecuteScriptMessage",
+  "AddEventListenerMessage": "AddEventListenerMessage",
+  "SetAttributeMessage": "SetAttributeMessage",
+  "CreateRefComponentMessage": "CreateRefComponentMessage",
+  "EnvelopedMessage": "EnvelopedMessage",
+  "GetElementValueMessage": "GetElementValueMessage",
+  "GetAttributeMessage": "GetAttributeMessage",
+  "SetInnerHtml": "SetInnerHtml",
+  //component messages
+  "ExecuteComponentMethod": "ExecuteComponentMethod",
+  "SetMutationObserverMessage": "SetMutationObserverMessage",
+  "SetResizeObserverMessage": "SetResizeObserverMessage",
+  "CleanupMessage": "CleanupMessage",
+  // external to host :
+  In: {
+    "DetectedMyopRefsMessage": "DetectedMyopRefsMessage",
+    "ClickReplayMessage": "ClickReplayMessage",
+    "ExecuteScriptReplyMessage": "ExecuteScriptReplyMessage",
+    "EventListenerCallbackMessage": "EventListenerCallbackMessage",
+    "ElementValueReplayMessage": "ElementValueReplayMessage",
+    "GetAttributeReplayMessage": "GetAttributeReplayMessage",
+    "RefComponentCreatedMessage": "RefComponentCreatedMessage",
+    "EnvelopedMessage": "EnvelopedMessage",
+    "MutationObserverMessage": "MutationObserverMessage",
+    "CleanupReplayMessage": "CleanupReplayMessage",
+    "ResizeObserverMessage": "ResizeObserverMessage"
+  }
+};
+
+// src/host/components/IMyopComponent.ts
+var BaseMyopComponent = class {
+  constructor(componentDefinition, container, options) {
+    this.componentDefinition = componentDefinition;
+    this.container = container;
+    __publicField(this, "id", "");
+    __publicField(this, "messageHandlers", {});
+    __publicField(this, "element");
+    __publicField(this, "_markedForDisposed", false);
+    //TODO: use bindWhen with return true predicate ...
+    __publicField(this, "bind", (messageType, handler) => {
+      if (!this.messageHandlers[messageType]) {
+        this.messageHandlers[messageType] = [];
+      }
+      if (!this.messageHandlers[messageType].includes(handler)) {
+        this.messageHandlers[messageType].push(handler);
+      }
+    });
+    __publicField(this, "bindWhen", (messageType, predicate, handler) => {
+      if (!handler) {
+        throw new Error("can't use component.bindWhen without an handler");
+      }
+      if (!this.messageHandlers[messageType]) {
+        this.messageHandlers[messageType] = [];
+      }
+      const handlers = this.messageHandlers[messageType];
+      const predicateWrappedHandler = (e) => {
+        if (predicate(e)) {
+          handler(e);
+          return true;
+        }
+        return false;
+      };
+      handlers.push(predicateWrappedHandler);
+      return () => {
+        const index = handlers.indexOf(predicateWrappedHandler);
+        if (index > -1) {
+          handlers.splice(index, 1);
+        }
+      };
+    });
+    __publicField(this, "setInitiated", () => {
+      this.isInitiated = true;
+      if (this._whenInitiatedResolve)
+        this._whenInitiatedResolve();
+    });
+    __publicField(this, "isInitiated", false);
+    __publicField(this, "_whenInitiatedResolve");
+    __publicField(this, "_whenInitiatedReject");
+    __publicField(this, "_whenInitiated", new Promise((resolve, reject) => {
+      this._whenInitiatedResolve = resolve;
+      this._whenInitiatedReject = reject;
+    }));
+    __publicField(this, "initiated", () => {
+      return this._whenInitiated;
+    });
+    __publicField(this, "props", {});
+    __publicField(this, "refs", {});
+    this.id = (options == null ? void 0 : options.id) || HostSDK.Instance().assignId(componentDefinition);
+    const timeout = (options == null ? void 0 : options.timeout) ? options == null ? void 0 : options.timeout : 5 * 1e3;
+    setTimeout(() => {
+      if (!this.isInitiated && this._whenInitiatedReject && !this._markedForDisposed) {
+        this._whenInitiatedReject(`timeout_${timeout} ${this.id}`);
+      }
+    }, timeout);
+    this.initiated().then(() => {
+      if (window.myop.hostSDK.inspected) {
+        this.inspect();
+      }
+    });
+  }
+  get markedForDisposed() {
+    return this._markedForDisposed;
+  }
+  set markedForDisposed(value) {
+    if (this._markedForDisposed) {
+      throw new Error("InvalidOperationException: The component is already in the process of being disposed. Dispose operation cannot be performed again until the current disposal process is complete.");
+    }
+    this._markedForDisposed = value;
+  }
+  onMessageReceived(incomeMessage) {
+    if (incomeMessage.messageType === MyopMessages.ExecuteComponentMethod) {
+      const typedMessage = incomeMessage;
+      if (this[typedMessage.method]) {
+        this[typedMessage.method](typedMessage.content);
+      } else {
+        console.log(`method not found ${typedMessage.method} on component`, this);
+      }
+      return true;
+    }
+    const handlers = this.messageHandlers[incomeMessage.messageType];
+    if (handlers && handlers.length) {
+      let handled = false;
+      handlers.forEach((handler) => {
+        handled = handled || handler(incomeMessage);
+      });
+      return handled;
+    } else {
+    }
+    return false;
+  }
+  sendCleanupMessage(message) {
+    message.source = this.id;
+    message.destination = this.id;
+    message.direction = MessageDirection.down;
+    const cleanupHandler = this.bindWhen(message.replyMessageKey, (msg) => {
+      return msg.replayToHandler === message.handlerUniqueId;
+    }, (m) => {
+      message.handler(m);
+      cleanupHandler();
+    });
+    const handler = message.handler;
+    delete message.handler;
+    this.send(message);
+    message.handler = handler;
+  }
+  send(message) {
+    if (!message.source)
+      message.source = this.id;
+    if (!message.destination)
+      message.destination = this.id;
+    message.direction = MessageDirection.down;
+    let cleanupHandler;
+    if (message.handler) {
+      const typedMessage = message;
+      cleanupHandler = this.bindWhen(typedMessage.replyMessageKey, (msg) => {
+        return msg.replayToHandler === typedMessage.handlerUniqueId;
+      }, typedMessage.handler);
+      delete message.handler;
+    }
+    if (message.ref) {
+      message.ref = message.ref.__nonProxied || message.ref;
+    }
+    if (message.cleanable) {
+      return () => {
+        this.sendCleanupMessage(new CleanupMessage(message.id, (replay) => {
+        }));
+        if (cleanupHandler) {
+          cleanupHandler();
+        }
+      };
+    } else {
+      return () => {
+      };
+    }
+  }
+  dispose() {
+    this.markedForDisposed = true;
+    if (!this.isInitiated) {
+      return;
+    }
+    console.log("disposing component", this.id);
+    this.send(new DisposeMessage());
+    const onDisposeHandlers = this.messageHandlers["onDispose"];
+    if (onDisposeHandlers) {
+      onDisposeHandlers.forEach((disposeHandler) => {
+        disposeHandler(null);
+      });
+    }
+    this.messageHandlers = {};
+    this.id += "_disposed";
+    this.isInitiated = false;
+  }
+};
+
+// src/common/MyopElementRef.ts
+var MyopElementRef = class {
+  constructor(myopId, htmlTagName, BoundingRect, offsetTop, offsetLeft) {
+    this.myopId = myopId;
+    this.htmlTagName = htmlTagName;
+    this.BoundingRect = BoundingRect;
+    this.offsetTop = offsetTop;
+    this.offsetLeft = offsetLeft;
+    __publicField(this, "type", "MyopElementRef");
+  }
+};
+
+// src/common/baseMessageHandler.ts
+var runExecutorCleanup = (task) => __async(void 0, null, function* () {
+  if (typeof task === "function") {
+    task();
+  } else if (task instanceof Promise) {
+    const result = yield task;
+    if (typeof result === "function") {
+      result();
+    }
+  }
+});
+var BaseMessageHandler = class {
+  //TODO : add dispose method
+  constructor(messageToHost) {
+    this.messageToHost = messageToHost;
+  }
+};
+var BaseContextMessageHandler = class extends BaseMessageHandler {
+  constructor(messageToHost, context) {
+    super(messageToHost);
+    this.messageToHost = messageToHost;
+    this.context = context;
+  }
+};
+
+// src/common/BaseMyopSDK.ts
+var HostedComponent = class {
+  //onMessageReceived: (msg: IMyopMessage) => void;
+  constructor(id, context) {
+    this.id = id;
+    this.context = context;
+    __publicField(this, "send", (message) => {
+    });
+  }
+};
+var BaseMyopSDK = class {
+  constructor() {
+    __publicField(this, "messageToHandleAfterInit", []);
+    __publicField(this, "components", {});
+    __publicField(this, "alwaysPassEnvelopesToHost", false);
+    __publicField(this, "messageCleanupCache", {});
+  }
+  handleIncomeMessages(event) {
+    const eventContent = event.data ? event.data : event.detail;
+    if (!eventContent || !eventContent.myop) {
+      return;
+    } else {
+      let message = eventContent;
+      if (message.direction !== MessageDirection.down) {
+        return;
+      }
+      if (message.messageType === MyopMessages.DisposeMessage) {
+        if (message.destination)
+          delete this.components[message.destination];
+        return;
+      }
+      if (message.messageType === MyopMessages.InitMessage) {
+        const newComponentId = message.content.id;
+        if (this.components[newComponentId]) {
+          return;
+        }
+        this.components[newComponentId] = new HostedComponent(newComponentId);
+        this.messageToHost(new InitResponse(newComponentId));
+        return;
+      }
+      if (message.messageType === MyopMessages.EnvelopedMessage) {
+        const envelopedMessage = message;
+        const innerMessage = envelopedMessage.message;
+        message = innerMessage;
+        if (this.alwaysPassEnvelopesToHost || this.components[message.destination]) {
+          const destinationComponent = myop.hostSDK.components.find((c) => c.id === innerMessage.destination);
+          if (destinationComponent) {
+            destinationComponent.send(innerMessage);
+            return;
+          }
+          const envelopedDestinationComponent = myop.hostSDK.components.find((c) => c.id === envelopedMessage.destination);
+          if (envelopedDestinationComponent) {
+            envelopedDestinationComponent.send(innerMessage);
+            return;
+          }
+        } else {
+          return;
+        }
+      }
+      if (message.messageType) {
+        if (message.messageType === MyopMessages.CleanupMessage) {
+          const typedMessage = message;
+          const cleanup = this.messageCleanupCache[typedMessage.cleanupForMessageId];
+          const cleanupMessage = new CleanupReplayMessage(!!cleanup);
+          cleanupMessage.destination = message.destination;
+          if (!!cleanup) {
+            delete this.messageCleanupCache[typedMessage.cleanupForMessageId];
+            runExecutorCleanup(cleanup).then(() => {
+              this.messageToHost(cleanupMessage, typedMessage);
+            }).catch(() => {
+            });
+          } else {
+            this.messageToHost(cleanupMessage, typedMessage);
+          }
+          return;
+        }
+        let actionHandlerFound = false;
+        this.supportedHandlers.forEach((handler) => {
+          if (handler.messageType === message.messageType) {
+            actionHandlerFound = true;
+            const cleanup = handler.executor(message);
+            if (message.cleanable && cleanup) {
+              this.messageCleanupCache[message.id] = cleanup;
+            }
+            if (cleanup && !message.cleanable) {
+              throw new Error(`Cleanup handler generated for non-cleanable message. 
+messageType - ${message.messageType}, handler executor was - ${handler.executor}
+
+Please review the message definition object & message handler.
+To ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`);
+            }
+            if (!cleanup && message.cleanable) {
+              throw new Error(`No cleanup handler generated for a cleanable message. 
+messageType - ${message.messageType}, handler executor was - ${handler.executor}
+
+Please review the message definition object & message handler.
+To ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`);
+            }
+          }
+        });
+        if (!actionHandlerFound) {
+        }
+      } else {
+        console.log("unsupported message type");
+      }
+    }
+  }
+};
+
+// src/common/index.ts
+var SkinLoaders = {
+  "IframeLoader": "IframeLoader",
+  "WebComponentLoader": "WebComponentLoader",
+  "HTMLLoader": "HTMLLoader",
+  "MinimizedLoader": "MinimizedLoader"
+};
+var ShadowRootModeType = {
+  "open": "open",
+  "closed": "closed",
+  "none": "none",
+  "localFrame": "localFrame"
+};
+var PropConfigBehaviorTypes = {
+  "message": "message",
+  "code": "code"
+};
+var RefBehaviorType = class {
+};
+__publicField(RefBehaviorType, "code", "code");
+__publicField(RefBehaviorType, "component", "component");
+var SkinSelectorTypes = {
+  "Segmented": "Segmented",
+  "Dedicated": "Dedicated",
+  /**
+   * This Selector Type is not yet supported but will be added in a future release.
+   * Please check the documentation for updates.
+   *
+   * @type {string}
+   */
+  "Default": "Default"
+};
+var ExperienceTypes = {
+  "Segment": "Segment",
+  "Promo": "Promo",
+  "AB": "AB"
+};
+var RootRef = class {
+  constructor(container, shadowRoot) {
+    this.container = container;
+    this.shadowRoot = shadowRoot;
+    __publicField(this, "getRootDiv", () => {
+      return (this.shadowRoot || this.container).querySelector("div");
+    });
+    __publicField(this, "getRoot", () => {
+      return this.shadowRoot || this.container;
+    });
+  }
+};
+
+// src/common/utils/serialization.ts
+var isPrimitive = (value) => {
+  return value !== Object(value);
+};
+var isFunction = (value) => {
+  return typeof value === "function";
+};
+var containsPrimitivesOnly = (obj) => {
+  if (isPrimitive(obj)) {
+    return true;
+  }
+  if (isFunction(obj)) {
+    return false;
+  }
+  if (Object.getPrototypeOf(obj)) {
+    return false;
+  }
+  for (const key in obj) {
+    const value = obj[key];
+    if (typeof value === "object") {
+      if (!containsPrimitivesOnly(value)) {
+        return false;
+      }
+    } else if (isPrimitive(value)) {
+      continue;
+    } else {
+      return false;
+    }
+  }
+  return true;
+};
+var makeSerializable = (obj, skeleton = {}, includeFalsyKeys = true, seen3 = /* @__PURE__ */ new WeakMap()) => {
+  if (isPrimitive(obj)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    if (seen3.has(obj)) {
+      return seen3.get(obj);
+    }
+    const serializableArray = [];
+    seen3.set(obj, serializableArray);
+    for (let index = 0; index < obj.length; index++) {
+      const element = obj[index];
+      serializableArray[index] = makeSerializable(element, skeleton, includeFalsyKeys, seen3);
+    }
+    return serializableArray;
+  }
+  if (obj !== null && typeof obj === "object") {
+    if (seen3.has(obj)) {
+      return seen3.get(obj);
+    }
+    const serializableObject = {};
+    seen3.set(obj, serializableObject);
+    for (const key in obj) {
+      const keyInSkeleton = typeof skeleton == "boolean" ? skeleton : skeleton[key];
+      if (keyInSkeleton) {
+        if (keyInSkeleton === true) {
+          if (includeFalsyKeys ? obj[key] !== void 0 : obj[key]) {
+            serializableObject[key] = makeSerializable(obj[key], true, includeFalsyKeys, seen3);
+          }
+        } else if (typeof keyInSkeleton === "object") {
+          serializableObject[key] = makeSerializable(obj[key], keyInSkeleton, includeFalsyKeys, seen3);
+        }
+      }
+    }
+    return serializableObject;
+  }
+  return {};
+};
+
+// src/host/logMessages.ts
+var Errors = {
+  notSerializableRefCall: (prop, arg) => {
+    throw new Error(`
+The input provided to '${prop.toString()}' is not serializable. Serialization is required to ensure that the data can be safely transferred to the skin implementation. 
+The following types of data are considered non-serializable and cannot be processed:
+
+- Functions
+- DOM elements
+- Class instances
+- Circular references
+- Symbols
+- BigInt values
+
+In the following execution we detected :
+~~~~~~~~
+${arg} 
+~~~~~~~~
+as not serializable.
+
+To resolve this issue, please ensure that all inputs passed to '${prop.toString()}' are in a serializable format.
+This typically includes primitive types (strings, numbers, booleans), arrays, and plain objects. 
+If you need to include complex data types, consider converting them to a serializable structure before passing them to the function.
+Or use Myop message that support it: CustomRefMessage, AddEventListenerMessage or ExecuteScriptMessage.
+
+Suggested Fix:
+1. Remove or replace non-serializable values from your input.
+2. If using objects, ensure they do not contain any functions or circular references.
+3. Convert any class instances to plain objects or JSON-compatible formats.
+4. Use dedicated Myop message.
+
+For more details on serialization and Myop message examples, refer to https://docs.myop.dev.
+
+`);
+  }
+};
+
+// src/host/components/myopRefComponent.ts
+var MyopRefComponent = class extends BaseMyopComponent {
+  constructor(componentDefinition, parent, options) {
+    super(componentDefinition, parent.container, options);
+    this.componentDefinition = componentDefinition;
+    this.parent = parent;
+    __publicField(this, "send", (message) => {
+      const handler = message.handler;
+      const cleanupHandler = super.send(message);
+      this.parent.send(new EnvelopedMessage(this.id, message));
+      message.handler = handler;
+      return cleanupHandler;
+    });
+    __publicField(this, "dispose", () => {
+      if (this.isInitiated)
+        this.send(new ExecuteComponentMethod("dispose"));
+      super.dispose();
+    });
+  }
+  hide() {
+    this.send(new ExecuteComponentMethod("hide"));
+  }
+  show() {
+    this.send(new ExecuteComponentMethod("show"));
+  }
+  inspect() {
+    return this.send(new ExecuteComponentMethod("inspect"));
+  }
+  setHeightBasedOnDocumentElement() {
+    this.send(new ExecuteComponentMethod("setHeightBasedOnDocumentElement"));
+  }
+  setHeightBasedOnScrollHeight() {
+    this.send(new ExecuteComponentMethod("setHeightBasedOnScrollHeight"));
+  }
+  onMessageReceived(incomeMessage) {
+    return super.onMessageReceived(incomeMessage);
+  }
+};
+
+// src/host/componentCore.ts
+var createDebugTitle = (text, top, componentDefinitionConfig) => {
+  const titleEl = document.createElement("a");
+  titleEl.textContent = text;
+  titleEl.style.position = "relative";
+  titleEl.style.padding = "0 5px";
+  titleEl.style.fontSize = "14px";
+  titleEl.style["top"] = "0";
+  titleEl.style.top = `${top}px`;
+  titleEl.style.transform = "translateX(-50%)";
+  titleEl.target = "_blank";
+  titleEl.href = `https://dashboard.myop.dev/dashboard/component/${componentDefinitionConfig.id}`;
+  return titleEl;
+};
+var setDebugStyle = (id, type, top, container, componentElement, componentDefinitionConfig) => {
+  const topText = createDebugTitle(`${componentDefinitionConfig.name} : ${type}`, top, componentDefinitionConfig);
+  container.insertBefore(topText, componentElement);
+  componentElement.style.border = "1px solid #007BFF";
+  componentElement.style.display = "block";
+  return () => {
+    componentElement.style.border = "unset";
+    container.removeChild(topText);
+  };
+};
+var reportError = (propConfig, propName, component) => {
+  if (!propConfig) {
+    console.error(
+      // throw new Error(
+      `Error: Undefined Prop
+
+It looks like you've tried to use a prop that hasn't been defined.
+Please check the prop name for any typos or ensure that it is properly defined in the component's prop list.
+
+Prop Name: ${propName}
+Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}
+
+For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`
+    );
+    return true;
+  }
+  return false;
+};
+var reportUnsupported = (propConfig, propName, component) => {
+  console.error(
+    `Error: Code Prop Not Supported
+
+Currently, code props are only supported in local frame components.
+\u26A0\uFE0F This is a work in progress feature \u2014 code props will be supported in upcoming versions.
+
+In the meantime, you can use message props.
+
+Prop Name: ${propName}
+Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}
+
+For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`
+  );
+};
+var connectProps = (component, propsConfig, selectedSkin) => {
+  const propsMap = propsConfig.reduce((previousValue, currentValue) => {
+    return __spreadProps(__spreadValues({}, previousValue), {
+      [currentValue.name]: __spreadValues({}, currentValue)
+    });
+  }, {});
+  const propsHandler = {
+    get: (_, prop) => {
+      const propConfig = propsMap[prop];
+      if (reportError(propConfig, prop, component)) {
+        return false;
+      }
+      if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {
+        if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {
+          const typedLoader = selectedSkin.loader;
+          if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {
+            const typedPropBehavior = propConfig.behavior;
+            return component.element.contentWindow[typedPropBehavior.remap || prop];
+          }
+        }
+        reportUnsupported(propConfig, prop, component);
+        return false;
+      }
+      if (propConfig.mode === "output") {
+        return new Promise((resolve) => {
+          const messageParams = [];
+          if (propConfig.behavior.ref) {
+            messageParams.push(Ref.create(propConfig.behavior.ref));
+          }
+          messageParams.push((data) => {
+            resolve(data);
+          });
+          if (propConfig.behavior.params) {
+            messageParams.push(...propConfig.behavior.params);
+          }
+          const messageCtor = messages_exports[propConfig.behavior.message];
+          component.send(new messageCtor(...messageParams));
+        });
+      }
+      return null;
+    },
+    set: (_, prop, value) => {
+      const propConfig = propsMap[prop];
+      if (reportError(propConfig, prop, component)) {
+        return false;
+      }
+      if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {
+        if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {
+          const typedLoader = selectedSkin.loader;
+          if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {
+            const typedPropBehavior = propConfig.behavior;
+            component.element.contentWindow[typedPropBehavior.remap || prop] = value;
+            return true;
+          }
+        }
+        reportUnsupported(propConfig, prop, component);
+        return false;
+      } else {
+        if (propConfig.mode === "input") {
+          if (propConfig.behavior.type === "message") {
+            const messageParams = [];
+            if (propConfig.behavior.ref) {
+              messageParams.push(Ref.create(propConfig.behavior.ref));
+            }
+            messageParams.push(value);
+            if (propConfig.behavior.params) {
+              messageParams.push(...propConfig.behavior.params);
+            }
+            const messageCtor = messages_exports[propConfig.behavior.message];
+            component.send(new messageCtor(...messageParams));
+            return true;
+          } else {
+            throw new Error(
+              `Error: Unsupported Behavior
+
+The 'behavior' field provided is not supported.
+Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}
+
+Prop Name: ${prop}
+Behavior Field: ${propConfig.behavior.type}
+
+Check the documentation for valid behavior options.`
+            );
+            return false;
+          }
+        }
+      }
+      return false;
+    }
+  };
+  component.props = {};
+  component.props = new Proxy(component.props, propsHandler);
+  return component;
+};
+var createRefProxy = (target, component) => {
+  return new Proxy(target, {
+    get(target2, prop) {
+      if (target2[prop]) {
+        return target2[prop];
+      }
+      const getterFunction = (...args) => {
+        return new Promise((resolve) => {
+          args.forEach((arg) => {
+            if (!containsPrimitivesOnly(arg)) {
+              Errors.notSerializableRefCall(prop, arg);
+            }
+          });
+          component.send(new CustomRefMessage(
+            ({ ref, propName, functionArgs, makeSerializable: makeSerializable2 }) => {
+              if (ref) {
+                const value = ref[propName];
+                if (typeof value === "function") {
+                  return makeSerializable2(ref[propName](...functionArgs), true);
+                } else {
+                  return makeSerializable2(value, true);
+                }
+              }
+              return null;
+            },
+            {
+              //TODO : turn it to config
+              elementId: target2.refConfig.selector,
+              propName: prop,
+              functionArgs: args
+            },
+            (msg) => {
+              resolve(msg.content);
+            }
+          ));
+        });
+      };
+      return getterFunction;
+    },
+    set(target2, prop, value) {
+      component.send(new CustomRefMessage(
+        ({ ref, propName, propValue }) => {
+          if (ref)
+            ref[propName] = propValue;
+        },
+        {
+          //TODO : fix that
+          elementId: target2.refConfig.selector,
+          propValue: value,
+          propName: prop
+        },
+        (msg) => {
+        }
+      ));
+      return true;
+    }
+  });
+};
+var createRefComponent = (ref, componentConfig, components, options) => __async(void 0, null, function* () {
+  const component = ref.component;
+  if (!component)
+    throw new Error("cant createRefComponent with detached ref");
+  return new Promise((resolve, reject) => __async(void 0, null, function* () {
+    const refComponent = new MyopRefComponent(componentConfig.type, component, options);
+    components.push(refComponent);
+    yield component.initiated();
+    const timeout = setTimeout(() => {
+      reject("timeout");
+    }, 5e3);
+    component.send(new CreateRefComponentMessage(
+      ref.refConfig,
+      componentConfig,
+      __spreadProps(__spreadValues({}, options ? options : {}), {
+        id: refComponent.id,
+        _hasParent: true
+      }),
+      (message) => __async(void 0, null, function* () {
+        clearTimeout(timeout);
+        if (message.failed) {
+          reject("CreateRefComponentMessage failed");
+          return;
+        }
+        const implementationComponent = components.find((c) => c.id == refComponent.id);
+        if (implementationComponent !== refComponent) {
+          component.refs[ref.refConfig.name] = implementationComponent;
+          resolve(implementationComponent);
+          return;
+        } else {
+          refComponent.setInitiated();
+          component.refs[ref.refConfig.name] = refComponent;
+        }
+        message.nestedRefs.forEach((nestedRefConfig) => {
+          const nestedComponentDefinition = componentConfig.instance.resolvedNestedComponents.find((c) => c.type.id === nestedRefConfig.componentDefinitionId).type;
+          const nestedComponent = new MyopRefComponent(nestedComponentDefinition, refComponent);
+          nestedComponent.setInitiated();
+          refComponent.refs[nestedRefConfig.refName] = nestedComponent;
+          components.push(nestedComponent);
+        });
+        try {
+          yield connectRefs(refComponent, componentConfig, components, true);
+          if (component.setHeightBasedOnScrollHeight)
+            component.setHeightBasedOnScrollHeight();
+          resolve(refComponent);
+        } catch (e) {
+          reject(e);
+        }
+      })
+    ));
+  }));
+});
+var connectRefs = (component, componentConfig, components, withoutRefComponents = false) => __async(void 0, null, function* () {
+  if (!component.refs)
+    component.refs = {};
+  const waitFor = Object.values(component.componentDefinition.refs).map((ref) => {
+    return new Promise((resolve, reject) => __async(void 0, null, function* () {
+      var _a;
+      if (ref.behavior.type == RefBehaviorType.component) {
+        if (withoutRefComponents) {
+          resolve();
+          return;
+        }
+        let refComponentId = ref.behavior.componentId;
+        if (!refComponentId)
+          refComponentId = ref.behavior.instance.componentId;
+        const nestedComponentConfig = (_a = componentConfig.instance.resolvedNestedComponents) == null ? void 0 : _a.find((nestedComponent) => nestedComponent.type.id === refComponentId);
+        if (!nestedComponentConfig) {
+          throw new Error("componentConfig provided without nestedComponentConfig check the config object");
+          return;
+        }
+        const _ref = Ref.create("", ref, component);
+        try {
+          const nestedComponent = yield createRefComponent(_ref, nestedComponentConfig, components);
+          component.refs[ref.name] = nestedComponent;
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      } else {
+        try {
+          const __nonProxied = Ref.create("", ref, component);
+          component.refs[ref.name] = createRefProxy(__nonProxied, component);
+          resolve();
+        } catch (e) {
+        }
+      }
+    }));
+  });
+  try {
+    yield Promise.all(waitFor);
+  } catch (e) {
+    throw e;
+  }
+});
+
+// src/host/components/myopIframeComponent.ts
+var MyopIframeComponent = class extends BaseMyopComponent {
+  constructor(componentConfig, skin, container, IframeElement, options) {
+    super(componentConfig, container, options);
+    this.componentConfig = componentConfig;
+    this.container = container;
+    this.IframeElement = IframeElement;
+    __publicField(this, "cleanupInspect");
+    __publicField(this, "setHeightBasedOnDocumentElement", () => {
+      const cleanupHandler = this.send(new ExecuteScriptMessage(() => {
+        return window.document.documentElement.scrollHeight;
+      }, (ret) => {
+        this.IframeElement.style.height = `${ret.content}px`;
+        cleanupHandler();
+      }));
+    });
+    __publicField(this, "observeSizeBasedOnDocumentElement", () => {
+      const cleanupHandler = this.send(new ExecuteScriptMessage(({ send }) => {
+        const { height, width } = document.documentElement.getBoundingClientRect();
+        const observer = new ResizeObserver(() => {
+          const { height: height2, width: width2 } = document.documentElement.getBoundingClientRect();
+          send({ height: height2, width: width2 });
+        });
+        observer.observe(document.documentElement);
+        observer.observe(document.body);
+        return { height, width };
+      }, (ret) => {
+        this.IframeElement.style.width = `${ret.content.width}px`;
+        this.IframeElement.style.height = `${ret.content.height}px`;
+      }));
+      return cleanupHandler;
+    });
+    __publicField(this, "setSizeBasedOnDocumentElement", () => {
+      const cleanupHandler = this.send(new ExecuteScriptMessage(() => {
+        const { height, width } = document.documentElement.getBoundingClientRect();
+        return { height, width };
+      }, (ret) => {
+        this.IframeElement.style.width = `${ret.content.width}px`;
+        this.IframeElement.style.height = `${ret.content.height}px`;
+        cleanupHandler();
+      }));
+    });
+    __publicField(this, "setHeightBasedOnScrollHeight", () => {
+      const cleanupHandler = this.send(new ExecuteScriptMessage(() => {
+        const noOp = () => {
+          return 0;
+        };
+        let x = noOp();
+        x++;
+        x--;
+        return Math.max(
+          Math.max(
+            window.document.body.clientHeight,
+            window.document.body.scrollHeight
+          ),
+          window.document.body.offsetHeight
+        ) + x + "px";
+      }, (ret) => {
+        this.IframeElement.style.height = ret.content;
+        cleanupHandler();
+      }));
+    });
+    __publicField(this, "send", (message) => {
+      var _a, _b;
+      let message_ = __spreadValues({}, message);
+      if (message_.messageType === MyopMessages.ExecuteComponentMethod) {
+        const typedMessage = message_;
+        this[typedMessage.method]();
+        return () => {
+        };
+      }
+      message_.direction = MessageDirection.down;
+      const cleanupHandler = super.send(message_);
+      (_b = (_a = this.IframeElement) == null ? void 0 : _a.contentWindow) == null ? void 0 : _b.postMessage(message_, "*");
+      return cleanupHandler;
+    });
+    __publicField(this, "dispose", () => {
+      if (this.cleanupInspect)
+        this.cleanupInspect();
+      super.dispose();
+      this.IframeElement.parentNode.removeChild(this.IframeElement);
+    });
+    if (skin.loader.autoHeight) {
+      this.initiated().then(() => {
+        this.setHeightBasedOnScrollHeight();
+      });
+    }
+    this.element = this.IframeElement;
+  }
+  inspect() {
+    if (this.cleanupInspect) {
+      return this.cleanupInspect;
+    }
+    this.cleanupInspect = setDebugStyle(this.id, "MyopIframeComponent", 10, this.container, this.IframeElement, this.componentDefinition);
+    return () => {
+      this.cleanupInspect();
+      this.cleanupInspect = void 0;
+    };
+  }
+  hide() {
+    this.IframeElement.style.opacity = "0";
+    this.IframeElement.style.position = "absolute";
+    this.IframeElement.style.pointerEvents = "none";
+    this.IframeElement.style.visibility = "hidden";
+  }
+  show() {
+    this.IframeElement.style.opacity = "1";
+    this.IframeElement.style.position = "unset";
+    this.IframeElement.style.pointerEvents = "all";
+    this.IframeElement.style.visibility = "visible";
+  }
+  onMessageReceived(incomeMessage) {
+    if (incomeMessage.messageType === MyopMessages.In.MutationObserverMessage || incomeMessage.messageType === MyopMessages.In.ResizeObserverMessage) {
+      this.setHeightBasedOnScrollHeight();
+      return true;
+    }
+    return super.onMessageReceived(incomeMessage);
+  }
+};
+
+// src/host/loaders/IMyopLoader.ts
+var BaseMyopLoader = class {
+  constructor() {
+    __publicField(this, "appendChild", (container, element, options) => {
+      var _a;
+      if (options == null ? void 0 : options.relative) {
+        if (options.relative.direction === "before") {
+          return container.insertBefore(element, options.relative.child);
+        }
+        if (options.relative.direction === "after") {
+          const nextSibling = (_a = options.relative.child) == null ? void 0 : _a.nextSibling;
+          return container.insertBefore(element, nextSibling ? nextSibling : null);
+        }
+      } else {
+        return container.appendChild(element);
+      }
+    });
+  }
+};
+
+// src/host/loaders/iframeLoader.ts
+var addQueryParam = (url, param, value) => {
+  const urlObj = new URL(url);
+  urlObj.searchParams.append(param, value);
+  return urlObj.toString();
+};
+var MyopIframeLoader = class extends BaseMyopLoader {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "type", SkinLoaders.IframeLoader);
+    // @ts-ignore
+    __publicField(this, "load", (componentDefinition, skin, container, options) => __async(this, null, function* () {
+      let IframeElement;
+      const typedLoaderConfig = skin.loader;
+      if ((container == null ? void 0 : container.nodeName) === "IFRAME") {
+        console.log("needs to load into an exsisting Iframe...", typedLoaderConfig.url, container);
+        IframeElement = container;
+        IframeElement.src = typedLoaderConfig.url;
+      } else {
+        const uniqId = uuidv4();
+        const domId = `myop-comp-${uniqId}`;
+        IframeElement = document.createElement("iframe");
+        if (!container.querySelector('[id^="myop-comp-"]'))
+          container.innerHTML = "";
+        if (options == null ? void 0 : options.hidden) {
+          IframeElement.style.visibility = "hidden";
+        }
+        IframeElement = this.appendChild(container, IframeElement, options);
+        let url2load = skin.loader.url;
+        if (options == null ? void 0 : options._hasParent)
+          url2load = addQueryParam(url2load, "_myop-comp", uniqId);
+        let elementAttributesString = "";
+        if (options == null ? void 0 : options.elementAttributes)
+          elementAttributesString = Object.entries(options == null ? void 0 : options.elementAttributes).map(([key, value]) => {
+            if (value === "" || value === null || value === void 0) {
+              return key;
+            }
+            return `${key}="${String(value)}"`;
+          }).join(" ");
+        IframeElement.outerHTML = `<iframe 
+               id="${domId}"
+               style="
+                   padding: 0;
+                   margin: 0;
+                   height: ${typedLoaderConfig.autoHeight || !typedLoaderConfig.height ? "" : typedLoaderConfig.height};    
+                   width : 100%;
+                   overflow: hidden;
+                   border: none;
+                   opacity: ${(options == null ? void 0 : options.hidden) ? "0" : "1"};
+                   position: ${(options == null ? void 0 : options.hidden) ? "absolute" : "static"};
+                   pointer-events: ${(options == null ? void 0 : options.hidden) ? "none" : "all"};
+               "
+            src="${url2load}"
+            ${elementAttributesString}
+            ></iframe>`;
+        IframeElement = container.querySelector(`#${domId}`);
+      }
+      return new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);
+    }));
+  }
+};
+
+// src/webcomponent/consts.ts
+var myopWebcomponentConsts = {
+  webcomponent_message_key: "myop_webcomponent_message"
+};
+
+// src/host/components/myopWebcomponent.ts
+var MyopWebComponent = class extends BaseMyopComponent {
+  constructor(componentDefinition, skin, container, customElement, options) {
+    super(componentDefinition, container, options);
+    this.container = container;
+    this.customElement = customElement;
+    __publicField(this, "cleanupInspect", () => {
+    });
+    __publicField(this, "send", (message) => {
+      let message_ = __spreadValues({}, message);
+      const cleanupHandler = super.send(message_);
+      const msg = new CustomEvent(myopWebcomponentConsts.webcomponent_message_key, {
+        // @ts-ignore
+        detail: message_
+        // bubbles: true,
+        // cancelable: false,
+        // composed: true
+      });
+      try {
+        this.customElement.dispatchEvent(msg);
+      } catch (e) {
+        console.log("error while trying to dispatchEvent", e);
+      }
+      return cleanupHandler;
+    });
+    __publicField(this, "dispose", () => {
+      var _a;
+      super.dispose();
+      (_a = this.customElement.parentNode) == null ? void 0 : _a.removeChild(this.customElement);
+    });
+    this.element = customElement;
+  }
+  inspect() {
+    this.cleanupInspect = setDebugStyle(this.id, "MyopWebComponent", 0, this.container, this.customElement, this.componentDefinition);
+    return this.cleanupInspect;
+  }
+  hide() {
+    this.customElement.style.opacity = "0";
+    this.customElement.style.position = "absolute";
+    this.customElement.style.pointerEvents = "none";
+    this.customElement.style.visibility = "hidden";
+    this.customElement.style.height = "0";
+    this.customElement.style.width = "0";
+  }
+  show() {
+    this.customElement.style.opacity = "1";
+    this.customElement.style.position = "unset";
+    this.customElement.style.pointerEvents = "all";
+    this.customElement.style.visibility = "visible";
+    this.customElement.style.height = "";
+    this.customElement.style.width = "";
+  }
+};
+
+// src/host/loaders/webcomponentLoader.ts
+var seen = {};
+var WebcomponentLoader = class extends BaseMyopLoader {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "type", SkinLoaders.WebComponentLoader);
+    __publicField(this, "load", (componentDefinition, skin, container, options) => __async(this, null, function* () {
+      const loaderConfig = skin.loader;
+      if (!seen[loaderConfig.url]) {
+        seen[loaderConfig.url] = new Promise((resolve, reject) => {
+          const webComponentLoadUrl = loaderConfig.url;
+          const script = document.createElement("script");
+          script.type = "module";
+          script.src = webComponentLoadUrl;
+          script.onload = () => {
+            resolve();
+          };
+          script.onerror = () => {
+            reject();
+          };
+          document.head.appendChild(script);
+        });
+      } else {
+        console.log("Module alreday loaded or in loading process");
+      }
+      yield seen[loaderConfig.url];
+      yield wait(1);
+      let domId = `myop-comp-${uuidv4()}`;
+      const element = document.createElement(loaderConfig.tag);
+      if (!container.querySelector('[id^="myop-comp-"]'))
+        container.innerHTML = "";
+      element.id = domId;
+      if (options == null ? void 0 : options.hidden) {
+        element.style.opacity = "0";
+        element.style.position = "absolute";
+        element.style.height = "0";
+        element.style.width = "0";
+        element.style.pointerEvents = "none";
+        element.style.visibility = "hidden";
+      }
+      if (options == null ? void 0 : options._environment) {
+        element._myopEnvironment = options == null ? void 0 : options._environment;
+      }
+      this.appendChild(container, element, options);
+      return new MyopWebComponent(componentDefinition, skin, container, element, options);
+    }));
+  }
+};
+
+// version:myop-sdk-version
+var myop_sdk_version_default = "0.1.47";
+
+// src/webcomponent/messageHandlers/BaseWebComponentMessageHandler.ts
+var BaseWebComponentMessageHandler = class extends BaseContextMessageHandler {
+  constructor(messageToHost, context) {
+    super(messageToHost);
+    this.context = context;
+    __publicField(this, "executor", (event) => {
+      if (event.destination) {
+        const destination = event.destination;
+        if (this.context[destination].context) {
+          const _messageToHost = (message, replayTo) => {
+            this.messageToHost(__spreadProps(__spreadValues({}, message), {
+              source: event.destination ? event.destination : event.source,
+              destination: event.source ? event.source : event.destination
+            }), replayTo);
+          };
+          return this.innerExecutor(event, this.context[destination].context, _messageToHost);
+        } else {
+          debugger;
+        }
+      } else {
+        debugger;
+      }
+    });
+  }
+};
+
+// src/consts.ts
+var myopAttributes = {
+  id: "myop-id"
+};
+
+// src/common/messageHandlers/helpers.ts
+var getElementsByRef = (ref, el) => {
+  return el.querySelectorAll(`[${myopAttributes.id}='${ref.refConfig.selector}']`);
+};
+
+// src/webcomponent/messageHandlers/bindOnClickHandler.ts
+var BindOnClickHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.BindClickMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      const cleanupTasks = [];
+      items.forEach((item) => {
+        const handler = () => {
+          messageToHost(new ClickReplayMessage(event.handlerUniqueId));
+        };
+        item.addEventListener("click", handler);
+        cleanupTasks.push(() => {
+          item.removeEventListener("click", handler);
+        });
+      });
+      return () => {
+        cleanupTasks.forEach((task) => task());
+      };
+    });
+  }
+};
+
+// src/webcomponent/messageHandlers/changeTextHandler.ts
+var ChangeTextHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.ChangeTextMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        item.textContent = event.content;
+      });
+    });
+  }
+};
+
+// src/webcomponent/shadowRootRef.ts
+var ShadowRootRef = class extends RootRef {
+  constructor(container, shadowRoot) {
+    super(container, shadowRoot);
+    this.container = container;
+    this.shadowRoot = shadowRoot;
+  }
+};
+
+// src/webcomponent/messageHandlers/DetectMyopRefsMessageHandler.ts
+var DetectMyopRefsMessageHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const allMyopItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}]`);
+      let myopRefs = [];
+      allMyopItems.forEach((item) => {
+        const myopId = item.getAttribute(myopAttributes.id);
+        if (myopId) {
+          myopRefs.push(new MyopElementRef(myopId, item.tagName, item.getBoundingClientRect(), item.offsetTop, item.offsetLeft));
+        }
+      });
+      this.messageToHost(new DetectedMyopRefsMessage(event.handlerUniqueId, myopRefs));
+    });
+    __publicField(this, "messageType", MyopMessages.DetectMyopRefsMessage);
+  }
+};
+
+// src/webcomponent/messageHandlers/setAttributeHandler.ts
+var setAttributeHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.SetAttributeMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        item.setAttribute(event.name, event.value);
+      });
+    });
+  }
+};
+
+// src/webcomponent/messageHandlers/addEventListenerHandler.ts
+var AddEventListenerHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.AddEventListenerMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      const cleanupTasks = [];
+      items.forEach((item) => {
+        const handler = (e) => {
+          messageToHost(new EventListenerCallbackMessage(event.handlerUniqueId, makeSerializable(e, event.serializableSkeleton)));
+        };
+        item.addEventListener(event.type, handler);
+        cleanupTasks.push(() => {
+          item.removeEventListener(event.type, handler);
+        });
+      });
+      return () => {
+        cleanupTasks.forEach((task) => task());
+      };
+    });
+  }
+};
+
+// src/webcomponent/messageHandlers/CreateRefComponentMessageHandler.ts
+var CreateRefComponentMessageHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.CreateRefComponentMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const createRef = () => __async(this, null, function* () {
+        const allItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}='${event.refConfig.selector}']`);
+        if (allItems.length === 1) {
+          const hostSDK2 = HostSDK.Instance();
+          const refComponent = hostSDK2.components.find((c) => c.id === event.options.id);
+          if (refComponent) {
+            refComponent.dispose();
+          } else {
+          }
+          const index = hostSDK2.components.indexOf(refComponent);
+          if (index !== -1) {
+            hostSDK2.components.splice(index, 1);
+          } else {
+          }
+          const implementationComponent = yield hostSDK2.loadComponent(
+            event.nestedComponentConfig,
+            allItems.item(0),
+            event.options
+          );
+          const nestedRefConfig = [];
+          Object.keys(implementationComponent.refs).forEach((refName) => {
+            let ref = implementationComponent.refs[refName];
+            ref = ref.__nonProxied || ref;
+            if (ref.componentDefinition) {
+              nestedRefConfig.push({
+                refName,
+                componentDefinitionId: ref.componentDefinition.id
+              });
+            }
+          });
+          messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, nestedRefConfig));
+        } else {
+          console.error("CreateRefComponentMessageHandler - DOM element not found");
+          this.messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, [], true));
+          debugger;
+        }
+      });
+      createRef().then();
+    });
+  }
+};
+
+// src/common/messageHandlers/executeScriptHandler.ts
+var ExecuteScriptHandlerExecutor = (event, replier, rootRef) => {
+  const __scriptInputs = event.scriptInputs ? event.scriptInputs : {};
+  __scriptInputs.makeSerializable = makeSerializable;
+  __scriptInputs.send = replier;
+  __scriptInputs.rootRef = rootRef;
+  __scriptInputs.__scriptInputs = __scriptInputs;
+  const dynamicFunction = new Function(`return (${event.script})(...arguments)`);
+  const ret = dynamicFunction(__scriptInputs);
+  replier(ret);
+};
+
+// src/webcomponent/messageHandlers/executeScriptHandler.ts
+var ExecuteScriptHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.ExecuteScriptMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const replier = (data) => {
+        messageToHost(new ExecuteScriptReplyMessage(event.handlerUniqueId, data));
+      };
+      ExecuteScriptHandlerExecutor(event, replier, shadowRootRef);
+    });
+  }
+};
+
+// src/webcomponent/messageHandlers/GetElementValueHandler.ts
+var getInputValue = (element) => {
+  if (!element) return null;
+  if (element.tagName === "FORM") {
+    const formData = new FormData(element);
+    const dataObject = {
+      formData: {},
+      unmappedData: []
+    };
+    const elements = element.querySelectorAll("input, select, textarea");
+    let autoNameIndexer = -1;
+    elements.forEach((element2) => {
+      if (typeof element2.value === "string") {
+        const myopId = element2.getAttribute(myopAttributes.id);
+        let key = element2.getAttribute("name");
+        const nodeData = {
+          id: element2.id,
+          name: key,
+          value: getInputValue(element2),
+          required: element2.required,
+          validity: makeSerializable(element2.validity, true),
+          myopId
+        };
+        if (!key) {
+          dataObject.unmappedData.push(nodeData);
+        } else {
+          if (dataObject.formData[key]) {
+            if (dataObject.formData[key].value) {
+              dataObject.unmappedData.push(nodeData);
+            } else {
+              dataObject.unmappedData.push(dataObject.formData[key]);
+              dataObject.formData[key] = nodeData;
+            }
+          } else {
+            dataObject.formData[key] = nodeData;
+          }
+        }
+      }
+    });
+    return dataObject;
+  }
+  if (element.type === "checkbox" || element.type === "radio") {
+    return element.checked ? element.value : null;
+  }
+  if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+    return element.value;
+  }
+  if (element.tagName === "SELECT") {
+    return element.value;
+  }
+  if (element.isContentEditable) {
+    return element.innerText || element.textContent;
+  }
+  return null;
+};
+var GetElementValueHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.GetElementValueMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        messageToHost(new ElementValueReplayMessage(getInputValue(item)), event);
+      });
+    });
+  }
+};
+
+// src/webcomponent/messageHandlers/setInnerHtmlHandler.ts
+var SetInnerHtmlHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.SetInnerHtml);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        item.innerHTML = event.content;
+      });
+    });
+  }
+};
+
+// src/webcomponent/WebComponentSDK.ts
+var WebComponentSDK = class extends BaseMyopSDK {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "alwaysPassEnvelopesToHost", true);
+    //when new web component created.
+    __publicField(this, "connectedCallback", (container, shadow) => {
+      container.addEventListener(myopWebcomponentConsts.webcomponent_message_key, (e) => {
+        const eventContent = e.data ? e.data : e.detail;
+        if (!eventContent || !eventContent.myop) {
+          debugger;
+          throw new Error("recvied webcomponent_message with wrong type");
+        } else {
+          const message = eventContent;
+          this.handleIncomeMessages(e);
+          if (message.messageType === MyopMessages.InitMessage) {
+            const newComponentId = message.content.id;
+            this.components[newComponentId].context = new ShadowRootRef(container, shadow);
+          }
+        }
+      });
+      setTimeout(() => {
+        this.messageToHost(new InitRequest());
+      }, 1);
+    });
+    __publicField(this, "messageToHost", (message, replayTo) => {
+      message.direction = MessageDirection.up;
+      if (!message.replayToHandler && (replayTo == null ? void 0 : replayTo.handlerUniqueId))
+        message.replayToHandler = replayTo.handlerUniqueId;
+      window.myop.hostSDK.send(message);
+    });
+    __publicField(this, "supportedHandlers", [
+      new ChangeTextHandler(this.messageToHost, this.components),
+      new SetInnerHtmlHandler(this.messageToHost, this.components),
+      new BindOnClickHandler(this.messageToHost, this.components),
+      new DetectMyopRefsMessageHandler(this.messageToHost, this.components),
+      new setAttributeHandler(this.messageToHost, this.components),
+      new AddEventListenerHandler(this.messageToHost, this.components),
+      new ExecuteScriptHandler(this.messageToHost, this.components),
+      new GetElementValueHandler(this.messageToHost, this.components),
+      //
+      new CreateRefComponentMessageHandler(this.messageToHost, this.components)
+    ]);
+    __publicField(this, "init", () => {
+    });
+  }
+};
+defineDynamicImport("WebComponentSDK", WebComponentSDK);
+
+// src/host/loaders/HTMLComponentLoader.ts
+var seen2 = [];
+var sdk;
+var getInitiatedSdk = () => __async(void 0, null, function* () {
+  if (!sdk) {
+    sdk = new WebComponentSDK();
+    sdk.init();
+  }
+  return sdk;
+});
+function createHTMLElementConstructor(htmlString, ShadowRootMode) {
+  return class extends HTMLElement {
+    connectedCallback() {
+      const mode = ShadowRootMode === ShadowRootModeType.open ? "open" : "closed";
+      const shadow = this.attachShadow({ mode });
+      getInitiatedSdk().then((sdk2) => {
+        sdk2.connectedCallback(this, shadow);
+        shadow.innerHTML = htmlString;
+      });
+    }
+  };
+}
+var createCustomWebComponent = (componentName, html, ShadowRootMode) => {
+  customElements.define(componentName, createHTMLElementConstructor(html, ShadowRootMode));
+  console.log(`define('${componentName}') was called, web component ready to use`);
+};
+var toWebComponentName = (str) => {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/(\d+)/g, "-$1").toLowerCase();
+};
+var toCustomElementName = (name) => {
+  name = toWebComponentName(name);
+  return name.replace(/_/g, "-");
+};
+var HTMLComponentLoader = class extends BaseMyopLoader {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "type", SkinLoaders.HTMLLoader);
+    __publicField(this, "load", (componentDefinition, skin, container, options) => __async(this, null, function* () {
+      const loaderConfig = skin.loader;
+      let domId = `myop-comp-${uuidv4()}`;
+      let element;
+      if (loaderConfig.shadowRootMode === ShadowRootModeType.localFrame) {
+        const uniqId = uuidv4();
+        const domId2 = `myop-comp-${uniqId}`;
+        let IframeElement = document.createElement("iframe");
+        if (!container.querySelector('[id^="myop-comp-"]'))
+          container.innerHTML = "";
+        if (options == null ? void 0 : options.hidden) {
+          IframeElement.style.visibility = "hidden";
+        }
+        IframeElement = this.appendChild(container, IframeElement, options);
+        IframeElement.id = domId2;
+        IframeElement.setAttribute("style", `
+                   padding: 0;
+                   margin: 0;
+                   overflow: hidden;
+                   border: none;
+                   opacity: ${(options == null ? void 0 : options.hidden) ? "0" : "1"};
+                   width: 100%;
+                   height: 100%;
+                   position: ${(options == null ? void 0 : options.hidden) ? "absolute" : "static"};
+                   pointer-events: ${(options == null ? void 0 : options.hidden) ? "none" : "all"};
+               `);
+        container.appendChild(IframeElement);
+        const doc = IframeElement.contentDocument || IframeElement.contentWindow.document;
+        doc.open();
+        let HTML2Render = loaderConfig.HTML;
+        if (options == null ? void 0 : options._inspection) {
+          const parser = new DOMParser();
+          const _doc = parser.parseFromString(loaderConfig.HTML, "text/html");
+          const myop_preview_script = _doc.getElementById("myop_preview");
+          myop_preview_script == null ? void 0 : myop_preview_script.removeAttribute("type");
+          const temp = _doc.implementation.createHTMLDocument();
+          temp.body.innerHTML = `<script>
+                        const beforeKeysWindow = new Set(Object.keys(window));
+                        window.myopState = {
+                            beforeKeysWindow,
+                        };
+                <\/script>`;
+          const node = temp.body.firstChild;
+          if (node && _doc.head) {
+            _doc.head.insertBefore(_doc.importNode(node, true), _doc.head.firstChild);
+          }
+          HTML2Render = _doc.documentElement.outerHTML;
+        }
+        doc.writeln(HTML2Render);
+        doc.writeln(`<script src="${window.myop.__ROOT_SDK_PUBLIC_URL__}"><\/script>
+                    <script>
+                  
+                   window.__federation__.__public_path__ =  window.__federation__.__public_path__;
+                  
+                   const __myop_init = async () => {
+                        const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());
+                        const sdk = new IframeSDK()
+                        sdk.init();
+                   }
+                    
+                   __myop_init().then();
+                    
+              <\/script>`);
+        doc.close();
+        const comp = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);
+        if (loaderConfig.autoHeight) {
+          IframeElement.onload = () => {
+            comp.observeSizeBasedOnDocumentElement();
+          };
+        }
+        return comp;
+      }
+      if (loaderConfig.shadowRootMode === ShadowRootModeType.none) {
+        const template = document.createElement("template");
+        template.innerHTML = loaderConfig.HTML;
+        element = template.content.firstElementChild;
+        getInitiatedSdk().then((sdk2) => {
+          sdk2.connectedCallback(element, element);
+        });
+      } else {
+        const customElementName = toCustomElementName(componentDefinition.name + skin.id);
+        if (!seen2.includes(customElementName)) {
+          createCustomWebComponent(customElementName, loaderConfig.HTML, loaderConfig.shadowRootMode);
+          seen2.push(customElementName);
+        }
+        element = document.createElement(customElementName);
+      }
+      if (!container.querySelector('[id^="myop-comp-"]'))
+        container.innerHTML = "";
+      element.id = domId;
+      if (options == null ? void 0 : options.hidden) {
+        element.style.opacity = "0";
+        element.style.position = "absolute";
+        element.style.height = "0";
+        element.style.width = "0";
+        element.style.pointerEvents = "none";
+        element.style.visibility = "hidden";
+      }
+      this.appendChild(container, element, options);
+      return new MyopWebComponent(componentDefinition, skin, container, element, options);
+    }));
+  }
+};
+
+// src/host/myopOverride.ts
+var checkMyopOverride = (componentConfig) => __async(void 0, null, function* () {
+  try {
+    const url = new URL(window.location.href);
+    const params = new URLSearchParams(url.search);
+    const myopOverride = params.get("myopOverride");
+    if (myopOverride) {
+      const [source, ...uuids] = decompressUUIDs(myopOverride);
+      switch (source) {
+        case "component":
+          {
+            const [componentId, skinId] = uuids;
+            const componentToOverride = yield CloudRepository.Main.fetchComponent(componentId);
+            if (componentToOverride) {
+              const skin = componentToOverride.type.skins.find((skin2) => skin2.id === skinId);
+              if (skin) {
+                componentToOverride.instance.skinSelector = {
+                  type: SkinSelectorTypes.Dedicated,
+                  skin: {
+                    id: skinId
+                  }
+                };
+                return componentToOverride;
+              }
+            }
+          }
+          break;
+        //    case 'flow': {
+        default:
+          {
+            const [flowId, experimentId] = decompressUUIDs(myopOverride);
+            const flow = yield CloudRepository.Main.fetchFlow(flowId);
+            const componentToOverride = flow.components.find((c) => c.type.id === componentConfig.type.id);
+            if (componentToOverride) {
+              if (componentToOverride.instance.skinSelector.type === SkinSelectorTypes.Segmented) {
+                if (componentToOverride.instance.resolvedExperiences) {
+                  const resolvedExperience = componentToOverride.instance.resolvedExperiences.find((e) => e.id === experimentId);
+                  if ((resolvedExperience == null ? void 0 : resolvedExperience.type) === ExperienceTypes.Segment) {
+                    const typedResolvedExperience = resolvedExperience;
+                    const typedSkinSelector = componentToOverride.instance.skinSelector;
+                    const segment = typedSkinSelector.segments.find((s) => s.segmentId === typedResolvedExperience.segment.id);
+                    if (segment) {
+                      componentToOverride.instance.skinSelector = segment == null ? void 0 : segment.skinSelector;
+                      return componentToOverride;
+                    }
+                  }
+                }
+              }
+            }
+          }
+          break;
+      }
+    }
+  } finally {
+    return null;
+  }
+});
+
+// src/host/hostSDK.ts
+var __ROOT_SDK_PUBLIC_URL__ = "https://cdn.myop.dev/sdk/next/myop_sdk.min.js";
+var HostSDK = class {
+  constructor() {
+    __publicField(this, "components2init", []);
+    __publicField(this, "components", []);
+    __publicField(this, "componentsLoaders", []);
+    __publicField(this, "initiated", false);
+    __publicField(this, "version", myop_sdk_version_default);
+    __publicField(this, "type2InstanceCount", {});
+    __publicField(this, "assignId", (componentDefinition) => {
+      if (!this.type2InstanceCount[componentDefinition.id]) {
+        this.type2InstanceCount[componentDefinition.id] = 0;
+      }
+      return `${componentDefinition.id}_${++this.type2InstanceCount[componentDefinition.id]}`;
+    });
+    //TODO : fix the inspect implementation inside refComponent
+    //then inspected maybe can be dropped
+    __publicField(this, "inspected", false);
+    __publicField(this, "inspect", () => {
+      if (this.inspected)
+        return;
+      this.inspected = true;
+      this.components.forEach((component) => {
+        if (component.inspect) {
+          component.inspect();
+        }
+      });
+    });
+    __publicField(this, "incomingMessageHandler", (event) => {
+      if (event.origin === document.location.origin) {
+      }
+      if (event.data.myop) {
+        if (event.data.direction !== MessageDirection.up && event.data.messageType !== MyopMessages.EnvelopedMessage) {
+          return;
+        }
+        const myopMessage = event.data;
+        if (myopMessage.messageType === MyopMessages.InitRequest) {
+          this.components2init.forEach((component2) => {
+            component2.send(new InitMessage(component2.id));
+          });
+          return;
+        }
+        if (myopMessage.messageType === MyopMessages.InitResponse) {
+          this.components2init = this.components2init.filter((component2) => component2.id !== myopMessage.content.id);
+          const initiatedComponent = this.components.find((component2) => {
+            var _a;
+            return component2.id === ((_a = myopMessage.content) == null ? void 0 : _a.id);
+          });
+          initiatedComponent == null ? void 0 : initiatedComponent.setInitiated();
+          return;
+        }
+        if (myopMessage.messageType === MyopMessages.EnvelopedMessage) {
+          const typedMessage = myopMessage;
+          const refComponent = this.components.find((component2) => component2.id === typedMessage.destination);
+          if (refComponent) {
+            if (typedMessage.direction === MessageDirection.down) {
+              if (typedMessage.message.messageType === ExecuteComponentMethod.name) {
+                refComponent.onMessageReceived(typedMessage.message);
+              } else {
+                typedMessage.message.route = typedMessage.route;
+                refComponent.send(typedMessage.message);
+              }
+              return;
+            }
+          } else {
+            const innerComponent = this.components.find((component2) => component2.id === typedMessage.message.destination);
+            if (innerComponent) {
+              innerComponent.send(typedMessage.message);
+            } else {
+            }
+          }
+          return;
+        }
+        const component = this.components.find((component2) => component2.id === myopMessage.destination);
+        if (!component) {
+          if (window.myop.IframeSDK) {
+            window.myop.IframeSDK.messageToHost(myopMessage);
+          }
+          return;
+        }
+        if (component) {
+          if (component.onMessageReceived(myopMessage)) {
+            return;
+          } else {
+            if (window.myop.IframeSDK)
+              window.myop.IframeSDK.messageToHost(myopMessage);
+          }
+        }
+      }
+    });
+    __publicField(this, "send", (message) => {
+      const syntheticEvent = new MessageEvent(
+        "",
+        { data: message }
+      );
+      this.incomingMessageHandler(syntheticEvent);
+    });
+    __publicField(this, "init", (customComponentLoaderCreators) => {
+      if (this.initiated) {
+        throw new Error("hostSDK already initiated");
+      }
+      const basicLoaders = [
+        new MyopIframeLoader(),
+        new WebcomponentLoader(),
+        new HTMLComponentLoader()
+      ];
+      this.componentsLoaders = [
+        ...basicLoaders
+      ];
+      if (customComponentLoaderCreators) {
+        const loaderByType = {};
+        customComponentLoaderCreators.forEach((customComponentLoaderCreator) => {
+          const customLoader = new customComponentLoaderCreator(this.componentsLoaders);
+          loaderByType[customLoader.type] = customLoader;
+        });
+        this.componentsLoaders.forEach((loader) => {
+          if (!loaderByType[loader.type])
+            loaderByType[loader.type] = loader;
+        });
+        this.componentsLoaders = Object.values(loaderByType);
+      }
+      window.addEventListener(
+        "message",
+        this.incomingMessageHandler,
+        false
+      );
+      console.log("myop hostSDK initiated", document.location.href);
+      this.initiated = true;
+    });
+    __publicField(this, "_getSkinIdBySkinSelector", (_0, ..._1) => __async(this, [_0, ..._1], function* (skinSelector, experiences = [], hooks) {
+      var _a;
+      function asyncFind(array, predicate) {
+        return __async(this, null, function* () {
+          for (const item of array) {
+            if (yield predicate(item)) {
+              return item;
+            }
+          }
+          return void 0;
+        });
+      }
+      switch (skinSelector.type) {
+        // @ts-ignore
+        case "DedicatedSkin":
+        //backward compatibility
+        case SkinSelectorTypes.Dedicated:
+          {
+            let selectedSkinId = ((_a = skinSelector.skin) == null ? void 0 : _a.id) || skinSelector.skins[0].id;
+            return selectedSkinId;
+          }
+          break;
+        case SkinSelectorTypes.Segmented:
+          {
+            const typedSkinSelector = skinSelector;
+            const segment = yield asyncFind(typedSkinSelector.segments, (segment2) => __async(this, null, function* () {
+              if (segment2.segmentId === "Default") {
+                return true;
+              }
+              const experience = experiences.find((experience2) => {
+                if (experience2.type === ExperienceTypes.Segment) {
+                  return experience2.segment.id === segment2.segmentId;
+                }
+                return false;
+              });
+              if (!experience) {
+                throw new Error("experience not found");
+              }
+              const typedExperience = experience;
+              const typedSegment = typedExperience.segment;
+              const segmentFunction = (hooks ? hooks : {})[typedSegment.function];
+              if (segmentFunction) {
+                const results = yield segmentFunction();
+                return results;
+              } else {
+                console.warn(`segmentId:${segment2.segmentId}, ${typedSegment.function} function not provided !`);
+              }
+              return false;
+            }));
+            if (segment)
+              return this._getSkinIdBySkinSelector(segment.skinSelector, experiences);
+            else {
+              debugger;
+            }
+          }
+          break;
+        default: {
+          debugger;
+        }
+      }
+      return "";
+    }));
+    __publicField(this, "runSkinSelector", (componentConfig, hooks) => __async(this, null, function* () {
+      const skinId = yield this._getSkinIdBySkinSelector(componentConfig.instance.skinSelector, componentConfig.instance.resolvedExperiences, hooks);
+      return componentConfig.type.skins.find((skin) => skin.id === skinId);
+    }));
+    __publicField(this, "loaderHooks");
+    __publicField(this, "loadComponent", (componentConfig, container, options) => __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      if (!container) {
+        debugger;
+        throw new Error("no container was found for this component");
+      }
+      const overriddenConfig = yield checkMyopOverride(componentConfig);
+      if (overriddenConfig) {
+        componentConfig = overriddenConfig;
+      }
+      const hooks = __spreadValues(__spreadValues({}, (_a = this.loaderHooks) != null ? _a : {}), (_b = options == null ? void 0 : options.hooks) != null ? _b : {});
+      const ref = container;
+      if (ref.myop) {
+        if (ref.component) {
+          componentConfig = __spreadValues({}, componentConfig);
+          componentConfig.instance = __spreadValues({}, componentConfig.instance);
+          let selectedSkin2 = yield this.runSkinSelector(componentConfig, hooks);
+          if (!selectedSkin2) {
+            throw new Error("runSkinSelector failed to choose skin, check the provided config");
+          }
+          if ((_c = options == null ? void 0 : options.hooks) == null ? void 0 : _c.afterSkinSelected) {
+            selectedSkin2 = yield options.hooks.afterSkinSelected(__spreadValues({}, selectedSkin2));
+          }
+          componentConfig.instance.skinSelector = {
+            type: SkinSelectorTypes.Dedicated,
+            skin: selectedSkin2
+            //  skins: [selectedSkin]
+          };
+          if (options) {
+            options = __spreadValues({}, options);
+            delete options.hooks;
+          }
+          const refComponent = yield createRefComponent(ref, componentConfig, this.components, options);
+          return refComponent;
+        } else {
+          throw new Error("load component got a detached ref.");
+        }
+      }
+      container = container;
+      let selectedSkin = yield this.runSkinSelector(componentConfig, hooks);
+      if (!selectedSkin) {
+        throw new Error("runSkinSelector failed to choose skin, check the provided config");
+      }
+      if ((_d = options == null ? void 0 : options.hooks) == null ? void 0 : _d.afterSkinSelected) {
+        selectedSkin = yield options.hooks.afterSkinSelected(__spreadValues({}, selectedSkin));
+      }
+      const componentLoader = this.componentsLoaders.find((loader) => loader.type === selectedSkin.loader.type);
+      if (!componentLoader) {
+        debugger;
+        throw new Error(`no loader "${selectedSkin.loader.type}" was found for component`);
+      }
+      let component = yield componentLoader.load(componentConfig.type, selectedSkin, container, options);
+      if (!component.isInitiated)
+        this.components2init.push(component);
+      component.bind("onDispose", () => {
+        this.components = this.components.filter((c) => c !== component);
+        this.components2init = this.components2init.filter((c) => c !== component);
+        return true;
+      });
+      this.components.push(component);
+      if (!options || options.connectProps !== false) {
+        component = connectProps(component, componentConfig.type.props, selectedSkin);
+      }
+      try {
+        yield connectRefs(component, componentConfig, this.components);
+      } catch (e) {
+        throw e;
+      }
+      if (!(options == null ? void 0 : options.skipInit))
+        yield component.initiated();
+      return component;
+    }));
+    __publicField(this, "navigate", (component, newComponentConfig, options) => __async(this, null, function* () {
+      if (component.parent) {
+        throw new Error("Navigating on remote ref components is not implemented yet");
+      }
+      if (options == null ? void 0 : options.staged) {
+        let newComponent = yield this.loadComponent(newComponentConfig, component.container, __spreadValues({
+          hidden: true,
+          relative: { direction: "after", child: component.element }
+        }, options));
+        if (options.init)
+          yield options.init(newComponent);
+        newComponent.show();
+        component.dispose();
+        return newComponent;
+      } else {
+        const nextSibling = component.element.nextSibling;
+        component.dispose();
+        return this.loadComponent(newComponentConfig, component.container, __spreadValues({
+          relative: {
+            direction: "before",
+            child: nextSibling
+          }
+        }, options));
+      }
+    }));
+  }
+};
+__publicField(HostSDK, "Instance", () => window.myop.hostSDK);
+if (!window.myop) {
+  window.myop = {
+    __ROOT_SDK_PUBLIC_URL__
+  };
+}
+if (!window.myop.hostSDK) {
+  const _hostSDK = new HostSDK();
+  _hostSDK.init();
+  if (!window.myop) {
+    window.myop = {
+      __ROOT_SDK_PUBLIC_URL__
+    };
+  }
+  window.myop.hostSDK = _hostSDK;
+}
+var hostSDK = window.myop.hostSDK;
+defineDynamicImport("hostSDK", hostSDK);
+
+// src/helpers/EnableV2.ts
+var _v2_CloudRepository = class _v2_CloudRepository {
+  constructor(_baseUrl = "https://cloud.myop.dev") {
+    this._baseUrl = _baseUrl;
+    __publicField(this, "variants", {});
+  }
+  fetchComponent(componentId, environmentIdentifier) {
+    return __async(this, null, function* () {
+      if (!this.variants[componentId]) {
+        this.variants[componentId] = new Promise(
+          (resolve, reject) => __async(this, null, function* () {
+            try {
+              const res = yield fetch(
+                `${this._baseUrl}/consume?id=${componentId}&env=${environmentIdentifier}`
+              );
+              const json = yield res.json();
+              resolve(json.item);
+            } catch (e) {
+              reject(e);
+            }
+          })
+        );
+      }
+      return yield this.variants[componentId];
+    });
+  }
+};
+__publicField(_v2_CloudRepository, "Main", new _v2_CloudRepository());
+var v2_CloudRepository = _v2_CloudRepository;
+var enableV2 = (environmentIdentifier, cloudRepository) => {
+  const _cloudRepository = cloudRepository ? cloudRepository : new v2_CloudRepository();
+  return {
+    loadComponent: (componentId, container, options) => __async(void 0, null, function* () {
+      const config = yield _cloudRepository.fetchComponent(componentId, environmentIdentifier);
+      if (!config.consume_variant || !config.consume_variant.length) {
+        console.warn(
+          `[Myop Warning] Component "${componentId}" has no implementation for environment "${environmentIdentifier}".`
+        );
+      }
+      const componentConfig = {
+        instance: {
+          id: "auto",
+          componentId: config.componentId,
+          componentName: config.name,
+          skinSelector: {
+            type: "Dedicated",
+            skin: {
+              id: "skin_auto_v2_converted"
+            }
+          }
+        },
+        type: {
+          id: config.id,
+          name: config.name,
+          description: config.description,
+          props: [
+            {
+              id: "in_auto_v2_converted",
+              name: "myop_init_interface",
+              type: "any",
+              behavior: {
+                type: PropConfigBehaviorTypes.code
+              }
+            },
+            {
+              id: "out_auto_v2_converted",
+              name: "myop_cta_handler",
+              type: "any",
+              behavior: {
+                type: PropConfigBehaviorTypes.code
+              }
+            }
+          ],
+          refs: [],
+          skins: [
+            {
+              id: "skin_auto_v2_converted",
+              name: "auto_v2_converted",
+              description: "",
+              //TODO : handle empty :
+              // @ts-ignore
+              loader: config.consume_variant[0].loader
+            }
+          ],
+          defaultSkin: 0
+        },
+        name: config.name
+      };
+      return yield hostSDK.loadComponent(componentConfig, container, options);
+    })
+  };
+};
 export {
   CloudRepository,
   ComponentConfig,
@@ -405,7 +2919,9 @@ export {
   applyStylesheetLink,
   changeSkinUrlByTokenizer,
   createIframeSkinByTokenizer,
+  enableV2,
   exec,
-  removeClass
+  removeClass,
+  v2_CloudRepository
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/utils/uuid.ts", "../../../src/messages/BaseMessage.ts", "../../../src/messages/ExecuteScriptMessage.ts", "../../../src/messages/CustomRefMessage.ts", "../../../src/helpers/applyStylesheet.ts", "../../../src/helpers/iframeSkinUrlTokenizer.ts", "../../../src/helpers/classList.ts", "../../../src/helpers/configBuilder.ts", "../../../src/helpers/CloudRepository.ts", "../../../src/helpers/exec.ts"],
  "sourcesContent": ["//TODO : reuse from one place.\n// needs to be used in myop-sdk, myop-dashbaord, myop-server, myop-cli ..\n\nexport const uuidv4 = () => {\n    return \"10000000-1000-4000-8000-100000000000\".replace(/[018]/g, c =>\n        (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)\n    );\n}\n\n// Convert UUID string to bytes\nexport const uuidToBytes = (uuid: string): Uint8Array => {\n    return Uint8Array.from(\n        uuid.replace(/-/g, '').match(/.{1,2}/g)!.map(byte => parseInt(byte, 16))\n    );\n};\n\n// Convert bytes to UUID string\nexport const bytesToUuid = (bytes: Uint8Array): string => {\n    const hex = [...bytes].map(b => b.toString(16).padStart(2, '0')).join('');\n    return [\n        hex.slice(0, 8),\n        hex.slice(8, 12),\n        hex.slice(12, 16),\n        hex.slice(16, 20),\n        hex.slice(20)\n    ].join('-');\n};\n\n// Base64 URL-safe encode\nexport const base64UrlEncode = (bytes: Uint8Array): string => {\n    const base64 = btoa(String.fromCharCode(...bytes));\n    return base64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n};\n\n// Base64 URL-safe decode\nexport const base64UrlDecode = (str: string): Uint8Array => {\n    let base64 = str.replace(/-/g, '+').replace(/_/g, '/');\n    while (base64.length % 4) base64 += '=';\n    const binary = atob(base64);\n    return Uint8Array.from(binary, char => char.charCodeAt(0));\n};\n\n// Compress an array of UUIDs into a short URL-safe string\nexport const compressUUIDs = (uuids: string[]): string => {\n    const allBytes = uuids.flatMap(uuid => Array.from(uuidToBytes(uuid)));\n    return base64UrlEncode(new Uint8Array(allBytes));\n};\n\n// Decompress from URL-safe string back to an array of UUIDs\nexport const decompressUUIDs = (encoded: string): string[] => {\n    const bytes = base64UrlDecode(encoded);\n    if (bytes.length % 16 !== 0) throw new Error('Invalid input length');\n\n    const uuids: string[] = [];\n    for (let i = 0; i < bytes.length; i += 16) {\n        uuids.push(bytesToUuid(bytes.slice(i, i + 16)));\n    }\n    return uuids;\n};\n", "import {MyopMessageKey} from \"../common/MyopMessages\";\nimport {uuidv4} from \"../utils/utils\";\nimport {IMyopComponent} from \"../host\";\nimport {IRefConfig} from \"../common\";\n\nexport class MessageDirection {\n    static down = 'down' as const\n    static up = 'up' as const\n}\n\nexport type MessageDirectionOption = 'up' | 'down';\n\nexport abstract class BaseMyopMessage<T = any> {\n    id = uuidv4()\n\n    static create<T, U extends new (...args: ConstructorParameters<U>) => T = typeof this>(\n        this: U,\n        ...args: ConstructorParameters<U>\n    ): InstanceType<typeof this> {\n        // @ts-ignore\n        return new this(...args);\n    }\n\n    constructor() {\n        //console.log('meesage id created', this.id, document.location.href);\n    }\n\n    myop = true\n\n    abstract messageType: MyopMessageKey | string;\n\n    content?: T\n\n    // TODO : cant be optional \n    source?: string\n    destination?: string\n\n    route?: string[]\n\n    ref?: Ref\n\n    direction?: MessageDirectionOption\n\n    cleanable: boolean = false\n\n    isTypeof(msg: BaseMyopMessage): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n\nexport abstract class MyopElementMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public ref: Ref) {\n        super()\n    }\n}\n\nexport abstract class MyopBindReplayMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public replayToHandler?: string) {\n        super();\n    }\n}\n\nexport abstract class MyopBindMessage<T = any, R extends MyopBindReplayMessage = any> extends BaseMyopMessage<T> {\n\n    public abstract replyMessageKey: MyopMessageKey;\n\n    public handlerUniqueId = uuidv4()\n\n    constructor(public handler: (message: R) => void) {\n        super()\n    }\n}\n\nexport class Ref {\n    public myop = true;\n\n    public __nonProxied?: Ref;\n\n    static create(selector: string, refConfig?: IRefConfig, component?: IMyopComponent) {\n        let _refConfig = refConfig;\n        if (!_refConfig) {\n            _refConfig = {\n                id: '',\n                name: '',\n                description: '',\n                selectorType: 'id-attribute',\n                selector: selector,\n                behavior: {\n                    type: 'code'\n                }\n            } as IRefConfig\n        }\n        return new Ref(_refConfig, component);\n    }\n\n    constructor(public refConfig: IRefConfig, public component?: IMyopComponent) {\n        this.__nonProxied = {\n            ...this,\n            component: null // in order to be serializable\n        }\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {RootRef} from \"../common\";\nimport {makeSerializable} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'ExecuteScriptReplyMessage'\n\nconst functionBodyRegex = /(?:function\\s*\\w*\\s*\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\}|(\\([^)]*\\)\\s*=>\\s*\\{([\\s\\S]*?)\\}))\\s*$/;\nconst expressionBodyRegex = /\\(\\s*[^)]+\\s*\\)\\s*=>\\s*(.+)/;\n\nexport const stripFunction = (content: string) => {\n    let match = content.match(functionBodyRegex);\n    if (match) {\n        return match[1] || match[3];\n    } else {\n        let match = content.match(expressionBodyRegex);\n        if (match)\n            return match[1].trim();\n    }\n}\n\nexport type scriptInputs = {\n    [key: string]: string | number | boolean\n} | {};\n\nexport type scriptVars<T> = {\n    send: (data: T) => void;\n    // completeStream: () => void;\n    rootRef: RootRef;\n    makeSerializable: typeof makeSerializable\n}\n\nexport type extendedScriptVars<T, I> = {\n    [K in keyof I]: I[K];\n} & scriptVars<T>\n\nexport class ExecuteScriptMessage<T = any, I extends scriptInputs = any> extends MyopBindMessage<string, ExecuteScriptReplyMessage<T>> {\n\n    replyMessageKey: MyopMessageKey = ReplayMessageKey;\n    messageType = 'ExecuteScriptMessage';\n    script: string = ''\n\n    static replierKey = 'send';\n    static completeStreamKey = 'completeStream';\n\n    constructor(script: (vars: extendedScriptVars<T, I>) => T, handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n    }, public scriptInputs?: I) {\n        super(handler);\n        this.script = script.toString();\n\n        //TODO: can be remove\n        this.content = script.toString()\n        this.content = stripFunction(this.content);\n    }\n}\n\nexport class ExecuteScriptReplyMessage<T = any> extends MyopBindReplayMessage<T> {\n\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, public content: T) {\n        super(replayToHandler);\n    }\n}\n", "import {\n    ExecuteScriptMessage,\n    ExecuteScriptReplyMessage,\n    extendedScriptVars,\n    scriptInputs, stripFunction\n} from \"./ExecuteScriptMessage.ts\";\n\nexport type customRefScriptInputs = {\n    elementId: string,\n    ref?: HTMLElement,\n    _script?: string,\n    __scriptInputs?: Object\n};\n\nexport class CustomRefMessage<T = any, I extends scriptInputs = customRefScriptInputs> extends ExecuteScriptMessage<T, I & customRefScriptInputs> {\n\n    constructor(script: (vars: extendedScriptVars<T, I & customRefScriptInputs>) => T,\n                public scriptInputs: I & customRefScriptInputs,\n                handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n                }) {\n\n        //mock vars\n        // let rootRef, elementId, _script, __scriptInputs;\n        super(({rootRef, elementId, _script, __scriptInputs}) => {\n            const refs = (rootRef.shadowRoot || rootRef.container).querySelectorAll(`[${'myop-id'}='${elementId}']`);\n            if (refs.length) {\n                //  const ref = refs[0];\n\n                //TODO : think about exposing \"refs\" and not only \"ref\"\n                //for cases where the Ref has multiplate implementations\n\n                // @ts-ignore\n                __scriptInputs.ref = refs[0];\n\n                const dynamicFunction = new Function(`return (${_script})(...arguments)`);\n                return dynamicFunction(__scriptInputs);\n\n                // @ts-ignore\n                //return Function('ref', 'rootRef', ...Object.keys(__scriptInputs), _script!)(ref, rootRef, ...Object.values(__scriptInputs))\n            }\n            return null as T;\n        }, handler);\n\n        this.scriptInputs = {\n            ...scriptInputs,\n            //_script: stripFunction(script.toString()),\n            _script: script.toString()\n        };\n    }\n}\n", "import type * as CSS from \"csstype\";\nimport {IMyopComponent} from \"../host\";\nimport {uuidv4} from \"../utils/utils.ts\";\nimport {ExecuteScriptMessage} from \"../messages\";\n\n// ignoring documentation\n/** @ignore */\nexport interface CSSProperties extends CSS.Properties<string | number> {\n}\n\nexport type StylesheetDefinition = { [key: string]: CSSProperties };\n\nexport const applyStylesheet = (component: IMyopComponent, stylesheet: StylesheetDefinition, css?: string) => {\n    const tagId = `myop-css-${uuidv4()}`;\n    component.send(new ExecuteScriptMessage(({rootRef, _stylesheet, _tagId, _css}) => {\n        const styleTag = document.createElement('style');\n        styleTag.type = 'text/css';\n\n        // Build the CSS string from the styles object\n        let cssString = _css;\n\n        for (const selector in _stylesheet) {\n            cssString += `${selector} { `;\n            const properties = _stylesheet[selector];\n            for (const property in properties) {\n                cssString += `${property}: ${properties[property]}; `;\n            }\n            cssString += '} ';\n        }\n\n        // Set the CSS string as the content of the <style> element\n        styleTag.appendChild(document.createTextNode(cssString));\n        styleTag.id = _tagId;\n        // Append the <style> element\n        (rootRef.shadowRoot || rootRef.container).appendChild(styleTag);\n\n    }, () => {\n    }, {\n        _stylesheet: stylesheet,\n        _css : css ? css : '',\n        _tagId: tagId\n    }));\n\n    return () => {\n        component.send(new ExecuteScriptMessage(({rootRef, _tagId}) => {\n            const element = (rootRef.shadowRoot || document).getElementById(_tagId);\n            if (element) {\n                element.remove();\n            }\n        }, () => {\n        }, {\n            _tagId: tagId\n        }))\n    }\n}\n\nexport const applyStylesheetLink = (component: IMyopComponent, link: string) => {\n    const tagId = `myop-css-${uuidv4()}`;\n    component.send(new ExecuteScriptMessage(({rootRef, _tagId, _link}) => {\n        const linkElement = document.createElement('link');\n        linkElement.id = _tagId;\n        linkElement.rel = 'stylesheet';\n        linkElement.href = _link;\n        document.head.appendChild(linkElement);\n\n        // Append the <style> element\n        (rootRef.shadowRoot || rootRef.container).appendChild(linkElement);\n    }, () => {\n    }, {\n        _link : link,\n        _tagId: tagId\n    }));\n\n    return () => {\n        component.send(new ExecuteScriptMessage(({rootRef, _tagId}) => {\n            const element = (rootRef.shadowRoot || document).getElementById(_tagId);\n            if (element) {\n                element.remove();\n            }\n        }, () => {\n        }, {\n            _tagId: tagId\n        }))\n    }\n}\n", "import {IIframeLoaderConfig, ISkinConfig} from \"../common\";\n\nexport type TokenMap = Record<string, string| number>\n\nconst replaceTokens = (input: string, tokenMap: TokenMap): string => {\n    // Create a regex pattern from the keys of the tokenMap\n    const pattern = new RegExp(Object.keys(tokenMap).join('|'), 'g');\n\n    // Replace tokens in the input string using the regex\n    return input.replace(pattern, (matched) => {\n        // Return the replacement value from the tokenMap\n        return (tokenMap[matched] || matched).toString();\n    });\n}\n\nexport const createIframeSkinByTokenizer = (selectedSkin: ISkinConfig, tokenMap: TokenMap) => {\n    const typedSkinConfig = (selectedSkin.loader as IIframeLoaderConfig)\n    if (typedSkinConfig.type !== 'IframeLoader') {\n        throw new Error(`iframeSkinUrlTokenizer received skin with loader type \"${typedSkinConfig.type}\", currently only \"IframeLoader\" is supported`)\n    }\n\n    selectedSkin.loader = {\n        ...selectedSkin.loader\n    }\n\n    selectedSkin.loader.url = replaceTokens(selectedSkin.loader.url, tokenMap);\n\n    return selectedSkin;\n}\n\nexport const changeSkinUrlByTokenizer = (tokenMap: TokenMap) => {\n    return async (selectedSkin: ISkinConfig) => {\n        return createIframeSkinByTokenizer(selectedSkin, tokenMap);\n    }\n}", "import {CustomRefMessage} from \"../messages\";\nimport {IMyopComponent} from \"../host\";\n\n// const space = ' ';\n// export const getClasses = async (connectedRef: Ref): Promise<string[]> => (await exec(actAs<HTMLDivElement>(connectedRef).classList)).value.split(space);\n// export const addClass = async (connectedRef: Ref, className: string) => {\n//     const classes = await getClasses(connectedRef);\n//     classes.includes(className) || classes.push(className);\n//     // @ts-ignore\n//     connectedRef.classList = classes.join(space);\n// }\n// export const removeClass = async (connectedRef: Ref, className: string,) => {\n//     let classes = await getClasses(connectedRef);\n//     // @ts-ignore\n//     connectedRef.classList = classes.filter(c => c !== className).join(space);\n// }\n//\n//\n\nexport const addClass = (component: IMyopComponent, className: string, myopId: string) => {\n    component.send(new CustomRefMessage(({ref, _className}) => {\n        ref?.classList.add(_className);\n    }, {\n        elementId: myopId,\n        _className: className\n    }));\n}\n\nexport const removeClass = (component: IMyopComponent, className: string, myopId: string) => {\n    component.send(new CustomRefMessage(({ref, _className}) => {\n        ref?.classList.remove(_className);\n    }, {\n        elementId: myopId,\n        _className: className\n    }));\n}", "import {\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IComponentInstanceConfig, IHTMLLoaderConfig, IRefConfig,\n    ISkinLoaderConfig,\n    ISkinSelectorConfig,\n    IDedicatedSkinConfig, ISkinConfig\n} from \"../common\";\nimport {uuidv4} from \"../utils/utils.ts\";\n\nexport class SkinConfig implements ISkinConfig {\n    _runTimeInstanceId = 'runtime-instance-id-' + uuidv4();\n    _runTimeId = 'runtime-id-' + uuidv4();\n    _runTimeName = 'runtime-name-' + uuidv4();\n\n    static create = () => {\n        return new SkinConfig();\n    }\n\n    id = this._runTimeId;\n    name = this._runTimeName;\n    description = '';\n    loader = null as unknown as ISkinLoaderConfig;\n\n    withLoader = (loader: ISkinLoaderConfig) => {\n        this.loader = loader;\n        return this;\n    }\n\n    withHTMLLoader = (loader: Omit<IHTMLLoaderConfig, 'type'>) => {\n        loader.type = 'HTMLLoader';\n        this.loader = loader as IHTMLLoaderConfig;\n        return this;\n    }\n\n    build = () => {\n        return this;\n    }\n}\n\nexport class ComponentConfig implements IComponentConfig {\n    _runTimeInstanceId = 'runtime-instance-id-' + uuidv4();\n    _runTimeId = 'runtime-id-' + uuidv4();\n    _runTimeName = 'runtime-name-' + uuidv4();\n\n    static create = () => {\n        return new ComponentConfig();\n    }\n\n    instance = {\n        id: this._runTimeInstanceId,\n        componentId: this._runTimeId,\n        componentName: this._runTimeName,\n        skinSelector: null as unknown as ISkinSelectorConfig\n    } as IComponentInstanceConfig;\n\n    name = this._runTimeName\n    type = {\n        id: this._runTimeId,\n        name: this._runTimeName,\n        description: '',\n        props: [],\n        refs: [],\n        skins: [],\n        defaultSkin: 0\n    } as IComponentDefinitionConfig\n\n    withInstance = (instance: IComponentInstanceConfig) => {\n        this.instance = instance;\n        return this;\n    }\n\n    withType = (type: IComponentDefinitionConfig) => {\n        this.type = type;\n        return this;\n    }\n\n    withName = (name: string) => {\n        this.name = name;\n        return this;\n    }\n\n    withDefaultSkin = (defaultSkin: ISkinConfig) => {\n        this.type.skins.push(defaultSkin);\n        this.type.defaultSkin = this.type.skins.length - 1;\n        this.instance.skinSelector = {\n            type: 'Dedicated',\n            skin: {\n                id: defaultSkin.id\n            }\n        } as IDedicatedSkinConfig\n\n        return this;\n    }\n\n    withRef = (ref: IRefConfig) => {\n        this.type.refs.push(ref);\n        return this;\n    }\n\n    withBasicRef = (refSelector: string) => {\n        const newBasicRef = {\n            id: '',\n            name: refSelector,\n            description: '',\n            selectorType: 'id-attribute',\n            selector: refSelector,\n            behavior: {\n                type: 'code'\n            }\n        } as IRefConfig\n\n        this.type.refs.push(newBasicRef);\n        return this;\n    }\n\n    build = () => {\n        return JSON.parse(JSON.stringify(this))\n    }\n}\n", "import {IUserFlow} from \"../common\";\n\n/**\n *\n * ## Overview\n *\n * The `CloudRepository` class serves as a centralized data access layer for retrieving user flows and components from the Myop.dev cloud service. It implements a singleton pattern and provides caching mechanisms to optimize API calls and improve performance.\n *\n * ## Class Structure\n *\n * ### Constructor\n *\n * ```typescript\n * constructor(private _baseUrl = 'https://cloud.myop.dev')\n * ```\n *\n * **Parameters:**\n * - `_baseUrl` (optional): The base URL for the Myop.dev cloud API. Defaults to `'https://cloud.myop.dev'`\n *\n * ### Static Properties\n *\n * #### Main\n * ```typescript\n * static Main = new CloudRepository();\n * ```\n *\n * A singleton instance of the `CloudRepository` class that can be used throughout the application without creating multiple instances.\n *\n * ### Private Properties\n *\n * #### userFlows\n * ```typescript\n * private userFlows: Record<string, Promise<IUserFlow>> = {};\n * ```\n *\n * A cache object that stores promises for user flows, indexed by flow ID. This prevents duplicate API calls for the same flow and ensures consistent data retrieval.\n *\n * #### _baseUrl\n * ```typescript\n * private _baseUrl: string\n * ```\n *\n * The base URL for the cloud API endpoints, set during construction.\n *\n * ## Methods\n *\n * ### fetchFlow(flowId: string)\n *\n * Retrieves a complete user flow from the cloud repository, including all resolved components.\n *\n * **Parameters:**\n * - `flowId`: The unique identifier for the user flow to retrieve\n *\n * **Returns:**\n * - `Promise<IUserFlow>`: A promise that resolves to the complete user flow object\n *\n * **Behavior:**\n * - Implements request caching to avoid duplicate API calls for the same flow ID\n * - Makes a GET request to `/flow?id={flowId}&resolve=components`\n * - Automatically resolves component references within the flow\n * - Stores the promise in the cache for future use\n *\n * **Example Usage:**\n * ```typescript\n * const flow = await CloudRepository.Main.fetchFlow('my-flow-id');\n * console.log(flow.components);\n * ```\n *\n * ### fetchComponent(componentId: string, flowId: string)\n *\n * Retrieves a specific component from within a user flow.\n *\n * **Parameters:**\n * - `componentId`: The unique identifier for the component to retrieve\n * - `flowId`: The unique identifier for the user flow containing the component\n *\n * **Returns:**\n * - `Promise<Component | undefined>`: A promise that resolves to the component object if found, or undefined if not found\n *\n * **Behavior:**\n * - First fetches the complete flow using `fetchFlow()`\n * - Searches through the flow's components array to find the matching component\n * - Uses the component's `type.id` property for matching\n *\n * **Example Usage:**\n * ```typescript\n * const component = await CloudRepository.Main.fetchComponent('button-component', 'my-flow-id');\n * if (component) {\n *     console.log('Component found:', component);\n * } else {\n *     console.log('Component not found in flow');\n * }\n * ```\n *\n * ## API Integration\n *\n * ### Endpoint Structure\n *\n * The class integrates with the following Myop.dev cloud API endpoint:\n *\n * ```\n * GET {baseUrl}/flow?id={flowId}&resolve=components\n * ```\n *\n * **Query Parameters:**\n * - `id`: The flow identifier\n * - `resolve=components`: Instructs the API to include resolved component data in the response\n *\n * ### Response Format\n *\n * The API is expected to return a JSON response with the following structure:\n *\n * ```json\n * {\n *     \"item\": {\n *         // IUserFlow object with resolved components\n *         \"components\": [\n *             {\n *                 \"type\": {\n *                     \"id\": \"component-id\"\n *                 }\n *                 // ... other component properties\n *             }\n *         ]\n *         // ... other flow properties\n *     }\n * }\n * ```\n *\n * ## Caching Strategy\n *\n * The `CloudRepository` implements a promise-based caching mechanism:\n *\n * 1. **Cache Key**: Flow ID is used as the cache key\n * 2. **Cache Value**: Promises are cached rather than resolved values to handle concurrent requests\n * 3. **Cache Duration**: Cache persists for the lifetime of the repository instance\n * 4. **Cache Invalidation**: No automatic cache invalidation is implemented\n *\n * ## Error Handling\n *\n * - Network errors and API failures are propagated through promise rejection\n * - No specific error handling or retry logic is implemented at the repository level\n * - Consumers should implement appropriate error handling when calling repository methods\n *\n * ## Usage Patterns\n *\n * ### Singleton Access\n * ```typescript\n * import { CloudRepository } from './path/to/CloudRepository';\n *\n * // Use the singleton instance\n * const flow = await CloudRepository.Main.fetchFlow('flow-id');\n * ```\n *\n * ### Custom Instance\n * ```typescript\n * // Create a custom instance with different base URL\n * const customRepo = new CloudRepository('https://custom-api.example.com');\n * const flow = await customRepo.fetchFlow('flow-id');\n * ```\n *\n * ### Component Retrieval\n * ```typescript\n * // Get a specific component from a flow\n * const component = await CloudRepository.Main.fetchComponent('component-id', 'flow-id');\n * ```\n *\n * ## Dependencies\n *\n * - **IUserFlow**: Interface imported from `../common` that defines the structure of user flow objects\n * - **Fetch API**: Uses the native `fetch` function for HTTP requests\n *\n * ## Performance Considerations\n *\n * - **Caching**: Prevents duplicate API calls for the same flow ID\n * - **Promise Caching**: Handles concurrent requests efficiently by caching promises\n * - **Component Resolution**: The `resolve=components` parameter ensures components are fully resolved in a single API call\n *\n * ## Future Enhancements\n *\n * The class structure suggests planned functionality that could be implemented:\n *\n * - **Component Caching**: The commented `components` property indicates potential individual component caching\n * - **Cache Invalidation**: Methods to clear or refresh cached data\n * - **Error Retry Logic**: Automatic retry mechanisms for failed requests\n * - **Batch Operations**: Methods to fetch multiple flows or components in a single request\n *\n */\nexport class CloudRepository {\n    static Main = new CloudRepository();\n\n    private userFlows: Record<string, Promise<IUserFlow>> = {};\n\n    // private components: Record<string, Promise<IUserFlow>> = {};\n\n    constructor(private _baseUrl = 'https://cloud.myop.dev') {\n    }\n\n    async fetchComponent(componentId: string, flowId?: string) {\n        if (flowId) {\n            const flow = await this.fetchFlow(flowId);\n            return flow.components.find(c => c.type.id === componentId);\n        }else{\n            const flow = await this.fetchAutoFlow(componentId);\n            return flow.components[0];\n        }\n    }\n\n    async fetchAutoFlow(componentId: string) {\n        if (!this.userFlows[componentId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[componentId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${componentId}&auto=true`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[componentId];\n    }\n\n\n    async fetchFlow(flowId: string) {\n        if (!this.userFlows[flowId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[flowId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${flowId}&resolve=components`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[flowId];\n    }\n}\n", "export const exec = async (getter: any) => {\n    return await getter()\n}\n"],
  "mappings": "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",
  "names": ["match", "scriptInputs", "scriptInputs"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/utils/uuid.ts", "../../../src/utils/utils.ts", "../../../src/messages/index.ts", "../../../src/messages/BaseMessage.ts", "../../../src/messages/BindClickMessage.ts", "../../../src/messages/ChangeTextMessage.ts", "../../../src/messages/ExecuteScriptMessage.ts", "../../../src/messages/CustomRefMessage.ts", "../../../src/messages/AddEventListenerMessage.ts", "../../../src/messages/SetAttributeMessage.ts", "../../../src/messages/GetElementValueMessage.ts", "../../../src/messages/SetInnerHtml.ts", "../../../src/messages/InitMessage.ts", "../../../src/messages/CreateRefComponentMessage.ts", "../../../src/messages/EnvelopedMessage.ts", "../../../src/messages/DetectMyopRefsMessage.ts", "../../../src/messages/GetAttributeMessage.ts", "../../../src/messages/componentMessages/ExecuteComponentMethod.ts", "../../../src/messages/componentMessages/SetMutationObserverMessage.ts", "../../../src/messages/CleanupMessage.ts", "../../../src/messages/DisposeMessage.ts", "../../../src/messages/componentMessages/SetResizeObserverMessage.ts", "../../../src/helpers/applyStylesheet.ts", "../../../src/helpers/iframeSkinUrlTokenizer.ts", "../../../src/helpers/classList.ts", "../../../src/helpers/configBuilder.ts", "../../../src/helpers/CloudRepository.ts", "../../../src/helpers/exec.ts", "../../../src/dynamicImport/defineDynamicImport.ts", "../../../src/common/MyopMessages.ts", "../../../src/host/components/IMyopComponent.ts", "../../../src/common/MyopElementRef.ts", "../../../src/common/baseMessageHandler.ts", "../../../src/common/BaseMyopSDK.ts", "../../../src/common/index.ts", "../../../src/common/utils/serialization.ts", "../../../src/host/logMessages.ts", "../../../src/host/components/myopRefComponent.ts", "../../../src/host/componentCore.ts", "../../../src/host/components/myopIframeComponent.ts", "../../../src/host/loaders/IMyopLoader.ts", "../../../src/host/loaders/iframeLoader.ts", "../../../src/webcomponent/consts.ts", "../../../src/host/components/myopWebcomponent.ts", "../../../src/host/loaders/webcomponentLoader.ts", "version:myop-sdk-version", "../../../src/webcomponent/messageHandlers/BaseWebComponentMessageHandler.ts", "../../../src/consts.ts", "../../../src/common/messageHandlers/helpers.ts", "../../../src/webcomponent/messageHandlers/bindOnClickHandler.ts", "../../../src/webcomponent/messageHandlers/changeTextHandler.ts", "../../../src/webcomponent/shadowRootRef.ts", "../../../src/webcomponent/messageHandlers/DetectMyopRefsMessageHandler.ts", "../../../src/webcomponent/messageHandlers/setAttributeHandler.ts", "../../../src/webcomponent/messageHandlers/addEventListenerHandler.ts", "../../../src/webcomponent/messageHandlers/CreateRefComponentMessageHandler.ts", "../../../src/common/messageHandlers/executeScriptHandler.ts", "../../../src/webcomponent/messageHandlers/executeScriptHandler.ts", "../../../src/webcomponent/messageHandlers/GetElementValueHandler.ts", "../../../src/webcomponent/messageHandlers/setInnerHtmlHandler.ts", "../../../src/webcomponent/WebComponentSDK.ts", "../../../src/host/loaders/HTMLComponentLoader.ts", "../../../src/host/myopOverride.ts", "../../../src/host/hostSDK.ts", "../../../src/helpers/EnableV2.ts"],
  "sourcesContent": ["//TODO : reuse from one place.\n// needs to be used in myop-sdk, myop-dashbaord, myop-server, myop-cli ..\n\nexport const uuidv4 = () => {\n    return \"10000000-1000-4000-8000-100000000000\".replace(/[018]/g, c =>\n        (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)\n    );\n}\n\n// Convert UUID string to bytes\nexport const uuidToBytes = (uuid: string): Uint8Array => {\n    return Uint8Array.from(\n        uuid.replace(/-/g, '').match(/.{1,2}/g)!.map(byte => parseInt(byte, 16))\n    );\n};\n\n// Convert bytes to UUID string\nexport const bytesToUuid = (bytes: Uint8Array): string => {\n    const hex = [...bytes].map(b => b.toString(16).padStart(2, '0')).join('');\n    return [\n        hex.slice(0, 8),\n        hex.slice(8, 12),\n        hex.slice(12, 16),\n        hex.slice(16, 20),\n        hex.slice(20)\n    ].join('-');\n};\n\n// Base64 URL-safe encode\nexport const base64UrlEncode = (bytes: Uint8Array): string => {\n    const base64 = btoa(String.fromCharCode(...bytes));\n    return base64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n};\n\n// Base64 URL-safe decode\nexport const base64UrlDecode = (str: string): Uint8Array => {\n    let base64 = str.replace(/-/g, '+').replace(/_/g, '/');\n    while (base64.length % 4) base64 += '=';\n    const binary = atob(base64);\n    return Uint8Array.from(binary, char => char.charCodeAt(0));\n};\n\n// Compress an array of UUIDs into a short URL-safe string\nexport const compressUUIDs = (uuids: string[]): string => {\n    const allBytes = uuids.flatMap(uuid => Array.from(uuidToBytes(uuid)));\n    return base64UrlEncode(new Uint8Array(allBytes));\n};\n\n// Decompress from URL-safe string back to an array of UUIDs\nexport const decompressUUIDs = (encoded: string): string[] => {\n    const bytes = base64UrlDecode(encoded);\n    if (bytes.length % 16 !== 0) throw new Error('Invalid input length');\n\n    const uuids: string[] = [];\n    for (let i = 0; i < bytes.length; i += 16) {\n        uuids.push(bytesToUuid(bytes.slice(i, i + 16)));\n    }\n    return uuids;\n};\n", "export * from './uuid.ts'\n\nexport const wait = (ms: number) => {\n    return new Promise(resolve => setTimeout(resolve, ms));\n}", "export * from './BaseMessage';\n\n//user's messages\nexport * from './BindClickMessage';\nexport * from './ChangeTextMessage';\nexport * from './ExecuteScriptMessage';\nexport * from './CustomRefMessage';\nexport * from './AddEventListenerMessage';\nexport * from './SetAttributeMessage';\nexport * from './GetElementValueMessage';\nexport * from './SetInnerHtml';\n\n//system messages\nexport * from './InitMessage';\nexport * from './CreateRefComponentMessage';\nexport * from './EnvelopedMessage';\nexport * from './DetectMyopRefsMessage';\nexport * from './GetElementValueMessage';\nexport * from  './GetAttributeMessage';\n\nexport * from './componentMessages/ExecuteComponentMethod';\nexport * from './componentMessages/SetMutationObserverMessage';\nexport * from './CleanupMessage';\nexport * from './DisposeMessage';\nexport * from './componentMessages/SetResizeObserverMessage';", "import {MyopMessageKey} from \"../common/MyopMessages\";\nimport {uuidv4} from \"../utils/utils\";\nimport {IMyopComponent} from \"../host\";\nimport {IRefConfig} from \"../common\";\n\nexport class MessageDirection {\n    static down = 'down' as const\n    static up = 'up' as const\n}\n\nexport type MessageDirectionOption = 'up' | 'down';\n\nexport abstract class BaseMyopMessage<T = any> {\n    id = uuidv4()\n\n    static create<T, U extends new (...args: ConstructorParameters<U>) => T = typeof this>(\n        this: U,\n        ...args: ConstructorParameters<U>\n    ): InstanceType<typeof this> {\n        // @ts-ignore\n        return new this(...args);\n    }\n\n    constructor() {\n        //console.log('meesage id created', this.id, document.location.href);\n    }\n\n    myop = true\n\n    abstract messageType: MyopMessageKey | string;\n\n    content?: T\n\n    // TODO : cant be optional \n    source?: string\n    destination?: string\n\n    route?: string[]\n\n    ref?: Ref\n\n    direction?: MessageDirectionOption\n\n    cleanable: boolean = false\n\n    isTypeof(msg: BaseMyopMessage): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n\nexport abstract class MyopElementMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public ref: Ref) {\n        super()\n    }\n}\n\nexport abstract class MyopBindReplayMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public replayToHandler?: string) {\n        super();\n    }\n}\n\nexport abstract class MyopBindMessage<T = any, R extends MyopBindReplayMessage = any> extends BaseMyopMessage<T> {\n\n    public abstract replyMessageKey: MyopMessageKey;\n\n    public handlerUniqueId = uuidv4()\n\n    constructor(public handler: (message: R) => void) {\n        super()\n    }\n}\n\nexport class Ref {\n    public myop = true;\n\n    public __nonProxied?: Ref;\n\n    static create(selector: string, refConfig?: IRefConfig, component?: IMyopComponent) {\n        let _refConfig = refConfig;\n        if (!_refConfig) {\n            _refConfig = {\n                id: '',\n                name: '',\n                description: '',\n                selectorType: 'id-attribute',\n                selector: selector,\n                behavior: {\n                    type: 'code'\n                }\n            } as IRefConfig\n        }\n        return new Ref(_refConfig, component);\n    }\n\n    constructor(public refConfig: IRefConfig, public component?: IMyopComponent) {\n        this.__nonProxied = {\n            ...this,\n            component: null // in order to be serializable\n        }\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'ClickReplayMessage'\n\nexport class BindClickMessage extends MyopBindMessage<void, ClickReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'BindClickMessage';\n    cleanable = true;\n\n    constructor(public ref: Ref, handler: (message: ClickReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class ClickReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n}\n\n", "import {BaseMyopMessage, Ref} from \"./BaseMessage\";\n\nexport class ChangeTextMessage extends BaseMyopMessage<string> {\n\n    messageType = 'ChangeTextMessage';\n\n    constructor(public ref: Ref, text: string) {\n        super();\n        this.content = text\n    }\n}", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {RootRef} from \"../common\";\nimport {makeSerializable} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'ExecuteScriptReplyMessage'\n\nconst functionBodyRegex = /(?:function\\s*\\w*\\s*\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\}|(\\([^)]*\\)\\s*=>\\s*\\{([\\s\\S]*?)\\}))\\s*$/;\nconst expressionBodyRegex = /\\(\\s*[^)]+\\s*\\)\\s*=>\\s*(.+)/;\n\nexport const stripFunction = (content: string) => {\n    let match = content.match(functionBodyRegex);\n    if (match) {\n        return match[1] || match[3];\n    } else {\n        let match = content.match(expressionBodyRegex);\n        if (match)\n            return match[1].trim();\n    }\n}\n\nexport type scriptInputs = {\n    [key: string]: string | number | boolean\n} | {};\n\nexport type scriptVars<T> = {\n    send: (data: T) => void;\n    // completeStream: () => void;\n    rootRef: RootRef;\n    makeSerializable: typeof makeSerializable\n}\n\nexport type extendedScriptVars<T, I> = {\n    [K in keyof I]: I[K];\n} & scriptVars<T>\n\nexport class ExecuteScriptMessage<T = any, I extends scriptInputs = any> extends MyopBindMessage<string, ExecuteScriptReplyMessage<T>> {\n\n    replyMessageKey: MyopMessageKey = ReplayMessageKey;\n    messageType = 'ExecuteScriptMessage';\n    script: string = ''\n\n    static replierKey = 'send';\n    static completeStreamKey = 'completeStream';\n\n    constructor(script: (vars: extendedScriptVars<T, I>) => T, handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n    }, public scriptInputs?: I) {\n        super(handler);\n        this.script = script.toString();\n\n        //TODO: can be remove\n        this.content = script.toString()\n        this.content = stripFunction(this.content);\n    }\n}\n\nexport class ExecuteScriptReplyMessage<T = any> extends MyopBindReplayMessage<T> {\n\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, public content: T) {\n        super(replayToHandler);\n    }\n}\n", "import {\n    ExecuteScriptMessage,\n    ExecuteScriptReplyMessage,\n    extendedScriptVars,\n    scriptInputs, stripFunction\n} from \"./ExecuteScriptMessage.ts\";\n\nexport type customRefScriptInputs = {\n    elementId: string,\n    ref?: HTMLElement,\n    _script?: string,\n    __scriptInputs?: Object\n};\n\nexport class CustomRefMessage<T = any, I extends scriptInputs = customRefScriptInputs> extends ExecuteScriptMessage<T, I & customRefScriptInputs> {\n\n    constructor(script: (vars: extendedScriptVars<T, I & customRefScriptInputs>) => T,\n                public scriptInputs: I & customRefScriptInputs,\n                handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n                }) {\n\n        //mock vars\n        // let rootRef, elementId, _script, __scriptInputs;\n        super(({rootRef, elementId, _script, __scriptInputs}) => {\n            const refs = (rootRef.shadowRoot || rootRef.container).querySelectorAll(`[${'myop-id'}='${elementId}']`);\n            if (refs.length) {\n                //  const ref = refs[0];\n\n                //TODO : think about exposing \"refs\" and not only \"ref\"\n                //for cases where the Ref has multiplate implementations\n\n                // @ts-ignore\n                __scriptInputs.ref = refs[0];\n\n                const dynamicFunction = new Function(`return (${_script})(...arguments)`);\n                return dynamicFunction(__scriptInputs);\n\n                // @ts-ignore\n                //return Function('ref', 'rootRef', ...Object.keys(__scriptInputs), _script!)(ref, rootRef, ...Object.values(__scriptInputs))\n            }\n            return null as T;\n        }, handler);\n\n        this.scriptInputs = {\n            ...scriptInputs,\n            //_script: stripFunction(script.toString()),\n            _script: script.toString()\n        };\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {Serializable, SerializableSkeleton} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'EventListenerCallbackMessage'\n\nexport class AddEventListenerMessage<T extends keyof HTMLElementEventMap = keyof HTMLElementEventMap> extends MyopBindMessage {\n\n    replyMessageKey: MyopMessageKey = ReplayMessageKey;\n    messageType = 'AddEventListenerMessage';\n    cleanable = true;\n    serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]> = false // {} // empty\n\n    constructor(public ref: Ref, public type: T, public handler: (message: EventListenerCallbackMessage) => void) {\n        super(handler)\n    }\n\n    withSerializableSkeleton(serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]>) {\n        this.serializableSkeleton = serializableSkeleton;\n        return this;\n    }\n}\n\nexport class EventListenerCallbackMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, public e: Serializable<Event>) {\n        super(replayToHandler);\n        this.content = {\n            e\n        }\n    }\n}\n", "import {BaseMyopMessage, Ref,} from \"./BaseMessage\";\n\n\nexport class SetAttributeMessage extends BaseMyopMessage {\n\n    messageType = 'SetAttributeMessage';\n\n    constructor(public ref: Ref, public name: string, public value: string) {\n        super()\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {Serializable} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'ElementValueReplayMessage'\n\nexport class GetElementValueMessage extends MyopBindMessage<void, ElementValueReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'GetElementValueMessage';\n\n    constructor(public ref: Ref, handler: (message: ElementValueReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport type FormDataEntry = {\n    id?: string,\n    name?: string,\n    value?: InputElementValue,\n    required?: boolean,\n    validity?: Serializable<ValidityState>,\n    myopId?: string\n}\n\nexport type InputElementFormValue = {\n    formData?: { [key: string]: FormDataEntry }\n    unmappedData?: FormDataEntry[]\n};\n\nexport type InputElementValue = string | InputElementFormValue | null | undefined\n\nexport class ElementValueReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public content: InputElementValue) {\n        super();\n    }\n}\n\n", "import {BaseMyopMessage, Ref} from \"./BaseMessage.ts\";\n\nexport class SetInnerHtml extends BaseMyopMessage<string> {\n\n    messageType = 'SetInnerHtml';\n\n    constructor(public ref: Ref, innerHtml: string) {\n        super();\n        this.content = innerHtml\n    }\n}", "import { BaseMyopMessage } from \"./BaseMessage\";\n\n// sent by host to components, contains thier id \nexport class InitMessage extends BaseMyopMessage<{ id: string }> {\n    messageType = 'InitMessage';\n\n    constructor(id: string) {\n        super()\n        this.content = { id }\n    }\n\n    isTypeof(msg: BaseMyopMessage): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n\n// component notify host the it was initated \nexport class InitResponse extends InitMessage {\n    messageType = 'InitResponse';\n}\n\n// component ask to host to get initated \nexport class InitRequest extends BaseMyopMessage {\n    messageType = 'InitRequest';\n}\n", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {IComponentConfig, IRefConfig} from \"../common\";\nimport {loaderOptions} from \"../host/hostSDK.ts\";\n\nconst ReplayMessageKey = 'RefComponentCreatedMessage'\n\nexport class CreateRefComponentMessage extends MyopBindMessage<void, RefComponentCreatedMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'CreateRefComponentMessage';\n\n    constructor(public refConfig: IRefConfig,\n                public nestedComponentConfig: IComponentConfig,\n                public options: loaderOptions,\n                handler: (message: RefComponentCreatedMessage) => void,\n    ) {\n        super(handler);\n\n    }\n}\n\nexport type NestedRef = {\n    refName: string,\n    componentDefinitionId: string\n}\n\nexport class RefComponentCreatedMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public replayToHandler: string, public nestedRefs: NestedRef[], public failed?: boolean) {\n        super(replayToHandler);\n    }\n}\n", "import {BaseMyopMessage} from \"./BaseMessage\";\n\nexport class EnvelopedMessage extends BaseMyopMessage {\n    messageType = 'EnvelopedMessage';\n\n    constructor(public destination: string, public message: BaseMyopMessage) {\n        super();\n\n        const innerEnvelopedMessage = (message as EnvelopedMessage);\n        this.route = [destination, ...innerEnvelopedMessage.route ? innerEnvelopedMessage.route : []];\n    }\n}\n", "import {BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {IElementRef} from \"../common\";\n\nconst ReplayMessageKey = 'DetectedMyopRefsMessage'\n\nexport class DetectMyopRefsMessage extends MyopBindMessage<any, DetectedMyopRefsMessage> {\n    messageType = 'DetectMyopRefsMessage'\n    replyMessageKey = ReplayMessageKey;\n}\n\nexport class DetectedMyopRefsMessage extends MyopBindReplayMessage<IElementRef[]> {\n\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, myopElementRefs: IElementRef[]) {\n        super(replayToHandler)\n        this.content = myopElementRefs;\n    }\n\n    isTypeof(msg: BaseMyopMessage<any>): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'GetAttributeReplayMessage'\n\nexport class GetAttributeMessage extends MyopBindMessage<void, GetAttributeReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'GetAttributeMessage';\n\n    constructor(public ref: Ref, public name: string, handler: (message: GetAttributeReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class GetAttributeReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public content: string | null) {\n        super();\n    }\n}\n\n", "import {BaseMyopMessage} from \"../BaseMessage\";\nimport {IMyopComponent} from \"../../host\";\n\ntype MethodNames<T> = {\n    // [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n    [K in keyof T]: T[K] extends () => void ? K : never;\n}[keyof T];\n\n// Define a type that allows only strings corresponding to the method names of T\ntype MethodString<T> = MethodNames<T> extends infer M ? M extends string ? M : never : never;\n\n\nexport class ExecuteComponentMethod extends BaseMyopMessage {\n    messageType = 'ExecuteComponentMethod';\n\n    constructor(public method: MethodString<IMyopComponent>) {\n        super();\n    }\n}\n", "import {BaseMyopMessage} from \"../BaseMessage\";\n\nexport class SetMutationObserverMessage extends BaseMyopMessage {\n    messageType = 'SetMutationObserverMessage';\n}\n\nexport class MutationObserverMessage extends BaseMyopMessage {\n    messageType = 'MutationObserverMessage';\n}", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'CleanupReplayMessage'\n\nexport class CleanupMessage extends MyopBindMessage<void, CleanupReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'CleanupMessage';\n\n    constructor(public cleanupForMessageId: string, handler: (message: CleanupReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class CleanupReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public customCleanup: boolean) {\n        super();\n    }\n}\n", "import {BaseMyopMessage} from \"./BaseMessage\";\n\nexport class DisposeMessage extends BaseMyopMessage {\n    messageType = 'DisposeMessage';\n}\n", "import {BaseMyopMessage} from \"../BaseMessage\";\n\nexport class SetResizeObserverMessage extends BaseMyopMessage {\n    cleanable = true;\n    messageType = 'SetResizeObserverMessage';\n}\n\nexport class ResizeObserverMessage extends BaseMyopMessage {\n    messageType = 'ResizeObserverMessage';\n}", "import type * as CSS from \"csstype\";\nimport {IMyopComponent} from \"../host\";\nimport {uuidv4} from \"../utils/utils.ts\";\nimport {ExecuteScriptMessage} from \"../messages\";\n\n// ignoring documentation\n/** @ignore */\nexport interface CSSProperties extends CSS.Properties<string | number> {\n}\n\nexport type StylesheetDefinition = { [key: string]: CSSProperties };\n\nexport const applyStylesheet = (component: IMyopComponent, stylesheet: StylesheetDefinition, css?: string) => {\n    const tagId = `myop-css-${uuidv4()}`;\n    component.send(new ExecuteScriptMessage(({rootRef, _stylesheet, _tagId, _css}) => {\n        const styleTag = document.createElement('style');\n        styleTag.type = 'text/css';\n\n        // Build the CSS string from the styles object\n        let cssString = _css;\n\n        for (const selector in _stylesheet) {\n            cssString += `${selector} { `;\n            const properties = _stylesheet[selector];\n            for (const property in properties) {\n                cssString += `${property}: ${properties[property]}; `;\n            }\n            cssString += '} ';\n        }\n\n        // Set the CSS string as the content of the <style> element\n        styleTag.appendChild(document.createTextNode(cssString));\n        styleTag.id = _tagId;\n        // Append the <style> element\n        (rootRef.shadowRoot || rootRef.container).appendChild(styleTag);\n\n    }, () => {\n    }, {\n        _stylesheet: stylesheet,\n        _css : css ? css : '',\n        _tagId: tagId\n    }));\n\n    return () => {\n        component.send(new ExecuteScriptMessage(({rootRef, _tagId}) => {\n            const element = (rootRef.shadowRoot || document).getElementById(_tagId);\n            if (element) {\n                element.remove();\n            }\n        }, () => {\n        }, {\n            _tagId: tagId\n        }))\n    }\n}\n\nexport const applyStylesheetLink = (component: IMyopComponent, link: string) => {\n    const tagId = `myop-css-${uuidv4()}`;\n    component.send(new ExecuteScriptMessage(({rootRef, _tagId, _link}) => {\n        const linkElement = document.createElement('link');\n        linkElement.id = _tagId;\n        linkElement.rel = 'stylesheet';\n        linkElement.href = _link;\n        document.head.appendChild(linkElement);\n\n        // Append the <style> element\n        (rootRef.shadowRoot || rootRef.container).appendChild(linkElement);\n    }, () => {\n    }, {\n        _link : link,\n        _tagId: tagId\n    }));\n\n    return () => {\n        component.send(new ExecuteScriptMessage(({rootRef, _tagId}) => {\n            const element = (rootRef.shadowRoot || document).getElementById(_tagId);\n            if (element) {\n                element.remove();\n            }\n        }, () => {\n        }, {\n            _tagId: tagId\n        }))\n    }\n}\n", "import {IIframeLoaderConfig, ISkinConfig} from \"../common\";\n\nexport type TokenMap = Record<string, string| number>\n\nconst replaceTokens = (input: string, tokenMap: TokenMap): string => {\n    // Create a regex pattern from the keys of the tokenMap\n    const pattern = new RegExp(Object.keys(tokenMap).join('|'), 'g');\n\n    // Replace tokens in the input string using the regex\n    return input.replace(pattern, (matched) => {\n        // Return the replacement value from the tokenMap\n        return (tokenMap[matched] || matched).toString();\n    });\n}\n\nexport const createIframeSkinByTokenizer = (selectedSkin: ISkinConfig, tokenMap: TokenMap) => {\n    const typedSkinConfig = (selectedSkin.loader as IIframeLoaderConfig)\n    if (typedSkinConfig.type !== 'IframeLoader') {\n        throw new Error(`iframeSkinUrlTokenizer received skin with loader type \"${typedSkinConfig.type}\", currently only \"IframeLoader\" is supported`)\n    }\n\n    selectedSkin.loader = {\n        ...selectedSkin.loader\n    }\n\n    selectedSkin.loader.url = replaceTokens(selectedSkin.loader.url, tokenMap);\n\n    return selectedSkin;\n}\n\nexport const changeSkinUrlByTokenizer = (tokenMap: TokenMap) => {\n    return async (selectedSkin: ISkinConfig) => {\n        return createIframeSkinByTokenizer(selectedSkin, tokenMap);\n    }\n}", "import {CustomRefMessage} from \"../messages\";\nimport {IMyopComponent} from \"../host\";\n\n// const space = ' ';\n// export const getClasses = async (connectedRef: Ref): Promise<string[]> => (await exec(actAs<HTMLDivElement>(connectedRef).classList)).value.split(space);\n// export const addClass = async (connectedRef: Ref, className: string) => {\n//     const classes = await getClasses(connectedRef);\n//     classes.includes(className) || classes.push(className);\n//     // @ts-ignore\n//     connectedRef.classList = classes.join(space);\n// }\n// export const removeClass = async (connectedRef: Ref, className: string,) => {\n//     let classes = await getClasses(connectedRef);\n//     // @ts-ignore\n//     connectedRef.classList = classes.filter(c => c !== className).join(space);\n// }\n//\n//\n\nexport const addClass = (component: IMyopComponent, className: string, myopId: string) => {\n    component.send(new CustomRefMessage(({ref, _className}) => {\n        ref?.classList.add(_className);\n    }, {\n        elementId: myopId,\n        _className: className\n    }));\n}\n\nexport const removeClass = (component: IMyopComponent, className: string, myopId: string) => {\n    component.send(new CustomRefMessage(({ref, _className}) => {\n        ref?.classList.remove(_className);\n    }, {\n        elementId: myopId,\n        _className: className\n    }));\n}", "import {\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IComponentInstanceConfig, IHTMLLoaderConfig, IRefConfig,\n    ISkinLoaderConfig,\n    ISkinSelectorConfig,\n    IDedicatedSkinConfig, ISkinConfig\n} from \"../common\";\nimport {uuidv4} from \"../utils/utils.ts\";\n\nexport class SkinConfig implements ISkinConfig {\n    _runTimeInstanceId = 'runtime-instance-id-' + uuidv4();\n    _runTimeId = 'runtime-id-' + uuidv4();\n    _runTimeName = 'runtime-name-' + uuidv4();\n\n    static create = () => {\n        return new SkinConfig();\n    }\n\n    id = this._runTimeId;\n    name = this._runTimeName;\n    description = '';\n    loader = null as unknown as ISkinLoaderConfig;\n\n    withLoader = (loader: ISkinLoaderConfig) => {\n        this.loader = loader;\n        return this;\n    }\n\n    withHTMLLoader = (loader: Omit<IHTMLLoaderConfig, 'type'>) => {\n        loader.type = 'HTMLLoader';\n        this.loader = loader as IHTMLLoaderConfig;\n        return this;\n    }\n\n    build = () => {\n        return this;\n    }\n}\n\nexport class ComponentConfig implements IComponentConfig {\n    _runTimeInstanceId = 'runtime-instance-id-' + uuidv4();\n    _runTimeId = 'runtime-id-' + uuidv4();\n    _runTimeName = 'runtime-name-' + uuidv4();\n\n    static create = () => {\n        return new ComponentConfig();\n    }\n\n    instance = {\n        id: this._runTimeInstanceId,\n        componentId: this._runTimeId,\n        componentName: this._runTimeName,\n        skinSelector: null as unknown as ISkinSelectorConfig\n    } as IComponentInstanceConfig;\n\n    name = this._runTimeName\n    type = {\n        id: this._runTimeId,\n        name: this._runTimeName,\n        description: '',\n        props: [],\n        refs: [],\n        skins: [],\n        defaultSkin: 0\n    } as IComponentDefinitionConfig\n\n    withInstance = (instance: IComponentInstanceConfig) => {\n        this.instance = instance;\n        return this;\n    }\n\n    withType = (type: IComponentDefinitionConfig) => {\n        this.type = type;\n        return this;\n    }\n\n    withName = (name: string) => {\n        this.name = name;\n        return this;\n    }\n\n    withDefaultSkin = (defaultSkin: ISkinConfig) => {\n        this.type.skins.push(defaultSkin);\n        this.type.defaultSkin = this.type.skins.length - 1;\n        this.instance.skinSelector = {\n            type: 'Dedicated',\n            skin: {\n                id: defaultSkin.id\n            }\n        } as IDedicatedSkinConfig\n\n        return this;\n    }\n\n    withRef = (ref: IRefConfig) => {\n        this.type.refs.push(ref);\n        return this;\n    }\n\n    withBasicRef = (refSelector: string) => {\n        const newBasicRef = {\n            id: '',\n            name: refSelector,\n            description: '',\n            selectorType: 'id-attribute',\n            selector: refSelector,\n            behavior: {\n                type: 'code'\n            }\n        } as IRefConfig\n\n        this.type.refs.push(newBasicRef);\n        return this;\n    }\n\n    build = () => {\n        return JSON.parse(JSON.stringify(this))\n    }\n}\n", "import {IUserFlow} from \"../common\";\n\n/**\n *\n * ## Overview\n *\n * The `CloudRepository` class serves as a centralized data access layer for retrieving user flows and components from the Myop.dev cloud service. It implements a singleton pattern and provides caching mechanisms to optimize API calls and improve performance.\n *\n * ## Class Structure\n *\n * ### Constructor\n *\n * ```typescript\n * constructor(private _baseUrl = 'https://cloud.myop.dev')\n * ```\n *\n * **Parameters:**\n * - `_baseUrl` (optional): The base URL for the Myop.dev cloud API. Defaults to `'https://cloud.myop.dev'`\n *\n * ### Static Properties\n *\n * #### Main\n * ```typescript\n * static Main = new CloudRepository();\n * ```\n *\n * A singleton instance of the `CloudRepository` class that can be used throughout the application without creating multiple instances.\n *\n * ### Private Properties\n *\n * #### userFlows\n * ```typescript\n * private userFlows: Record<string, Promise<IUserFlow>> = {};\n * ```\n *\n * A cache object that stores promises for user flows, indexed by flow ID. This prevents duplicate API calls for the same flow and ensures consistent data retrieval.\n *\n * #### _baseUrl\n * ```typescript\n * private _baseUrl: string\n * ```\n *\n * The base URL for the cloud API endpoints, set during construction.\n *\n * ## Methods\n *\n * ### fetchFlow(flowId: string)\n *\n * Retrieves a complete user flow from the cloud repository, including all resolved components.\n *\n * **Parameters:**\n * - `flowId`: The unique identifier for the user flow to retrieve\n *\n * **Returns:**\n * - `Promise<IUserFlow>`: A promise that resolves to the complete user flow object\n *\n * **Behavior:**\n * - Implements request caching to avoid duplicate API calls for the same flow ID\n * - Makes a GET request to `/flow?id={flowId}&resolve=components`\n * - Automatically resolves component references within the flow\n * - Stores the promise in the cache for future use\n *\n * **Example Usage:**\n * ```typescript\n * const flow = await CloudRepository.Main.fetchFlow('my-flow-id');\n * console.log(flow.components);\n * ```\n *\n * ### fetchComponent(componentId: string, flowId: string)\n *\n * Retrieves a specific component from within a user flow.\n *\n * **Parameters:**\n * - `componentId`: The unique identifier for the component to retrieve\n * - `flowId`: The unique identifier for the user flow containing the component\n *\n * **Returns:**\n * - `Promise<Component | undefined>`: A promise that resolves to the component object if found, or undefined if not found\n *\n * **Behavior:**\n * - First fetches the complete flow using `fetchFlow()`\n * - Searches through the flow's components array to find the matching component\n * - Uses the component's `type.id` property for matching\n *\n * **Example Usage:**\n * ```typescript\n * const component = await CloudRepository.Main.fetchComponent('button-component', 'my-flow-id');\n * if (component) {\n *     console.log('Component found:', component);\n * } else {\n *     console.log('Component not found in flow');\n * }\n * ```\n *\n * ## API Integration\n *\n * ### Endpoint Structure\n *\n * The class integrates with the following Myop.dev cloud API endpoint:\n *\n * ```\n * GET {baseUrl}/flow?id={flowId}&resolve=components\n * ```\n *\n * **Query Parameters:**\n * - `id`: The flow identifier\n * - `resolve=components`: Instructs the API to include resolved component data in the response\n *\n * ### Response Format\n *\n * The API is expected to return a JSON response with the following structure:\n *\n * ```json\n * {\n *     \"item\": {\n *         // IUserFlow object with resolved components\n *         \"components\": [\n *             {\n *                 \"type\": {\n *                     \"id\": \"component-id\"\n *                 }\n *                 // ... other component properties\n *             }\n *         ]\n *         // ... other flow properties\n *     }\n * }\n * ```\n *\n * ## Caching Strategy\n *\n * The `CloudRepository` implements a promise-based caching mechanism:\n *\n * 1. **Cache Key**: Flow ID is used as the cache key\n * 2. **Cache Value**: Promises are cached rather than resolved values to handle concurrent requests\n * 3. **Cache Duration**: Cache persists for the lifetime of the repository instance\n * 4. **Cache Invalidation**: No automatic cache invalidation is implemented\n *\n * ## Error Handling\n *\n * - Network errors and API failures are propagated through promise rejection\n * - No specific error handling or retry logic is implemented at the repository level\n * - Consumers should implement appropriate error handling when calling repository methods\n *\n * ## Usage Patterns\n *\n * ### Singleton Access\n * ```typescript\n * import { CloudRepository } from './path/to/CloudRepository';\n *\n * // Use the singleton instance\n * const flow = await CloudRepository.Main.fetchFlow('flow-id');\n * ```\n *\n * ### Custom Instance\n * ```typescript\n * // Create a custom instance with different base URL\n * const customRepo = new CloudRepository('https://custom-api.example.com');\n * const flow = await customRepo.fetchFlow('flow-id');\n * ```\n *\n * ### Component Retrieval\n * ```typescript\n * // Get a specific component from a flow\n * const component = await CloudRepository.Main.fetchComponent('component-id', 'flow-id');\n * ```\n *\n * ## Dependencies\n *\n * - **IUserFlow**: Interface imported from `../common` that defines the structure of user flow objects\n * - **Fetch API**: Uses the native `fetch` function for HTTP requests\n *\n * ## Performance Considerations\n *\n * - **Caching**: Prevents duplicate API calls for the same flow ID\n * - **Promise Caching**: Handles concurrent requests efficiently by caching promises\n * - **Component Resolution**: The `resolve=components` parameter ensures components are fully resolved in a single API call\n *\n * ## Future Enhancements\n *\n * The class structure suggests planned functionality that could be implemented:\n *\n * - **Component Caching**: The commented `components` property indicates potential individual component caching\n * - **Cache Invalidation**: Methods to clear or refresh cached data\n * - **Error Retry Logic**: Automatic retry mechanisms for failed requests\n * - **Batch Operations**: Methods to fetch multiple flows or components in a single request\n *\n */\nexport class CloudRepository {\n    static Main = new CloudRepository();\n\n    private userFlows: Record<string, Promise<IUserFlow>> = {};\n\n    // private components: Record<string, Promise<IUserFlow>> = {};\n\n    constructor(private _baseUrl = 'https://cloud.myop.dev') {\n    }\n\n    async fetchComponent(componentId: string, flowId?: string) {\n        if (flowId) {\n            const flow = await this.fetchFlow(flowId);\n            return flow.components.find(c => c.type.id === componentId);\n        }else{\n            const flow = await this.fetchAutoFlow(componentId);\n            return flow.components[0];\n        }\n    }\n\n    async fetchAutoFlow(componentId: string) {\n        if (!this.userFlows[componentId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[componentId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${componentId}&auto=true`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[componentId];\n    }\n\n\n    async fetchFlow(flowId: string) {\n        if (!this.userFlows[flowId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[flowId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${flowId}&resolve=components`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[flowId];\n    }\n}\n", "export const exec = async (getter: any) => {\n    return await getter()\n}\n", "export const __federation__ = \"__federation__\"\nexport const onLoadKey = \"onLoad\"\nexport const moduleInstanceKey = \"moduleInstance\"\n\nexport const defineDynamicImport = (globalName: string, module: any) => {\n    // @ts-ignore\n    if (window[__federation__] && window[__federation__][globalName] && window[__federation__][globalName][onLoadKey]) {\n        // @ts-ignore\n        window[__federation__][globalName][onLoadKey]({[globalName]: module})\n    } else {\n        //console.log('__federation__ loader not defined for module', module);\n    }\n}", "type StringWithAutocomplete<T> = T | (string & Record<never, never>);\n\nexport type MyopMessageKey = StringWithAutocomplete<keyof typeof MyopMessages | keyof typeof MyopMessages.In>;\n\nexport const MyopMessages = {\n    //host to component\n    'InitRequest': 'InitRequest',\n    'InitResponse': 'InitResponse',\n    'InitMessage': 'InitMessage',\n    'DisposeMessage': 'DisposeMessage',\n\n    'ChangeTextMessage': 'ChangeTextMessage',\n    'BindClickMessage': 'BindClickMessage',\n    'DetectMyopRefsMessage': 'DetectMyopRefsMessage',\n\n    'ExecuteScriptMessage': 'ExecuteScriptMessage',\n\n    'AddEventListenerMessage': 'AddEventListenerMessage',\n    'SetAttributeMessage': 'SetAttributeMessage',\n\n    'CreateRefComponentMessage': 'CreateRefComponentMessage',\n    'EnvelopedMessage': 'EnvelopedMessage',\n\n    'GetElementValueMessage': 'GetElementValueMessage',\n    'GetAttributeMessage': 'GetAttributeMessage',\n\n    'SetInnerHtml': 'SetInnerHtml',\n\n    //component messages\n    'ExecuteComponentMethod': 'ExecuteComponentMethod',\n    'SetMutationObserverMessage': 'SetMutationObserverMessage',\n    'SetResizeObserverMessage': 'SetResizeObserverMessage',\n\n    'CleanupMessage': 'CleanupMessage',\n\n    // external to host :\n    In: {\n        'DetectedMyopRefsMessage': 'DetectedMyopRefsMessage',\n        'ClickReplayMessage': 'ClickReplayMessage',\n        'ExecuteScriptReplyMessage': 'ExecuteScriptReplyMessage',\n\n        'EventListenerCallbackMessage': 'EventListenerCallbackMessage',\n        'ElementValueReplayMessage': 'ElementValueReplayMessage',\n\n        \"GetAttributeReplayMessage\": \"GetAttributeReplayMessage\",\n        'RefComponentCreatedMessage': 'RefComponentCreatedMessage',\n        'EnvelopedMessage': 'EnvelopedMessage',\n\n        'MutationObserverMessage': 'MutationObserverMessage',\n        'CleanupReplayMessage': 'CleanupReplayMessage',\n        'ResizeObserverMessage': 'ResizeObserverMessage'\n    }\n}\n", "import {MyopMessageKey, MyopMessages} from \"../../common/MyopMessages\";\nimport {\n    BaseMyopMessage,\n    DisposeMessage, ExecuteComponentMethod, MessageDirection,\n    CleanupMessage, CleanupReplayMessage,\n    MyopBindMessage,\n    MyopBindReplayMessage, Ref\n} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig} from \"../../common\";\nimport {HostSDK, loaderOptions} from \"../hostSDK.ts\";\n\n//TODO : change IMyopComponent to ref specific impl\ntype RefTypes = {\n    [key: string]: IMyopComponent | Ref\n};\n\nexport interface IMyopComponent<P = any, R = any> {\n\n    id: string;\n\n    isInitiated: boolean;\n\n    markedForDisposed: boolean;\n\n    setInitiated: () => void\n\n    componentDefinition: IComponentDefinitionConfig\n\n    container: HTMLElement\n\n    //ref components can be element-less\n    element?: HTMLElement\n\n    send: (msg: BaseMyopMessage) => CleanupHandler\n\n    bind(messageType: MyopMessageKey, handler: () => boolean): void;\n\n    bind<T extends BaseMyopMessage>(messageType: MyopMessageKey, handler: (message: T) => boolean): void;\n\n    // boolean returned value = handled or not\n    onMessageReceived: (msg: BaseMyopMessage) => boolean\n\n    initiated: () => Promise<any>;\n\n    dispose: () => void\n\n    hide(): void;\n\n    show(): void;\n\n    inspect(): void;\n\n    parent?: IMyopComponent;\n\n    props: P\n\n    refs: R\n}\n\nfunction isInheritFrom(obj: any, baseClass: any) {\n    if (!obj) {\n        return false;\n    }\n\n    const proto = Object.getPrototypeOf(obj);\n\n    if (!proto) {\n        return false;\n    }\n\n    if (proto.constructor.name === baseClass.name) {\n        return true;\n    }\n    return isInheritFrom(proto, baseClass);\n}\n\n// TODO : move : \ntype messageHandler<T> = (message: T) => boolean;\n\nexport abstract class BaseMyopComponent<P = any, R extends RefTypes = RefTypes> implements IMyopComponent<P> {\n    id: string = ''\n\n    messageHandlers: Record<string, messageHandler<any>[]> = {};\n\n    element?: HTMLElement\n\n    protected constructor(public componentDefinition: IComponentDefinitionConfig, public container: HTMLElement, options?: loaderOptions) {\n        this.id = options?.id || HostSDK.Instance().assignId(componentDefinition);\n        const timeout = options?.timeout ? options?.timeout : 5 * 1000;\n        setTimeout(() => {\n            if (!this.isInitiated && this._whenInitiatedReject && !this._markedForDisposed) {\n                this._whenInitiatedReject(`timeout_${timeout} ${this.id}`);\n            }\n        }, timeout);\n\n        // TODO : auto inspect, control from config\n        this.initiated().then(() => {\n            // @ts-ignore\n            if (window.myop.hostSDK.inspected) {\n                this.inspect()\n            }\n        });\n    }\n\n    _markedForDisposed: boolean = false;\n\n    get markedForDisposed(): boolean {\n        return this._markedForDisposed;\n    }\n\n    set markedForDisposed(value: boolean) {\n        if (this._markedForDisposed) {\n            throw new Error('InvalidOperationException: The component is already in the process of being disposed. Dispose operation cannot be performed again until the current disposal process is complete.')\n        }\n        this._markedForDisposed = value;\n    }\n\n    abstract hide(): void;\n\n    abstract show(): void;\n\n    abstract inspect(): CleanupHandler;\n\n    //TODO: use bindWhen with return true predicate ...\n    bind = <T extends BaseMyopMessage>(messageType: string, handler: (message: T) => boolean) => {\n        if (!this.messageHandlers[messageType]) {\n            this.messageHandlers[messageType] = []\n        }\n\n        // handle duplicate registration\n        if (!this.messageHandlers[messageType].includes(handler)) {\n            this.messageHandlers[messageType].push(handler);\n        }\n    }\n\n    bindWhen = <T extends BaseMyopMessage>(messageType: string, predicate: (message: T) => boolean, handler: (message: T) => void): CleanupHandler => {\n        if (!handler) {\n            throw new Error('can\\'t use component.bindWhen without an handler');\n        }\n\n        if (!this.messageHandlers[messageType]) {\n            this.messageHandlers[messageType] = []\n        }\n\n        const handlers = this.messageHandlers[messageType];\n\n        const predicateWrappedHandler = (e: T) => {\n            if (predicate(e)) {\n                handler(e);\n                return true;\n            }\n            return false;\n        };\n\n        //TODO : handle duplicate registration ?\n        handlers.push(predicateWrappedHandler);\n\n        return () => {\n            const index = handlers.indexOf(predicateWrappedHandler);\n            if (index > -1) {\n                handlers.splice(index, 1);\n            }\n        }\n    }\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        //console.log('onMessageReceived', document.location.href, incomeMessage, this);\n        //TODO : handel special evets ? like initRes ?\n        if (incomeMessage.messageType === MyopMessages.ExecuteComponentMethod) {\n            const typedMessage = (incomeMessage as ExecuteComponentMethod);\n\n            //keeping this.method() so that context will saved\n            if ((this as any)[typedMessage.method]) {\n                (this as any)[typedMessage.method](typedMessage.content);\n            } else {\n                console.log(`method not found ${typedMessage.method} on component`, this)\n            }\n\n            return true;\n        }\n\n        const handlers = this.messageHandlers[incomeMessage.messageType];\n        if (handlers && handlers.length) {\n            let handled = false;\n\n            handlers.forEach(handler => {\n                handled = handled || handler(incomeMessage)\n            })\n            return handled;\n        } else {\n            //TODO : console only when debug config\n            //console.log('no handlers found for ', incomeMessage)\n        }\n        return false;\n    }\n\n    setInitiated = () => {\n        this.isInitiated = true;\n\n        if (this._whenInitiatedResolve)\n            this._whenInitiatedResolve();\n    }\n\n    isInitiated: boolean = false;\n\n    _whenInitiatedResolve?: (value?: any) => any;\n    _whenInitiatedReject?: (value?: any) => any;\n\n    _whenInitiated: Promise<any> = new Promise((resolve, reject) => {\n        this._whenInitiatedResolve = resolve;\n        this._whenInitiatedReject = reject;\n    });\n\n    initiated = () => {\n        return this._whenInitiated;\n    }\n\n    private sendCleanupMessage(message: CleanupMessage): void {\n        message.source = this.id;\n        message.destination = this.id;\n        message.direction = MessageDirection.down;\n\n        const cleanupHandler = this.bindWhen(message.replyMessageKey, (msg: MyopBindReplayMessage) => {\n            return msg.replayToHandler === message.handlerUniqueId\n        }, (m: CleanupReplayMessage) => {\n            message.handler(m);\n            cleanupHandler();\n        });\n\n        const handler = message.handler;\n        // @ts-ignore\n        delete message.handler\n\n        this.send(message);\n\n        message.handler = handler;\n    }\n\n    send(message: BaseMyopMessage): CleanupHandler {\n        //messages that exetracted from envelope already have source in them\n        if (!message.source)\n            message.source = this.id;\n\n        if (!message.destination)\n            message.destination = this.id;\n\n        message.direction = MessageDirection.down;\n\n        let cleanupHandler;\n        // TODO : fix heavy op..\n        //  if (isInheritFrom(message, MyopBindMessage)) {\n        // @ts-ignore\n        if (message.handler) {\n            const typedMessage = (message as MyopBindMessage);\n            cleanupHandler = this.bindWhen(typedMessage.replyMessageKey, (msg: MyopBindReplayMessage) => {\n                return msg.replayToHandler === typedMessage.handlerUniqueId\n            }, typedMessage.handler);\n\n            // @ts-ignore\n            delete message.handler\n        }\n\n        //TODO: think about that\n        if (message.ref) {\n            // serializable\n            message.ref = message.ref.__nonProxied || message.ref;\n        }\n\n        if (message.cleanable) {\n            return () => {\n                this.sendCleanupMessage(new CleanupMessage(message.id, (replay) => {\n                    //TODO : log replay?\n                }));\n\n                if (cleanupHandler) {\n                    cleanupHandler()\n                }\n            };\n        } else {\n            return () => {\n            }\n        }\n    }\n\n    dispose(): void {\n        this.markedForDisposed = true;\n\n        if (!this.isInitiated) {\n            //TODO : use sdk.logger\n            //console.log('disposing before isInitiated', this.id);\n            return;\n        }\n        console.log('disposing component', this.id);\n\n        // //TODO : implement dispose flow\n        // Object.keys(this.refs).forEach(refKey=>{\n        //     this.refs[refKey].dispose();\n        // });\n\n        //TODO : check if there is any time for the o\n        // ther side to proccess to message before die ?\n        //notify the other side SDK\n        this.send(new DisposeMessage())\n\n        const onDisposeHandlers = this.messageHandlers['onDispose']\n        if (onDisposeHandlers) {\n            onDisposeHandlers.forEach(disposeHandler => {\n                //TODO : send null or fix the type ?\n                disposeHandler(null);\n            })\n        }\n\n        //console.log(this.container);\n        //this.container.innerHTML = '';\n        this.messageHandlers = {}\n        this.id += '_disposed';\n        this.isInitiated = false;\n    }\n\n    props: P = {} as unknown as P;\n    refs: R = {} as unknown as R;\n}\n", "export interface IElementRef {\n    myopId?: string\n    htmlTagName: string\n    BoundingRect?: DOMRect\n    offsetTop?: number\n    offsetLeft?: number\n\n    type: string\n}\n\nexport class XPathElementRef implements IElementRef {\n    constructor(public xPath: string,\n                public htmlTagName: string,\n                public BoundingRect?: DOMRect,\n                public offsetTop?: number,\n                public offsetLeft?: number) {\n    }\n\n    public readonly type: string = 'XPathElementRef'\n}\n\nexport class MyopElementRef implements IElementRef {\n    constructor(public myopId: string,\n                public htmlTagName: string,\n                public BoundingRect?: DOMRect,\n                public offsetTop?: number,\n                public offsetLeft?: number) {\n\n    }\n\n    public readonly type: string = 'MyopElementRef'\n}\n", "import {MyopMessageKey} from \"./MyopMessages\";\nimport {BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage} from \"../messages\";\nimport {CleanupHandler} from \"./index.ts\";\n\nexport type IMessageExecutorCleanup = CleanupHandler | Promise<CleanupHandler> | Promise<void> | void;\n\nexport const runExecutorCleanup = async (task: IMessageExecutorCleanup) => {\n    if (typeof task === 'function') {\n        // It's a function, call it\n        task();\n    } else if (task instanceof Promise) {\n        // It's a Promise, await it\n        const result = await task;\n\n        if (typeof result === 'function') {\n            // If the result is a function, call it\n            result();\n        }\n    }\n    // If task is void, do nothing\n}\n\ntype IMessageExecutor<T extends BaseMyopMessage> = (message: T) => IMessageExecutorCleanup;\n\ninterface IMessageHandler<T extends BaseMyopMessage> {\n    messageType: MyopMessageKey\n\n    executor: IMessageExecutor<T>;\n\n    messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;\n}\n\nexport abstract class BaseMessageHandler<T extends BaseMyopMessage = any> implements IMessageHandler<T> {\n\n    //TODO : add dispose method\n\n    constructor(public messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void) {\n\n    }\n\n    abstract messageType: MyopMessageKey\n    abstract executor: IMessageExecutor<T>;\n}\n\nexport abstract class BaseContextMessageHandler<T extends BaseMyopMessage = any, E = any> extends BaseMessageHandler<T> {\n    constructor(public messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void, public context?: E) {\n        super(messageToHost);\n    }\n}\n", "import {MyopMessages} from \"./MyopMessages\";\nimport {CleanupHandler, runExecutorCleanup} from \"./index.ts\";\nimport {BaseMessageHandler} from \"./baseMessageHandler\";\nimport {\n    BaseMyopMessage, CleanupMessage, CleanupReplayMessage, CreateRefComponentMessage, EnvelopedMessage,\n    InitMessage,\n    InitResponse,\n    MessageDirection,\n    MyopBindMessage,\n    MyopBindReplayMessage\n} from \"../messages\";\n\nexport class HostedComponent<T = any> {\n    send = (message: BaseMyopMessage) => {\n        //debugger;\n    }\n\n    //onMessageReceived: (msg: IMyopMessage) => void;\n\n    constructor(public id: string, public context?: T) {\n\n    }\n}\n\nexport interface IMyopSDK {\n    init: () => void;\n\n    messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void\n\n    supportedHandlers: BaseMessageHandler[];\n\n    handleIncomeMessages: (message: BaseMyopMessage) => void\n\n    components: Record<string, HostedComponent>;\n}\n\n// const localHostHandledMessages = [\n//     MyopMessages.InitRequest,\n//     MyopMessages.InitResponse,\n//     //MyopMessages.EnvelopedMessage,\n// ]\n\nexport abstract class BaseMyopSDK implements IMyopSDK {\n\n    abstract messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;\n\n    abstract supportedHandlers: BaseMessageHandler[];\n\n    messageToHandleAfterInit: BaseMyopMessage[] = [];\n\n    components: Record<string, HostedComponent> = {};\n\n    alwaysPassEnvelopesToHost: boolean = false\n\n    messageCleanupCache: Record<string, CleanupHandler | Promise<CleanupHandler>> | Promise<void> = {};\n\n    handleIncomeMessages(event: any) {\n        const eventContent = event.data ? event.data : event.detail;\n\n        if (!eventContent || !eventContent.myop) {\n            // not myop marked event \n            return;\n        } else {\n            let message = eventContent as BaseMyopMessage;\n\n            if (message.direction !== MessageDirection.down) {\n                //console.log('message dropped in baseSDK, direction was ', event.data.direction)\n                return;\n            }\n\n            // if (localHostHandledMessages.includes(message.messageType)) {\n            //     debugger;\n            //     //TODO : fix direction ? message will not proccess otherwise\n            //     window.myop.hostSDK.send(message)\n            //     return;\n            // }\n\n            if (message.messageType === MyopMessages.DisposeMessage) {\n                //debugger;\n\n                //TODO : should not be optional, fix and remove 'if'\n                if (message.destination)\n                    delete this.components[message.destination]\n                return;\n            }\n\n            // We got our id from our hostSDK\n            if (message.messageType === MyopMessages.InitMessage) {\n                //TODO : SDK may serve more than 1 component .. think about that\n                // @ts-ignore\n                const newComponentId = (message as InitMessage).content.id;\n\n                if (this.components[newComponentId]) {\n                    //debugger;\n                    //throw new Error(\"rechived init message for an exsising component.\")\n                    return;\n                }\n\n                this.components[newComponentId] = new HostedComponent(newComponentId)\n                this.messageToHost(new InitResponse(newComponentId));\n\n                // TODO : is it true to not pass further ( to the component )\n                return;\n            }\n\n            // for same HostSDK cases\n            // when both RefComponent and realComponent hosted in the same HostSDK\n            if (message.messageType === MyopMessages.EnvelopedMessage) {\n                const envelopedMessage = (message as EnvelopedMessage);\n                const innerMessage = envelopedMessage.message;\n                message = innerMessage;\n\n                if (this.alwaysPassEnvelopesToHost || this.components[message.destination!]) {\n                    // @ts-ignore\n                    const destinationComponent = myop.hostSDK.components.find(c => c.id === innerMessage.destination);\n                    if (destinationComponent) {\n                        destinationComponent.send(innerMessage);\n                        return;\n                    }\n\n                    // @ts-ignore\n                    const envelopedDestinationComponent = myop.hostSDK.components.find(c => c.id === envelopedMessage.destination);\n                    if (envelopedDestinationComponent) {\n                        envelopedDestinationComponent.send(innerMessage);\n                        return;\n                    }\n                } else {\n                    return;\n                }\n            }\n\n            // if(message.messageType === MyopMessages.CreateRefComponentMessage){\n            //     const typedMessage : CreateRefComponentMessage = message as CreateRefComponentMessage;\n            // //    debugger;\n            // }\n            if (message.messageType) {\n\n                if (message.messageType === MyopMessages.CleanupMessage) {\n                    const typedMessage = message as CleanupMessage;\n                    const cleanup = this.messageCleanupCache[typedMessage.cleanupForMessageId];\n\n                    const cleanupMessage = new CleanupReplayMessage(!!cleanup);\n                    cleanupMessage.destination = message.destination;\n\n                    if (!!cleanup) {\n                        delete this.messageCleanupCache[typedMessage.cleanupForMessageId];\n                        runExecutorCleanup(cleanup).then(() => {\n                            this.messageToHost(cleanupMessage, typedMessage);\n                        }).catch(() => {\n                            //TODO : handel error?\n                        })\n                    } else {\n                        this.messageToHost(cleanupMessage, typedMessage);\n                    }\n                    return;\n                }\n\n                let actionHandlerFound = false;\n\n                this.supportedHandlers.forEach(handler => {\n                    if (handler.messageType === message.messageType) {\n                        actionHandlerFound = true;\n                        const cleanup = handler.executor(message);\n\n                        if (message.cleanable && cleanup) {\n                            this.messageCleanupCache[message.id] = cleanup;\n                        }\n\n                        if (cleanup && !message.cleanable) {\n                            throw new Error(`Cleanup handler generated for non-cleanable message. \nmessageType - ${message.messageType}, handler executor was - ${handler.executor}\n\nPlease review the message definition object & message handler.\nTo ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`)\n                        }\n\n                        if (!cleanup && message.cleanable) {\n                            throw new Error(`No cleanup handler generated for a cleanable message. \nmessageType - ${message.messageType}, handler executor was - ${handler.executor}\n\nPlease review the message definition object & message handler.\nTo ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`)\n                        }\n                    }\n                })\n\n                if (!actionHandlerFound) {\n                    //TODO : print with debug config only\n                    //console.log('no message handler was found for ', message)\n                }\n            } else {\n                console.log('unsupported message type')\n            }\n        }\n    }\n\n    abstract init: () => void;\n}\n", "import {MyopMessageKey} from \"./MyopMessages\";\n\nexport * from './MyopElementRef';\nexport * from './baseMessageHandler';\nexport * from './BaseMyopSDK';\n\nexport type CleanupHandler = () => void\n\nexport type Dictionary<T> = { [key: string]: T; };\n\n//export type SkinLoaderType = 'IframeLoader' | 'WebComponentLoader' | 'HTMLLoader' | string;\n\nexport const SkinLoaders = {\n    \"IframeLoader\": \"IframeLoader\",\n    \"WebComponentLoader\": \"WebComponentLoader\",\n    \"HTMLLoader\": \"HTMLLoader\",\n    \"MinimizedLoader\": \"MinimizedLoader\"\n} as const;\nexport type SkinLoaderType = keyof typeof SkinLoaders;\n\nexport type PropType = 'any' | 'string' | 'number' | string; // TODO : <\nexport type RefSelectorType = 'id-attribute' | 'css-selector' | 'xpath' | string;\n\nexport const LoaderFrameworks = {\n    \"react\": \"react\",\n    \"vue\": \"vue\",\n    \"angular\": \"angular\",\n} as const\nexport type LoaderFrameworkType = keyof typeof LoaderFrameworks;\n\nexport interface IWebComponentLoaderConfig extends ISkinLoaderConfig {\n    type: \"WebComponentLoader\";\n    url: string,\n    tag: string,\n    framework?: LoaderFrameworkType\n}\n\nexport interface IIframeLoaderConfig extends ISkinLoaderConfig {\n    type: \"IframeLoader\";\n    url: string\n    autoHeight: boolean\n    height?: string\n    width?: string\n}\n\nexport const ShadowRootModeType = {\n    \"open\": \"open\",\n    \"closed\": \"closed\",\n    \"none\": \"none\",\n    \"localFrame\": \"localFrame\"\n} as const;\n\n\nexport interface IHTMLLoaderConfig extends ISkinLoaderConfig {\n    type: \"HTMLLoader\";\n    HTML: string;\n    //TODO: rename(rootMode/customElementMode) + db migration\n    shadowRootMode?: keyof typeof ShadowRootModeType;\n    autoHeight?: boolean;\n    height?: string;\n    width?: string;\n}\n\n//for internal dashboard usage\nexport interface IMinimizedLoaderConfig extends ISkinLoaderConfig {\n    type: \"MinimizedLoader\";\n}\n\ninterface DashboardObject {\n    _temp_client_id?: string,\n}\n\ntype Extend<T, U> = T & U;\n\ntype ExtendRecursively<T, E> = {\n    [K in keyof E]: E[K];\n} & {\n    [K in keyof T]: T[K] extends object\n        ? ExtendRecursively<T[K], E>\n        : T[K];\n};\n\nexport type IDashboard<T> = ExtendRecursively<T, DashboardObject>;\n\nexport interface ISkinLoaderConfig {\n    type: SkinLoaderType\n\n    [key: string]: any; // Allows any additional properties\n}\n\nexport interface v2_IReleaseMetadata {\n    environmentId: string;\n    environmentIdentifier: string;\n    //\n    // updatedOn?: string\n    // updatedBy?: string\n}\n\nexport interface v2_IVariantConfig extends v2_IMyopStoredObject {\n    loader: ISkinLoaderConfig\n    componentId: string;\n\n    releases?: v2_IReleaseMetadata[]\n}\n\nexport interface ISkinConfig {\n    id: string\n    name: string\n    description: string\n    loader: ISkinLoaderConfig\n    createdBy?: string\n    createdOn?: string\n}\n\nexport interface v2_ISkinConfig extends ISkinConfig {\n    componentId: string\n}\n\nexport interface IMessagePropConfig extends IPropConfig {\n    type: PropType\n    messageType: MyopMessageKey\n}\n\nexport interface IBindMessagePropConfig extends IPropConfig {\n    type: PropType\n    messageType: MyopMessageKey\n}\n\nexport const PropMessageModes = {\n    \"input\": \"input\",\n    \"output\": \"output\"\n} as const;\n\nexport const PropConfigBehaviorTypes = {\n    \"message\": \"message\",\n    \"code\": \"code\"\n} as const;\n\nexport interface IPropMessageBehaviorParam {\n    value: string\n}\n\nexport interface IPropBehavior {\n    type: keyof typeof PropConfigBehaviorTypes\n}\n\nexport interface IPropCodeBehavior extends IPropBehavior {\n    type: \"code\"\n    remap?: string\n}\n\nexport interface IPropMessageBehavior extends IPropBehavior {\n    type: \"message\"\n    message: MyopMessageKey\n    ref: string, //TODO make it id\n    params: IPropMessageBehaviorParam[]\n    mode: keyof typeof PropMessageModes\n}\n\nexport interface IPropConfig {\n    id: string\n    name: string\n    description: string\n    type: PropType\n    behavior: IPropBehavior\n}\n\n\nexport class RefBehaviorType {\n    static code = 'code' as const\n    static component = 'component' as const\n}\n\nexport type IRefBehaviorType = 'code' | 'component';\n\nexport interface IRefBehavior {\n    type: IRefBehaviorType\n}\n\nexport interface IComponentRefBehavior extends IRefBehavior {\n    type: 'component'\n    componentId: string\n\n    /**\n     * @deprecated\n     * Property instance is deprecated and will be removed in future versions.\n     */\n    instance: IComponentInstanceConfig\n}\n\nexport interface ICodeRefBehavior extends IRefBehavior {\n    type: 'code'\n}\n\nexport interface IRefConfig {\n    id: string\n    name: string\n    description: string\n    selectorType: RefSelectorType\n    selector: string\n    behavior: IRefBehavior\n}\n\nexport interface IComponentDefinitionConfig {\n    id: string;\n    name: string,\n    description: string,\n    // props: Record<string, IPropConfig> //id - type\n    // refs: Record<string, IRefConfig>,\n    // skins: Record<string, ISkinConfig>\n    props: IPropConfig[],\n    refs: IRefConfig[],\n    skins: ISkinConfig[],\n    defaultSkin: number;\n\n    //TODO : think about that\n    //resolvedDefinitions?: IComponentDefinitionConfig[]\n    //TODO : move to base class ( IStorableItem or so...)\n\n    createdOn?: string\n    createdBy?: string\n    updatedBy?: string\n}\n\n\nexport interface v2_IBaseMyopObject {\n    id: string,\n    name: string,\n    description: string,\n}\n\nexport interface v2_IMyopStoredObject extends v2_IBaseMyopObject {\n    updatedOn?: string\n    updatedBy?: string\n}\n\nexport interface v2_IComponentDefinitionConfig extends v2_IMyopStoredObject {\n    variants_ids: string[],\n    DTOs: v2_IDTO[],\n    tags: string[],\n\n    //\n    variants_names: string[],\n    variants_data: {\n        name: string;\n        id: string\n        updatedOn?: string\n        updatedBy?: string\n        has_releases?: boolean\n    }[],\n\n    preview_variant: v2_IVariantConfig;\n    extra?: {\n        firstVariant: v2_IVariantConfig; //when new component creates at the client\n    }\n}\n\nexport interface v2_IDTO extends v2_IMyopStoredObject {\n    data: object\n    methodName: string\n}\n\nexport interface ISkinInstanceConfig {\n    id: string\n}\n\nexport interface ISkinSelectorConfig {\n    type: keyof typeof SkinSelectorTypes,\n    //skins: ISkinInstanceConfig[]\n}\n\nexport const SegmentType = {\n    \"FunctionResult\": \"FunctionResult\",\n} as const;\n\nexport interface ISegmentInstance {\n    segmentId: string;\n    skinSelector: ISkinSelectorConfig\n}\n\nexport interface ISegmentDefinition {\n    id: string;\n    type: keyof typeof SegmentType\n}\n\nexport interface IFunctionResultsSegment extends ISegmentDefinition {\n    id: string;\n    type: typeof SegmentType.FunctionResult\n    name: string\n    description: string\n    function: string\n}\n\nexport const SkinSelectorTypes = {\n    \"Segmented\": \"Segmented\",\n    \"Dedicated\": \"Dedicated\",\n\n    /**\n     * This Selector Type is not yet supported but will be added in a future release.\n     * Please check the documentation for updates.\n     *\n     * @type {string}\n     */\n    \"Default\": \"Default\"\n} as const;\n\n\n/**\n * This Skin Config Type is not yet supported but will be added in a future release.\n * Please check the documentation for updates.\n *\n * @type {IDefaultSkinConfig}\n */\nexport interface IDefaultSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Default,\n}\n\nexport interface ISegmentedSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Segmented,\n    segments: ISegmentInstance[]\n}\n\nexport interface IDedicatedSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Dedicated,\n\n    /**\n     * @deprecated Use {@link skin} instead.\n     * Property skins is deprecated and will be removed in future versions.\n     * Please update your code to use {@link skin} for better compatibility.\n     *\n     * @type {string}\n     */\n    skins?: ISkinInstanceConfig[] // deprecated\n    skin: ISkinInstanceConfig\n}\n\nexport interface IComponentInstanceConfig {\n    id: string;\n    componentId: string;\n\n    //TODO :\n    // RefID ? to support more than 1 component from the same type in composites ?\n\n    //TODO : remove\n    componentName: string; // << check\n\n    skinSelector: ISkinSelectorConfig\n\n    // storing the nested config for ref components\n    nestedComponents?: IComponentInstanceConfig[]\n\n    //only on GET?\n    //TODO : think about that\n    resolvedExperiences?: IExperience[]\n    // will include instance and def config in order to render in production\n    resolvedNestedComponents?: IComponentConfig[]\n}\n\nexport const ExperienceTypes = {\n    \"Segment\": \"Segment\",\n    \"Promo\": \"Promo\",\n    \"AB\": \"AB\"\n} as const;\n\nexport interface IExperience {\n    id: string\n    name: string\n    description: string\n    type: keyof typeof ExperienceTypes\n    experiences: IExperience[]\n    //stickinessFactor\n    //EndDate\n}\n\n// export interface IABExperienceGroup {\n//     id: string\n//     name: string\n//     percentage: number\n// }\n\nexport interface IABExperience extends IExperience {\n    type: typeof ExperienceTypes.AB\n    // groups: IABExperienceGroup[]\n    experiences: IExperience[]\n    percentage: number\n}\n\nexport interface IDateRange {\n    id: string\n    start: Date\n    end: Date\n    timezone: string\n}\n\nexport interface ISegmentExperience extends IExperience {\n    type: keyof typeof ExperienceTypes\n    segment: ISegmentDefinition\n    dateRange?: IDateRange\n}\n\nexport interface IUserFlowDefinition {\n    id: string;\n    name: string;\n    description: string;\n    components: IComponentInstanceConfig[];\n    origins: string[],\n    experiences: IExperience[]\n    branch?: string\n}\n\nexport interface IComponentConfig {\n    instance: IComponentInstanceConfig\n    type: IComponentDefinitionConfig\n\n    // TODO : verify uniqueness (dashboard & server)\n    name: string\n}\n\ninterface IBranchable {\n    branch?: string\n}\n\nexport interface IUserFlow extends Omit<IUserFlowDefinition, 'components'>, IBranchable {\n    components: IComponentConfig[]\n}\n\nexport class RootRef {\n    constructor(public container: HTMLElement, public shadowRoot?: ShadowRoot) {\n\n    }\n\n    getRootDiv = () => {\n        return (this.shadowRoot || this.container).querySelector('div')\n    }\n\n    getRoot = () => {\n        return (this.shadowRoot || this.container);\n    }\n}\n", "export type Serializable<T> =\n    T extends Function ? never : // Exclude functions\n        T extends Array<infer U> ? Serializable<U>[] : // Handle arrays\n            T extends object ? {\n                [K in keyof T as T[K] extends Function ? never : K]: Serializable<T[K]>\n            } : T; // Handle objects\n\nconst isPrimitive = (value) => {\n    return value !== Object(value);\n}\n\nconst isFunction = (value) => {\n    return typeof value === 'function';\n}\n\nexport const containsPrimitivesOnly = (obj) => {\n    if (isPrimitive(obj)) {\n        return true;\n    }\n\n    if (isFunction(obj)) {\n        return false\n    }\n\n    if (Object.getPrototypeOf(obj)) {\n        return false\n    }\n\n    for (const key in obj) {\n        const value = obj[key];\n        if (typeof value === 'object') {\n            // Recursively check if it's a nested object\n            if (!containsPrimitivesOnly(value)) {\n                return false;\n            }\n        } else if (isPrimitive(value)) {\n            continue; // It's a primitive, so we can skip it\n        } else {\n            return false; // Found a non-primitive value\n        }\n    }\n\n    return true; // All values are primitives or nested objects with primitives\n}\n\n// currently support root level only\n// {x: 1, y : 'a', z : ()=>{...}, inner : { x: 1 , y : 'a'} }\n// {x: 1, y : 'a'}\n//https://developer.mozilla.org/en-US/docs/Glossary/Falsy\nexport type SerializableSkeleton<T> = Partial<Record<keyof T, boolean | Partial<Record<string, boolean>>>> | boolean;\n\nexport const makeSerializable = <T>(\n    obj: T,\n    skeleton: SerializableSkeleton<T> = {},\n    includeFalsyKeys: boolean = true, // TODO : use that arg\n    seen: WeakMap<object, Serializable<any>> = new WeakMap()\n): Serializable<T> => {\n\n    if (isPrimitive(obj)) {\n        return obj as Serializable<T>; // Directly return primitive values\n    }\n\n    if (Array.isArray(obj)) {\n        if (seen.has(obj)) {\n            return seen.get(obj)!; // Return the already processed object\n        }\n\n        // Handle array serialization\n        const serializableArray: Serializable<any>[] = [];\n        seen.set(obj, serializableArray); // Store the array in seen\n\n        for (let index = 0; index < obj.length; index++) {\n            const element = obj[index];\n            serializableArray[index] = makeSerializable(element, skeleton, includeFalsyKeys, seen);\n        }\n        return serializableArray as Serializable<T>;\n    }\n\n    if (obj !== null && typeof obj === 'object') {\n        // Check for cyclic references\n        if (seen.has(obj)) {\n            return seen.get(obj)!; // Return the already processed object\n        }\n        const serializableObject: Partial<Serializable<T>> = {};\n        seen.set(obj, serializableObject); // Store the object in seen\n\n        for (const key in obj) {\n            // Check if the key is in the skeleton and if it's a valid key to serialize\n\n            const keyInSkeleton = typeof skeleton == \"boolean\" ? skeleton : skeleton[key];\n\n            if (keyInSkeleton) {\n                if (keyInSkeleton === true) {\n                    // If the skeleton indicates to serialize this key\n                    if (includeFalsyKeys ? obj[key] !== undefined : obj[key]) {\n                        // @ts-ignore\n                        serializableObject[key] = makeSerializable(obj[key], true, includeFalsyKeys, seen);\n                    }\n                } else if (typeof keyInSkeleton === 'object') {\n                    // If the skeleton indicates nested keys to serialize\n                    // @ts-ignore\n                    serializableObject[key] = makeSerializable(obj[key], keyInSkeleton, includeFalsyKeys, seen);\n                }\n            }\n        }\n        return serializableObject as Serializable<T>;\n    }\n\n    return {} as any; // Return an empty object for other cases\n}\n", "export const Errors = {\n    notSerializableRefCall: (prop, arg) => {\n        throw new Error(`\nThe input provided to '${prop.toString()}' is not serializable. Serialization is required to ensure that the data can be safely transferred to the skin implementation. \nThe following types of data are considered non-serializable and cannot be processed:\n\n- Functions\n- DOM elements\n- Class instances\n- Circular references\n- Symbols\n- BigInt values\n\nIn the following execution we detected :\n~~~~~~~~\n${arg} \n~~~~~~~~\nas not serializable.\n\nTo resolve this issue, please ensure that all inputs passed to '${prop.toString()}' are in a serializable format.\nThis typically includes primitive types (strings, numbers, booleans), arrays, and plain objects. \nIf you need to include complex data types, consider converting them to a serializable structure before passing them to the function.\nOr use Myop message that support it: CustomRefMessage, AddEventListenerMessage or ExecuteScriptMessage.\n\nSuggested Fix:\n1. Remove or replace non-serializable values from your input.\n2. If using objects, ensure they do not contain any functions or circular references.\n3. Convert any class instances to plain objects or JSON-compatible formats.\n4. Use dedicated Myop message.\n\nFor more details on serialization and Myop message examples, refer to https://docs.myop.dev\\.\n\n`);\n    }\n}\n\n", "import {BaseMyopComponent, IMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage, ExecuteComponentMethod} from \"../../messages\";\nimport {IComponentDefinitionConfig} from \"../../common\";\nimport {EnvelopedMessage} from \"../../messages/EnvelopedMessage\";\nimport {loaderOptions} from \"../hostSDK.ts\";\n\nexport class MyopRefComponent extends BaseMyopComponent {\n\n    constructor(public componentDefinition: IComponentDefinitionConfig, public parent: IMyopComponent, options?: loaderOptions) {\n        //TODO : check parentComponent.container...\n        super(componentDefinition, parent.container, options);\n    }\n\n    hide() {\n        //this.send(new ExecuteComponentMethod(arguments.callee.name));\n        this.send(new ExecuteComponentMethod('hide'));\n    }\n\n    show() {\n        this.send(new ExecuteComponentMethod('show'));\n    }\n\n    inspect() {\n        //TODO : support real cleanup\n        //console.log('ref inspect called, creating ExecuteComponentMethod inspect', document.location.href, this.id);\n        return this.send(new ExecuteComponentMethod('inspect'));\n    }\n\n    setHeightBasedOnDocumentElement() {\n        // @ts-ignore\n        this.send(new ExecuteComponentMethod('setHeightBasedOnDocumentElement'));\n    }\n\n    setHeightBasedOnScrollHeight() {\n        // @ts-ignore\n        this.send(new ExecuteComponentMethod('setHeightBasedOnScrollHeight'));\n    }\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        // if (incomeMessage.messageType === 'MutationObserverMessage') {\n        //  debugger;\n        //     this.setHeightBasedOnScrollHeight();\n        //     return true;\n        // }\n        return super.onMessageReceived(incomeMessage);\n    }\n\n\n    send = (message: BaseMyopMessage) => {\n        //console.log('ref message sending ', message);\n        // @ts-ignore\n        const handler = message.handler\n        const cleanupHandler = super.send(message);\n\n        // this.id will be available on the nested component\n        this.parent.send(new EnvelopedMessage(this.id, message));\n\n        // @ts-ignore\n        message.handler = handler\n        return cleanupHandler;\n    };\n\n    dispose = () => {\n        if (this.isInitiated)\n            this.send(new ExecuteComponentMethod('dispose'));\n        super.dispose();\n    }\n}\n", "//type AConstructorTypeOf<T> = new (...args: any[]) => T;\nimport {IMyopComponent} from \"./components/IMyopComponent\";\nimport {CreateRefComponentMessage, CustomRefMessage, Ref} from \"../messages\";\nimport * as messages from \"../messages\";\nimport {\n    CleanupHandler, IComponentConfig,\n    type IComponentDefinitionConfig,\n    IComponentRefBehavior, IHTMLLoaderConfig, IPropCodeBehavior,\n    IPropConfig, ISkinConfig, PropConfigBehaviorTypes,\n    RefBehaviorType, ShadowRootModeType, SkinLoaders, SkinLoaderType\n} from \"../common\";\nimport {containsPrimitivesOnly} from \"../common/utils/serialization\";\nimport {Errors} from \"./logMessages\";\nimport {MyopRefComponent} from \"./components/myopRefComponent\";\nimport {loaderOptions} from \"./hostSDK\";\n\ntype componentDefinitionProps = IComponentDefinitionConfig['props']\n\nconst createDebugTitle = (text: string, top: number, componentDefinitionConfig: IComponentDefinitionConfig) => {\n    const titleEl = document.createElement('a');\n    titleEl.textContent = text;\n    titleEl.style.position = 'relative';\n    titleEl.style.padding = '0 5px';\n    titleEl.style.fontSize = '14px';\n    titleEl.style['top'] = '0';\n    titleEl.style.top = `${top}px`;\n    //titleEl.style.left = '50%';\n    titleEl.style.transform = 'translateX(-50%)';\n    titleEl.target = '_blank';\n    titleEl.href = `https://dashboard.myop.dev/dashboard/component/${componentDefinitionConfig.id}`\n\n    return titleEl;\n};\n\nexport const setDebugStyle = (id: string,\n                              type: string,\n                              top: number,\n                              container: HTMLElement,\n                              componentElement: HTMLElement,\n                              componentDefinitionConfig: IComponentDefinitionConfig\n): CleanupHandler => {\n    //#007BFF (blue) or #FF5722 (orange)\n    //#4CAF50 (green) or #FFC107 (amber)\n    // const topText = createDebugTitle(`${id} : ${type}`, top, componentDefinitionConfig);\n    const topText = createDebugTitle(`${componentDefinitionConfig.name} : ${type}`, top, componentDefinitionConfig);\n    container.insertBefore(topText, componentElement);\n    componentElement.style.border = '1px solid #007BFF';\n    componentElement.style.display = 'block';\n\n    return () => {\n        componentElement.style.border = 'unset';\n        container.removeChild(topText);\n    }\n}\n\nconst reportError = (propConfig: IPropConfig, propName: string, component: IMyopComponent<any, any>) => {\n    if (!propConfig) {\n\n        console.error(\n            // throw new Error(\n            `Error: Undefined Prop\\n\\n` +\n            `It looks like you've tried to use a prop that hasn't been defined.\\n` +\n            `Please check the prop name for any typos or ensure that it is properly defined in the component's prop list.\\n\\n` +\n            `Prop Name: ${propName}\\n` +\n            `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n            `For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`\n        );\n        return true\n    }\n    return false\n}\n\nconst reportUnsupported = (propConfig: IPropConfig, propName: string, component: IMyopComponent<any, any>) => {\n    console.error(\n        `Error: Code Prop Not Supported\\n\\n` +\n        `Currently, code props are only supported in local frame components.\\n` +\n        `\u26A0\uFE0F This is a work in progress feature \u2014 code props will be supported in upcoming versions.\\n\\n` +\n        `In the meantime, you can use message props.\\n\\n` +\n        `Prop Name: ${propName}\\n` +\n        `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n        `For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`\n    );\n}\n\nexport const connectProps = <T extends componentDefinitionProps>(component: IMyopComponent, propsConfig: IPropConfig[], selectedSkin: ISkinConfig) => {\n\n    const propsMap = propsConfig.reduce((previousValue, currentValue) => {\n        return {\n            ...previousValue,\n            [currentValue.name]: {...currentValue}\n        }\n    }, {});\n\n    const propsHandler = {\n        get: (_: IMyopComponent, prop: string) => {\n            // @ts-ignore\n            const propConfig = propsMap[prop];\n\n            if (reportError(propConfig, prop, component)) {\n                return false;\n            }\n\n            if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {\n\n                if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {\n                    const typedLoader = selectedSkin.loader as IHTMLLoaderConfig;\n                    // for local frame component\n                    if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {\n                        const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                        // @ts-ignore\n                        return component.element.contentWindow[typedPropBehavior.remap || prop]\n                    }\n                }\n\n                reportUnsupported(propConfig, prop, component);\n                return false;\n            }\n\n            if (propConfig.mode === 'output') {\n                return new Promise((resolve) => {\n                    const messageParams: any[] = [];\n                    //TODO : turn it into config\n                    if (propConfig.behavior.ref) {\n                        messageParams.push(Ref.create(propConfig.behavior.ref));\n                    }\n\n                    messageParams.push((data: any) => {\n                        resolve(data);\n                    });\n\n                    if (propConfig.behavior.params) {\n                        messageParams.push(...propConfig.behavior.params);\n                    }\n\n                    // @ts-ignore\n                    const messageCtor = messages[propConfig.behavior.message];\n\n                    component.send(new messageCtor(...messageParams));\n                })\n            }\n            return null\n        },\n        set: (_: IMyopComponent, prop: string, value: any) => {\n            // @ts-ignore\n            const propConfig = propsMap[prop];\n\n            if (reportError(propConfig, prop, component)) {\n                return false;\n            }\n\n            if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {\n                if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {\n                    const typedLoader = selectedSkin.loader as IHTMLLoaderConfig;\n                    // for local frame component\n                    if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {\n                        const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                        // @ts-ignore\n                        component.element.contentWindow[typedPropBehavior.remap || prop] = value;\n\n                        return true\n                    }\n                }\n\n                reportUnsupported(propConfig, prop, component);\n                return false;\n            } else {\n                //if(propConfig.behavior === PropConfigBehaviorTypes.message)\n                if (propConfig.mode === 'input') {\n                    //TODO : support multi behaviors\n\n                    if (propConfig.behavior.type === 'message') {\n                        const messageParams: any[] = [];\n                        //TODO : turn it into config\n                        if (propConfig.behavior.ref) {\n                            messageParams.push(Ref.create(propConfig.behavior.ref));\n                        }\n                        messageParams.push(value);\n                        if (propConfig.behavior.params) {\n                            messageParams.push(...propConfig.behavior.params);\n                        }\n\n                        // @ts-ignore\n                        const messageCtor = messages[propConfig.behavior.message];\n                        component.send(new messageCtor(...messageParams));\n                        return true\n                    } else {\n                        throw new Error(\n                            `Error: Unsupported Behavior\\n\\n` +\n                            `The 'behavior' field provided is not supported.\\n` +\n                            `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n                            `Prop Name: ${prop}\\n` +\n                            `Behavior Field: ${propConfig.behavior.type}\\n\\n` +\n                            `Check the documentation for valid behavior options.`\n                        );\n\n                        return false\n                    }\n                }\n            }\n            return false\n        }\n    }\n\n    component.props = {};\n    component.props = new Proxy(component.props, propsHandler);\n\n    return component as (Omit<IMyopComponent, 'props'> & {\n        props: propTypes<T>\n    })\n}\n\nexport const createRefProxy = (target: Ref, component: IMyopComponent) => {\n    return new Proxy(target, {\n        get(target, prop) {\n\n            // if (prop === '__nonProxied') {\n            //     return target;\n            // }\n\n            // @ts-ignore\n            if (target[prop]) {\n                // @ts-ignore\n                return target[prop];\n            }\n\n            // @ts-ignore\n            const getterFunction = (...args) => {\n                return new Promise((resolve) => {\n                    args.forEach(arg => {\n                        if (!containsPrimitivesOnly(arg)) {\n                            Errors.notSerializableRefCall(prop, arg);\n                        }\n                    });\n                    component.send(new CustomRefMessage(({ref, propName, functionArgs, makeSerializable}) => {\n                            if (ref) {\n                                // @ts-ignore\n                                const value = ref[propName];\n                                if (typeof value === 'function') {\n                                    // @ts-ignore\n                                    return makeSerializable(ref[propName](...functionArgs), true) // Invoke the function and return its result\n                                } else {\n                                    // @ts-ignore\n                                    return makeSerializable(value, true); // Return the property value\n                                }\n                            }\n                            return null;\n                        },\n                        {\n                            //TODO : turn it to config\n                            elementId: target.refConfig.selector,\n                            propName: prop,\n                            functionArgs: args\n                        },\n                        (msg) => {\n                            resolve(msg.content);\n                        }))\n                });\n            };\n\n            //TODO: we can implement things like auto serialization and binding functions here\n            //getterFunction.test = '123';\n\n            return getterFunction;\n\n            //return Reflect.get(target, prop);\n        },\n        set(target, prop: string, value) {\n            component.send(new CustomRefMessage(({ref, propName, propValue}) => {\n                    if (ref)\n                        // @ts-ignore\n                        ref[propName] = propValue;\n                },\n                {\n                    //TODO : fix that\n                    elementId: target.refConfig.selector,\n                    propValue: value,\n                    propName: prop\n                },\n                (msg) => {\n                    //TODO : log?\n                }))\n            return true;\n        },\n    });\n}\n\nexport const createRefComponent = async <T extends IMyopComponent = IMyopComponent>(ref: Ref, componentConfig: IComponentConfig, components: IMyopComponent[], options?: loaderOptions): Promise<T> => {\n    const component = ref.component;\n    if (!component)\n        throw new Error('cant createRefComponent with detached ref');\n\n    //console.log('createRefComponent called', ref, componentConfig);\n\n    return new Promise(async (resolve, reject) => {\n        const refComponent = new MyopRefComponent(componentConfig.type, component, options);\n        components.push(refComponent);\n\n        //for cases where ref components define in the component config\n        // we need to wait for the root component the be initiated before interacting with it\n        await component.initiated();\n\n\n        //TODO :\n        const timeout = setTimeout(() => {\n            //reject('timeout?');\n            reject('timeout');\n        }, 5000);\n\n        component.send(new CreateRefComponentMessage(ref.refConfig,\n            componentConfig,\n            {\n                ...options ? options : {},\n                id: refComponent.id,\n                _hasParent: true\n            },\n            async (message) => {\n\n                //TODO : check if timeout already passed\n                clearTimeout(timeout);\n\n                if (message.failed) {\n                    //TODO :\n                    reject('CreateRefComponentMessage failed');\n                    return;\n                }\n\n                const implementationComponent = components.find(c => c.id == refComponent.id);\n\n                //same memory env, same HostSDK\n                if (implementationComponent !== refComponent) {\n                    //TODO : clean refComponent ?\n\n                    component.refs[ref.refConfig.name] = implementationComponent;\n                    resolve(implementationComponent as unknown as T);\n                    return;\n                } else {\n                    refComponent.setInitiated()\n                    component.refs[ref.refConfig.name] = refComponent;\n                }\n\n                //TODO : here >\n                //TODO : what about reapters ?! dynamic ?!\n                // const exsistingRefComponent = component.refs[ref.refConfig.name] as MyopRefComponent;\n                // if (exsistingRefComponent.id && exsistingRefComponent.parent) {\n                //     component.refs[ref.refConfig.name] = [component.refs[ref.refConfig.name], refComponent];\n                // } else if (Array.isArray(component.refs[ref.refConfig.name])) {\n                //     component.refs[ref.refConfig.name].push(refComponent)\n                // } else {\n                //   component.refs[ref.refConfig.name] = refComponent; //hostSDK.components.find(c => c.id === refComponent.id)!;\n                // }\n\n                //TODO : in webcomponent case the same id will alreday be here, which is good !\n                // name:\n                //     id\n                //     componentDefinitionId\n\n                // for inner components inside ref component :\n                message.nestedRefs.forEach(nestedRefConfig => {\n                    const nestedComponentDefinition = componentConfig.instance.resolvedNestedComponents!.find(c => c.type.id === nestedRefConfig.componentDefinitionId)!.type;\n                    //const nestedComponentDefinition = component.componentDefinition.resolvedDefinitions?.find(def => def.id === nestedRefConfig.componentDefinitionId)!;\n                    // const refConfig = componentConfig.type.refs.find(r => r.name === nestedRefConfig.refName);\n                    // if (!refConfig) {\n                    //     throw new Error('no refConfig found for nested ref');\n                    // }\n\n                    //debugger;\n\n                    const nestedComponent = new MyopRefComponent(nestedComponentDefinition, refComponent);\n                    nestedComponent.setInitiated();\n                    refComponent.refs[nestedRefConfig.refName] = nestedComponent;\n                    components.push(nestedComponent);\n                });\n\n\n                try {\n                    await connectRefs(refComponent, componentConfig, components, true);\n\n                    //TODO :use config check for auto-hight and convert type properly\n                    // @ts-ignore\n                    if (component.setHeightBasedOnScrollHeight)\n                        // @ts-ignore\n                        component.setHeightBasedOnScrollHeight();\n\n                    resolve(refComponent as unknown as T);\n                } catch (e) {\n                    //debugger\n                    reject(e);\n                    // throw e\n                }\n            }));\n    })\n}\n\nexport const connectRefs = async (component: IMyopComponent, componentConfig: IComponentConfig, components: IMyopComponent[], withoutRefComponents: boolean = false) => {\n\n    if (!component.refs)\n        component.refs = {};\n\n    const waitFor = Object.values(component.componentDefinition.refs).map(ref => {\n        return new Promise<void>(async (resolve, reject) => {\n            if (ref.behavior.type == RefBehaviorType.component) {\n                // component.refs[ref.name] =\n\n                if (withoutRefComponents) {\n                    resolve();\n                    return;\n                }\n\n                // component.\n                //TODO : change to get it from the flow\n                let refComponentId = (ref.behavior as IComponentRefBehavior).componentId;\n                if (!refComponentId)\n                    refComponentId = (ref.behavior as IComponentRefBehavior).instance.componentId\n\n                // if (!component.componentDefinition.resolvedDefinitions) {\n                //     reject(new Error('componentConfig provided without resolvedDefinitions check the config object'));\n                //     //throw new Error('componentConfig provided without resolvedDefinitions check the config object');\n                // }\n                // const componentDefinitionConfig = component.componentDefinition.resolvedDefinitions!.find(compdef => compdef.id === refComponentId)!;\n                // //const componentDefinitionConfig = await getComponentDefinitionConfig(componentInstanceConfig.componentId);\n                //\n                // if (!componentDefinitionConfig) {\n                //     reject(new Error('componentConfig provided without resolvedDefinitions check the config object'));\n                //     return;\n                // }\n\n                //TODO: if we have the same component more than once we will need instance id here ...\n                const nestedComponentConfig = componentConfig.instance.resolvedNestedComponents?.find(nestedComponent => nestedComponent.type.id === refComponentId);\n\n                if (!nestedComponentConfig) {\n                    throw new Error('componentConfig provided without nestedComponentConfig check the config object');\n                    return;\n                }\n\n                //const componentInstanceConfig = componentConfig.instance.nestedComponents?.find(componentInstace => componentInstace.componentId === componentDefinitionConfig.id);\n                // if(!componentDefinitionConfig){\n                //     throw new Error('TODO TODO TODO ');\n                //     return;\n                // }\n\n                //TODO :think about that :\n                //   componentDefinitionConfig.resolvedDefinitions = component.componentDefinition.resolvedDefinitions;\n                //   const nestedComponentConfig: IComponentConfig = {\n                //       instance: nestedComponentConfig.instance!,\n                //       type: nestedComponentConfig.type,\n                //       name: nestedComponentConfig.name\n                //   }\n\n                const _ref = Ref.create('', ref, component);\n\n                try {\n                    //console.log('nested !! createRefComponent called');\n                    const nestedComponent = await createRefComponent(_ref, nestedComponentConfig!, components)\n                    //TDOO : put that ref component somewhere?\n\n                    // debugger;\n                    component.refs[ref.name] = nestedComponent;\n\n                    resolve();\n                } catch (e) {\n                    reject(e);\n                }\n            } else {\n                try {\n                    const __nonProxied = Ref.create('', ref, component);\n                    component.refs[ref.name] = createRefProxy(__nonProxied, component);\n                    resolve();\n                } catch (e) {\n                    //alert('?')\n                }\n            }\n        })\n    })\n    try {\n        await Promise.all(waitFor);\n    } catch (e) {\n        //debugger\n        throw e;\n    }\n\n}\n\nexport type propTypes<T extends componentDefinitionProps> = {\n    [Property in keyof T]:\n    T[Property] extends { mode: 'input' } ?\n        T[Property]['type'] :\n        Promise<T[Property]['type']>\n}\n\nexport const exec = async (getter: any) => {\n    return await getter()\n}\n\nexport const actAs = <T>(ref: Ref) => {\n    return ref as unknown as FunctionifyRef<T>\n}\n\nexport type FunctionifyRef<T = any> = {\n    [K in keyof T]: T[K] extends (...args: infer A) => infer R // If it's a function\n        ? (...args: A) => Promise<R> // Convert it to a promised function\n        : T[K]\n};\n", "import {BaseMyopComponent} from \"./IMyopComponent\";\nimport {\n    BaseMyopMessage,\n    ExecuteComponentMethod,\n    ExecuteScriptMessage, MessageDirection\n} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, IIframeLoaderConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {MyopMessages} from \"../../common/MyopMessages.ts\";\nimport {loaderOptions} from \"../hostSDK.ts\";\n\nexport class MyopIframeComponent extends BaseMyopComponent {\n\n    constructor(public componentConfig: IComponentDefinitionConfig, skin: ISkinConfig, public container: HTMLElement, private IframeElement: HTMLIFrameElement, options?: loaderOptions) {\n        super(componentConfig, container, options)\n\n        if ((skin.loader as IIframeLoaderConfig).autoHeight) {\n            this.initiated().then(() => {\n                this.setHeightBasedOnScrollHeight();\n            })\n        }\n        this.element = this.IframeElement;\n        // this.IframeElement.addEventListener('error', () => {\n        //     if (this._whenInitiatedReject)\n        //         this._whenInitiatedReject(`IframeElement error`);\n        // });\n    }\n\n    cleanupInspect?: CleanupHandler;\n\n    inspect() {\n        // TODO : use better check for inspect mode\n        if (this.cleanupInspect) {\n            //console.log('inspect call more than once');\n            return this.cleanupInspect\n        }\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopIframeComponent', 10, this.container, this.IframeElement, this.componentDefinition);\n        return () => {\n            this.cleanupInspect!();\n            this.cleanupInspect = undefined;\n        };\n    }\n\n    hide() {\n        this.IframeElement.style.opacity = '0';\n        this.IframeElement.style.position = 'absolute'\n        this.IframeElement.style.pointerEvents = 'none'\n        this.IframeElement.style.visibility = 'hidden';\n    }\n\n    show() {\n        this.IframeElement.style.opacity = '1';\n        this.IframeElement.style.position = 'unset'\n        this.IframeElement.style.pointerEvents = 'all'\n        this.IframeElement.style.visibility = 'visible';\n    }\n\n    setHeightBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            return window.document.documentElement.scrollHeight;\n        }, (ret) => {\n            this.IframeElement.style.height = `${ret.content}px`;\n            cleanupHandler();\n        }));\n    }\n\n    observeSizeBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(({send}) => {\n            const {height, width} = document.documentElement.getBoundingClientRect();\n\n            const observer = new ResizeObserver(() => {\n                const {height, width} = document.documentElement.getBoundingClientRect();\n                send({height, width});\n            });\n            observer.observe(document.documentElement);\n            observer.observe(document.body);\n\n            return {height, width}\n        }, (ret) => {\n            this.IframeElement.style.width = `${ret.content.width}px`;\n            this.IframeElement.style.height = `${ret.content.height}px`;\n        }));\n\n        return cleanupHandler;\n    }\n\n    setSizeBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            const {height, width} = document.documentElement.getBoundingClientRect();\n            return {height, width}\n        }, (ret) => {\n            this.IframeElement.style.width = `${ret.content.width}px`;\n            this.IframeElement.style.height = `${ret.content.height}px`;\n            cleanupHandler();\n        }));\n    }\n\n    setHeightBasedOnScrollHeight = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            // @ts-ignore\n            // return window.document.body.scrollHeight + 'px';\n\n\n            //TODO: fix that hack, keep the function in right format while minified :(\n            const noOp = () => {\n                // No operation performed\n                return 0;\n            }\n            // To ensure it's not optimized away, you can call it at least once\n            let x = noOp();\n            x++;\n            x--;\n\n            //return `${window.document.body.offsetHeight}px`;\n\n            //TODO : check that +1 ?\n            return Math.max(Math.max(\n                    window.document.body.clientHeight,\n                    window.document.body.scrollHeight)\n                , window.document.body.offsetHeight) + x + 'px'\n\n        }, (ret) => {\n            this.IframeElement.style.height = ret.content;\n            cleanupHandler();\n        }));\n    }\n\n    send = (message: BaseMyopMessage): CleanupHandler => {\n        let message_ = {...message} as BaseMyopMessage;\n        //TODO : ?!?! should it be here ?\n        if (message_.messageType === MyopMessages.ExecuteComponentMethod) {\n            const typedMessage = (message_ as ExecuteComponentMethod)\n            this[typedMessage.method]();\n            return () => {\n            }\n        }\n\n        //TODO : fix that hack :(\n        // @ts-ignore\n        //const handler = message.handler\n\n        message_.direction = MessageDirection.down;\n        const cleanupHandler = super.send(message_);\n        this.IframeElement?.contentWindow?.postMessage(message_, '*');\n\n        // @ts-ignore\n        //message.handler = handler\n\n        return cleanupHandler;\n    };\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        if (incomeMessage.messageType === MyopMessages.In.MutationObserverMessage\n            || incomeMessage.messageType === MyopMessages.In.ResizeObserverMessage) {\n            this.setHeightBasedOnScrollHeight();\n            //debugger\n            //this.setHeightBasedOnDocumentElement();\n            return true;\n        }\n\n        return super.onMessageReceived(incomeMessage);\n    }\n\n    dispose = () => {\n        if (this.cleanupInspect)\n            this.cleanupInspect();\n\n        super.dispose();\n        this.IframeElement.parentNode!.removeChild(this.IframeElement);\n    }\n}\n", "import {IMyopComponent} from \"../components/IMyopComponent\";\nimport {loaderOptions} from \"../hostSDK\";\nimport {IComponentDefinitionConfig, ISkinConfig, SkinLoaderType} from \"../../common\";\n\nexport interface IMyopLoader {\n    type: SkinLoaderType;\n    load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;\n}\n\nexport abstract class BaseMyopLoader implements IMyopLoader {\n    abstract type: SkinLoaderType;\n    abstract load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;\n\n    appendChild = (container: HTMLElement, element: HTMLElement, options?: loaderOptions,) => {\n        if (options?.relative) {\n            if (options.relative.direction === 'before') {\n                return container.insertBefore(element, options.relative.child);\n            }\n\n            if (options.relative.direction === 'after') {\n                const nextSibling = options.relative.child?.nextSibling;\n                return container.insertBefore(element, nextSibling ? nextSibling : null);\n            }\n        } else {\n            return container.appendChild(element);\n        }\n    }\n}\n", "import {MyopIframeComponent} from \"../components/myopIframeComponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {uuidv4} from \"../../utils/utils\";\nimport {loaderOptions} from \"../hostSDK\";\nimport {IComponentDefinitionConfig, IIframeLoaderConfig, ISkinConfig, SkinLoaders} from \"../../common\";\n\nconst addQueryParam = (url: string, param: string, value: string) => {\n    // Create a URL object\n    const urlObj = new URL(url);\n\n    // Add the query parameter\n    urlObj.searchParams.append(param, value);\n\n    // Return the updated URL\n    return urlObj.toString();\n}\n\nexport class MyopIframeLoader extends BaseMyopLoader {\n    type = SkinLoaders.IframeLoader\n\n    // @ts-ignore\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n        let IframeElement: HTMLIFrameElement;\n\n        const typedLoaderConfig = (skin.loader as IIframeLoaderConfig);\n\n        if (container?.nodeName === \"IFRAME\") {\n            console.log('needs to load into an exsisting Iframe...', typedLoaderConfig.url, container);\n\n            IframeElement = (container as HTMLIFrameElement)\n            IframeElement.src = typedLoaderConfig.url\n        } else {\n            const uniqId = uuidv4();\n            const domId = `myop-comp-${uniqId}`\n\n            // console.log('needs to create new Iframe...', domId, typedLoaderConfig.url, container);\n            IframeElement = document.createElement('iframe');\n\n            // TODO : do it only with flag ?\n            if (!container.querySelector('[id^=\"myop-comp-\"]'))\n                container.innerHTML = '';\n\n            //TODO : check that :\n            if (options?.hidden) {\n                IframeElement.style.visibility = 'hidden';\n            }\n\n            IframeElement = this.appendChild(container, IframeElement, options) as HTMLIFrameElement;\n\n            // in order to handle issue to load iframe inside an iframe with the same url\n            let url2load = (skin.loader as IIframeLoaderConfig).url;\n            //const uniqUrl = url2load === document.location.href ? addQueryParam(url2load, \"_m\", domId) : url2load\n            if (options?._hasParent)\n                url2load = addQueryParam(url2load, \"_myop-comp\", uniqId);\n\n            //TODO : handle 'style' attr merge here\n            let elementAttributesString = '';\n            if (options?.elementAttributes)\n                elementAttributesString = Object.entries(options?.elementAttributes)\n                    .map(([key, value]) => {\n                       if (value === '' || value === null || value === undefined) {\n                            return key;\n                        }\n                        return `${key}=\"${String(value)}\"`;\n                    })\n                    .join(' ');\n\n            IframeElement.outerHTML = `<iframe \n               id=\"${domId}\"\n               style=\"\n                   padding: 0;\n                   margin: 0;\n                   height: ${typedLoaderConfig.autoHeight || !typedLoaderConfig.height ? '' : typedLoaderConfig.height};    \n                   width : 100%;\n                   overflow: hidden;\n                   border: none;\n                   opacity: ${options?.hidden ? '0' : '1'};\n                   position: ${options?.hidden ? 'absolute' : 'static'};\n                   pointer-events: ${options?.hidden ? 'none' : 'all'};\n               \"\n            src=\"${url2load}\"\n            ${elementAttributesString}\n            ></iframe>`;\n\n            IframeElement = container.querySelector(`#${domId}`) as HTMLIFrameElement;\n\n            //   IframeElement = document.getElementById(domId) as HTMLIFrameElement;\n            //NO : IframeElement = container.lastElementChild as HTMLIFrameElement;\n        }\n\n        return new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);\n    }\n}\n", "export const myopWebcomponentConsts = {\n    webcomponent_message_key: 'myop_webcomponent_message'\n}\n", "import {myopWebcomponentConsts} from \"../../webcomponent/consts\";\nimport {BaseMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {loaderOptions} from \"../hostSDK\";\n\nexport class MyopWebComponent extends BaseMyopComponent {\n\n    constructor(componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, public container: HTMLElement, private customElement: HTMLElement, options?: loaderOptions) {\n        super(componentDefinition, container , options);\n        this.element = customElement;\n    }\n\n    cleanupInspect: CleanupHandler = () => {\n    }\n\n    inspect() {\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopWebComponent', 0, this.container, this.customElement, this.componentDefinition);\n        return this.cleanupInspect;\n    }\n\n    hide() {\n        this.customElement.style.opacity = '0';\n        this.customElement.style.position = 'absolute'\n        this.customElement.style.pointerEvents = 'none'\n        this.customElement.style.visibility = 'hidden';\n        this.customElement.style.height = '0'\n        this.customElement.style.width = '0'\n    }\n\n    show() {\n        this.customElement.style.opacity = '1';\n        this.customElement.style.position = 'unset'\n        this.customElement.style.pointerEvents = 'all'\n        this.customElement.style.visibility = 'visible';\n        this.customElement.style.height = '';\n        this.customElement.style.width = '';\n    }\n\n    send = (message: BaseMyopMessage<any>) => {\n        let message_ = {...message} as BaseMyopMessage;\n\n        //TODO : can be done without cloning?\n        // @ts-ignore\n        //const handler = message_.handler\n        const cleanupHandler = super.send(message_);\n\n        const msg = new CustomEvent<BaseMyopMessage>(myopWebcomponentConsts.webcomponent_message_key, {\n            // @ts-ignore\n            detail: message_,\n            // bubbles: true,\n            // cancelable: false,\n            // composed: true\n        })\n\n        //this.container.dispatchEvent(msg)\n\n        //sending data from host to the component\n        try {\n            this.customElement.dispatchEvent(msg)\n            // if (this.customElement.children.length > 0) {\n            // } else {\n            //     this.customElement.children[0].dispatchEvent(msg)\n            // }\n        } catch (e) {\n            console.log('error while trying to dispatchEvent', e);\n        }\n\n        // @ts-ignore\n        //message.handler = handler\n\n        return cleanupHandler;\n    }\n\n    dispose = () => {\n        super.dispose();\n        this.customElement.parentNode?.removeChild(this.customElement);\n    }\n}\n", "import {MyopWebComponent} from \"../components/myopWebcomponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {loaderOptions} from \"../hostSDK.ts\";\nimport {uuidv4, wait} from \"../../utils/utils.ts\";\nimport {IComponentDefinitionConfig, ISkinConfig, IWebComponentLoaderConfig, SkinLoaders} from \"../../common\";\n\nconst seen: Record<string, Promise<void>> = {};\n\nexport class WebcomponentLoader extends BaseMyopLoader {\n\n    type = SkinLoaders.WebComponentLoader\n\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n\n        const loaderConfig = (skin.loader as IWebComponentLoaderConfig);\n\n        if (!seen[loaderConfig.url]) {\n            // await import( /* @vite-ignore */ webComponentLoadUrl);\n            // console.log('module loaded');\n            seen[loaderConfig.url] = new Promise((resolve, reject) => {\n                const webComponentLoadUrl = loaderConfig.url\n                const script = document.createElement('script');\n                script.type = 'module';\n                script.src = webComponentLoadUrl;\n                script.onload = () => {\n                    resolve();\n                }\n\n                script.onerror = () => {\n                    reject();\n                }\n                document.head.appendChild(script);\n            })\n        } else {\n            console.log('Module alreday loaded or in loading process');\n        }\n\n        await seen[loaderConfig.url];\n\n        //TODO : add retry mechanism in fail case.\n\n        //TODO : fix that hack, should fix the race condition for loaded modules\n        await wait(1);\n\n        let domId = `myop-comp-${uuidv4()}`\n        const element = document.createElement(loaderConfig.tag);\n\n        // TODO : do it only with flag ?\n        if (!container.querySelector('[id^=\"myop-comp-\"]'))\n            container.innerHTML = '';\n\n        //element.style.visibility = 'hidden';\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute'\n            element.style.height = '0'\n            element.style.width = '0'\n            element.style.pointerEvents = 'none'\n            element.style.visibility = 'hidden';\n        }\n\n        // if (container.id.startsWith('myop-comp-')) {\n        //     // in place replacement\n        //     container.replaceWith(element);\n        //     //container = element.parentElement!;\n        // } else {\n        //     container.appendChild(element);\n        // }\n\n        if(options?._environment){\n            // @ts-ignore\n            element._myopEnvironment = options?._environment;\n        }\n\n        this.appendChild(container, element, options);\n        //element.innerHTML = `<${loaderConfig.tag} />`;\n        return new MyopWebComponent(componentDefinition, skin, container, element, options);\n    }\n\n}\n", "export default '0.1.47';", "import {BaseContextMessageHandler, HostedComponent} from \"../../common\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseMyopMessage, MyopBindMessage} from \"../../messages\";\n\nexport type MessageToHost = (message: BaseMyopMessage) => void\n\nexport abstract class BaseWebComponentMessageHandler<T extends BaseMyopMessage = any> extends BaseContextMessageHandler<T, Record<string, HostedComponent<ShadowRootRef>>> {\n\n    abstract messageType: string\n\n    constructor(messageToHost: any, public context: Record<string, HostedComponent<ShadowRootRef>>) {\n        super(messageToHost);\n    }\n\n    abstract innerExecutor: (event: T, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => void;\n\n    executor = (event: T) => {\n        //debugger;\n        if (event.destination) {\n            const destination = event.destination;\n            if (this.context[destination].context) {\n\n                // patch the source id, think about that ?\n                const _messageToHost = (message: BaseMyopMessage, replayTo?: MyopBindMessage) => {\n                    this.messageToHost({\n                        ...message,\n                        source: event.destination ? event.destination : event.source,\n                        destination: event.source ? event.source : event.destination\n                    } as BaseMyopMessage, replayTo)\n                }\n\n                return this.innerExecutor(event, this.context[destination].context, _messageToHost);\n            } else {\n                debugger;\n            }\n        } else {\n            debugger;\n        }\n    }\n}\n", "export const myopAttributes = {\n    id: 'myop-id'\n}\n", "import {myopAttributes} from \"../../consts.ts\";\nimport {Ref} from \"../../messages\";\n\nexport const getElementsByRef = (ref: Ref, el: ParentNode) => {\n    return el.querySelectorAll(`[${myopAttributes.id}='${ref.refConfig.selector}']`);\n}\n\nexport const getFirstElementByRef = (ref: Ref, el: ParentNode) => {\n    const elements = getElementsByRef(ref, el);\n    if (elements.length) {\n        return elements.item(0);\n    }\n    return null;\n}", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {BindClickMessage, ClickReplayMessage, MyopBindMessage} from \"../../messages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class BindOnClickHandler extends BaseWebComponentMessageHandler<BindClickMessage> {\n\n    messageType = MyopMessages.BindClickMessage;\n\n    innerExecutor = (event: BindClickMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot)\n        const cleanupTasks: any[] = [];\n\n        items.forEach(item => {\n            const handler = () => {\n                messageToHost(new ClickReplayMessage(event.handlerUniqueId));\n            };\n\n            item.addEventListener('click', handler);\n            cleanupTasks.push(() => {\n                item.removeEventListener('click', handler);\n            })\n        })\n\n        return () => {\n            cleanupTasks.forEach(task => task());\n        }\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {MyopElementMessage} from \"../../messages\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class ChangeTextHandler extends BaseWebComponentMessageHandler<MyopElementMessage> {\n\n    messageType = MyopMessages.ChangeTextMessage;\n\n    innerExecutor = (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.textContent = event.content;\n        })\n    }\n}\n", "import {RootRef} from \"../common\";\n\nexport class ShadowRootRef extends RootRef {\n    constructor(public container: HTMLElement, public shadowRoot: ShadowRoot) {\n        super(container, shadowRoot);\n    }\n}\n", "import {MyopElementRef} from \"../../common\";\nimport {myopAttributes} from \"../../consts\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {DetectedMyopRefsMessage, DetectMyopRefsMessage} from \"../../messages\";\nimport {MyopMessages} from \"../../common/MyopMessages\";\n\nexport class DetectMyopRefsMessageHandler extends BaseWebComponentMessageHandler<DetectMyopRefsMessage> {\n    innerExecutor = (event: DetectMyopRefsMessage, shadowRootRef: ShadowRootRef) => {\n\n        //debugger;\n        const allMyopItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}]`);\n\n        let myopRefs: MyopElementRef[] = [];\n\n        allMyopItems.forEach(item => {\n\n            // TODO : take that back to the dashboard?\n            //console.log(item, item.getBoundingClientRect());\n\n            const myopId = item.getAttribute(myopAttributes.id);\n\n            if (myopId) {\n                //console.log('wc rect',  item.parentElement.getBoundingClientRect(), item.getBoundingClientRect())\n                // @ts-ignore\n                myopRefs.push(new MyopElementRef(myopId, item.tagName, item.getBoundingClientRect(), item.offsetTop, item.offsetLeft))\n            }\n        })\n\n        this.messageToHost(new DetectedMyopRefsMessage(event.handlerUniqueId, myopRefs))\n    };\n\n    messageType = MyopMessages.DetectMyopRefsMessage;\n\n\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {SetAttributeMessage} from \"../../messages\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class setAttributeHandler extends BaseWebComponentMessageHandler<SetAttributeMessage> {\n\n    messageType = MyopMessages.SetAttributeMessage;\n\n    innerExecutor = (event: SetAttributeMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.setAttribute(event.name, event.value)\n        })\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {\n    AddEventListenerMessage,\n    EventListenerCallbackMessage,\n} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\nimport {makeSerializable} from \"../../common/utils/serialization.ts\";\n\nexport class AddEventListenerHandler extends BaseWebComponentMessageHandler<AddEventListenerMessage> {\n\n    messageType = MyopMessages.AddEventListenerMessage;\n\n    innerExecutor = (event: AddEventListenerMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        const cleanupTasks: (() => void)[] = [];\n\n        items.forEach(item => {\n            const handler = (e) => {\n                // in fact when running in WebComponent we can transfer the original e\n                // currently using makeSerializable for nested cases, think about that\n                messageToHost(new EventListenerCallbackMessage(event.handlerUniqueId,  makeSerializable(e, event.serializableSkeleton)));\n            };\n\n            item.addEventListener(event.type, handler);\n\n            cleanupTasks.push(() => {\n                item.removeEventListener(event.type, handler);\n            })\n        });\n\n        return () => {\n            cleanupTasks.forEach(task => task())\n        }\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {myopAttributes} from \"../../consts\";\nimport {HostSDK} from \"../../host/hostSDK\";\nimport {CreateRefComponentMessage, RefComponentCreatedMessage} from \"../../messages/CreateRefComponentMessage\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {IMyopComponent} from \"../../host\";\n\nexport class CreateRefComponentMessageHandler extends BaseWebComponentMessageHandler<CreateRefComponentMessage> {\n\n    messageType = MyopMessages.CreateRefComponentMessage;\n\n    innerExecutor = (event: CreateRefComponentMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n\n        const createRef = async () => {\n            //const allItems = shadowRootRef.shadowRoot.querySelectorAll<HTMLElement>(`[${myopAttributes.id}='${event.ref?.refConfig.selector}']`);\n            const allItems = shadowRootRef.shadowRoot.querySelectorAll<HTMLElement>(`[${myopAttributes.id}='${event.refConfig.selector}']`);\n\n            if (allItems.length === 1) {\n                const hostSDK = HostSDK.Instance();\n\n                const refComponent = hostSDK.components.find(c => c.id === event.options.id)!;\n                if (refComponent) {\n                    ////>>>>\n                    refComponent.dispose();\n                } else {\n                  //  console.log(`failed to find ${event.options.id} in mem scope`, hostSDK);\n                }\n                //we have the ref component in our HostSDK (same memory when using webcomponent)\n                //  refComponent.parent = implementationComponent;\n                //delete the ref component\n                const index = hostSDK.components.indexOf(refComponent);\n                if (index !== -1) {\n                    hostSDK.components.splice(index, 1);\n                    //console.log('createRefComponent called removed temp ref component');\n                } else {\n                    //console.log('createRefComponent called using temp ref component');\n                }\n\n                const implementationComponent = await hostSDK.loadComponent(event.nestedComponentConfig,\n                    allItems.item(0),\n                    event.options)\n\n                //TODO : no need this, pass options from parent\n                //implementationComponent.id = event.predefinedId;\n                //refComponent.id += '.';\n\n                //TODO : not really needed ?\n                // await implementationComponent.initiated();\n\n                const nestedRefConfig: any[] = [];\n\n                Object.keys(implementationComponent.refs).forEach(refName => {\n                    let ref = implementationComponent.refs[refName];\n                    ref = ref.__nonProxied || ref;\n\n                    if ((ref as IMyopComponent).componentDefinition) {\n                        nestedRefConfig.push({\n                            refName,\n                            componentDefinitionId: (ref as IMyopComponent).componentDefinition.id,\n                        });\n                    }\n                })\n\n                messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, nestedRefConfig));\n            } else {\n                console.error('CreateRefComponentMessageHandler - DOM element not found')\n                this.messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, [], true));\n\n                debugger;\n            }\n        }\n\n        createRef().then()\n        //returning undefined so it won't act as a cleanup\n    }\n}\n", "import {ExecuteScriptMessage} from \"../../messages\";\nimport {RootRef} from \"../../common\";\nimport {makeSerializable} from \"../utils/serialization.ts\";\n\nexport const ExecuteScriptHandlerExecutor = (event: ExecuteScriptMessage, replier: (data: any) => void, rootRef: RootRef) => {\n    const __scriptInputs = event.scriptInputs ? event.scriptInputs : {}\n    __scriptInputs.makeSerializable = makeSerializable;\n\n    __scriptInputs.send = replier;\n    __scriptInputs.rootRef = rootRef;\n    __scriptInputs.__scriptInputs = __scriptInputs;\n\n    const dynamicFunction = new Function(`return (${event.script})(...arguments)`);\n    const ret = dynamicFunction(__scriptInputs);\n\n    // const dynamicFunction = Function('send', 'rootRef','__scriptInputs', ...Object.keys(__scriptInputs), event.content ? event.content : '')\n    //const ret = dynamicFunction(replier, rootRef, __scriptInputs, ...Object.values(__scriptInputs));\n    replier(ret);\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ExecuteScriptMessage, ExecuteScriptReplyMessage} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {ExecuteScriptHandlerExecutor} from \"../../common/messageHandlers/executeScriptHandler.ts\";\n\nexport class ExecuteScriptHandler extends BaseWebComponentMessageHandler<ExecuteScriptMessage> {\n    messageType = MyopMessages.ExecuteScriptMessage\n\n    innerExecutor = (event: ExecuteScriptMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const replier = (data: any) => {\n            messageToHost(new ExecuteScriptReplyMessage(event.handlerUniqueId, data));\n        };\n\n        ExecuteScriptHandlerExecutor(event, replier, shadowRootRef);\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ElementValueReplayMessage, FormDataEntry, GetElementValueMessage, InputElementValue,} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\nimport {myopAttributes} from \"../../consts.ts\";\nimport {makeSerializable} from \"../../common/utils/serialization.ts\";\n\nconst getInputValue = (element): InputElementValue => {\n    if (!element) return null;\n\n    // Check if it's a form\n    if (element.tagName === 'FORM') {\n        const formData = new FormData(element);\n        const dataObject: InputElementValue = {\n            formData: {},\n            unmappedData: []\n        };\n\n        // Manually add elements without names\n        const elements = element.querySelectorAll('input, select, textarea');\n        let autoNameIndexer = -1;\n\n        elements.forEach(element => {\n            if (typeof element.value === 'string') {\n                const myopId = element.getAttribute(myopAttributes.id);\n                let key = element.getAttribute('name');\n\n                // `_${(++autoNameIndexer)}`\n\n                const nodeData: FormDataEntry = {\n                    id: element.id,\n                    name: key,\n                    value: getInputValue(element),\n                    required: element.required,\n                    validity: makeSerializable(element.validity, true),\n                    myopId,\n                };\n\n                if (!key) {\n                    dataObject.unmappedData!.push(nodeData);\n                } else {\n                    if (dataObject.formData![key]) {\n                        if (dataObject.formData![key].value) {\n                            dataObject.unmappedData!.push(nodeData);\n                        } else {\n                            dataObject.unmappedData!.push(dataObject.formData![key]);\n                            dataObject.formData![key] = nodeData\n                        }\n                    } else {\n                        dataObject.formData![key] = nodeData\n                    }\n                }\n            }\n        });\n\n        return dataObject;\n    }\n\n    // Check if it's a checkbox or radio button\n    if (element.type === 'checkbox' || element.type === 'radio') {\n        return element.checked ? element.value : null;\n    }\n\n    // Handle input and textarea elements\n    if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {\n        return element.value;\n    }\n\n    // Handle select elements (dropdowns)\n    if (element.tagName === 'SELECT') {\n        return element.value;\n    }\n\n    // Handle editable divs (contentEditable)\n    if (element.isContentEditable) {\n        return element.innerText || element.textContent;\n    }\n\n    // If it's an unsupported element type\n    return null;\n}\n\nexport class GetElementValueHandler extends BaseWebComponentMessageHandler<GetElementValueMessage> {\n\n    messageType = MyopMessages.GetElementValueMessage;\n\n    innerExecutor = (event: GetElementValueMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            // @ts-ignore\n            messageToHost(new ElementValueReplayMessage(getInputValue(item)), event);\n        })\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {SetInnerHtml} from \"../../messages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {MyopElementMessage} from \"../../messages\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class SetInnerHtmlHandler extends BaseWebComponentMessageHandler<SetInnerHtml> {\n\n    messageType = MyopMessages.SetInnerHtml;\n\n    innerExecutor = (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.innerHTML = event.content;\n        })\n    }\n}\n", "/**\n * @packageDocumentation\n * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>\n * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>\n * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.\n *\n *\n * Once loaded the `RootSDK`, you can load the `IframeSDK`\n * ```js\n * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {getWebcomponentModule} from '@myop/sdk';\n * const {WebComponentSDK} = (await getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {WebComponentSDK} from '@myop/sdk/webcomponent';\n * ```\n *\n */\nimport {BaseMyopSDK} from \"../common\";\nimport {MyopMessages} from \"../common/MyopMessages\";\nimport {myopWebcomponentConsts} from \"./consts\";\nimport {BaseWebComponentMessageHandler} from \"./messageHandlers/BaseWebComponentMessageHandler\";\nimport {BindOnClickHandler} from \"./messageHandlers/bindOnClickHandler\";\nimport {ChangeTextHandler} from \"./messageHandlers/changeTextHandler\";\nimport {ShadowRootRef} from \"./shadowRootRef\";\nimport {DetectMyopRefsMessageHandler} from \"./messageHandlers/DetectMyopRefsMessageHandler\";\nimport {defineDynamicImport} from \"../dynamicImport/defineDynamicImport\";\nimport {\n    BaseMyopMessage,\n    InitMessage,\n    InitRequest,\n    MessageDirection,\n    MyopBindMessage,\n    MyopBindReplayMessage\n} from \"../messages\";\nimport {setAttributeHandler} from \"./messageHandlers/setAttributeHandler.ts\";\nimport {AddEventListenerHandler} from \"./messageHandlers/addEventListenerHandler.ts\";\nimport {CreateRefComponentMessageHandler} from \"./messageHandlers/CreateRefComponentMessageHandler.ts\";\nimport {ExecuteScriptHandler} from \"./messageHandlers/executeScriptHandler.ts\";\nimport {GetElementValueHandler} from \"./messageHandlers/GetElementValueHandler.ts\";\nimport {SetInnerHtmlHandler} from \"./messageHandlers/setInnerHtmlHandler.ts\";\n\n/**\n * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>\n * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>\n * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.\n *\n *\n * Once loaded the `Root SDK`, you can load the `IframeSDK`\n * ```js\n * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {getWebcomponentModule} from '@myop/sdk';\n * const {WebComponentSDK} = (await getWebcomponentModule());\n * ```\n *\n */\nexport class WebComponentSDK extends BaseMyopSDK {\n\n    alwaysPassEnvelopesToHost = true;\n\n    //when new web component created.\n    connectedCallback = (container: HTMLElement, shadow: ShadowRoot) => {\n        container.addEventListener(myopWebcomponentConsts.webcomponent_message_key, (e: any) => {\n            //debugger;\n            const eventContent = e.data ? e.data : e.detail;\n            if (!eventContent || !eventContent.myop) {\n                debugger;\n                throw new Error('recvied webcomponent_message with wrong type')\n            } else {\n                const message = eventContent as BaseMyopMessage;\n\n                //TODO : send container / compoennt identifier for multil components support\n                this.handleIncomeMessages(e)\n\n                if (message.messageType === MyopMessages.InitMessage) {\n                    // @ts-ignore\n                    const newComponentId = (message as InitMessage).content.id;\n                    this.components[newComponentId].context = new ShadowRootRef(container, shadow)\n\n                    // this.supportedHandlers.forEach(handler => {\n                    //     handler.context = this.shadowRoots;\n                    // });\n                }\n            }\n        })\n\n        //TODO : fix that hack. race condition with host.load when module loaded\n        setTimeout(() => {\n            this.messageToHost(new InitRequest())\n        }, 1)\n    }\n\n    messageToHost = (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => {\n        message.direction = MessageDirection.up\n        //message.replayToHandler = replayTo?.handlerUniqueId;\n\n        if (!message.replayToHandler && replayTo?.handlerUniqueId)\n            message.replayToHandler = replayTo.handlerUniqueId\n\n        window.myop.hostSDK.send(message)\n    }\n\n    supportedHandlers: BaseWebComponentMessageHandler[] = [\n        new ChangeTextHandler(this.messageToHost, this.components),\n        new SetInnerHtmlHandler(this.messageToHost, this.components),\n        new BindOnClickHandler(this.messageToHost, this.components),\n        new DetectMyopRefsMessageHandler(this.messageToHost, this.components),\n        new setAttributeHandler(this.messageToHost, this.components),\n        new AddEventListenerHandler(this.messageToHost, this.components),\n        new ExecuteScriptHandler(this.messageToHost, this.components),\n        new GetElementValueHandler(this.messageToHost, this.components),\n        //\n        new CreateRefComponentMessageHandler(this.messageToHost, this.components)\n    ];\n\n    public init = () => {\n        //this.myComponentId\n        //this.handleIncomeMessages\n    }\n}\n\ndefineDynamicImport('WebComponentSDK', WebComponentSDK);\n", "import {MyopWebComponent} from \"../components/myopWebcomponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {loaderOptions} from \"../hostSDK.ts\";\nimport {uuidv4} from \"../../utils/utils.ts\";\nimport {\n    IComponentDefinitionConfig,\n    IHTMLLoaderConfig,\n    ISkinConfig, ShadowRootModeType,\n    SkinLoaders\n} from \"../../common\";\nimport {WebComponentSDK} from \"../../webcomponent\";\nimport {MyopIframeComponent} from \"../components/myopIframeComponent.ts\";\n//import {getWebcomponentModule} from \"../../SDK.ts\";\n\nconst seen: string[] = [];\nlet sdk;\nconst getInitiatedSdk = async () => {\n    if (!sdk) {\n        //const {WebComponentSDK} = await getWebcomponentModule()\n        sdk = new WebComponentSDK();\n        sdk.init();\n    }\n    return sdk;\n}\n\nfunction createHTMLElementConstructor(htmlString: string, ShadowRootMode?: keyof typeof ShadowRootModeType): new () => HTMLElement {\n    return class extends HTMLElement {\n\n        connectedCallback() {\n            const mode = ShadowRootMode === ShadowRootModeType.open ? 'open' : 'closed';\n            const shadow = this.attachShadow({mode});\n            getInitiatedSdk().then((sdk) => {\n                sdk.connectedCallback(this, shadow);\n                shadow.innerHTML = htmlString\n            })\n        }\n    };\n}\n\nconst createCustomWebComponent = (componentName: string, html: string, ShadowRootMode?: keyof typeof ShadowRootModeType) => {\n    customElements.define(componentName, createHTMLElementConstructor(html, ShadowRootMode));\n    console.log(`define('${componentName}') was called, web component ready to use`);\n}\n\nconst toWebComponentName = (str) => {\n    return str\n        .replace(/([a-z])([A-Z])/g, '$1-$2') // Add hyphen before uppercase letters\n        .replace(/(\\d+)/g, '-$1') // Add hyphen before digits\n        .toLowerCase(); // Convert to lowercase\n}\n\nconst toCustomElementName = (name: string) => {\n    name = toWebComponentName(name);\n    return name.replace(/_/g, '-');\n}\n\nlet parser: DOMParser; // = new DOMParser();\n\nexport class HTMLComponentLoader extends BaseMyopLoader {\n\n    type = SkinLoaders.HTMLLoader\n\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n\n        const loaderConfig = (skin.loader as IHTMLLoaderConfig);\n        let domId = `myop-comp-${uuidv4()}`\n        let element;\n\n        if (loaderConfig.shadowRootMode === ShadowRootModeType.localFrame) {\n            const uniqId = uuidv4();\n            const domId = `myop-comp-${uniqId}`\n\n            // console.log('needs to create new Iframe...', domId, typedLoaderConfig.url, container);\n            let IframeElement = document.createElement('iframe');\n\n            // TODO : do it only with flag ?\n            if (!container.querySelector('[id^=\"myop-comp-\"]'))\n                container.innerHTML = '';\n\n            if (options?.hidden) {\n                IframeElement.style.visibility = 'hidden';\n            }\n\n            IframeElement = this.appendChild(container, IframeElement, options) as HTMLIFrameElement;\n            IframeElement.id = domId;\n            IframeElement.setAttribute('style', `\n                   padding: 0;\n                   margin: 0;\n                   overflow: hidden;\n                   border: none;\n                   opacity: ${options?.hidden ? '0' : '1'};\n                   width: 100%;\n                   height: 100%;\n                   position: ${options?.hidden ? 'absolute' : 'static'};\n                   pointer-events: ${options?.hidden ? 'none' : 'all'};\n               `);\n            //  height: ${typedLoaderConfig.autoHeight || !typedLoaderConfig.height ? '' : typedLoaderConfig.height};\n\n            container.appendChild(IframeElement);\n\n            // Write content into the iframe\n            //@ts-ignore\n            const doc = IframeElement.contentDocument || IframeElement.contentWindow.document;\n            doc.open();\n\n\n            let HTML2Render = loaderConfig.HTML;\n\n            if (options?._inspection) {\n                //inject inspection script for props detection\n                const parser = new DOMParser();\n                const _doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n\n                // TODO : part of AI components, think about that, document it.\n                const myop_preview_script = _doc.getElementById('myop_preview');\n                myop_preview_script?.removeAttribute('type');\n\n                // Parse the injected HTML string into a node\n                const temp = _doc.implementation.createHTMLDocument();\n                temp.body.innerHTML = `<script>\n                        const beforeKeysWindow = new Set(Object.keys(window));\n                        window.myopState = {\n                            beforeKeysWindow,\n                        };\n                </script>`;\n\n                const node = temp.body.firstChild;\n\n                if (node && _doc.head) {\n                    _doc.head.insertBefore(_doc.importNode(node, true), _doc.head.firstChild);\n                }\n\n                HTML2Render = _doc.documentElement.outerHTML;\n            }\n\n            //\n            // debugger;\n            // const parser = new DOMParser();\n            // const _doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n            // const x = _doc.getElementById('myop_preview');\n            //\n            // if(x){\n            //     x.remove();\n            //     HTML2Render = _doc.documentElement.outerHTML;\n            // }\n            // console.log(x);\n            // debugger;\n\n\n            doc.writeln(HTML2Render);\n\n            // window.__federation__ =\n            //     { ...window.__federation__,\n            //         //TODO : get from ENV at build time,\n            //         // inject value to module at build time\n            //         // today we doing so just for the CJS version\n            //         __public_path__ :'https://cdn.myop.dev/sdk/next'\n            //         ,...${JSON.stringify(\n            //                 // @ts-ignore\n            //                 window.__federation__)\n            //              }\n            //     };\n\n            doc.writeln(`<script src=\"${window.myop.__ROOT_SDK_PUBLIC_URL__}\"></script>\n                    <script>\n                  \n                   window.__federation__.__public_path__ =  window.__federation__.__public_path__;\n                  \n                   const __myop_init = async () => {\n                        const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());\n                        const sdk = new IframeSDK()\n                        sdk.init();\n                   }\n                    \n                   __myop_init().then();\n                    \n              </script>`);\n\n            doc.close();\n\n            // TODO : control from dashboard\n            //  (skin.loader as IIframeLoaderConfig).autoHeight = true;\n\n            const comp = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);\n\n            if (loaderConfig.autoHeight) {\n                IframeElement.onload = () => {\n                    comp.observeSizeBasedOnDocumentElement();\n                };\n            }\n            // // @ts-ignore\n            // comp.props._global = comp.element.contentWindow;\n            return comp;\n\n        }\n\n        if (loaderConfig.shadowRootMode === ShadowRootModeType.none) {\n            // parser = parser ? parser : new DOMParser();\n            // const doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n            // element = doc.body.firstChild;\n            //element.setAttribute('id', domId);\n\n            const template = document.createElement('template');\n            template.innerHTML = loaderConfig.HTML;//.trim();\n            element = template.content.firstElementChild;\n\n            //   const firstElement = template.content.firstElementChild;\n            //   const z = firstElement ? firstElement.tagName.toLowerCase() : null;\n            //   debugger;\n            //   console.log(template, firstElement, z)\n            //   element = firstElement\n\n            // const container = document.createElement('tbody');\n            // debugger;\n            // container.innerHTML = loaderConfig.HTML;\n            // element = container.firstElementChild;\n\n            getInitiatedSdk().then((sdk) => {\n                sdk.connectedCallback(element, element);\n            })\n        } else {\n            const customElementName = toCustomElementName(componentDefinition.name + skin.id);\n\n            //TODO : support redefine !\n            if (!seen.includes(customElementName)) {\n                createCustomWebComponent(customElementName, loaderConfig.HTML, loaderConfig.shadowRootMode);\n                seen.push(customElementName);\n            }\n            element = document.createElement(customElementName);\n        }\n        // TODO : do it only with flag ?\n        if (!container.querySelector('[id^=\"myop-comp-\"]'))\n            container.innerHTML = '';\n\n        //element.style.visibility = 'hidden';\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute'\n            element.style.height = '0'\n            element.style.width = '0'\n            element.style.pointerEvents = 'none'\n            element.style.visibility = 'hidden';\n        }\n\n        // if (container.id.startsWith('myop-comp-')) {\n        //     // in place replacement\n        //     container.replaceWith(element);\n        //     //container = element.parentElement!;\n        // } else {\n        //     container.appendChild(element);\n        // }\n\n        this.appendChild(container, element, options);\n\n        //element.innerHTML = `<${customElementName} />`;\n        return new MyopWebComponent(componentDefinition, skin, container, element, options);\n    }\n}\n", "import {decompressUUIDs} from \"../utils/uuid.ts\";\nimport {CloudRepository} from \"../helpers\";\nimport {\n    ExperienceTypes,\n    IComponentConfig, IDedicatedSkinConfig,\n    ISegmentedSkinConfig,\n    ISegmentExperience, ISkinInstanceConfig,\n    SkinSelectorTypes\n} from \"../common\";\n\nexport const checkMyopOverride = async (componentConfig: IComponentConfig): Promise<IComponentConfig | null> => {\n    try {\n        //TODO: support disabling the mechanism\n        const url = new URL(window.location.href);\n        const params = new URLSearchParams(url.search);\n        const myopOverride = params.get('myopOverride');\n        if (myopOverride) {\n            const [source, ...uuids] = decompressUUIDs(myopOverride);\n\n            switch (source) {\n                case 'component': {\n                    const [componentId, skinId] = uuids;\n                    const componentToOverride = await CloudRepository.Main.fetchComponent(componentId);\n                    if (componentToOverride) {\n                        // todo: check fetchAutoFlow. Looks like only one skin is returned\n                        const skin = componentToOverride.type.skins.find(skin => skin.id === skinId);\n                        if (skin) {\n                            // todo: for now just set skin id. Check the cloud implementation\n\n                            componentToOverride.instance.skinSelector = {\n                                type: SkinSelectorTypes.Dedicated,\n                                skin: {\n                                    id: skinId\n                                } as ISkinInstanceConfig\n\n                            } as IDedicatedSkinConfig;\n\n                            return componentToOverride\n                        }\n                    }\n                }\n                    break;\n            //    case 'flow': {\n                default : {\n                   // const [flowId, experimentId] = uuids;\n                    const [flowId, experimentId] = decompressUUIDs(myopOverride);\n                    const flow = await CloudRepository.Main.fetchFlow(flowId);\n                    const componentToOverride = flow.components.find(c => c.type.id === componentConfig.type.id);\n                    if (componentToOverride) {\n                        if (componentToOverride.instance.skinSelector.type === SkinSelectorTypes.Segmented) {\n\n                            if (componentToOverride.instance.resolvedExperiences) {\n                                const resolvedExperience = componentToOverride.instance.resolvedExperiences.find(e => e.id === experimentId);\n\n                                if (resolvedExperience?.type === ExperienceTypes.Segment) {\n\n                                    const typedResolvedExperience = resolvedExperience as ISegmentExperience\n\n                                    const typedSkinSelector = componentToOverride.instance.skinSelector as ISegmentedSkinConfig\n                                    const segment = typedSkinSelector.segments.find(s => s.segmentId === typedResolvedExperience.segment.id);\n                                    if (segment) {\n                                        componentToOverride.instance.skinSelector = segment?.skinSelector;\n                                        return componentToOverride;\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                    break;\n            }\n        }\n    } finally {\n        return null;\n    }\n}", "/**\n * @packageDocumentation\n * The Host SDK is designed for integration within the host application that serves as the container for Myop  components.<br/><br/>\n * It provides essential functionalities and APIs for registering, managing, and communicating with Myop components.<br/><br/>\n * This SDK enables seamless embedding of independently developed components into the host application, ensuring smooth interoperability and consistent user experience across various Myop component implementations.\n */\nimport {defineDynamicImport} from \"../dynamicImport/defineDynamicImport\";\nimport {IMyopLoader} from \"./loaders/IMyopLoader\";\nimport {IMyopComponent} from \"./components/IMyopComponent\";\nimport {MyopMessages} from \"../common/MyopMessages\";\nimport {\n    BaseMyopMessage,\n    EnvelopedMessage, ExecuteComponentMethod,\n    InitMessage,\n    InitResponse, MessageDirection, Ref\n} from \"../messages\";\nimport {MyopIframeLoader} from \"./loaders/iframeLoader\";\nimport {WebcomponentLoader} from \"./loaders/webcomponentLoader\";\nimport type {IframeSDK} from \"../Iframe\";\nimport {connectProps, connectRefs, createRefComponent} from \"./componentCore\";\nimport {\n    ExperienceTypes,\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IDedicatedSkinConfig, IExperience, IFunctionResultsSegment, ISegmentedSkinConfig, ISegmentExperience,\n    ISkinConfig, ISkinSelectorConfig, SkinSelectorTypes,\n\n\n} from \"../common\";\n// @ts-ignore handled by custom esbuild plugin\nimport version from \"myop-sdk-version\";\nimport {HTMLComponentLoader} from \"./loaders/HTMLComponentLoader\";\nimport {checkMyopOverride} from \"./myopOverride.ts\";\n\ninterface componentLoaderCreator {\n    new(loaders: IMyopLoader[]): any;\n}\n\n// const getComponentDefinitionConfig = async (id: string) => {\n//     const res = await fetch(`http://localhost:3000/component?id=${id}`);\n//     const componentDef: IComponentDefinitionConfig = (await res.json()).item;\n//     return componentDef\n// }\n\n//const __ROOT_SDK_PUBLIC_URL__ = 'https://dfdlk2p1m187v.cloudfront.net/myop_sdk.min.js'\nconst __ROOT_SDK_PUBLIC_URL__ = 'https://cdn.myop.dev/sdk/next/myop_sdk.min.js'\n\n/**\n * The Host SDK is designed for integration within the host application that serves as the container for Myop  components.<br/><br/>\n * It provides essential functionalities and APIs for registering, managing, and communicating with Myop components.<br/><br/>\n * This SDK enables seamless embedding of independently developed components into the host application, ensuring smooth interoperability and consistent user experience across various Myop component implementations.\n */\nexport class HostSDK {\n    static Instance = () => window.myop.hostSDK;\n\n    components2init: IMyopComponent[] = [];\n    components: IMyopComponent[] = [];\n    componentsLoaders: IMyopLoader[] = [];\n\n    public initiated: boolean = false;\n\n    public version = version;\n\n    type2InstanceCount: Record<string, number> = {};\n    public assignId = (componentDefinition: IComponentDefinitionConfig) => {\n        if (!this.type2InstanceCount[componentDefinition.id]) {\n            this.type2InstanceCount[componentDefinition.id] = 0;\n        }\n        return `${componentDefinition.id}_${++this.type2InstanceCount[componentDefinition.id]}`;\n    }\n\n    //TODO : fix the inspect implementation inside refComponent\n    //then inspected maybe can be dropped\n    private inspected = false;\n    public inspect = () => {\n        if (this.inspected)\n            return;\n\n        this.inspected = true;\n\n        this.components.forEach(component => {\n            if (component.inspect) {\n                component.inspect()\n            }\n        })\n    }\n\n    private incomingMessageHandler = (event: MessageEvent<BaseMyopMessage>) => {\n        //console.log('incomingMessageHandler GOT ', event)\n        //TODO :  if (event.origin !== \"http://example.org:8080\") return;\n        if (event.origin === document.location.origin) {\n            //console.log('I Know that !!!');\n            //  return;\n        }\n        //console.log(\"event on host side \", event);\n\n        if (event.data.myop) {\n            if (event.data.direction !== MessageDirection.up && event.data.messageType !== MyopMessages.EnvelopedMessage) {\n                //console.log('message dropped in hostsdk, direction was ', event.data.direction)\n                return;\n            }\n            // console.log(\"event on host side \", event);\n\n            const myopMessage: BaseMyopMessage = event.data;\n\n            if (myopMessage.messageType === MyopMessages.InitRequest) {\n                this.components2init.forEach(component => {\n                    component.send(new InitMessage(component.id))\n                });\n                return;\n            }\n\n            if (myopMessage.messageType === MyopMessages.InitResponse) {\n                // remove from components 2 init\n                // @ts-ignore\n                this.components2init = this.components2init.filter(component => component.id !== (myopMessage as InitResponse).content.id)\n\n                const initiatedComponent = this.components.find(component => component.id === (myopMessage as InitResponse).content?.id);\n                initiatedComponent?.setInitiated()\n                //initiatedComponent?.parent?.setInitiated();\n                // TODO : is it true to not pass further ( to the component )\n                return;\n            }\n\n            if (myopMessage.messageType === MyopMessages.EnvelopedMessage) {\n                //debugger;\n                const typedMessage = myopMessage as EnvelopedMessage\n                const refComponent = this.components.find(component => component.id === typedMessage.destination);\n\n                if (refComponent) {\n                    if (typedMessage.direction === MessageDirection.down) {\n                        if (typedMessage.message.messageType === ExecuteComponentMethod.name) {\n                            refComponent.onMessageReceived(typedMessage.message)\n                        } else {\n                            //\n                            typedMessage.message.route = typedMessage.route;\n                            refComponent.send(typedMessage.message);\n                        }\n                        return;\n                    }\n                } else {\n                    const innerComponent = this.components.find(component => component.id === typedMessage.message.destination);\n                    if (innerComponent) {\n                        innerComponent.send(typedMessage.message)\n                    } else {\n                        // TODO : log ?\n                    }\n                }\n                // @ts-ignore\n                //component.refs.body.onMessageReceived(myopMessage.message);\n\n                return;\n            }\n\n            const component = this.components.find(component => component.id === myopMessage.destination);\n\n            if (!component) {\n                //no in mem component\n                //pass to parent HostSDK to try process there\n                if (window.myop.IframeSDK) {\n                    window.myop.IframeSDK.messageToHost(myopMessage);\n                }\n                return;\n            }\n\n            if (component) {\n                if (component.onMessageReceived(myopMessage)) {\n                    return;\n                } else {\n                    //not processed in onMessageReceived\n                    //pass to parent HostSDK to try process there\n                    if (window.myop.IframeSDK)\n                        window.myop.IframeSDK.messageToHost(myopMessage);\n                }\n            }\n        }\n\n        // event.source.postMessage(\n        //     \"hi there yourself!  the secret response \" + \"is: rheeeeet!\",\n        //     event.origin,\n        //   );\n    }\n\n    public send = (message: BaseMyopMessage) => {\n        const syntheticEvent = new MessageEvent<BaseMyopMessage>('',\n            {data: message}\n        )\n\n        this.incomingMessageHandler(syntheticEvent);\n    }\n\n    public init = (customComponentLoaderCreators?: componentLoaderCreator[]) => {\n        if (this.initiated) {\n            throw new Error('hostSDK already initiated');\n        }\n\n        const basicLoaders = [\n            new MyopIframeLoader(),\n            new WebcomponentLoader(),\n            new HTMLComponentLoader()\n        ];\n\n        this.componentsLoaders = [\n            ...basicLoaders\n        ];\n\n        if (customComponentLoaderCreators) {\n            //debugger;\n            const loaderByType: Record<string, IMyopLoader> = {};\n\n            customComponentLoaderCreators.forEach(customComponentLoaderCreator => {\n                const customLoader = new customComponentLoaderCreator(this.componentsLoaders);\n                loaderByType[customLoader.type] = customLoader;\n            })\n\n            this.componentsLoaders.forEach(loader => {\n                if (!loaderByType[loader.type])\n                    loaderByType[loader.type] = loader;\n            })\n\n            this.componentsLoaders = Object.values(loaderByType);\n        }\n\n        // Incomming messages from IFrames\n        window.addEventListener(\n            \"message\",\n            this.incomingMessageHandler,\n            false,\n        );\n\n        console.log('myop hostSDK initiated', document.location.href);\n        this.initiated = true;\n    }\n\n    private _getSkinIdBySkinSelector = async (skinSelector: ISkinSelectorConfig, experiences: IExperience[] = [], hooks?: loaderHooks): Promise<string> => {\n        async function asyncFind<T>(\n            array: T[],\n            predicate: (item: T) => Promise<boolean>\n        ): Promise<T | undefined> {\n            for (const item of array) {\n                if (await predicate(item)) {\n                    return item;\n                }\n            }\n            return undefined; // Return undefined if no match is found\n        }\n\n        switch (skinSelector.type) {\n            // @ts-ignore\n            case \"DedicatedSkin\" : //backward compatibility\n            case SkinSelectorTypes.Dedicated: {\n                let selectedSkinId = (skinSelector as IDedicatedSkinConfig).skin?.id\n                    || (skinSelector as IDedicatedSkinConfig).skins![0].id;\n\n                return selectedSkinId;\n            }\n                break;\n            case SkinSelectorTypes.Segmented: {\n                const typedSkinSelector = (skinSelector as ISegmentedSkinConfig)\n                const segment = await asyncFind(typedSkinSelector.segments, async segment => {\n                    if (segment.segmentId === 'Default') {\n                        return true;\n                    }\n\n                    const experience = experiences.find(experience => {\n                        if (experience.type === ExperienceTypes.Segment) {\n                            return (experience as ISegmentExperience).segment.id === segment.segmentId\n                        }\n                        return false;\n                    });\n\n                    if (!experience) {\n                        throw new Error(\"experience not found\");\n                    }\n\n                    const typedExperience = experience as ISegmentExperience;\n                    const typedSegment = (typedExperience.segment as IFunctionResultsSegment)\n\n                    const segmentFunction = (hooks ? hooks : {})[typedSegment.function];\n                    if (segmentFunction) {\n                        const results = await segmentFunction();\n                        return results;\n                    } else {\n                        console.warn(`segmentId:${segment.segmentId}, ${typedSegment.function} function not provided !`)\n                    }\n\n                    return false;\n                });\n\n                if (segment)\n                    return this._getSkinIdBySkinSelector(segment.skinSelector, experiences);\n                else {\n                    debugger;\n                }\n            }\n                break;\n            default: {\n                debugger;\n            }\n        }\n        return '' //TODO\n    }\n\n    private runSkinSelector = async (componentConfig: IComponentConfig, hooks?: loaderHooks) => {\n        const skinId = await this._getSkinIdBySkinSelector(componentConfig.instance.skinSelector, componentConfig.instance.resolvedExperiences, hooks);\n        return componentConfig.type.skins.find(skin => skin.id === skinId);\n    }\n\n    public loaderHooks?: loaderHooks;\n\n    public loadComponent = async <T extends IMyopComponent = IMyopComponent>(componentConfig: IComponentConfig, container?: HTMLElement | Ref, options?: loaderOptions):\n        Promise<T> => {\n\n        if (!container) {\n            debugger;\n            throw new Error('no container was found for this component');\n        }\n\n        const overriddenConfig = await checkMyopOverride(componentConfig);\n        if (overriddenConfig) {\n            //TODO : log\n            componentConfig = overriddenConfig;\n        }\n\n        // // @ts-ignore\n        // if (!container.__nonProxied) {\n        //     const refComponent = (container as unknown as MyopRefComponent);\n        //     //if we got loadComponent over MyopRefComponent\n        //     if (refComponent.id && refComponent.parent) {\n        //         return this.loadComponent(componentConfig, refComponent.ref, options);\n        //\n        //         // let rootComponent: IMyopComponent = refComponent;\n        //         // while(!rootComponent.element && rootComponent.parent){\n        //         //     rootComponent = rootComponent.parent\n        //         // }\n        //         //\n        //         // rootComponent.element\n        //         // //what now ?\n        //     }\n        // }\n\n        const hooks = {...(this.loaderHooks ?? {}), ...(options?.hooks ?? {})};\n\n        const ref = container as Ref;\n        if (ref.myop) {\n            if (ref.component) {\n\n                componentConfig = {...componentConfig};\n                componentConfig.instance = {\n                    ...componentConfig.instance\n                }\n\n                let selectedSkin = await this.runSkinSelector(componentConfig, hooks)!\n                if (!selectedSkin) {\n                    throw new Error(\"runSkinSelector failed to choose skin, check the provided config\");\n                }\n\n                if (options?.hooks?.afterSkinSelected) {\n                    selectedSkin = await options.hooks.afterSkinSelected({...selectedSkin});\n                }\n\n                componentConfig.instance.skinSelector = {\n                    type: SkinSelectorTypes.Dedicated,\n                    skin: selectedSkin\n                    //  skins: [selectedSkin]\n                } as IDedicatedSkinConfig\n\n                if (options) {\n                    options = {...options}\n                    delete options.hooks\n                }\n\n                const refComponent = await createRefComponent<T>(ref, componentConfig, this.components, options);\n\n                //TODO : connect refs and props insode createRefComponent, elsewhere its not really <T>\n                return refComponent;\n            } else {\n                throw new Error('load component got a detached ref.')\n            }\n        }\n\n        container = container as HTMLElement;\n\n        /**\n         *\n         * choose skin on runtime ...\n         *        componentConfig.instance.skinSelector.type\n         */\n\n        let selectedSkin = await this.runSkinSelector(componentConfig, hooks)!\n\n        if (!selectedSkin) {\n            throw new Error(\"runSkinSelector failed to choose skin, check the provided config\");\n        }\n\n        if (options?.hooks?.afterSkinSelected) {\n            selectedSkin = await options.hooks.afterSkinSelected({...selectedSkin});\n        }\n        const componentLoader = this.componentsLoaders.find(loader => loader.type === selectedSkin.loader.type);\n\n        if (!componentLoader) {\n            debugger;\n            throw new Error(`no loader \"${selectedSkin.loader.type}\" was found for component`);\n        }\n\n        //for loaded webcomponent modules to following line creates a race condition with the init message flow\n        let component = await componentLoader.load(componentConfig.type, selectedSkin, container, options);\n\n        // TODO : when this is not true ?\n        if (!component.isInitiated)\n            this.components2init.push(component)\n\n        component.bind('onDispose', () => {\n            //console.log('component dispose', component);\n            this.components = this.components.filter(c => c !== component)\n            this.components2init = this.components2init.filter(c => c !== component)\n            return true;\n        })\n\n        this.components.push(component);\n\n        // true by default\n        if (!options || options.connectProps !== false) {\n            //TODO : make type field conditional type infer \"string\" > string, \"number\" > number, etc...\n            component = connectProps(component, componentConfig.type.props, selectedSkin);\n        }\n\n        try {\n            //TODO : make optional?\n            //TODO : fix issues with timeout and wrong ref names from config vs current skin\n            await connectRefs(component, componentConfig, this.components);\n        } catch (e) {\n            throw e;\n            //debugger;\n            // TOOD : throw ?\n        }\n        if (!options?.skipInit)\n            await component.initiated();\n\n        return component as T;\n    }\n\n    public navigate = async <T extends IMyopComponent = IMyopComponent>(component: IMyopComponent, newComponentConfig: IComponentConfig, options?: navigationOptions) => {\n        if (component.parent) {\n            throw new Error('Navigating on remote ref components is not implemented yet');\n        }\n\n        //component.markedForDisposed = true;\n\n        // if (options?.inplace) {\n        //     if (component.element) {\n        //         let newComponent = await this.loadComponent<T>(newComponentConfig, component.element);\n        //         await newComponent.initiated();\n        //\n        //         if (options.init)\n        //             await options.init(newComponent);\n        //\n        //         return newComponent;\n        //     } else {\n        //         throw new Error('...')\n        //     }\n        // }\n\n        if (options?.staged) {\n            //const selectedSkin = this.runSkinSelector(newComponentConfig)\n            let newComponent = await this.loadComponent<T>(newComponentConfig, component.container, {\n                hidden: true,\n                relative: {direction: 'after', child: component.element!},\n                ...options\n            });\n\n            if (options.init)\n                await options.init(newComponent);\n\n            newComponent.show();\n            component.dispose();\n            return newComponent;\n        } else {\n            const nextSibling = component.element!.nextSibling;\n\n            component.dispose();\n            return this.loadComponent<T>(newComponentConfig, component.container, {\n                relative: {\n                    direction: \"before\",\n                    child: nextSibling,\n                },\n                ...options\n            });\n        }\n    }\n}\n\nexport type navigationOptions = {\n    staged?: boolean,\n    //inplace?: boolean,\n    init?: (component: IMyopComponent) => Promise<void>\n    skipInit?: boolean\n} & loaderOptions\n\ntype relativeLoadConfigDirection = 'before' | 'after';\n\n\nexport type loaderHooks = {\n    afterSkinSelected?: (selectedSkin: ISkinConfig) => Promise<ISkinConfig>\n} &\n    // segmentation hooks\n    ({ [key: string]: () => Promise<boolean> | boolean } | {})\n\n//TODO: support serializable version of that object\nexport interface relativeLoadConfig {\n    //If this is null, then newNode is inserted at the end of node's child nodes.\n    //https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore\n    child: ChildNode | null\n    direction: relativeLoadConfigDirection\n}\n\nexport interface IEnvironment {\n    [key: string]: any\n}\n\ntype ElementAttributes = {\n    [key: string]: string | number | boolean | undefined | null;\n};\n\nexport interface loaderOptions {\n    id?: string\n    hidden?: boolean\n    connectProps?: boolean\n    timeout?: number\n    skipInit?: boolean\n    relative?: relativeLoadConfig\n    hooks?: loaderHooks\n    elementAttributes?: ElementAttributes\n    _environment?: IEnvironment\n    _hasParent?: boolean\n    _inspection?: boolean\n}\n\nif (!window.myop) {\n    // @ts-ignore\n    window.myop = {\n        __ROOT_SDK_PUBLIC_URL__\n    };\n}\n\nif (!window.myop.hostSDK) {\n    const _hostSDK = new HostSDK();\n    //TODO: enable lazy init?\n    _hostSDK.init();\n\n    if (!window.myop) {\n        // @ts-ignore\n        window.myop = {\n            __ROOT_SDK_PUBLIC_URL__\n        };\n    }\n    window.myop.hostSDK = _hostSDK;\n}\n\n// @ts-ignore\nexport const hostSDK: HostSDK = window.myop.hostSDK;\n\ndefineDynamicImport('hostSDK', hostSDK);\n\ndeclare global {\n    interface Window {\n        myop: {\n            __ROOT_SDK_PUBLIC_URL__: string,\n            hostSDK: HostSDK,\n            IframeSDK: InstanceType<typeof IframeSDK>\n        }\n    }\n}\n", "import {hostSDK} from '../host';\nimport {\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IComponentInstanceConfig, IDedicatedSkinConfig,\n    IPropConfig,\n    ISkinConfig,\n    PropConfigBehaviorTypes,\n    v2_IVariantConfig\n} from \"../common\";\nimport {loaderOptions} from \"../host/hostSDK.ts\";\n\nexport class v2_CloudRepository {\n    static Main = new v2_CloudRepository();\n\n    private variants: Record<string, Promise<v2_IVariantConfig>> = {};\n\n    constructor(private _baseUrl = 'https://cloud.myop.dev') {\n    }\n\n    async fetchComponent(componentId: string, environmentIdentifier?: string) {\n        if (!this.variants[componentId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.variants[componentId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/consume?id=${componentId}&env=${environmentIdentifier}`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.variants[componentId];\n    }\n\n}\n\nexport const enableV2 = (environmentIdentifier: string, cloudRepository?: v2_CloudRepository) => {\n    const _cloudRepository = cloudRepository ? cloudRepository : new v2_CloudRepository();\n\n    return {\n        loadComponent: async (componentId: string, container: HTMLElement, options?: loaderOptions) => {\n            const config = await _cloudRepository.fetchComponent(componentId, environmentIdentifier)\n\n            //@ts-ignore\n            if (!config.consume_variant || !config.consume_variant.length) {\n                console.warn(\n                    `[Myop Warning] Component \"${componentId}\" has no implementation for environment \"${environmentIdentifier}\".`\n                );\n            }\n\n            const componentConfig = {\n                instance: {\n                    id: 'auto',\n                    componentId: config.componentId,\n                    componentName: config.name,\n\n                    skinSelector: {\n                        type: 'Dedicated',\n                        skin: {\n                            id: 'skin_auto_v2_converted'\n                        }\n                    } as IDedicatedSkinConfig\n\n                } as IComponentInstanceConfig,\n                type: {\n                    id: config.id,\n                    name: config.name,\n                    description: config.description,\n                    props: [\n                        {\n                            id: 'in_auto_v2_converted',\n                            name: 'myop_init_interface',\n                            type: 'any',\n                            behavior: {\n                                type: PropConfigBehaviorTypes.code\n                            }\n                        } as IPropConfig,\n\n                        {\n                            id: 'out_auto_v2_converted',\n                            name: 'myop_cta_handler',\n                            type: 'any',\n                            behavior: {\n                                type: PropConfigBehaviorTypes.code\n                            }\n                        } as IPropConfig\n                    ],\n                    refs: [],\n                    skins: [\n                        {\n                            id: 'skin_auto_v2_converted',\n                            name: 'auto_v2_converted',\n                            description: '',\n                            //TODO : handle empty :\n                            // @ts-ignore\n                            loader: config.consume_variant[0].loader\n                        } as ISkinConfig\n                    ],\n                    defaultSkin: 0\n                } as IComponentDefinitionConfig,\n                name: config.name\n            } as IComponentConfig;\n\n            return await hostSDK.loadComponent(componentConfig, container, options);\n        }\n    }\n}\n"],
  "mappings": "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",
  "names": ["ReplayMessageKey", "match", "scriptInputs", "scriptInputs", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "seen", "target", "makeSerializable", "height", "width", "hostSDK", "element", "seen", "sdk", "domId", "sdk", "seen", "skin", "component", "segment", "experience", "selectedSkin"]
}
