@openfeature/web-sdk 1.6.1 → 1.7.0

package/dist/global/index.js

@@ -235,12 +235,18 @@ var OpenFeature = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    AggregateError: () => AggregateError,
     AllProviderEvents: () => ClientProviderEvents,
     AllProviderStatus: () => ClientProviderStatus,
+    BaseEvaluationStrategy: () => BaseEvaluationStrategy,
     ClientProviderEvents: () => ClientProviderEvents,
     ClientProviderStatus: () => ClientProviderStatus,
+    ComparisonStrategy: () => ComparisonStrategy,
     DefaultLogger: () => DefaultLogger,
     ErrorCode: () => ErrorCode,
+    ErrorWithCode: () => ErrorWithCode,
+    FirstMatchStrategy: () => FirstMatchStrategy,
+    FirstSuccessfulStrategy: () => FirstSuccessfulStrategy,
     FlagNotFoundError: () => FlagNotFoundError,
     GeneralError: () => GeneralError,
     GenericEventEmitter: () => GenericEventEmitter,
@@ -248,6 +254,7 @@ var OpenFeature = (() => {
     InvalidContextError: () => InvalidContextError,
     LOG_LEVELS: () => LOG_LEVELS,
     MapHookData: () => MapHookData,
+    MultiProvider: () => MultiProvider,
     NOOP_PROVIDER: () => NOOP_PROVIDER,
     OpenFeature: () => OpenFeature,
     OpenFeatureAPI: () => OpenFeatureAPI,
@@ -268,13 +275,15 @@ var OpenFeature = (() => {
     TelemetryAttribute: () => TelemetryAttribute,
     TelemetryFlagMetadata: () => TelemetryFlagMetadata,
     TypeMismatchError: () => TypeMismatchError,
+    constructAggregateError: () => constructAggregateError,
     createEvaluationEvent: () => createEvaluationEvent,
     instantiateErrorByErrorCode: () => instantiateErrorByErrorCode,
     isObject: () => isObject,
     isString: () => isString,
     objectOrUndefined: () => objectOrUndefined,
     statusMatchesEvent: () => statusMatchesEvent,
-    stringOrUndefined: () => stringOrUndefined
+    stringOrUndefined: () => stringOrUndefined,
+    throwAggregateErrorFromPromiseResults: () => throwAggregateErrorFromPromiseResults
   });
 
   // ../shared/src/hooks/hook-data.ts
@@ -667,7 +676,6 @@ var OpenFeature = (() => {
      *
      * - type: `undefined`
      * - requirement level: `conditionally required`
-     * - condition: variant is not defined on the evaluation details
      * - example: `#ff0000`; `1`; `true`
      */
     VALUE: "feature_flag.result.value",
@@ -734,7 +742,7 @@ var OpenFeature = (() => {
   // ../shared/src/telemetry/evaluation-event.ts
   var FLAG_EVALUATION_EVENT_NAME = "feature_flag.evaluation";
   function createEvaluationEvent(hookContext, evaluationDetails) {
-    var _a, _b;
+    var _a, _b, _c;
     const attributes = {
       [TelemetryAttribute.KEY]: hookContext.flagKey,
       [TelemetryAttribute.PROVIDER]: hookContext.providerMetadata.name,
@@ -742,10 +750,18 @@ var OpenFeature = (() => {
     };
     if (evaluationDetails.variant) {
       attributes[TelemetryAttribute.VARIANT] = evaluationDetails.variant;
-    } else {
-      attributes[TelemetryAttribute.VALUE] = evaluationDetails.value;
     }
-    const contextId = evaluationDetails.flagMetadata[TelemetryFlagMetadata.CONTEXT_ID] || hookContext.context.targetingKey;
+    if (evaluationDetails.value !== null) {
+      if (typeof evaluationDetails.value !== "object") {
+        attributes[TelemetryAttribute.VALUE] = evaluationDetails.value;
+      } else {
+        try {
+          attributes[TelemetryAttribute.VALUE] = JSON.stringify(evaluationDetails.value);
+        } catch (e) {
+        }
+      }
+    }
+    const contextId = (_b = evaluationDetails.flagMetadata[TelemetryFlagMetadata.CONTEXT_ID]) != null ? _b : hookContext.context.targetingKey;
     if (contextId) {
       attributes[TelemetryAttribute.CONTEXT_ID] = contextId;
     }
@@ -758,7 +774,7 @@ var OpenFeature = (() => {
       attributes[TelemetryAttribute.VERSION] = version;
     }
     if (evaluationDetails.reason === StandardResolutionReasons.ERROR) {
-      attributes[TelemetryAttribute.ERROR_CODE] = ((_b = evaluationDetails.errorCode) != null ? _b : "GENERAL" /* GENERAL */).toLowerCase();
+      attributes[TelemetryAttribute.ERROR_CODE] = ((_c = evaluationDetails.errorCode) != null ? _c : "GENERAL" /* GENERAL */).toLowerCase();
       if (evaluationDetails.errorMessage) {
         attributes[TelemetryAttribute.ERROR_MESSAGE] = evaluationDetails.errorMessage;
       }
@@ -1252,6 +1268,509 @@ var OpenFeature = (() => {
     }
   };
 
+  // src/provider/multi-provider/hook-executor.ts
+  var HookExecutor = class {
+    constructor(logger) {
+      this.logger = logger;
+    }
+    beforeHooks(hooks, hookContext, hints) {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(hints));
+      }
+    }
+    afterHooks(hooks, hookContext, evaluationDetails, hints) {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, hints);
+      }
+    }
+    errorHooks(hooks, hookContext, err, hints) {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        try {
+          (_a = hook == null ? void 0 : hook.error) == null ? void 0 : _a.call(hook, hookContext, err, hints);
+        } catch (err2) {
+          this.logger.error(`Unhandled error during 'error' hook: ${err2}`);
+          if (err2 instanceof Error) {
+            this.logger.error(err2.stack);
+          }
+        }
+      }
+    }
+    finallyHooks(hooks, hookContext, evaluationDetails, hints) {
+      var _a;
+      for (const hook of hooks != null ? hooks : []) {
+        try {
+          (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, hints);
+        } catch (err) {
+          this.logger.error(`Unhandled error during 'finally' hook: ${err}`);
+          if (err instanceof Error) {
+            this.logger.error(err.stack);
+          }
+        }
+      }
+    }
+  };
+
+  // src/provider/multi-provider/errors.ts
+  var ErrorWithCode = class extends OpenFeatureError {
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+    }
+  };
+  var AggregateError = class extends GeneralError {
+    constructor(message, originalErrors) {
+      super(message);
+      this.originalErrors = originalErrors;
+    }
+  };
+  var constructAggregateError = (providerErrors) => {
+    const errorsWithSource = providerErrors.map(({ providerName, error }) => {
+      return { source: providerName, error };
+    }).flat();
+    return new AggregateError(
+      `Provider errors occurred: ${errorsWithSource[0].source}: ${errorsWithSource[0].error}`,
+      errorsWithSource
+    );
+  };
+  var throwAggregateErrorFromPromiseResults = (result, providerEntries) => {
+    const errors = result.map((r, i) => {
+      if (r.status === "rejected") {
+        return { error: r.reason, providerName: providerEntries[i].name };
+      }
+      return null;
+    }).filter((val) => Boolean(val));
+    if (errors.length) {
+      throw constructAggregateError(errors);
+    }
+  };
+
+  // src/provider/multi-provider/strategies/base-evaluation-strategy.ts
+  var BaseEvaluationStrategy = class {
+    shouldEvaluateThisProvider(strategyContext, _evalContext) {
+      if (strategyContext.providerStatus === "NOT_READY" /* NOT_READY */ || strategyContext.providerStatus === "FATAL" /* FATAL */) {
+        return false;
+      }
+      return true;
+    }
+    shouldEvaluateNextProvider(_strategyContext, _context, _result) {
+      return true;
+    }
+    shouldTrackWithThisProvider(strategyContext, _context, _trackingEventName, _trackingEventDetails) {
+      if (strategyContext.providerStatus === "NOT_READY" /* NOT_READY */ || strategyContext.providerStatus === "FATAL" /* FATAL */) {
+        return false;
+      }
+      return true;
+    }
+    hasError(resolution) {
+      return "thrownError" in resolution || !!resolution.details.errorCode;
+    }
+    hasErrorWithCode(resolution, code) {
+      var _a;
+      return "thrownError" in resolution ? ((_a = resolution.thrownError) == null ? void 0 : _a.code) === code : resolution.details.errorCode === code;
+    }
+    collectProviderErrors(resolutions) {
+      var _a;
+      const errors = [];
+      for (const resolution of resolutions) {
+        if ("thrownError" in resolution) {
+          errors.push({ providerName: resolution.providerName, error: resolution.thrownError });
+        } else if (resolution.details.errorCode) {
+          errors.push({
+            providerName: resolution.providerName,
+            error: new ErrorWithCode(resolution.details.errorCode, (_a = resolution.details.errorMessage) != null ? _a : "unknown error")
+          });
+        }
+      }
+      return { errors };
+    }
+    resolutionToFinalResult(resolution) {
+      return { details: resolution.details, provider: resolution.provider, providerName: resolution.providerName };
+    }
+  };
+
+  // src/provider/multi-provider/strategies/first-match-strategy.ts
+  var FirstMatchStrategy = class extends BaseEvaluationStrategy {
+    shouldEvaluateNextProvider(strategyContext, context, result) {
+      if (this.hasErrorWithCode(result, "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */)) {
+        return true;
+      }
+      if (this.hasError(result)) {
+        return false;
+      }
+      return false;
+    }
+    determineFinalResult(strategyContext, context, resolutions) {
+      const finalResolution = resolutions[resolutions.length - 1];
+      if (this.hasError(finalResolution)) {
+        return this.collectProviderErrors(resolutions);
+      }
+      return this.resolutionToFinalResult(finalResolution);
+    }
+  };
+
+  // src/provider/multi-provider/strategies/first-successful-strategy.ts
+  var FirstSuccessfulStrategy = class extends BaseEvaluationStrategy {
+    shouldEvaluateNextProvider(strategyContext, context, result) {
+      return this.hasError(result);
+    }
+    determineFinalResult(strategyContext, context, resolutions) {
+      const finalResolution = resolutions[resolutions.length - 1];
+      if (this.hasError(finalResolution)) {
+        return this.collectProviderErrors(resolutions);
+      }
+      return this.resolutionToFinalResult(finalResolution);
+    }
+  };
+
+  // src/provider/multi-provider/strategies/comparison-strategy.ts
+  var ComparisonStrategy = class extends BaseEvaluationStrategy {
+    constructor(fallbackProvider, onMismatch) {
+      super();
+      this.fallbackProvider = fallbackProvider;
+      this.onMismatch = onMismatch;
+    }
+    determineFinalResult(strategyContext, context, resolutions) {
+      var _a;
+      let value;
+      let fallbackResolution;
+      let finalResolution;
+      let mismatch = false;
+      for (const [i, resolution] of resolutions.entries()) {
+        if (this.hasError(resolution)) {
+          return this.collectProviderErrors(resolutions);
+        }
+        if (resolution.provider === this.fallbackProvider) {
+          fallbackResolution = resolution;
+        }
+        if (i === 0) {
+          finalResolution = resolution;
+        }
+        if (typeof value !== "undefined" && value !== resolution.details.value) {
+          mismatch = true;
+        } else {
+          value = resolution.details.value;
+        }
+      }
+      if (!fallbackResolution) {
+        throw new GeneralError("Fallback provider not found in resolution results");
+      }
+      if (!finalResolution) {
+        throw new GeneralError("Final resolution not found in resolution results");
+      }
+      if (mismatch) {
+        (_a = this.onMismatch) == null ? void 0 : _a.call(this, resolutions);
+        return {
+          details: fallbackResolution.details,
+          provider: fallbackResolution.provider
+        };
+      }
+      return this.resolutionToFinalResult(finalResolution);
+    }
+  };
+
+  // src/provider/multi-provider/status-tracker.ts
+  var StatusTracker = class {
+    constructor(events) {
+      this.events = events;
+      this.providerStatuses = {};
+    }
+    wrapEventHandler(providerEntry) {
+      var _a, _b, _c, _d, _e;
+      const provider = providerEntry.provider;
+      (_a = provider.events) == null ? void 0 : _a.addHandler("PROVIDER_ERROR" /* Error */, (details) => {
+        this.changeProviderStatus(providerEntry.name, "ERROR" /* ERROR */, details);
+      });
+      (_b = provider.events) == null ? void 0 : _b.addHandler("PROVIDER_STALE" /* Stale */, (details) => {
+        this.changeProviderStatus(providerEntry.name, "STALE" /* STALE */, details);
+      });
+      (_c = provider.events) == null ? void 0 : _c.addHandler("PROVIDER_CONFIGURATION_CHANGED" /* ConfigurationChanged */, (details) => {
+        this.events.emit("PROVIDER_CONFIGURATION_CHANGED" /* ConfigurationChanged */, details);
+      });
+      (_d = provider.events) == null ? void 0 : _d.addHandler("PROVIDER_READY" /* Ready */, (details) => {
+        this.changeProviderStatus(providerEntry.name, "READY" /* READY */, details);
+      });
+      (_e = provider.events) == null ? void 0 : _e.addHandler("PROVIDER_RECONCILING" /* Reconciling */, (details) => {
+        this.changeProviderStatus(providerEntry.name, "RECONCILING" /* RECONCILING */, details);
+      });
+    }
+    providerStatus(name) {
+      return this.providerStatuses[name];
+    }
+    getStatusFromProviderStatuses() {
+      const statuses = Object.values(this.providerStatuses);
+      if (statuses.includes("FATAL" /* FATAL */)) {
+        return "FATAL" /* FATAL */;
+      } else if (statuses.includes("NOT_READY" /* NOT_READY */)) {
+        return "NOT_READY" /* NOT_READY */;
+      } else if (statuses.includes("ERROR" /* ERROR */)) {
+        return "ERROR" /* ERROR */;
+      } else if (statuses.includes("STALE" /* STALE */)) {
+        return "STALE" /* STALE */;
+      } else if (statuses.includes("RECONCILING" /* RECONCILING */)) {
+        return "RECONCILING" /* RECONCILING */;
+      }
+      return "READY" /* READY */;
+    }
+    changeProviderStatus(name, status, details) {
+      const currentStatus = this.getStatusFromProviderStatuses();
+      this.providerStatuses[name] = status;
+      const newStatus = this.getStatusFromProviderStatuses();
+      if (currentStatus !== newStatus) {
+        if (newStatus === "FATAL" /* FATAL */ || newStatus === "ERROR" /* ERROR */) {
+          this.events.emit("PROVIDER_ERROR" /* Error */, details);
+        } else if (newStatus === "STALE" /* STALE */) {
+          this.events.emit("PROVIDER_STALE" /* Stale */, details);
+        } else if (newStatus === "READY" /* READY */) {
+          this.events.emit("PROVIDER_READY" /* Ready */, details);
+        } else if (newStatus === "RECONCILING" /* RECONCILING */) {
+          this.events.emit("PROVIDER_RECONCILING" /* Reconciling */, details);
+        }
+      }
+    }
+  };
+
+  // src/provider/multi-provider/multi-provider-web.ts
+  var MultiProvider = class _MultiProvider {
+    constructor(constructorProviders, evaluationStrategy = new FirstMatchStrategy(), logger = new DefaultLogger()) {
+      this.constructorProviders = constructorProviders;
+      this.evaluationStrategy = evaluationStrategy;
+      this.logger = logger;
+      this.runsOn = "client";
+      this.events = new OpenFeatureEventEmitter();
+      this.hookContexts = /* @__PURE__ */ new WeakMap();
+      this.hookHints = /* @__PURE__ */ new WeakMap();
+      this.providerEntries = [];
+      this.providerEntriesByName = {};
+      this.statusTracker = new StatusTracker(this.events);
+      this.hookExecutor = new HookExecutor(this.logger);
+      this.registerProviders(constructorProviders);
+      const aggregateMetadata = Object.keys(this.providerEntriesByName).reduce((acc, name) => {
+        return __spreadProps(__spreadValues({}, acc), { [name]: this.providerEntriesByName[name].provider.metadata });
+      }, {});
+      this.metadata = __spreadProps(__spreadValues({}, aggregateMetadata), {
+        name: _MultiProvider.name
+      });
+    }
+    registerProviders(constructorProviders) {
+      var _a, _b;
+      const providersByName = {};
+      for (const constructorProvider of constructorProviders) {
+        const providerName = constructorProvider.provider.metadata.name;
+        const candidateName = (_a = constructorProvider.name) != null ? _a : providerName;
+        if (constructorProvider.name && providersByName[constructorProvider.name]) {
+          throw new Error("Provider names must be unique");
+        }
+        (_b = providersByName[candidateName]) != null ? _b : providersByName[candidateName] = [];
+        providersByName[candidateName].push(constructorProvider.provider);
+      }
+      for (const name of Object.keys(providersByName)) {
+        const useIndexedNames = providersByName[name].length > 1;
+        for (let i = 0; i < providersByName[name].length; i++) {
+          const indexedName = useIndexedNames ? `${name}-${i + 1}` : name;
+          this.providerEntriesByName[indexedName] = { provider: providersByName[name][i], name: indexedName };
+          this.providerEntries.push(this.providerEntriesByName[indexedName]);
+          this.statusTracker.wrapEventHandler(this.providerEntriesByName[indexedName]);
+        }
+      }
+      Object.freeze(this.providerEntries);
+      Object.freeze(this.providerEntriesByName);
+    }
+    initialize(context) {
+      return __async(this, null, function* () {
+        const result = yield Promise.allSettled(
+          this.providerEntries.map((provider) => {
+            var _a, _b;
+            return (_b = (_a = provider.provider).initialize) == null ? void 0 : _b.call(_a, context);
+          })
+        );
+        throwAggregateErrorFromPromiseResults(result, this.providerEntries);
+      });
+    }
+    onClose() {
+      return __async(this, null, function* () {
+        const result = yield Promise.allSettled(this.providerEntries.map((provider) => {
+          var _a, _b;
+          return (_b = (_a = provider.provider).onClose) == null ? void 0 : _b.call(_a);
+        }));
+        throwAggregateErrorFromPromiseResults(result, this.providerEntries);
+      });
+    }
+    onContextChange(oldContext, newContext) {
+      return __async(this, null, function* () {
+        var _a, _b;
+        for (const providerEntry of this.providerEntries) {
+          yield (_b = (_a = providerEntry.provider).onContextChange) == null ? void 0 : _b.call(_a, oldContext, newContext);
+        }
+      });
+    }
+    resolveBooleanEvaluation(flagKey, defaultValue, context) {
+      return this.flagResolutionProxy(flagKey, "boolean", defaultValue, context);
+    }
+    resolveStringEvaluation(flagKey, defaultValue, context) {
+      return this.flagResolutionProxy(flagKey, "string", defaultValue, context);
+    }
+    resolveNumberEvaluation(flagKey, defaultValue, context) {
+      return this.flagResolutionProxy(flagKey, "number", defaultValue, context);
+    }
+    resolveObjectEvaluation(flagKey, defaultValue, context) {
+      return this.flagResolutionProxy(flagKey, "object", defaultValue, context);
+    }
+    track(trackingEventName, context, trackingEventDetails) {
+      var _a, _b;
+      for (const providerEntry of this.providerEntries) {
+        if (!providerEntry.provider.track) {
+          continue;
+        }
+        const strategyContext = {
+          provider: providerEntry.provider,
+          providerName: providerEntry.name,
+          providerStatus: this.statusTracker.providerStatus(providerEntry.name)
+        };
+        if (this.evaluationStrategy.shouldTrackWithThisProvider(
+          strategyContext,
+          context,
+          trackingEventName,
+          trackingEventDetails
+        )) {
+          try {
+            (_b = (_a = providerEntry.provider).track) == null ? void 0 : _b.call(_a, trackingEventName, context, trackingEventDetails);
+          } catch (error) {
+            this.logger.error(
+              `Error tracking event "${trackingEventName}" with provider "${providerEntry.name}":`,
+              error
+            );
+          }
+        }
+      }
+    }
+    flagResolutionProxy(flagKey, flagType, defaultValue, context) {
+      var _a;
+      const hookContext = this.hookContexts.get(context);
+      const hookHints = this.hookHints.get(context);
+      if (!hookContext || !hookHints) {
+        throw new GeneralError("Hook context not available for evaluation");
+      }
+      const results = [];
+      for (const providerEntry of this.providerEntries) {
+        const [shouldEvaluateNext, result] = this.evaluateProviderEntry(
+          flagKey,
+          flagType,
+          defaultValue,
+          providerEntry,
+          hookContext,
+          hookHints,
+          context
+        );
+        results.push(result);
+        if (!shouldEvaluateNext) {
+          break;
+        }
+      }
+      const resolutions = results.filter((r) => Boolean(r));
+      const finalResult = this.evaluationStrategy.determineFinalResult({ flagKey, flagType }, context, resolutions);
+      if ((_a = finalResult.errors) == null ? void 0 : _a.length) {
+        throw constructAggregateError(finalResult.errors);
+      }
+      if (!finalResult.details) {
+        throw new GeneralError("No result was returned from any provider");
+      }
+      return finalResult.details;
+    }
+    evaluateProviderEntry(flagKey, flagType, defaultValue, providerEntry, hookContext, hookHints, context) {
+      let evaluationResult = void 0;
+      const provider = providerEntry.provider;
+      const strategyContext = {
+        flagKey,
+        flagType,
+        provider,
+        providerName: providerEntry.name,
+        providerStatus: this.statusTracker.providerStatus(providerEntry.name)
+      };
+      if (!this.evaluationStrategy.shouldEvaluateThisProvider(strategyContext, context)) {
+        return [true, null];
+      }
+      let resolution;
+      try {
+        evaluationResult = this.evaluateProviderAndHooks(flagKey, defaultValue, provider, hookContext, hookHints);
+        resolution = {
+          details: evaluationResult,
+          provider,
+          providerName: providerEntry.name
+        };
+      } catch (error) {
+        resolution = {
+          thrownError: error,
+          provider,
+          providerName: providerEntry.name
+        };
+      }
+      return [this.evaluationStrategy.shouldEvaluateNextProvider(strategyContext, context, resolution), resolution];
+    }
+    evaluateProviderAndHooks(flagKey, defaultValue, provider, hookContext, hookHints) {
+      var _a;
+      let evaluationDetails;
+      try {
+        this.hookExecutor.beforeHooks(provider.hooks, hookContext, hookHints);
+        const resolutionDetails = this.callProviderResolve(
+          provider,
+          flagKey,
+          defaultValue,
+          hookContext.context
+        );
+        evaluationDetails = __spreadProps(__spreadValues({}, resolutionDetails), {
+          flagMetadata: Object.freeze((_a = resolutionDetails.flagMetadata) != null ? _a : {}),
+          flagKey
+        });
+        this.hookExecutor.afterHooks(provider.hooks, hookContext, evaluationDetails, hookHints);
+      } catch (error) {
+        this.hookExecutor.errorHooks(provider.hooks, hookContext, error, hookHints);
+        evaluationDetails = this.getErrorEvaluationDetails(flagKey, defaultValue, error);
+      }
+      this.hookExecutor.finallyHooks(provider.hooks, hookContext, evaluationDetails, hookHints);
+      return evaluationDetails;
+    }
+    callProviderResolve(provider, flagKey, defaultValue, context) {
+      switch (typeof defaultValue) {
+        case "string":
+          return provider.resolveStringEvaluation(flagKey, defaultValue, context, this.logger);
+        case "number":
+          return provider.resolveNumberEvaluation(flagKey, defaultValue, context, this.logger);
+        case "object":
+          return provider.resolveObjectEvaluation(flagKey, defaultValue, context, this.logger);
+        case "boolean":
+          return provider.resolveBooleanEvaluation(flagKey, defaultValue, context, this.logger);
+        default:
+          throw new GeneralError("Invalid flag evaluation type");
+      }
+    }
+    get hooks() {
+      return [
+        {
+          before: (hookContext, hints) => {
+            this.hookContexts.set(hookContext.context, hookContext);
+            this.hookHints.set(hookContext.context, hints != null ? hints : {});
+            return hookContext.context;
+          }
+        }
+      ];
+    }
+    getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
+      const errorMessage = err == null ? void 0 : err.message;
+      const errorCode = (err == null ? void 0 : err.code) || "GENERAL" /* GENERAL */;
+      return {
+        errorCode,
+        errorMessage,
+        value: defaultValue,
+        reason: StandardResolutionReasons.ERROR,
+        flagMetadata: Object.freeze(flagMetadata),
+        flagKey
+      };
+    }
+  };
+
   // src/client/internal/open-feature-client.ts
   var OpenFeatureClient = class {
     constructor(providerAccessor, providerStatusAccessor, emitterAccessor, apiContextAccessor, apiHooksAccessor, globalLogger, options) {
@@ -1676,7 +2195,7 @@ var OpenFeature = (() => {
         try {
           if (typeof wrapper.provider.onContextChange === "function") {
             const maybePromise = wrapper.provider.onContextChange(oldContext, newContext);
-            if (typeof (maybePromise == null ? void 0 : maybePromise.then) === "function") {
+            if (maybePromise && typeof (maybePromise == null ? void 0 : maybePromise.then) === "function") {
               wrapper.incrementPendingContextChanges();
               wrapper.status = this._statusEnumType.RECONCILING;
               this.getAssociatedEventEmitters(domain).forEach((emitter) => {