lifecycleion 0.0.19 → 0.0.21

package/dist/lib/logger/index.cjs

@@ -757,18 +757,204 @@ function isFunction(value) {
   return typeof value === "function" || value instanceof Function;
 }
 
+// src/lib/global-event-target.ts
+var GLOBAL_KEY = "__lifecycleion_global_event_target__";
+var METHOD_NAMES = [
+  "addEventListener",
+  "removeEventListener",
+  "dispatchEvent"
+];
+var g = globalThis;
+function getState() {
+  const value = readGlobal(GLOBAL_KEY);
+  return value === UNREADABLE ? void 0 : asUsableState(value);
+}
+function asUsableState(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  return asUsableTarget(readMember(value, "target")) === null ? void 0 : value;
+}
+function asUsableTarget(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  for (const name of METHOD_NAMES) {
+    if (typeof readMember(value, name) !== "function") {
+      return null;
+    }
+  }
+  return value;
+}
+function bindTargetMethods(target) {
+  const bound = {};
+  for (const name of METHOD_NAMES) {
+    const method = readMember(target, name);
+    if (typeof method !== "function") {
+      return null;
+    }
+    let boundMethod;
+    try {
+      boundMethod = method.bind(target);
+    } catch {
+      return null;
+    }
+    if (typeof boundMethod !== "function") {
+      return null;
+    }
+    bound[name] = boundMethod;
+  }
+  return bound;
+}
+function isStateInstalled(state) {
+  return state !== void 0 && readMember(state, "isInstalled") === true;
+}
+function readStateTarget(state) {
+  if (state === void 0) {
+    return null;
+  }
+  return asUsableTarget(readMember(state, "target"));
+}
+var UNREADABLE = /* @__PURE__ */ Symbol("lifecycleion.unreadable");
+function readGlobal(name) {
+  try {
+    return g[name];
+  } catch {
+    return UNREADABLE;
+  }
+}
+function readMember(source, key) {
+  try {
+    return source[key];
+  } catch {
+    return UNREADABLE;
+  }
+}
+function probeMember(name) {
+  const value = readGlobal(name);
+  if (value === UNREADABLE) {
+    return "hostile";
+  }
+  if (typeof value === "function") {
+    return "usable";
+  }
+  return value === void 0 ? "absent" : "occupied";
+}
+function canDefineProperty(key) {
+  const descriptor = Object.getOwnPropertyDescriptor(g, key);
+  if (descriptor === void 0) {
+    return Object.isExtensible(g);
+  }
+  return descriptor.configurable === true;
+}
+function installGlobalEventTarget() {
+  const members = METHOD_NAMES.map((name) => probeMember(name));
+  if (members.every((member) => member === "usable")) {
+    return isStateInstalled(getState()) ? "already-installed" : "native";
+  }
+  if (members.some((member) => member !== "absent")) {
+    return "partial";
+  }
+  const eventTargetConstructor = readGlobal("EventTarget");
+  if (typeof eventTargetConstructor !== "function") {
+    return "unsupported";
+  }
+  const isDefinable = [...METHOD_NAMES, GLOBAL_KEY].every(
+    (key) => canDefineProperty(key)
+  );
+  if (!isDefinable) {
+    return "blocked";
+  }
+  const existingState = getState();
+  const defined = [];
+  const priorStateDescriptor = Object.getOwnPropertyDescriptor(g, GLOBAL_KEY);
+  const rollback = () => {
+    for (const key of defined) {
+      if (key === GLOBAL_KEY && priorStateDescriptor !== void 0) {
+        try {
+          Object.defineProperty(g, GLOBAL_KEY, priorStateDescriptor);
+        } catch {
+        }
+        continue;
+      }
+      try {
+        Reflect.deleteProperty(g, key);
+      } catch {
+      }
+    }
+  };
+  const reusableTarget = readStateTarget(existingState);
+  const reusableMethods = reusableTarget === null ? null : bindTargetMethods(reusableTarget);
+  let state;
+  let methods;
+  try {
+    if (existingState === void 0 || reusableMethods === null) {
+      let target;
+      try {
+        target = new eventTargetConstructor();
+      } catch {
+        return "unsupported";
+      }
+      const freshMethods = bindTargetMethods(target);
+      if (freshMethods === null) {
+        return "unsupported";
+      }
+      state = { target, isInstalled: false };
+      methods = freshMethods;
+      Object.defineProperty(g, GLOBAL_KEY, {
+        value: state,
+        enumerable: false,
+        writable: false,
+        configurable: true
+      });
+      defined.push(GLOBAL_KEY);
+    } else {
+      state = existingState;
+      methods = reusableMethods;
+    }
+    for (const name of METHOD_NAMES) {
+      Object.defineProperty(g, name, {
+        value: methods[name],
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+      defined.push(name);
+    }
+    if (readMember(state, "isInstalled") !== true) {
+      state.isInstalled = true;
+    }
+  } catch {
+    rollback();
+    return "blocked";
+  }
+  return "installed";
+}
+function isGlobalEventTargetAvailable() {
+  return METHOD_NAMES.every((name) => probeMember(name) === "usable") && probeMember("ErrorEvent") === "usable";
+}
+
 // src/lib/safe-handle-callback.ts
+installGlobalEventTarget();
+function reportCallbackError(callbackName, error) {
+  installGlobalEventTarget();
+  if (!isGlobalEventTargetAvailable()) {
+    return;
+  }
+  try {
+    globalThis.dispatchEvent(
+      new ErrorEvent("reportError", {
+        error: new Error(
+          `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
+        )
+      })
+    );
+  } catch {
+  }
+}
 function safeHandleCallback(callbackName, callback, ...args) {
   const handleError = (error) => {
-    if (typeof globalThis.dispatchEvent === "function") {
-      globalThis.dispatchEvent(
-        new ErrorEvent("reportError", {
-          error: new Error(
-            `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
-          )
-        })
-      );
-    }
+    reportCallbackError(callbackName, error);
   };
   if (isFunction(callback)) {
     try {
@@ -789,15 +975,7 @@ function safeHandleCallback(callbackName, callback, ...args) {
 }
 async function safeHandleCallbackAndWait(callbackName, callback, ...args) {
   const handleError = (error) => {
-    if (typeof globalThis.dispatchEvent === "function") {
-      globalThis.dispatchEvent(
-        new ErrorEvent("reportError", {
-          error: new Error(
-            `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
-          )
-        })
-      );
-    }
+    reportCallbackError(callbackName, error);
     return { success: false, error };
   };
   if (isFunction(callback)) {
@@ -2344,6 +2522,7 @@ var Logger = class _Logger extends EventEmitter {
     if (this._reportErrorListenerRegistered) {
       return "already_registered";
     }
+    installGlobalEventTarget();
     if (!this.isReportErrorAvailable()) {
       return "not_available";
     }
@@ -2386,13 +2565,16 @@ var Logger = class _Logger extends EventEmitter {
     return this._reportErrorListenerRegistered;
   }
   /**
-   * Check if the global event primitives used for `reportError` dispatch are available.
+   * Check if the global event primitives used for `reportError` dispatch are available:
+   * the `EventTarget` methods on `globalThis` plus the `ErrorEvent` constructor.
+   *
+   * On Node.js the event methods are supplied by Lifecycleion's `global-event-target`
+   * polyfill, which is installed when this module is imported.
    *
    * @returns 'true' if the required global event primitives are available, 'false' otherwise.
    */
   isReportErrorAvailable() {
-    const globalRecord = globalThis;
-    return typeof globalRecord.addEventListener === "function" && typeof globalRecord.removeEventListener === "function" && typeof globalRecord.dispatchEvent === "function" && typeof globalRecord.ErrorEvent === "function";
+    return isGlobalEventTargetAvailable();
   }
   /**
    * Add a sink to the logger