@adobe/uix-core 0.7.0 → 0.7.1-nightly.20230114

package/dist/constants.d.ts

@@ -1,6 +1,7 @@
 /** @internal */
 export declare const NS_ROOT = "_$pg";
-export declare const VERSION = "0.0.1";
+export declare const VERSION: string;
+export declare const BUILDMODE: string;
 export declare const SYM_CLEANUP: unique symbol;
 export declare const SYM_INTERNAL: unique symbol;
 export declare const INIT_CALLBACK: string;

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,eAAO,MAAM,OAAO,SAAS,CAAC;AAC9B,eAAO,MAAM,OAAO,UAAU,CAAC;AAC/B,eAAO,MAAM,WAAW,eAA+B,CAAC;AACxD,eAAO,MAAM,YAAY,eAAgC,CAAC;AAC1D,eAAO,MAAM,aAAa,QAAuB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,gBAAgB;AAChB,eAAO,MAAM,OAAO,SAAS,CAAC;AAC9B,eAAO,MAAM,OAAO,QAAkB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAC3C,eAAO,MAAM,WAAW,eAA+B,CAAC;AACxD,eAAO,MAAM,YAAY,eAAgC,CAAC;AAC1D,eAAO,MAAM,aAAa,QAAuB,CAAC"}

package/dist/index.js

