@openfeature/web-sdk 0.4.10 → 0.4.12

package/README.md

@@ -16,8 +16,8 @@
     <img alt="Specification" src="https://img.shields.io/static/v1?label=specification&message=v0.7.0&color=yellow&style=for-the-badge" />
   </a>
   <!-- x-release-please-start-version -->
-  <a href="https://github.com/open-feature/js-sdk/releases/tag/web-sdk-v0.4.10">
-    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.4.10&color=blue&style=for-the-badge" />
+  <a href="https://github.com/open-feature/js-sdk/releases/tag/web-sdk-v0.4.12">
+    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.4.12&color=blue&style=for-the-badge" />
   </a>
   <!-- x-release-please-end -->
   <br/>
@@ -47,7 +47,7 @@
 
 ### Requirements
 
-- ES2015-compatible web browser (Chrome, Edge, Firefox, etc)
+- ES2022-compatible web browser (Chrome, Edge, Firefox, etc)
 
 ### Install
 
@@ -267,43 +267,52 @@ This can be a new repository or included in [the existing contrib repository](ht
 You’ll then need to write the provider by implementing the [Provider interface](./src/provider/provider.ts) exported by the OpenFeature SDK.
 
 ```ts
-import { JsonValue, Provider, ResolutionDetails } from '@openfeature/web-sdk';
+import {
+  AnyProviderEvent,
+  EvaluationContext,
+  Hook,
+  JsonValue,
+  Logger,
+  Provider,
+  ProviderEventEmitter,
+  ProviderStatus,
+  ResolutionDetails
+} from '@openfeature/web-sdk';
 
 // implement the provider interface
 class MyProvider implements Provider {
   // Adds runtime validation that the provider is used with the expected SDK
-  public readonly runsOn = 'client';
-
+  public readonly runsOn = 'server';
   readonly metadata = {
     name: 'My Provider',
   } as const;
-
   // Optional provider managed hooks
-  hooks?: Hook<FlagValue>[];
-
+  hooks?: Hook[];
   resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext, logger: Logger): ResolutionDetails<boolean> {
     // code to evaluate a boolean
   }
-
   resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext, logger: Logger): ResolutionDetails<string> {
     // code to evaluate a string
   }
-
   resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext, logger: Logger): ResolutionDetails<number> {
     // code to evaluate a number
   }
-
   resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext, logger: Logger): ResolutionDetails<T> {
     // code to evaluate an object
   }
 
+  onContextChange?(oldContext: EvaluationContext, newContext: EvaluationContext): Promise<void> {
+    // reconcile the provider's cached flags, if applicable
+  }
+
   status?: ProviderStatus | undefined;
-  events?: OpenFeatureEventEmitter | undefined;
+
+  // implement with "new OpenFeatureEventEmitter()", and use "emit()" to emit events
+  events?: ProviderEventEmitter<AnyProviderEvent> | undefined; 
 
   initialize?(context?: EvaluationContext | undefined): Promise<void> {
     // code to initialize your provider
   }
-
   onClose?(): Promise<void> {
     // code to shut down your provider
   }

package/dist/cjs/index.js

@@ -1,28 +1,10 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __reflectGet = Reflect.get;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -48,27 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 
 // ../../node_modules/events/events.js
 var require_events = __commonJS({
@@ -465,12 +426,11 @@ var import_core6 = require("@openfeature/core");
 var import_core = require("@openfeature/core");
 var import_events = __toESM(require_events());
 var OpenFeatureEventEmitter = class extends import_core.GenericEventEmitter {
+  eventEmitter = new import_events.default({ captureRejections: true });
   constructor() {
     super();
-    this.eventEmitter = new import_events.default({ captureRejections: true });
     this.eventEmitter.on("error", (err) => {
-      var _a;
-      (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
+      this._logger?.error("Error running event handler:", err);
     });
   }
 };
@@ -482,11 +442,9 @@ var import_core2 = require("@openfeature/core");
 var import_core3 = require("@openfeature/core");
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
-  constructor() {
-    this.metadata = {
-      name: "No-op Provider"
-    };
-  }
+  metadata = {
+    name: "No-op Provider"
+  };
   get status() {
     return import_core3.ProviderStatus.NOT_READY;
   }
@@ -517,6 +475,7 @@ var import_core5 = require("@openfeature/core");
 // src/provider/in-memory-provider/variant-not-found-error.ts
 var import_core4 = require("@openfeature/core");
 var VariantNotFoundError = class extends import_core4.OpenFeatureError {
+  code;
   constructor(message) {
     super(message);
     Object.setPrototypeOf(this, VariantNotFoundError.prototype);
@@ -527,48 +486,46 @@ var VariantNotFoundError = class extends import_core4.OpenFeatureError {
 
 // src/provider/in-memory-provider/in-memory-provider.ts
 var InMemoryProvider = class {
+  events = new OpenFeatureEventEmitter();
+  runsOn = "client";
+  status = import_core5.ProviderStatus.NOT_READY;
+  metadata = {
+    name: "in-memory"
+  };
+  _flagConfiguration;
+  _context;
   constructor(flagConfiguration = {}) {
-    this.events = new OpenFeatureEventEmitter();
-    this.runsOn = "client";
-    this.status = import_core5.ProviderStatus.NOT_READY;
-    this.metadata = {
-      name: "in-memory"
-    };
-    this._flagConfiguration = __spreadValues({}, flagConfiguration);
+    this._flagConfiguration = { ...flagConfiguration };
   }
-  initialize(context) {
-    return __async(this, null, function* () {
-      try {
-        for (const key in this._flagConfiguration) {
-          this.resolveFlagWithReason(key, context);
-        }
-        this._context = context;
-        this.status = import_core5.ProviderStatus.READY;
-      } catch (error) {
-        this.status = import_core5.ProviderStatus.ERROR;
-        throw error;
+  async initialize(context) {
+    try {
+      for (const key in this._flagConfiguration) {
+        this.resolveFlagWithReason(key, context);
       }
-    });
+      this._context = context;
+      this.status = import_core5.ProviderStatus.READY;
+    } catch (error) {
+      this.status = import_core5.ProviderStatus.ERROR;
+      throw error;
+    }
   }
   /**
    * Overwrites the configured flags.
    * @param { FlagConfiguration } flagConfiguration new flag configuration
    */
-  putConfiguration(flagConfiguration) {
-    return __async(this, null, function* () {
-      const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
-      this.status = import_core5.ProviderStatus.STALE;
-      this.events.emit(import_core2.ClientProviderEvents.Stale);
-      this._flagConfiguration = __spreadValues({}, flagConfiguration);
-      this.events.emit(import_core2.ClientProviderEvents.ConfigurationChanged, { flagsChanged });
-      try {
-        yield this.initialize(this._context);
-        this.events.emit(import_core2.ClientProviderEvents.Ready);
-      } catch (err) {
-        this.events.emit(import_core2.ClientProviderEvents.Error);
-        throw err;
-      }
-    });
+  async putConfiguration(flagConfiguration) {
+    const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
+    this.status = import_core5.ProviderStatus.STALE;
+    this.events.emit(import_core2.ClientProviderEvents.Stale);
+    this._flagConfiguration = { ...flagConfiguration };
+    this.events.emit(import_core2.ClientProviderEvents.ConfigurationChanged, { flagsChanged });
+    try {
+      await this.initialize(this._context);
+      this.events.emit(import_core2.ClientProviderEvents.Ready);
+    } catch (err) {
+      this.events.emit(import_core2.ClientProviderEvents.Error);
+      throw err;
+    }
   }
   resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
     return this.resolveAndCheckFlag(flagKey, defaultValue, context || this._context, logger);
@@ -585,7 +542,7 @@ var InMemoryProvider = class {
   resolveAndCheckFlag(flagKey, defaultValue, context, logger) {
     if (!(flagKey in this._flagConfiguration)) {
       const message = `no flag found with key ${flagKey}`;
-      logger == null ? void 0 : logger.debug(message);
+      logger?.debug(message);
       throw new import_core5.FlagNotFoundError(message);
     }
     if (this._flagConfiguration[flagKey].disabled) {
@@ -594,7 +551,7 @@ var InMemoryProvider = class {
     const resolvedFlag = this.resolveFlagWithReason(flagKey, context);
     if (resolvedFlag.value === void 0) {
       const message = `no value associated with variant provided for ${flagKey} found`;
-      logger == null ? void 0 : logger.error(message);
+      logger?.error(message);
       throw new VariantNotFoundError(message);
     }
     if (typeof resolvedFlag.value != typeof defaultValue) {
@@ -608,24 +565,23 @@ var InMemoryProvider = class {
       return resolutionResult;
     } catch (error) {
       if (!(error instanceof import_core5.OpenFeatureError)) {
-        throw new import_core5.GeneralError((error == null ? void 0 : error.message) || "unknown error");
+        throw new import_core5.GeneralError(error?.message || "unknown error");
       }
       throw error;
     }
   }
   lookupFlagValue(flagKey, ctx) {
-    var _a;
     const flagSpec = this._flagConfiguration[flagKey];
-    const isContextEval = ctx && (flagSpec == null ? void 0 : flagSpec.contextEvaluator);
-    const variant = isContextEval ? (_a = flagSpec.contextEvaluator) == null ? void 0 : _a.call(flagSpec, ctx) : flagSpec.defaultVariant;
-    const value = variant && (flagSpec == null ? void 0 : flagSpec.variants[variant]);
+    const isContextEval = ctx && flagSpec?.contextEvaluator;
+    const variant = isContextEval ? flagSpec.contextEvaluator?.(ctx) : flagSpec.defaultVariant;
+    const value = variant && flagSpec?.variants[variant];
     const evalReason = isContextEval ? import_core5.StandardResolutionReasons.TARGETING_MATCH : import_core5.StandardResolutionReasons.STATIC;
     const reason = this.status === import_core5.ProviderStatus.STALE ? import_core5.StandardResolutionReasons.CACHED : evalReason;
-    return __spreadProps(__spreadValues({
-      value
-    }, variant && { variant }), {
+    return {
+      value,
+      ...variant && { variant },
       reason
-    });
+    };
   }
 };
 
@@ -633,12 +589,12 @@ var InMemoryProvider = class {
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
 var _globalThis = globalThis;
 var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
+  _events = new OpenFeatureEventEmitter();
+  _defaultProvider = NOOP_PROVIDER;
+  _createEventEmitter = () => new OpenFeatureEventEmitter();
+  _namedProviderContext = /* @__PURE__ */ new Map();
   constructor() {
     super("client");
-    this._events = new OpenFeatureEventEmitter();
-    this._defaultProvider = NOOP_PROVIDER;
-    this._createEventEmitter = () => new OpenFeatureEventEmitter();
-    this._namedProviderContext = /* @__PURE__ */ new Map();
   }
   /**
    * Gets a singleton instance of the OpenFeature API.
@@ -654,39 +610,36 @@ var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
     _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
     return instance;
   }
-  setContext(nameOrContext, contextOrUndefined) {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const clientName = (0, import_core6.stringOrUndefined)(nameOrContext);
-      const context = (_b = (_a = (0, import_core6.objectOrUndefined)(nameOrContext)) != null ? _a : (0, import_core6.objectOrUndefined)(contextOrUndefined)) != null ? _b : {};
-      if (clientName) {
-        const provider = this._clientProviders.get(clientName);
-        if (provider) {
-          const oldContext = this.getContext(clientName);
-          this._namedProviderContext.set(clientName, context);
-          yield this.runProviderContextChangeHandler(clientName, provider, oldContext, context);
-        } else {
-          this._namedProviderContext.set(clientName, context);
-        }
+  async setContext(nameOrContext, contextOrUndefined) {
+    const clientName = (0, import_core6.stringOrUndefined)(nameOrContext);
+    const context = (0, import_core6.objectOrUndefined)(nameOrContext) ?? (0, import_core6.objectOrUndefined)(contextOrUndefined) ?? {};
+    if (clientName) {
+      const provider = this._clientProviders.get(clientName);
+      if (provider) {
+        const oldContext = this.getContext(clientName);
+        this._namedProviderContext.set(clientName, context);
+        await this.runProviderContextChangeHandler(clientName, provider, oldContext, context);
       } else {
-        const oldContext = this._context;
-        this._context = context;
-        const defaultContextNameProviders = Array.from(this._clientProviders.entries()).filter(([name]) => !this._namedProviderContext.has(name)).reduce((acc, [name, provider]) => {
-          acc.push({ name, provider });
-          return acc;
-        }, []);
-        const allProviders = [
-          // add in the default (no name)
-          { name: void 0, provider: this._defaultProvider },
-          ...defaultContextNameProviders
-        ];
-        yield Promise.all(
-          allProviders.map(
-            (tuple) => this.runProviderContextChangeHandler(tuple.name, tuple.provider, oldContext, context)
-          )
-        );
+        this._namedProviderContext.set(clientName, context);
       }
-    });
+    } else {
+      const oldContext = this._context;
+      this._context = context;
+      const defaultContextNameProviders = Array.from(this._clientProviders.entries()).filter(([name]) => !this._namedProviderContext.has(name)).reduce((acc, [name, provider]) => {
+        acc.push({ name, provider });
+        return acc;
+      }, []);
+      const allProviders = [
+        // add in the default (no name)
+        { name: void 0, provider: this._defaultProvider },
+        ...defaultContextNameProviders
+      ];
+      await Promise.all(
+        allProviders.map(
+          (tuple) => this.runProviderContextChangeHandler(tuple.name, tuple.provider, oldContext, context)
+        )
+      );
+    }
   }
   getContext(nameOrUndefined) {
     const clientName = (0, import_core6.stringOrUndefined)(nameOrUndefined);
@@ -700,33 +653,29 @@ var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
     }
     return this._context;
   }
-  clearContext(nameOrUndefined) {
-    return __async(this, null, function* () {
-      const clientName = (0, import_core6.stringOrUndefined)(nameOrUndefined);
-      if (clientName) {
-        const provider = this._clientProviders.get(clientName);
-        if (provider) {
-          const oldContext = this.getContext(clientName);
-          this._namedProviderContext.delete(clientName);
-          const newContext = this.getContext();
-          yield this.runProviderContextChangeHandler(clientName, provider, oldContext, newContext);
-        } else {
-          this._namedProviderContext.delete(clientName);
-        }
+  async clearContext(nameOrUndefined) {
+    const clientName = (0, import_core6.stringOrUndefined)(nameOrUndefined);
+    if (clientName) {
+      const provider = this._clientProviders.get(clientName);
+      if (provider) {
+        const oldContext = this.getContext(clientName);
+        this._namedProviderContext.delete(clientName);
+        const newContext = this.getContext();
+        await this.runProviderContextChangeHandler(clientName, provider, oldContext, newContext);
       } else {
-        return this.setContext({});
+        this._namedProviderContext.delete(clientName);
       }
-    });
+    } else {
+      return this.setContext({});
+    }
   }
   /**
    * Resets the global evaluation context and removes the evaluation context for
    * all named clients.
    */
-  clearContexts() {
-    return __async(this, null, function* () {
-      yield this.clearContext();
-      yield Promise.allSettled(Array.from(this._clientProviders.keys()).map((name) => this.clearContext(name)));
-    });
+  async clearContexts() {
+    await this.clearContext();
+    await Promise.allSettled(Array.from(this._clientProviders.keys()).map((name) => this.clearContext(name)));
   }
   /**
    * A factory function for creating new named OpenFeature clients. Clients can contain
@@ -753,32 +702,27 @@ var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
    * Clears all registered providers and resets the default provider.
    * @returns {Promise<void>}
    */
-  clearProviders() {
-    return __async(this, null, function* () {
-      yield __superGet(OpenFeatureAPI.prototype, this, "clearProvidersAndSetDefault").call(this, NOOP_PROVIDER);
-      this._namedProviderContext.clear();
-    });
+  async clearProviders() {
+    await super.clearProvidersAndSetDefault(NOOP_PROVIDER);
+    this._namedProviderContext.clear();
   }
-  runProviderContextChangeHandler(clientName, provider, oldContext, newContext) {
-    return __async(this, null, function* () {
-      var _a, _b, _c, _d, _e;
-      const providerName = provider.metadata.name;
-      try {
-        yield (_a = provider.onContextChange) == null ? void 0 : _a.call(provider, oldContext, newContext);
-        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
-          emitter == null ? void 0 : emitter.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
-        });
-        (_b = this._events) == null ? void 0 : _b.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
-      } catch (err) {
-        const error = err;
-        const message = `Error running ${(_c = provider == null ? void 0 : provider.metadata) == null ? void 0 : _c.name}'s context change handler: ${error == null ? void 0 : error.message}`;
-        (_d = this._logger) == null ? void 0 : _d.error(`${message}`, err);
-        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
-          emitter == null ? void 0 : emitter.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message });
-        });
-        (_e = this._events) == null ? void 0 : _e.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message });
-      }
-    });
+  async runProviderContextChangeHandler(clientName, provider, oldContext, newContext) {
+    const providerName = provider.metadata.name;
+    try {
+      await provider.onContextChange?.(oldContext, newContext);
+      this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+        emitter?.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
+      });
+      this._events?.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
+    } catch (err) {
+      const error = err;
+      const message = `Error running ${provider?.metadata?.name}'s context change handler: ${error?.message}`;
+      this._logger?.error(`${message}`, err);
+      this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+        emitter?.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message });
+      });
+      this._events?.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message });
+    }
   }
 };
 var OpenFeature = OpenFeatureAPI.getInstance();
