@uniformdev/mesh-sdk 17.7.1-alpha.34 → 18.0.1-alpha.3

package/dist/index.esm.js

@@ -1 +1,605 @@
-import I from"mitt";var S=(n,e)=>e?{log(o,...t){return console.log(`${n}: ${o}`,...t)},error(o,...t){return console.error(`${n}: ${o}`,...t)}}:{log(){},error(){}};var E=5e3;var d=class extends Error{constructor(){super("Request timed out"),Object.setPrototypeOf(this,d.prototype),this.name="RequestTimeoutError"}},c=class extends Error{constructor(){super("Client destroyed"),Object.setPrototypeOf(this,c.prototype),this.name="ClientDestroyedError"}};var T=()=>{let n=()=>{},e=()=>{},o=new Promise((t,s)=>{n=t,e=s});return{resolve:n,reject:e,promise:o}},u=(n=16)=>[...Array(n)].map(()=>(~~(Math.random()*36)).toString(36)).join(""),g=(n,e)=>{let{[e]:o,...t}=n;return t},L=n=>({message:n.message,name:n.name,stack:n.stack}),V=({name:n,message:e,stack:o})=>{switch(n){case d.name:return new d;default:{let t=new Error(e);return t.name=n,t.stack=o,t}}},D=n=>{let e=n.data,o="none";return e instanceof Error&&(o="error",e=L(e)),{...n,serialization:o,data:e}},M=n=>n.serialization==="error"?{...n,data:V(n.data)}:n;var p=class{constructor({debug:e=!1,requestTimeout:o=E}={}){this.debug=e,this.requestTimeout=o,this.channel=T(),this.eventSubscriptions={},this.responseSubscriptions={},this.requestSubscriptions={},this.onDestroyRequestHandlers={},this.destroyed=!1,this.logger=this.getLogger(),this.getChannel().then(()=>{this.logger.log("Secure parent <-> child channel established")}).catch(t=>{this.logger.log(t)})}async send(e,o){return this.postMessage("event",e,o)}on(e,o){this.eventSubscriptions[e]||(this.eventSubscriptions[e]={});let t=u(8);return this.eventSubscriptions[e][t]=o,this.logger.log(`Registered handler for event "${e}"`),()=>{this.eventSubscriptions[e]=g(this.eventSubscriptions[e],t),this.logger.log(`Unsubscribed handler for event ${e}`)}}async request(e,o,t={}){let a=(await this.postMessage("request",e,o)).id,i=()=>{this.responseSubscriptions=g(this.responseSubscriptions,a)},r=()=>{this.onDestroyRequestHandlers=g(this.responseSubscriptions,a)};return new Promise((l,f)=>{let y,x=(R,O)=>{clearTimeout(y),i(),r(),O.type==="error_response"?f(R):l(R)},C=()=>{clearTimeout(y),f(new c)};this.responseSubscriptions[a]=x,this.onDestroyRequestHandlers[a]=C,y=setTimeout(()=>{i(),r(),f(new d)},t.timeout||this.requestTimeout)})}onRequest(e,o){let t=async(s,a)=>{try{let i=await o(s,a);this.postMessage("response",e,i,a.id)}catch(i){this.postMessage("error_response",e,i,a.id)}};return this.requestSubscriptions[e]=t,()=>{this.requestSubscriptions=g(this.requestSubscriptions,e)}}async getChannel(){if(await this.channel.promise,this.destroyed)throw new c;return this.channel.promise}async messageListener(e){try{await this.getChannel();let o=this.isValidMessage(e),t=M(e.data);if(o)switch(t.type){case"event":{this.handleEvent(t);break}case"request":{this.handleRequest(t);break}case"error_response":case"response":{this.handleResponse(t);break}}else this.logger.error("Invalid message format. Skipping.")}catch(o){this.logger.error(o)}}handleEvent(e){let o=this.eventSubscriptions[e.key];o&&Object.values(o).forEach(t=>t(e.data,e))}handleRequest(e){let o=this.requestSubscriptions[e.key];o&&(o(e.data,e),this.logger.log(`Handled request type ${e.key}`))}handleResponse(e){let o=e.requestId,t=o&&this.responseSubscriptions[o];t&&t(e.data,e)}async postMessage(e,o,t,s){let{port:a}=await this.getChannel();if(this.destroyed)throw new c;let i=D({type:e,apiVersion:"framepost/v1",key:o,data:t,id:u(),requestId:s});return this.logger.log("posting message from child to parent",i),a.postMessage(i),i}initListener(e){this.isInitMessage(e)?(this.onChannelInit(e),this.messagePort&&(this.messagePort.onmessage=this.messageListener.bind(this)),this.resolveChannel(e)):this.logger.error("Invalid message format. Skipping.")}isValidMessage(e){let o=e.data;return o.type&&o.id&&o.apiVersion==="framepost/v1"}isInitMessage(e){return this.isValidMessage(e)&&e.data.type==="channel_init"}resolveChannel(e){if(this.messagePort){let o={port:this.messagePort,origin:e.origin,context:e.data.data};this.channel.resolve(o)}}getInitMessage(e){return D({type:"channel_init",apiVersion:"framepost/v1",key:"",data:e,id:u()})}destroy(){this.destroyed=!0,this.channel.reject(new c),this.messagePort&&this.messagePort.close(),Object.values(this.onDestroyRequestHandlers).forEach(e=>e())}};var h=class extends p{constructor(o={}){super(o);this.context=o.context||null,this.initListener=this.initListener.bind(this),window.addEventListener("message",this.initListener)}getLogger(){return S("child-client",this.debug)}onChannelInit(o){window.removeEventListener("message",this.initListener),this.messagePort=o.ports[0];let t=this.getInitMessage(this.context);this.logger.log("channel init, posting init message from child to parent",t),this.messagePort.postMessage(t)}destroy(){super.destroy(),window.removeEventListener("message",this.initListener)}};async function v({dialogResponseHandlers:n}){let e=new h({debug:!1});window.parent.postMessage("parents just don't understand","*");let o=await e.request("initialize");return e.onRequest("dialog-value",async t=>{let s=n[t.dialogId];!s||(t.value?s.resolve({value:t.value,dialogId:t.dialogId}):t.error&&s.reject(t.error),delete n[t.dialogId])}),{initData:o,parent:{resize:async t=>{await e.request("resize",{height:t})},getValue:async()=>{let t=await e.request("getValue");return t==null?void 0:t.data},setValue:async(t,s)=>{let a={uniformMeshLocationValue:t,options:s};await e.request("setValue",a)},getMetadata:async()=>{let t=await e.request("getMetadata");return t==null?void 0:t.data},openDialog:async t=>{var i;if(P((i=t.options)==null?void 0:i.params)>1e5)throw new Error("Dialog parameters object is too large, maximum size is 100KB");let s=await e.request("openDialog",t),a=s==null?void 0:s.dialogId;if(!!a)return new Promise((r,l)=>{n[a]={resolve:r,reject:l}})},closeDialog:async t=>{await e.request("closeDialog",t)},getDataResource:async t=>await e.request("getDataResource",t,{timeout:3e4})}}}function P(n){if(!n||typeof Blob=="undefined")return 0;try{let e=JSON.stringify(n);return new Blob([e]).size}catch(e){throw new Error("Error calculating object size: "+e.message)}}var m,b=({onHeightChange:n,autoResizingDisabled:e})=>{if(typeof window=="undefined")return;let o=window,t=r=>{if(r&&r!==m){m=r,n==null||n(r);return}let l=`${Math.ceil(o.document.documentElement.getBoundingClientRect().height)}px`;l!==m&&(m=l,n==null||n(l))},s=()=>{t()},a=e?void 0:new MutationObserver(s),i={instance:o,height:o.document.documentElement.getBoundingClientRect().height,observer:a,enableAutoResizing:()=>{a==null||a.observe(document.body,{attributes:!0,childList:!0,subtree:!0,characterData:!0}),o.addEventListener("resize",s)},disableAutoResizing:()=>{a==null||a.disconnect(),o.removeEventListener("resize",s)},updateHeight:t};return e||i.enableAutoResizing(),i};var k={},w=!1;async function se({autoResizingDisabled:n}={}){var e;if(typeof window!="undefined"&&typeof window.UniformMeshSDK=="undefined"&&!w){if(typeof window.parent=="undefined"||window.parent==window)throw new Error("It appears you are trying to connect with the Uniform Mesh SDK outside of an iframe. Be sure you are loading your app via a location URL configured in the Uniform dashboard.");w=!0;let o=await v({dialogResponseHandlers:k}),{initData:t,parent:s}=o,a={events:I(),getCurrentLocation:()=>{let i={getDataResource:s.getDataResource,type:t.locationType,isReadOnly:t.isReadOnly,getValue:()=>i.value,value:t.locationValue,setValue:async(r,l)=>{t.dialogContext&&console.warn("Using setValue() inside a dialog is deprecated. Use dialogContext.returnDialogValue() instead."),t.locationValue=r,a.events.emit("onValueChanged",{newValue:r}),await s.setValue(r,l)},getMetadata:()=>t.locationMetadata,metadata:t.locationMetadata,setValidationResult:async r=>{await i.setValue(t.locationValue,r)},dialogContext:t.dialogContext?{...t.dialogContext,params:t.locationMetadata.dialogParams,returnDialogValue:async r=>{t.locationValue=r,a.events.emit("onValueChanged",{newValue:r}),await s.setValue(r)}}:void 0};return i},currentWindow:b({onHeightChange:i=>{s.resize(i)},autoResizingDisabled:(e=t.dialogContext)!=null&&e.contentHeight?!0:n}),version:t.uniformApiVersion,openLocationDialog:async({locationKey:i,options:r})=>{let l=await s.openDialog({dialogType:"location",dialogData:{locationKey:i},options:r});if(!!l)return{dialogId:l.dialogId,value:l.value,closeDialog:async()=>{await s.closeDialog({dialogId:l.dialogId,dialogType:"location"})}}},async closeLocationDialog({dialogId:i}){await s.closeDialog({dialogId:i,dialogType:"location"})},openConfirmationDialog:async({titleText:i,bodyText:r})=>{let l=await s.openDialog({dialogType:"confirm",dialogData:{titleText:i,bodyText:r}});if(!!l)return{dialogId:l.dialogId,value:l.value,closeDialog:async()=>{await s.closeDialog({dialogId:void 0,dialogType:"confirm"})}}},openCurrentLocationDialog:async i=>{let r=await s.openDialog({dialogType:"location",dialogData:{},options:i==null?void 0:i.options});if(!!r)return{dialogId:r.dialogId,value:r.value,closeDialog:async()=>{await s.closeDialog({dialogId:void 0,dialogType:"location"})}}},closeCurrentLocationDialog:async()=>{await s.closeDialog({dialogId:void 0,dialogType:"location"})},dialogContext:t.dialogContext};return window.UniformMeshSDK=a,w=!1,a}}export{se as initializeUniformMeshSDK};
+// src/sdk.ts
+import mitt from "mitt";
+
+// src/framepost/logger.ts
+var getLogger = (prefix, debug) => {
+  if (debug) {
+    return {
+      log(message, ...params) {
+        return console.log(`${prefix}: ${message}`, ...params);
+      },
+      error(message, ...params) {
+        return console.error(`${prefix}: ${message}`, ...params);
+      }
+    };
+  } else {
+    return {
+      log() {
+        return;
+      },
+      error() {
+        return;
+      }
+    };
+  }
+};
+
+// src/framepost/constants.ts
+var DEFAULT_REQUEST_TIMEOUT = 5e3;
+
+// src/framepost/errors.ts
+var RequestTimeoutError = class extends Error {
+  constructor() {
+    super("Request timed out");
+    Object.setPrototypeOf(this, RequestTimeoutError.prototype);
+    this.name = "RequestTimeoutError";
+  }
+};
+var ClientDestroyedError = class extends Error {
+  constructor() {
+    super("Client destroyed");
+    Object.setPrototypeOf(this, ClientDestroyedError.prototype);
+    this.name = "ClientDestroyedError";
+  }
+};
+
+// src/framepost/utils.ts
+var defer = () => {
+  let resolve = () => {
+    return;
+  };
+  let reject = () => {
+    return;
+  };
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    resolve,
+    reject,
+    promise
+  };
+};
+var randomInsecureId = (len = 16) => [...Array(len)].map(() => (~~(Math.random() * 36)).toString(36)).join("");
+var omit = (object, key) => {
+  const { [key]: _, ...rest } = object;
+  return rest;
+};
+var serializeError = (error) => {
+  return {
+    message: error.message,
+    name: error.name,
+    stack: error.stack
+  };
+};
+var deserializeError = ({ name, message, stack }) => {
+  switch (name) {
+    case RequestTimeoutError.name: {
+      return new RequestTimeoutError();
+    }
+    default: {
+      const e = new Error(message);
+      e.name = name;
+      e.stack = stack;
+      return e;
+    }
+  }
+};
+var serialize = (message) => {
+  let data = message.data;
+  let serialization = "none" /* NONE */;
+  if (data instanceof Error) {
+    serialization = "error" /* ERROR */;
+    data = serializeError(data);
+  }
+  return {
+    ...message,
+    serialization,
+    data
+  };
+};
+var deserialize = (message) => {
+  if (message.serialization === "error" /* ERROR */) {
+    return {
+      ...message,
+      data: deserializeError(message.data)
+    };
+  }
+  return message;
+};
+
+// src/framepost/shared.ts
+var SharedClient = class {
+  constructor({ debug = false, requestTimeout = DEFAULT_REQUEST_TIMEOUT } = {}) {
+    this.debug = debug;
+    this.requestTimeout = requestTimeout;
+    this.channel = defer();
+    this.eventSubscriptions = {};
+    this.responseSubscriptions = {};
+    this.requestSubscriptions = {};
+    this.onDestroyRequestHandlers = {};
+    this.destroyed = false;
+    this.logger = this.getLogger();
+    this.getChannel().then(() => {
+      this.logger.log("Secure parent <-> child channel established");
+    }).catch((reason) => {
+      this.logger.log(reason);
+    });
+  }
+  async send(eventType, data) {
+    return this.postMessage("event" /* EVENT */, eventType, data);
+  }
+  on(eventType, handler) {
+    if (!this.eventSubscriptions[eventType]) {
+      this.eventSubscriptions[eventType] = {};
+    }
+    const id = randomInsecureId(8);
+    this.eventSubscriptions[eventType][id] = handler;
+    this.logger.log(`Registered handler for event "${eventType}"`);
+    return () => {
+      this.eventSubscriptions[eventType] = omit(this.eventSubscriptions[eventType], id);
+      this.logger.log(`Unsubscribed handler for event ${eventType}`);
+    };
+  }
+  async request(requestKey, data, options = {}) {
+    const sentMessage = await this.postMessage("request" /* REQUEST */, requestKey, data);
+    const requestId = sentMessage.id;
+    const unsubscribeResponseHandler = () => {
+      this.responseSubscriptions = omit(this.responseSubscriptions, requestId);
+    };
+    const clearOnDestroy = () => {
+      this.onDestroyRequestHandlers = omit(this.responseSubscriptions, requestId);
+    };
+    return new Promise((resolve, reject) => {
+      let timer;
+      const responseHandler = (response, message) => {
+        clearTimeout(timer);
+        unsubscribeResponseHandler();
+        clearOnDestroy();
+        if (message.type === "error_response" /* ERROR_RESPONSE */) {
+          reject(response);
+        } else {
+          resolve(response);
+        }
+      };
+      const onDestroyHandler = () => {
+        clearTimeout(timer);
+        reject(new ClientDestroyedError());
+      };
+      this.responseSubscriptions[requestId] = responseHandler;
+      this.onDestroyRequestHandlers[requestId] = onDestroyHandler;
+      timer = setTimeout(() => {
+        unsubscribeResponseHandler();
+        clearOnDestroy();
+        reject(new RequestTimeoutError());
+      }, options.timeout || this.requestTimeout);
+    });
+  }
+  onRequest(requestKey, requestHandler) {
+    const requestEventHandler = async (requestData, requestMessage) => {
+      try {
+        const response = await requestHandler(requestData, requestMessage);
+        this.postMessage("response" /* RESPONSE */, requestKey, response, requestMessage.id);
+      } catch (e) {
+        this.postMessage("error_response" /* ERROR_RESPONSE */, requestKey, e, requestMessage.id);
+      }
+    };
+    this.requestSubscriptions[requestKey] = requestEventHandler;
+    return () => {
+      this.requestSubscriptions = omit(this.requestSubscriptions, requestKey);
+    };
+  }
+  async getChannel() {
+    await this.channel.promise;
+    if (this.destroyed) {
+      throw new ClientDestroyedError();
+    }
+    return this.channel.promise;
+  }
+  async messageListener(ev) {
+    try {
+      await this.getChannel();
+      const isValidMessage = this.isValidMessage(ev);
+      const message = deserialize(ev.data);
+      if (isValidMessage) {
+        switch (message.type) {
+          case "event" /* EVENT */: {
+            this.handleEvent(message);
+            break;
+          }
+          case "request" /* REQUEST */: {
+            this.handleRequest(message);
+            break;
+          }
+          case "error_response" /* ERROR_RESPONSE */:
+          case "response" /* RESPONSE */: {
+            this.handleResponse(message);
+            break;
+          }
+        }
+      } else {
+        this.logger.error("Invalid message format. Skipping.");
+      }
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+  handleEvent(message) {
+    const subscriptions = this.eventSubscriptions[message.key];
+    if (subscriptions) {
+      Object.values(subscriptions).forEach((handler) => handler(message.data, message));
+    }
+  }
+  handleRequest(message) {
+    const handler = this.requestSubscriptions[message.key];
+    if (handler) {
+      handler(message.data, message);
+      this.logger.log(`Handled request type ${message.key}`);
+    }
+  }
+  handleResponse(message) {
+    const requestId = message.requestId;
+    const handler = requestId && this.responseSubscriptions[requestId];
+    if (handler) {
+      handler(message.data, message);
+    }
+  }
+  async postMessage(type, key, data, requestId) {
+    const { port } = await this.getChannel();
+    if (this.destroyed) {
+      throw new ClientDestroyedError();
+    }
+    const message = serialize({
+      type,
+      apiVersion: "framepost/v1" /* v1 */,
+      key,
+      data,
+      id: randomInsecureId(),
+      requestId
+    });
+    this.logger.log(`posting message from child to parent`, message);
+    port.postMessage(message);
+    return message;
+  }
+  initListener(ev) {
+    if (this.isInitMessage(ev)) {
+      this.onChannelInit(ev);
+      if (this.messagePort) {
+        this.messagePort.onmessage = this.messageListener.bind(this);
+      }
+      this.resolveChannel(ev);
+    } else {
+      this.logger.error("Invalid message format. Skipping.");
+    }
+  }
+  isValidMessage(ev) {
+    const message = ev.data;
+    return message.type && message.id && message.apiVersion === "framepost/v1" /* v1 */;
+  }
+  isInitMessage(ev) {
+    return this.isValidMessage(ev) && ev.data.type === "channel_init" /* CHANNEL_INIT */;
+  }
+  resolveChannel(ev) {
+    if (this.messagePort) {
+      const channel = {
+        port: this.messagePort,
+        origin: ev.origin,
+        context: ev.data.data
+      };
+      this.channel.resolve(channel);
+    }
+  }
+  getInitMessage(context) {
+    const message = serialize({
+      type: "channel_init" /* CHANNEL_INIT */,
+      apiVersion: "framepost/v1" /* v1 */,
+      key: "",
+      data: context,
+      id: randomInsecureId()
+    });
+    return message;
+  }
+  destroy() {
+    this.destroyed = true;
+    this.channel.reject(new ClientDestroyedError());
+    if (this.messagePort) {
+      this.messagePort.close();
+    }
+    Object.values(this.onDestroyRequestHandlers).forEach((destroy) => destroy());
+  }
+};
+
+// src/framepost/child.ts
+var ChildClient = class extends SharedClient {
+  constructor(options = {}) {
+    super(options);
+    this.context = options.context || null;
+    this.initListener = this.initListener.bind(this);
+    window.addEventListener("message", this.initListener);
+  }
+  getLogger() {
+    return getLogger("child-client", this.debug);
+  }
+  onChannelInit(ev) {
+    window.removeEventListener("message", this.initListener);
+    this.messagePort = ev.ports[0];
+    const message = this.getInitMessage(this.context);
+    this.logger.log(`channel init, posting init message from child to parent`, message);
+    this.messagePort.postMessage(message);
+  }
+  destroy() {
+    super.destroy();
+    window.removeEventListener("message", this.initListener);
+  }
+};
+
+// src/sdkComms.ts
+async function connectToParent({
+  dialogResponseHandlers
+}) {
+  const client = new ChildClient({ debug: false });
+  window.parent.postMessage("parents just don't understand", "*");
+  const initData = await client.request("initialize");
+  client.onRequest("dialog-value", async (data) => {
+    const handler = dialogResponseHandlers[data.dialogId];
+    if (!handler) {
+      return;
+    }
+    if (data.value) {
+      handler.resolve({ value: data.value, dialogId: data.dialogId });
+    } else if (data.error) {
+      handler.reject(data.error);
+    }
+    delete dialogResponseHandlers[data.dialogId];
+  });
+  return {
+    initData,
+    parent: {
+      resize: async (height) => {
+        await client.request("resize", { height });
+      },
+      getValue: async () => {
+        const res = await client.request("getValue");
+        return res == null ? void 0 : res.data;
+      },
+      setValue: async (value, options) => {
+        const message = { uniformMeshLocationValue: value, options };
+        await client.request("setValue", message);
+      },
+      getMetadata: async () => {
+        const res = await client.request("getMetadata");
+        return res == null ? void 0 : res.data;
+      },
+      openDialog: async (message) => {
+        var _a;
+        if (getByteSize((_a = message.options) == null ? void 0 : _a.params) > 1e5) {
+          throw new Error(`Dialog parameters object is too large, maximum size is 100KB`);
+        }
+        const res = await client.request(
+          "openDialog",
+          message
+        );
+        const dialogId = res == null ? void 0 : res.dialogId;
+        if (!dialogId) {
+          return;
+        }
+        return new Promise((resolve, reject) => {
+          dialogResponseHandlers[dialogId] = { resolve, reject };
+        });
+      },
+      closeDialog: async (message) => {
+        await client.request("closeDialog", message);
+      },
+      getDataResource: async (message) => {
+        return await client.request("getDataResource", message, {
+          timeout: 3e4
+        });
+      }
+    }
+  };
+}
+function getByteSize(val) {
+  if (!val || typeof Blob === "undefined") {
+    return 0;
+  }
+  try {
+    const serialized = JSON.stringify(val);
+    const size = new Blob([serialized]).size;
+    return size;
+  } catch (error) {
+    throw new Error("Error calculating object size: " + error.message);
+  }
+}
+
+// src/sdkWindow.ts
+var oldHeight;
+var createSdkWindow = ({
+  onHeightChange,
+  autoResizingDisabled
+}) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const windowInstance = window;
+  const updateHeight = (height) => {
+    if (height && height !== oldHeight) {
+      oldHeight = height;
+      onHeightChange == null ? void 0 : onHeightChange(height);
+      return;
+    }
+    const windowHeight = `${Math.ceil(
+      windowInstance.document.documentElement.getBoundingClientRect().height
+    )}px`;
+    if (windowHeight !== oldHeight) {
+      oldHeight = windowHeight;
+      onHeightChange == null ? void 0 : onHeightChange(windowHeight);
+    }
+  };
+  const heightCallback = () => {
+    updateHeight();
+  };
+  const observer = autoResizingDisabled ? void 0 : new MutationObserver(heightCallback);
+  const sdkWindow = {
+    instance: windowInstance,
+    height: windowInstance.document.documentElement.getBoundingClientRect().height,
+    observer,
+    enableAutoResizing: () => {
+      observer == null ? void 0 : observer.observe(document.body, {
+        attributes: true,
+        childList: true,
+        subtree: true,
+        characterData: true
+      });
+      windowInstance.addEventListener("resize", heightCallback);
+    },
+    disableAutoResizing: () => {
+      observer == null ? void 0 : observer.disconnect();
+      windowInstance.removeEventListener("resize", heightCallback);
+    },
+    updateHeight
+  };
+  if (!autoResizingDisabled) {
+    sdkWindow.enableAutoResizing();
+  }
+  return sdkWindow;
+};
+
+// src/sdk.ts
+var sdkDialogResponseHandlers = {};
+var initializing = false;
+async function initializeUniformMeshSDK({
+  autoResizingDisabled
+} = {}) {
+  var _a;
+  if (typeof window !== "undefined" && typeof window.UniformMeshSDK === "undefined" && !initializing) {
+    if (typeof window.parent === "undefined" || window.parent == window) {
+      throw new Error(
+        `It appears you are trying to connect with the Uniform Mesh SDK outside of an iframe. Be sure you are loading your app via a location URL configured in the Uniform dashboard.`
+      );
+    }
+    initializing = true;
+    const connectResult = await connectToParent({
+      dialogResponseHandlers: sdkDialogResponseHandlers
+    });
+    const { initData: contextData, parent } = connectResult;
+    const sdk = {
+      events: mitt(),
+      getCurrentLocation: () => {
+        const location = {
+          getDataResource: parent.getDataResource,
+          type: contextData.locationType,
+          isReadOnly: contextData.isReadOnly,
+          getValue: () => {
+            return location.value;
+          },
+          value: contextData.locationValue,
+          setValue: async (value, options) => {
+            if (contextData.dialogContext) {
+              console.warn(
+                "Using setValue() inside a dialog is deprecated. Use dialogContext.returnDialogValue() instead."
+              );
+            }
+            contextData.locationValue = value;
+            sdk.events.emit("onValueChanged", { newValue: value });
+            await parent.setValue(value, options);
+          },
+          getMetadata: () => contextData.locationMetadata,
+          metadata: contextData.locationMetadata,
+          setValidationResult: async (value) => {
+            await location.setValue(contextData.locationValue, value);
+          },
+          dialogContext: contextData.dialogContext ? {
+            ...contextData.dialogContext,
+            params: contextData.locationMetadata.dialogParams,
+            returnDialogValue: async (value) => {
+              contextData.locationValue = value;
+              sdk.events.emit("onValueChanged", { newValue: value });
+              await parent.setValue(value);
+            }
+          } : void 0
+        };
+        return location;
+      },
+      currentWindow: createSdkWindow({
+        onHeightChange: (height) => {
+          parent.resize(height);
+        },
+        autoResizingDisabled: ((_a = contextData.dialogContext) == null ? void 0 : _a.contentHeight) ? true : autoResizingDisabled
+      }),
+      version: contextData.uniformApiVersion,
+      openLocationDialog: async ({
+        locationKey,
+        options
+      }) => {
+        const result = await parent.openDialog({
+          dialogType: "location",
+          dialogData: { locationKey },
+          options
+        });
+        if (!result) {
+          return;
+        }
+        return {
+          dialogId: result.dialogId,
+          value: result.value,
+          closeDialog: async () => {
+            await parent.closeDialog({
+              dialogId: result.dialogId,
+              dialogType: "location"
+            });
+          }
+        };
+      },
+      async closeLocationDialog({ dialogId }) {
+        await parent.closeDialog({ dialogId, dialogType: "location" });
+      },
+      openConfirmationDialog: async ({ titleText, bodyText }) => {
+        const result = await parent.openDialog({
+          dialogType: "confirm",
+          dialogData: { titleText, bodyText }
+        });
+        if (!result) {
+          return;
+        }
+        return {
+          dialogId: result.dialogId,
+          value: result.value,
+          closeDialog: async () => {
+            await parent.closeDialog({ dialogId: void 0, dialogType: "confirm" });
+          }
+        };
+      },
+      openCurrentLocationDialog: async (options) => {
+        const result = await parent.openDialog({
+          dialogType: "location",
+          dialogData: {},
+          options: options == null ? void 0 : options.options
+        });
+        if (!result) {
+          return;
+        }
+        return {
+          dialogId: result.dialogId,
+          value: result.value,
+          closeDialog: async () => {
+            await parent.closeDialog({
+              dialogId: void 0,
+              dialogType: "location"
+            });
+          }
+        };
+      },
+      closeCurrentLocationDialog: async () => {
+        await parent.closeDialog({ dialogId: void 0, dialogType: "location" });
+      },
+      dialogContext: contextData.dialogContext
+    };
+    window.UniformMeshSDK = sdk;
+    initializing = false;
+    return sdk;
+  }
+}
+export {
+  initializeUniformMeshSDK
+};