@adobe/uix-core 0.7.1-nightly.20230226 → 0.7.1-nightly.20230227

package/dist/cross-realm-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cross-realm-object.d.ts","sourceRoot":"","sources":["../src/cross-realm-object.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAK/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAIlC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB,CAAC,WAAW;IAC3C;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;CACtC;AAmDD;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAChD,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,EACpC,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAGrC;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAC1C,KAAK,EAAE,iBAAiB,EACxB,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,EACpC,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAGrC"}
+{"version":3,"file":"cross-realm-object.d.ts","sourceRoot":"","sources":["../src/cross-realm-object.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAK/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAIlC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB,CAAC,WAAW;IAC3C;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;CACtC;AAuDD;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAChD,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,EACpC,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAGrC;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAC1C,KAAK,EAAE,iBAAiB,EACxB,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,EACpC,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAGrC"}

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from "./emitter";
 export * from "./namespace-proxy";
 export * from "./types";
 export * from "./cross-realm-object";
+export * from "./logging-formatters";
 export * from "./promises";
 export * from "./tunnel";
 export type { Asynced } from "./object-walker";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA;;;GAGG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA;;;GAGG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -468,6 +468,9 @@ function isPrimitive(value) {
 function isIterable(value) {
   return Array.isArray(value);
 }
+function isFunction(value) {
+  return typeof value === "function";
+}
 function hasProp(value, prop) {
   return !isPrimitive(value) && Reflect.has(value, prop);
 }
@@ -816,17 +819,23 @@ var ObjectSimulator = class {
 };
 
 // src/promises/timed.ts
-function timeoutPromise(description, promise, ms, onReject) {
+function timeoutPromise(describe, promise, ms, onReject) {
   return new Promise((resolve, reject) => {
     const cleanupAndReject = async (e) => {
       try {
-        await onReject(e);
+        if (onReject) {
+          await onReject(e);
+        }
       } finally {
         reject(e);
       }
     };
     const timeout = setTimeout(() => {
-      cleanupAndReject(new Error(`${description} timed out after ${ms}ms`));
+      cleanupAndReject(
+        new Error(
+          `${typeof describe === "function" ? describe() : describe} timed out after ${ms}ms`
+        )
+      );
     }, ms);
     promise.then((result) => {
       clearTimeout(timeout);
@@ -951,21 +960,47 @@ var Tunnel = class extends import_eventemitter3.default {
         )}`
       );
     }
-    const source = target.contentWindow;
     const config = Tunnel._normalizeConfig(options);
     const tunnel = new Tunnel(config);
     const messenger = new TunnelMessenger({
       myOrigin: window.location.origin,
-      targetOrigin: options.targetOrigin,
-      logger: options.logger || console
+      targetOrigin: config.targetOrigin,
+      logger: config.logger
     });
+    tunnel.on(
+      "destroyed",
+      () => config.logger.log(
+        `Tunnel to iframe at ${config.targetOrigin} destroyed!`,
+        tunnel,
+        target
+      )
+    );
+    tunnel.on(
+      "connected",
+      () => config.logger.log(
+        `Tunnel to iframe at ${config.targetOrigin} connected!`,
+        tunnel,
+        target
+      )
+    );
+    tunnel.on(
+      "error",
+      (e) => config.logger.log(
+        `Tunnel to iframe at ${config.targetOrigin} error!`,
+        tunnel,
+        target,
+        e
+      )
+    );
     let frameStatusCheck;
     let timeout;
     const offerListener = (event) => {
-      if (isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeOffer(event.data)) {
+      if (!tunnel.isConnected && isFromOrigin(event, target.contentWindow, config.targetOrigin) && messenger.isHandshakeOffer(event.data)) {
         const accepted = messenger.makeAccepted(unwrap(event.data).offers);
         const channel = new MessageChannel();
-        source.postMessage(accepted, config.targetOrigin, [channel.port1]);
+        target.contentWindow.postMessage(accepted, config.targetOrigin, [
+          channel.port1
+        ]);
         tunnel.connect(channel.port2);
       }
     };
@@ -975,19 +1010,26 @@ var Tunnel = class extends import_eventemitter3.default {
       window.removeEventListener("message", offerListener);
     };
     timeout = window.setTimeout(() => {
-      tunnel.emitLocal(
-        "error",
+      tunnel.abort(
         new Error(
-          `Timed out awaiting initial message from iframe after ${config.timeout}ms`
+          `Timed out awaiting initial message from target iframe after ${config.timeout}ms`
         )
       );
-      tunnel.destroy();
     }, config.timeout);
     tunnel.on("destroyed", cleanup);
     tunnel.on("connected", () => clearTimeout(timeout));
     frameStatusCheck = window.setInterval(() => {
       if (!target.isConnected) {
-        tunnel.destroy();
+        cleanup();
+        if (tunnel.isConnected) {
+          const frameDisconnectError = new Error(
+            `Tunnel target iframe at ${tunnel.config.targetOrigin} was disconnected from the document!`
+          );
+          Object.assign(frameDisconnectError, { target });
+          tunnel.abort(frameDisconnectError);
+        } else {
+          tunnel.destroy();
+        }
       }
     }, STATUSCHECK_MS);
     window.addEventListener("message", offerListener);
@@ -996,16 +1038,29 @@ var Tunnel = class extends import_eventemitter3.default {
   static toParent(source, opts) {
     let retrying;
     let timeout;
+    let timedOut = false;
     const key = makeKey();
     const config = Tunnel._normalizeConfig(opts);
     const tunnel = new Tunnel(config);
+    tunnel.on(
+      "destroyed",
+      () => config.logger.log(`Tunnel ${key} to parent window destroyed!`, tunnel)
+    );
+    tunnel.on(
+      "connected",
+      () => config.logger.log(`Tunnel ${key} to parent window connected!`, tunnel)
+    );
+    tunnel.on(
+      "error",
+      (e) => config.logger.log(`Tunnel ${key} to parent window error!`, tunnel, e)
+    );
     const messenger = new TunnelMessenger({
       myOrigin: window.location.origin,
       targetOrigin: config.targetOrigin,
       logger: config.logger
     });
     const acceptListener = (event) => {
-      if (isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeAccepting(event.data, key)) {
+      if (!timedOut && isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeAccepting(event.data, key)) {
         cleanup();
         if (!event.ports || !event.ports.length) {
           const portError = new Error(
@@ -1023,18 +1078,29 @@ var Tunnel = class extends import_eventemitter3.default {
       window.removeEventListener("message", acceptListener);
     };
     timeout = window.setTimeout(() => {
-      tunnel.emitLocal(
-        "error",
-        new Error(
-          `Timed out waiting for initial response from parent after ${config.timeout}ms`
-        )
-      );
-      tunnel.destroy();
+      if (!timedOut) {
+        timedOut = true;
+        tunnel.abort(
+          new Error(
+            `Timed out waiting for initial response from parent after ${config.timeout}ms`
+          )
+        );
+      }
     }, config.timeout);
     window.addEventListener("message", acceptListener);
-    tunnel.on("destroyed", cleanup);
-    tunnel.on("connected", cleanup);
-    const sendOffer = () => source.postMessage(messenger.makeOffered(key), config.targetOrigin);
+    tunnel.on("destroyed", () => {
+      cleanup();
+    });
+    tunnel.on("connected", () => {
+      cleanup();
+    });
+    const sendOffer = () => {
+      if (tunnel.isConnected) {
+        clearInterval(retrying);
+      } else {
+        source.postMessage(messenger.makeOffered(key), config.targetOrigin);
+      }
+    };
     retrying = window.setInterval(sendOffer, RETRY_MS);
     sendOffer();
     return tunnel;
@@ -1046,16 +1112,22 @@ var Tunnel = class extends import_eventemitter3.default {
     }
     this._messagePort = remote;
     remote.addEventListener("message", this._emitFromMessage);
-    this.emit("connected");
+    this.emitLocal("connected");
     this._messagePort.start();
+    this.isConnected = true;
+  }
+  abort(error) {
+    this.emitLocal("error", error);
+    this.destroy(error);
   }
-  destroy() {
+  destroy(e) {
     if (this._messagePort) {
       this._messagePort.close();
       this._messagePort = null;
+      this.isConnected = false;
     }
-    this.emitLocal("destroyed");
-    this.emit("destroyed");
+    const context = e ? [e] : [];
+    this.emitLocal("destroyed", ...context);
   }
   emit(type, payload) {
     if (!this._messagePort) {
@@ -1068,8 +1140,8 @@ var Tunnel = class extends import_eventemitter3.default {
     let errorMessage = "";
     const config = {
       timeout: 4e3,
-      logger: console,
-      ...options
+      ...options,
+      logger: options.logger || quietConsole
     };
     const timeoutMs = Number(config.timeout);
     if (!Number.isSafeInteger(timeoutMs)) {
@@ -1122,7 +1194,9 @@ async function setupApiExchange(tunnel, apiToSend) {
         unsubscribe();
         if (!done) {
           done = true;
-          reject(e);
+          if (e) {
+            reject(e);
+          }
         }
       };
       tunnel.on("destroyed", destroy);
@@ -1132,7 +1206,9 @@ async function setupApiExchange(tunnel, apiToSend) {
       );
     }),
     tunnel.config.timeout,
-    () => tunnel.destroy()
+    (e) => {
+      tunnel.abort(e);
+    }
   );
 }
 async function connectParentWindow(tunnelOptions, apiToSend) {
@@ -1144,6 +1220,27 @@ async function connectIframe(frame, tunnelOptions, apiToSend) {
   return setupApiExchange(tunnel, apiToSend);
 }
 
+// src/logging-formatters.ts
+function formatHostMethodArgument(argument) {
+  try {
+    return JSON.stringify(argument, null, 2);
+  } catch (e) {
+    if (isIterable(argument)) {
+      return `Iterable<${argument.length}>`;
+    }
+    if (isPrimitive(argument) || isFunction(argument)) {
+      return `${argument}`;
+    }
+    return Object.prototype.toString.call(argument);
+  }
+}
+function formatHostMethodAddress(address) {
+  const path = address.path?.length < 1 ? "<Missing method path!>" : address.path.join(".");
+  const name = address.name || "<Missing method name!>";
+  const args = address.args?.map(formatHostMethodArgument).join(",");
+  return `host.${path}.${name}(${args})`;
+}
+
 // src/promises/wait.ts
 function wait(ms) {
   return new Promise((resolve) => {
@@ -1157,6 +1254,8 @@ exports._customConsole = _customConsole;
 exports.connectIframe = connectIframe;
 exports.connectParentWindow = connectParentWindow;
 exports.debugEmitter = debugEmitter;
+exports.formatHostMethodAddress = formatHostMethodAddress;
+exports.formatHostMethodArgument = formatHostMethodArgument;
 exports.makeNamespaceProxy = makeNamespaceProxy;
 exports.quietConsole = quietConsole;
 exports.timeoutPromise = timeoutPromise;