@@ -447,7 +447,7 @@ function makeNamespaceProxy(invoke, path = []) {
 
 // src/constants.ts
 var NS_ROOT = "_$pg";
-var VERSION = "0.0.1";
+var VERSION = "0.7.0";
 var INIT_CALLBACK = `${NS_ROOT}_init_cb`;
 
 // src/value-assertions.ts
@@ -478,6 +478,13 @@ function isIframe(value) {
   const { nodeName } = value;
   return typeof nodeName === "string" && nodeName.toLowerCase() === "iframe";
 }
+function isObjectWithPrototype(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Reflect.getPrototypeOf(value);
+  return proto !== Object.prototype;
+}
 
 // src/message-wrapper.ts
 function wrap(message) {
@@ -504,28 +511,63 @@ function isWrapped(item) {
 
 // src/object-walker.ts
 var NOT_TRANSFORMED = Symbol.for("NOT_TRANSFORMED");
-function transformRecursive(transform, value) {
+var CIRCULAR = "[[Circular]]";
+function transformRecursive(transform, value, parent, _refs = /* @__PURE__ */ new WeakSet()) {
   if (isPrimitive(value)) {
     return value;
   }
-  const transformed = transform(value);
+  const transformed = transform(value, parent);
   if (transformed !== NOT_TRANSFORMED) {
     return transformed;
   }
   if (isIterable(value)) {
     const outArray = [];
     for (const item of value) {
-      outArray.push(transformRecursive(transform, item));
+      outArray.push(transformRecursive(transform, item, void 0, _refs));
     }
     return outArray;
   }
   if (isPlainObject(value)) {
+    if (_refs.has(value)) {
+      return CIRCULAR;
+    }
+    _refs.add(value);
     const outObj = {};
     for (const key of Reflect.ownKeys(value)) {
       Reflect.set(
         outObj,
         key,
-        transformRecursive(transform, Reflect.get(value, key))
+        transformRecursive(transform, Reflect.get(value, key), void 0, _refs)
+      );
+    }
+    return outObj;
+  }
+  if (isObjectWithPrototype(value)) {
+    if (_refs.has(value)) {
+      return CIRCULAR;
+    }
+    _refs.add(value);
+    const getObjectKeys = (obj) => {
+      const result = /* @__PURE__ */ new Set();
+      do {
+        if (Reflect.getPrototypeOf(obj) !== null) {
+          for (const prop of Object.getOwnPropertyNames(obj)) {
+            if (prop === "constructor") {
+              continue;
+            }
+            result.add(prop);
+          }
+        }
+      } while (obj = Reflect.getPrototypeOf(obj));
+      return [...result];
+    };
+    const outObj = {};
+    const properties = getObjectKeys(value);
+    for (const key of properties) {
+      Reflect.set(
+        outObj,
+        key,
+        transformRecursive(transform, Reflect.get(value, key), value, _refs)
       );
     }
     return outObj;
@@ -722,7 +764,7 @@ var ObjectSimulator = class {
     simulator = new ObjectSimulator(subject, cleanupNotifier);
     return simulator;
   }
-  makeReceiver(fn) {
+  makeReceiver(fn, parent) {
     if (typeof fn !== "function") {
       return NOT_TRANSFORMED;
     }
@@ -731,9 +773,17 @@ var ObjectSimulator = class {
       fnTicket = {
         fnId: `${fn.name || "<anonymous>"}_${++this.fnCounter}`
       };
-      const cleanup = receiveCalls(fn, fnTicket, new WeakRef(this.subject));
+      let boundFunction = fn;
+      if (parent) {
+        boundFunction = fn.bind(parent);
+      }
+      const cleanup = receiveCalls(
+        boundFunction,
+        fnTicket,
+        new WeakRef(this.subject)
+      );
       this.subject.onOutOfScope(fnTicket, cleanup);
-      this.receiverTicketCache.set(fn, fnTicket);
+      this.receiverTicketCache.set(boundFunction, fnTicket);
     }
     return wrap(fnTicket);
   }
@@ -796,46 +846,74 @@ var INIT_TICKET = {
 // src/tunnel/tunnel.ts
 var import_eventemitter3 = __toESM(require_eventemitter3());
 
-// src/tunnel/tunnel-message.ts
-var VERSION_WARNINGS = /* @__PURE__ */ new Set();
-function makeAccepted(id) {
-  return wrap({
-    accepts: id,
-    version: VERSION
-  });
-}
-function makeOffered(id) {
-  return wrap({
-    offers: id,
-    version: VERSION
-  });
-}
-function isHandshakeAccepting(message, id) {
-  return isHandshake(message) && unwrap(message).accepts === id;
-}
-function isHandshakeOffer(message) {
-  return isHandshake(message) && typeof unwrap(message).offers === "string";
-}
-function isHandshake(message) {
-  if (!isWrapped(message)) {
-    return false;
+// src/tunnel/tunnel-messenger.ts
+var TunnelMessenger = class {
+  constructor(opts) {
+    this.versionWarnings = /* @__PURE__ */ new Set();
+    this.myOrigin = opts.myOrigin;
+    this.remoteOrigin = opts.targetOrigin === "*" ? "remote document" : opts.targetOrigin;
+    this.logger = opts.logger;
   }
-  const tunnelData = unwrap(message);
-  if (!isPlainObject(tunnelData) || typeof tunnelData.version !== "string" || !(Reflect.has(tunnelData, "accepts") || Reflect.has(tunnelData, "offers"))) {
-    console.error(
-      `malformed tunnel message, message.${NS_ROOT} must be an object with a "version" string and an either an "accepts" or "offers" property containing an ID string.`
+  resetWarnings() {
+    this.versionWarnings.clear();
+  }
+  makeAccepted(id) {
+    return wrap({
+      accepts: id,
+      version: VERSION
+    });
+  }
+  makeOffered(id) {
+    return wrap({
+      offers: id,
+      version: VERSION
+    });
+  }
+  isHandshakeAccepting(message, id) {
+    return this.isHandshake(message) && unwrap(message).accepts === id;
+  }
+  isHandshakeOffer(message) {
+    return this.isHandshake(message) && typeof unwrap(message).offers === "string";
+  }
+  isHandshake(message) {
+    if (!isWrapped(message)) {
+      this.logMalformed(message);
+      return false;
+    }
+    const tunnelData = unwrap(
+      message
     );
-    return false;
+    if (!isPlainObject(tunnelData) || typeof tunnelData.version !== "string" || !(Reflect.has(tunnelData, "accepts") || Reflect.has(tunnelData, "offers"))) {
+      this.logMalformed(message);
+      return false;
+    }
+    const { version } = tunnelData;
+    if (version !== VERSION && !this.versionWarnings.has(version)) {
+      this.versionWarnings.add(version);
+      this.logger.warn(
+        `SDK version mismatch. ${this.myOrigin} is using v${VERSION}, but received message from ${this.remoteOrigin} using SDK v${version}. Extensions may be broken or unresponsive.`
+      );
+    }
+    return true;
   }
-  const { version } = tunnelData;
-  if (version !== VERSION && !VERSION_WARNINGS.has(version)) {
-    VERSION_WARNINGS.add(version);
-    console.warn(
-      `Version mismatch: current Tunnel is ${VERSION} and remote Tunnel is ${version}. May cause problems.`
+  logMalformed(message) {
+    let inspectedMessage;
+    try {
+      inspectedMessage = JSON.stringify(message, null, 2);
+    } catch (_) {
+      try {
+        inspectedMessage = message.toString();
+      } catch (e) {
+        inspectedMessage = Object.prototype.toString.call(message);
+      }
+    }
+    this.logger.error(
+      `Malformed tunnel message sent from SDK at ${this.remoteOrigin} to ${this.myOrigin}:
+${inspectedMessage}
+Message must be an object with "${NS_ROOT}" property, which must be an object with a "version" string and an either an "accepts" or "offers" property containing an ID string.`
     );
   }
-  return true;
-}
+};
 
 // src/tunnel/tunnel.ts
 var RETRY_MS = 100;
@@ -876,11 +954,16 @@ 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
+    });
     let frameStatusCheck;
     let timeout;
     const offerListener = (event) => {
-      if (isFromOrigin(event, source, config.targetOrigin) && isHandshakeOffer(event.data)) {
-        const accepted = makeAccepted(unwrap(event.data).offers);
+      if (isFromOrigin(event, source, 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]);
         tunnel.connect(channel.port2);
@@ -916,8 +999,13 @@ var Tunnel = class extends import_eventemitter3.default {
     const key = makeKey();
     const config = Tunnel._normalizeConfig(opts);
     const tunnel = new Tunnel(config);
+    const messenger = new TunnelMessenger({
+      myOrigin: window.location.origin,
+      targetOrigin: config.targetOrigin,
+      logger: config.logger
+    });
     const acceptListener = (event) => {
-      if (isFromOrigin(event, source, config.targetOrigin) && isHandshakeAccepting(event.data, key)) {
+      if (isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeAccepting(event.data, key)) {
         cleanup();
         if (!event.ports || !event.ports.length) {
           const portError = new Error(
@@ -946,7 +1034,7 @@ var Tunnel = class extends import_eventemitter3.default {
     window.addEventListener("message", acceptListener);
     tunnel.on("destroyed", cleanup);
     tunnel.on("connected", cleanup);
-    const sendOffer = () => source.postMessage(makeOffered(key), config.targetOrigin);
+    const sendOffer = () => source.postMessage(messenger.makeOffered(key), config.targetOrigin);
     retrying = window.setInterval(sendOffer, RETRY_MS);
     sendOffer();
     return tunnel;
@@ -980,6 +1068,7 @@ var Tunnel = class extends import_eventemitter3.default {
     let errorMessage = "";
     const config = {
       timeout: 4e3,
+      logger: console,
       ...options
     };
     const timeoutMs = Number(config.timeout);