@@ -790,8 +734,9 @@ var OpenFeatureClient = class {
     this.emitterAccessor = emitterAccessor;
     this.globalLogger = globalLogger;
     this.options = options;
-    this._hooks = [];
   }
+  _hooks = [];
+  _clientLogger;
   get metadata() {
     return {
       name: this.options.name,
@@ -800,18 +745,16 @@ var OpenFeatureClient = class {
     };
   }
   get providerStatus() {
-    var _a;
-    return ((_a = this.providerAccessor()) == null ? void 0 : _a.status) || import_core7.ProviderStatus.READY;
+    return this.providerAccessor()?.status || import_core7.ProviderStatus.READY;
   }
   addHandler(eventType, handler) {
-    var _a;
     this.emitterAccessor().addHandler(eventType, handler);
     const shouldRunNow = (0, import_core7.statusMatchesEvent)(eventType, this._provider.status);
     if (shouldRunNow) {
       try {
         handler({ clientName: this.metadata.name, providerName: this._provider.metadata.name });
       } catch (err) {
-        (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
+        this._logger?.error("Error running event handler:", err);
       }
     }
   }
@@ -875,7 +818,6 @@ var OpenFeatureClient = class {
     return this.evaluate(flagKey, this._provider.resolveObjectEvaluation, defaultValue, "object", options);
   }
   evaluate(flagKey, resolver, defaultValue, flagType, options = {}) {
-    var _a, _b;
     const allHooks = [
       ...OpenFeature.getHooks(),
       ...this.getHooks(),
@@ -883,7 +825,9 @@ var OpenFeatureClient = class {
       ...this._provider.hooks || []
     ];
     const allHooksReversed = [...allHooks].reverse();
-    const context = __spreadValues({}, OpenFeature.getContext((_a = this == null ? void 0 : this.options) == null ? void 0 : _a.name));
+    const context = {
+      ...OpenFeature.getContext(this?.options?.name)
+    };
     const hookContext = {
       flagKey,
       defaultValue,
@@ -896,15 +840,16 @@ var OpenFeatureClient = class {
     try {
       this.beforeHooks(allHooks, hookContext, options);
       const resolution = resolver.call(this._provider, flagKey, defaultValue, context, this._logger);
-      const evaluationDetails = __spreadProps(__spreadValues({}, resolution), {
-        flagMetadata: Object.freeze((_b = resolution.flagMetadata) != null ? _b : {}),
+      const evaluationDetails = {
+        ...resolution,
+        flagMetadata: Object.freeze(resolution.flagMetadata ?? {}),
         flagKey
-      });
+      };
       this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
       return evaluationDetails;
     } catch (err) {
-      const errorMessage = err == null ? void 0 : err.message;
-      const errorCode = (err == null ? void 0 : err.code) || import_core7.ErrorCode.GENERAL;
+      const errorMessage = err?.message;
+      const errorCode = err?.code || import_core7.ErrorCode.GENERAL;
       this.errorHooks(allHooksReversed, hookContext, err, options);
       return {
         errorCode,
@@ -919,44 +864,40 @@ var OpenFeatureClient = class {
     }
   }
   beforeHooks(hooks, hookContext, options) {
-    var _a;
     Object.freeze(hookContext);
     Object.freeze(hookContext.context);
     for (const hook of hooks) {
-      (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(options.hookHints));
+      hook?.before?.(hookContext, Object.freeze(options.hookHints));
     }
   }
   afterHooks(hooks, hookContext, evaluationDetails, options) {
-    var _a;
     for (const hook of hooks) {
-      (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, options.hookHints);
+      hook?.after?.(hookContext, evaluationDetails, options.hookHints);
     }
   }
   errorHooks(hooks, hookContext, err, options) {
-    var _a;
     for (const hook of hooks) {
       try {
-        (_a = hook == null ? void 0 : hook.error) == null ? void 0 : _a.call(hook, hookContext, err, options.hookHints);
+        hook?.error?.(hookContext, err, options.hookHints);
       } catch (err2) {
         this._logger.error(`Unhandled error during 'error' hook: ${err2}`);
         if (err2 instanceof Error) {
           this._logger.error(err2.stack);
         }
-        this._logger.error(err2 == null ? void 0 : err2.stack);
+        this._logger.error(err2?.stack);
       }
     }
   }
   finallyHooks(hooks, hookContext, options) {
-    var _a;
     for (const hook of hooks) {
       try {
-        (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, hookContext, options.hookHints);
+        hook?.finally?.(hookContext, options.hookHints);
       } catch (err) {
         this._logger.error(`Unhandled error during 'finally' hook: ${err}`);
         if (err instanceof Error) {
           this._logger.error(err.stack);
         }
-        this._logger.error(err == null ? void 0 : err.stack);
+        this._logger.error(err?.stack);
       }
     }
   }