@openfeature/web-sdk 1.0.3 → 1.1.0

package/README.md

@@ -16,8 +16,8 @@
     <img alt="Specification" src="https://img.shields.io/static/v1?label=specification&message=v0.8.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-v1.0.3">
-    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v1.0.3&color=blue&style=for-the-badge" />
+  <a href="https://github.com/open-feature/js-sdk/releases/tag/web-sdk-v1.1.0">
+    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v1.1.0&color=blue&style=for-the-badge" />
   </a>
   <!-- x-release-please-end -->
   <br/>
@@ -54,6 +54,9 @@
 npm install --save @openfeature/web-sdk
 ```
 
+> [!TIP]
+> This SDK is designed to run in the browser. If you're interested in server support, check out the [Node.js SDK](https://openfeature.dev/docs/reference/technologies/server/javascript/).
+
 #### yarn
 
 ```sh
@@ -118,7 +121,7 @@ To register a provider and ensure it is ready before further actions are taken,
 
 ```ts
 await OpenFeature.setProviderAndWait(new MyProvider());
-```  
+```
 
 #### Synchronous
 
@@ -155,9 +158,16 @@ Sometimes, the value of a flag must consider some dynamic criteria about the app
 In OpenFeature, we refer to this as [targeting](https://openfeature.dev/specification/glossary#targeting).
 If the flag management system you're using supports targeting, you can provide the input data using the [evaluation context](https://openfeature.dev/docs/reference/concepts/evaluation-context).
 
+```ts
+// Sets global context during provider registration
+await OpenFeature.setProvider(new MyProvider(), { origin: document.location.host });
+```
+
+Change context after the provider has been registered using `setContext`.
+
 ```ts
 // Set a value to the global context
-await OpenFeature.setContext({ origin: document.location.host });
+await OpenFeature.setContext({ targetingKey: localStorage.getItem("targetingKey") });
 ```
 
 Context is global and setting it is `async`.
@@ -230,6 +240,24 @@ const domainScopedClient = OpenFeature.getClient("my-domain");
 Domains can be defined on a provider during registration.
 For more details, please refer to the [providers](#providers) section.
 
+#### Manage evaluation context for domains
+
+By default, domain-scoped clients use the global context.
+This can be overridden by explicitly setting context when registering the provider or by references the domain when updating context:
+
+```ts
+OpenFeature.setProvider("my-domain", new NewCachedProvider(), { targetingKey: localStorage.getItem("targetingKey") });
+```
+
+To change context after the provider has been registered, use `setContext` with a name:
+
+```ts
+await OpenFeature.setContext("my-domain", { targetingKey: localStorage.getItem("targetingKey") })
+```
+
+Once context has been defined for a named client, it will override the global context for all clients using the associated provider.
+Context can be cleared using for a named provider using `OpenFeature.clearContext("my-domain")` or call `OpenFeature.clearContexts()` to reset all context.
+
 ### Eventing
 
 Events allow you to react to state changes in the provider or underlying flag management system, such as flag definition changes, provider readiness, or error conditions.

package/dist/cjs/index.js

@@ -220,38 +220,14 @@ __export(src_exports, {
   NOOP_PROVIDER: () => NOOP_PROVIDER,
   OpenFeature: () => OpenFeature,
   OpenFeatureAPI: () => OpenFeatureAPI,
-  OpenFeatureClient: () => OpenFeatureClient,
   OpenFeatureEventEmitter: () => OpenFeatureEventEmitter,
-  ProviderEvents: () => import_core2.ClientProviderEvents,
-  ProviderStatus: () => import_core3.ClientProviderStatus
+  ProviderEvents: () => import_core3.ClientProviderEvents,
+  ProviderStatus: () => import_core.ClientProviderStatus
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/client/open-feature-client.ts
-var import_core7 = require("@openfeature/core");
-
-// src/open-feature.ts
-var import_core6 = require("@openfeature/core");
-
-// src/events/open-feature-event-emitter.ts
-var import_core = require("@openfeature/core");
-
-// ../../node_modules/eventemitter3/index.mjs
-var import_index = __toESM(require_eventemitter3(), 1);
-
-// src/events/open-feature-event-emitter.ts
-var OpenFeatureEventEmitter = class extends import_core.GenericEventEmitter {
-  eventEmitter = new import_index.default();
-  constructor() {
-    super();
-  }
-};
-
-// src/events/events.ts
-var import_core2 = require("@openfeature/core");
-
 // src/provider/provider.ts
-var import_core3 = require("@openfeature/core");
+var import_core = require("@openfeature/core");
 
 // src/provider/no-op-provider.ts
 var REASON_NO_OP = "No-op";
@@ -283,6 +259,23 @@ var NOOP_PROVIDER = new NoopFeatureProvider();
 // src/provider/in-memory-provider/in-memory-provider.ts
 var import_core5 = require("@openfeature/core");
 
+// src/events/open-feature-event-emitter.ts
+var import_core2 = require("@openfeature/core");
+
+// ../../node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+
+// src/events/open-feature-event-emitter.ts
+var OpenFeatureEventEmitter = class extends import_core2.GenericEventEmitter {
+  eventEmitter = new import_index.default();
+  constructor() {
+    super();
+  }
+};
+
+// src/events/events.ts
+var import_core3 = require("@openfeature/core");
+
 // src/provider/in-memory-provider/variant-not-found-error.ts
 var import_core4 = require("@openfeature/core");
 var VariantNotFoundError = class _VariantNotFoundError extends import_core4.OpenFeatureError {
@@ -326,9 +319,9 @@ var InMemoryProvider = class {
     this._flagConfiguration = { ...flagConfiguration };
     try {
       await this.initialize(this._context);
-      this.events.emit(import_core2.ClientProviderEvents.ConfigurationChanged, { flagsChanged });
+      this.events.emit(import_core3.ClientProviderEvents.ConfigurationChanged, { flagsChanged });
     } catch (err) {
-      this.events.emit(import_core2.ClientProviderEvents.Error);
+      this.events.emit(import_core3.ClientProviderEvents.Error);
       throw err;
     }
   }
@@ -390,172 +383,10 @@ var InMemoryProvider = class {
 };
 
 // src/open-feature.ts
-var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
-var _globalThis = globalThis;
-var OpenFeatureAPI = class _OpenFeatureAPI extends import_core6.OpenFeatureCommonAPI {
-  _statusEnumType = import_core3.ClientProviderStatus;
-  _apiEmitter = new OpenFeatureEventEmitter();
-  _defaultProvider = new import_core6.ProviderWrapper(NOOP_PROVIDER, import_core3.ClientProviderStatus.NOT_READY, this._statusEnumType);
-  _domainScopedProviders = /* @__PURE__ */ new Map();
-  _createEventEmitter = () => new OpenFeatureEventEmitter();
-  constructor() {
-    super("client");
-  }
-  /**
-   * Gets a singleton instance of the OpenFeature API.
-   * @ignore
-   * @returns {OpenFeatureAPI} OpenFeature API
-   */
-  static getInstance() {
-    const globalApi = _globalThis[GLOBAL_OPENFEATURE_API_KEY];
-    if (globalApi) {
-      return globalApi;
-    }
-    const instance = new _OpenFeatureAPI();
-    _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
-    return instance;
-  }
-  getProviderStatus(domain) {
-    if (!domain) {
-      return this._defaultProvider.status;
-    }
-    return this._domainScopedProviders.get(domain)?.status ?? this._defaultProvider.status;
-  }
-  async setContext(domainOrContext, contextOrUndefined) {
-    const domain = (0, import_core6.stringOrUndefined)(domainOrContext);
-    const context = (0, import_core6.objectOrUndefined)(domainOrContext) ?? (0, import_core6.objectOrUndefined)(contextOrUndefined) ?? {};
-    if (domain) {
-      const wrapper = this._domainScopedProviders.get(domain);
-      if (wrapper) {
-        const oldContext = this.getContext(domain);
-        this._domainScopedContext.set(domain, context);
-        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, context);
-      } else {
-        this._domainScopedContext.set(domain, context);
-      }
-    } else {
-      const oldContext = this._context;
-      this._context = context;
-      const unboundProviders = Array.from(this._domainScopedProviders.entries()).filter(([domain2]) => !this._domainScopedContext.has(domain2)).reduce((acc, [domain2, wrapper]) => {
-        acc.push({ domain: domain2, wrapper });
-        return acc;
-      }, []);
-      const allDomainRecords = [
-        // add in the default (no domain)
-        { domain: void 0, wrapper: this._defaultProvider },
-        ...unboundProviders
-      ];
-      await Promise.all(
-        allDomainRecords.map(
-          (dm) => this.runProviderContextChangeHandler(dm.domain, dm.wrapper, oldContext, context)
-        )
-      );
-    }
-  }
-  getContext(domainOrUndefined) {
-    const domain = (0, import_core6.stringOrUndefined)(domainOrUndefined);
-    if (domain) {
-      const context = this._domainScopedContext.get(domain);
-      if (context) {
-        return context;
-      } else {
-        this._logger.debug(`Unable to find context for '${domain}'.`);
-      }
-    }
-    return this._context;
-  }
-  async clearContext(domainOrUndefined) {
-    const domain = (0, import_core6.stringOrUndefined)(domainOrUndefined);
-    if (domain) {
-      const wrapper = this._domainScopedProviders.get(domain);
-      if (wrapper) {
-        const oldContext = this.getContext(domain);
-        this._domainScopedContext.delete(domain);
-        const newContext = this.getContext();
-        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, newContext);
-      } else {
-        this._domainScopedContext.delete(domain);
-      }
-    } else {
-      return this.setContext({});
-    }
-  }
-  /**
-   * Resets the global evaluation context and removes the evaluation context for
-   * all domains.
-   */
-  async clearContexts() {
-    await this.clearContext();
-    await Promise.allSettled(Array.from(this._domainScopedProviders.keys()).map((domain) => this.clearContext(domain)));
-  }
-  /**
-   * A factory function for creating new named OpenFeature clients. Clients can contain
-   * their own state (e.g. logger, hook, context). Multiple clients can be used
-   * to segment feature flag configuration.
-   *
-   * If there is already a provider bound to this name via {@link this.setProvider setProvider}, this provider will be used.
-   * Otherwise, the default provider is used until a provider is assigned to that name.
-   * @param {string} domain An identifier which logically binds clients with providers
-   * @param {string} version The version of the client (only used for metadata)
-   * @returns {Client} OpenFeature Client
-   */
-  getClient(domain, version) {
-    return new OpenFeatureClient(
-      // functions are passed here to make sure that these values are always up to date,
-      // and so we don't have to make these public properties on the API class.
-      () => this.getProviderForClient(domain),
-      () => this.getProviderStatus(domain),
-      () => this.buildAndCacheEventEmitterForClient(domain),
-      () => this._logger,
-      { domain, version }
-    );
-  }
-  /**
-   * Clears all registered providers and resets the default provider.
-   * @returns {Promise<void>}
-   */
-  async clearProviders() {
-    await super.clearProvidersAndSetDefault(NOOP_PROVIDER);
-    this._domainScopedContext.clear();
-  }
-  async runProviderContextChangeHandler(domain, wrapper, oldContext, newContext) {
-    const providerName = wrapper.provider?.metadata?.name || "unnamed-provider";
-    try {
-      if (typeof wrapper.provider.onContextChange === "function") {
-        wrapper.incrementPendingContextChanges();
-        wrapper.status = this._statusEnumType.RECONCILING;
-        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
-          emitter?.emit(import_core2.ClientProviderEvents.Reconciling, { domain, providerName });
-        });
-        this._apiEmitter?.emit(import_core2.ClientProviderEvents.Reconciling, { domain, providerName });
-        await wrapper.provider.onContextChange(oldContext, newContext);
-        wrapper.decrementPendingContextChanges();
-      }
-      wrapper.status = this._statusEnumType.READY;
-      if (wrapper.allContextChangesSettled) {
-        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
-          emitter?.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
-        });
-        this._apiEmitter?.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
-      }
-    } catch (err) {
-      wrapper.decrementPendingContextChanges();
-      wrapper.status = this._statusEnumType.ERROR;
-      if (wrapper.allContextChangesSettled) {
-        const error = err;
-        const message = `Error running ${providerName}'s context change handler: ${error?.message}`;
-        this._logger?.error(`${message}`, err);
-        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
-          emitter?.emit(import_core2.ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
-        });
-        this._apiEmitter?.emit(import_core2.ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
-      }
-    }
-  }
-};
-var OpenFeature = OpenFeatureAPI.getInstance();
+var import_core7 = require("@openfeature/core");
 
-// src/client/open-feature-client.ts
+// src/client/internal/open-feature-client.ts
+var import_core6 = require("@openfeature/core");
 var OpenFeatureClient = class {
   constructor(providerAccessor, providerStatusAccessor, emitterAccessor, globalLogger, options) {
     this.providerAccessor = providerAccessor;
@@ -580,7 +411,7 @@ var OpenFeatureClient = class {
   }
   addHandler(eventType, handler) {
     this.emitterAccessor().addHandler(eventType, handler);
-    const shouldRunNow = (0, import_core7.statusMatchesEvent)(eventType, this.providerStatus);
+    const shouldRunNow = (0, import_core6.statusMatchesEvent)(eventType, this.providerStatus);
     if (shouldRunNow) {
       try {
         handler({
@@ -600,7 +431,7 @@ var OpenFeatureClient = class {
     return this.emitterAccessor().getHandlers(eventType);
   }
   setLogger(logger) {
-    this._clientLogger = new import_core7.SafeLogger(logger);
+    this._clientLogger = new import_core6.SafeLogger(logger);
     return this;
   }
   addHooks(...hooks) {
@@ -674,10 +505,10 @@ var OpenFeatureClient = class {
     };
     try {
       this.beforeHooks(allHooks, hookContext, options);
-      if (this.providerStatus === import_core3.ClientProviderStatus.NOT_READY) {
-        throw new import_core7.ProviderNotReadyError("provider has not yet initialized");
-      } else if (this.providerStatus === import_core3.ClientProviderStatus.FATAL) {
-        throw new import_core7.ProviderFatalError("provider is in an irrecoverable error state");
+      if (this.providerStatus === import_core.ClientProviderStatus.NOT_READY) {
+        throw new import_core6.ProviderNotReadyError("provider has not yet initialized");
+      } else if (this.providerStatus === import_core.ClientProviderStatus.FATAL) {
+        throw new import_core6.ProviderFatalError("provider is in an irrecoverable error state");
       }
       const resolution = resolver.call(this._provider, flagKey, defaultValue, context, this._logger);
       const evaluationDetails = {
@@ -685,17 +516,20 @@ var OpenFeatureClient = class {
         flagMetadata: Object.freeze(resolution.flagMetadata ?? {}),
         flagKey
       };
+      if (evaluationDetails.errorCode) {
+        throw (0, import_core6.instantiateErrorByErrorCode)(evaluationDetails.errorCode);
+      }
       this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
       return evaluationDetails;
     } catch (err) {
       const errorMessage = err?.message;
-      const errorCode = err?.code || import_core7.ErrorCode.GENERAL;
+      const errorCode = err?.code || import_core6.ErrorCode.GENERAL;
       this.errorHooks(allHooksReversed, hookContext, err, options);
       return {
         errorCode,
         errorMessage,
         value: defaultValue,
-        reason: import_core7.StandardResolutionReasons.ERROR,
+        reason: import_core6.StandardResolutionReasons.ERROR,
         flagMetadata: Object.freeze({}),
         flagKey
       };
@@ -749,6 +583,207 @@ var OpenFeatureClient = class {
   }
 };
 
+// src/open-feature.ts
+var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
+var _globalThis = globalThis;
+var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommonAPI {
+  _statusEnumType = import_core.ClientProviderStatus;
+  _apiEmitter = new OpenFeatureEventEmitter();
+  _defaultProvider = new import_core7.ProviderWrapper(
+    NOOP_PROVIDER,
+    import_core.ClientProviderStatus.NOT_READY,
+    this._statusEnumType
+  );
+  _domainScopedProviders = /* @__PURE__ */ new Map();
+  _createEventEmitter = () => new OpenFeatureEventEmitter();
+  constructor() {
+    super("client");
+  }
+  /**
+   * Gets a singleton instance of the OpenFeature API.
+   * @ignore
+   * @returns {OpenFeatureAPI} OpenFeature API
+   */
+  static getInstance() {
+    const globalApi = _globalThis[GLOBAL_OPENFEATURE_API_KEY];
+    if (globalApi) {
+      return globalApi;
+    }
+    const instance = new _OpenFeatureAPI();
+    _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
+    return instance;
+  }
+  getProviderStatus(domain) {
+    if (!domain) {
+      return this._defaultProvider.status;
+    }
+    return this._domainScopedProviders.get(domain)?.status ?? this._defaultProvider.status;
+  }
+  async setProviderAndWait(clientOrProvider, providerContextOrUndefined, contextOrUndefined) {
+    const domain = (0, import_core7.stringOrUndefined)(clientOrProvider);
+    const provider = domain ? (0, import_core7.objectOrUndefined)(providerContextOrUndefined) : (0, import_core7.objectOrUndefined)(clientOrProvider);
+    const context = domain ? (0, import_core7.objectOrUndefined)(contextOrUndefined) : (0, import_core7.objectOrUndefined)(providerContextOrUndefined);
+    if (context) {
+      if (domain) {
+        this._domainScopedContext.set(domain, context);
+      } else {
+        this._context = context;
+      }
+    }
+    await this.setAwaitableProvider(domain, provider);
+  }
+  setProvider(domainOrProvider, providerContextOrUndefined, contextOrUndefined) {
+    const domain = (0, import_core7.stringOrUndefined)(domainOrProvider);
+    const provider = domain ? (0, import_core7.objectOrUndefined)(providerContextOrUndefined) : (0, import_core7.objectOrUndefined)(domainOrProvider);
+    const context = domain ? (0, import_core7.objectOrUndefined)(contextOrUndefined) : (0, import_core7.objectOrUndefined)(providerContextOrUndefined);
+    if (context) {
+      if (domain) {
+        this._domainScopedContext.set(domain, context);
+      } else {
+        this._context = context;
+      }
+    }
+    const maybePromise = this.setAwaitableProvider(domain, provider);
+    Promise.resolve(maybePromise).catch((err) => {
+      this._logger.error("Error during provider initialization:", err);
+    });
+    return this;
+  }
+  async setContext(domainOrContext, contextOrUndefined) {
+    const domain = (0, import_core7.stringOrUndefined)(domainOrContext);
+    const context = (0, import_core7.objectOrUndefined)(domainOrContext) ?? (0, import_core7.objectOrUndefined)(contextOrUndefined) ?? {};
+    if (domain) {
+      const wrapper = this._domainScopedProviders.get(domain);
+      if (wrapper) {
+        const oldContext = this.getContext(domain);
+        this._domainScopedContext.set(domain, context);
+        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, context);
+      } else {
+        this._domainScopedContext.set(domain, context);
+      }
+    } else {
+      const oldContext = this._context;
+      this._context = context;
+      const unboundProviders = Array.from(this._domainScopedProviders.entries()).filter(([domain2]) => !this._domainScopedContext.has(domain2)).reduce((acc, [domain2, wrapper]) => {
+        acc.push({ domain: domain2, wrapper });
+        return acc;
+      }, []);
+      const allDomainRecords = [
+        // add in the default (no domain)
+        { domain: void 0, wrapper: this._defaultProvider },
+        ...unboundProviders
+      ];
+      await Promise.all(
+        allDomainRecords.map((dm) => this.runProviderContextChangeHandler(dm.domain, dm.wrapper, oldContext, context))
+      );
+    }
+  }
+  getContext(domainOrUndefined) {
+    const domain = (0, import_core7.stringOrUndefined)(domainOrUndefined);
+    if (domain) {
+      const context = this._domainScopedContext.get(domain);
+      if (context) {
+        return context;
+      } else {
+        this._logger.debug(`Unable to find context for '${domain}'.`);
+      }
+    }
+    return this._context;
+  }
+  async clearContext(domainOrUndefined) {
+    const domain = (0, import_core7.stringOrUndefined)(domainOrUndefined);
+    if (domain) {
+      const wrapper = this._domainScopedProviders.get(domain);
+      if (wrapper) {
+        const oldContext = this.getContext(domain);
+        this._domainScopedContext.delete(domain);
+        const newContext = this.getContext();
+        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, newContext);
+      } else {
+        this._domainScopedContext.delete(domain);
+      }
+    } else {
+      return this.setContext({});
+    }
+  }
+  /**
+   * Resets the global evaluation context and removes the evaluation context for
+   * all domains.
+   */
+  async clearContexts() {
+    await this.clearContext();
+    await Promise.allSettled(Array.from(this._domainScopedProviders.keys()).map((domain) => this.clearContext(domain)));
+  }
+  /**
+   * A factory function for creating new named OpenFeature clients. Clients can contain
+   * their own state (e.g. logger, hook, context). Multiple clients can be used
+   * to segment feature flag configuration.
+   *
+   * If there is already a provider bound to this name via {@link this.setProvider setProvider}, this provider will be used.
+   * Otherwise, the default provider is used until a provider is assigned to that name.
+   * @param {string} domain An identifier which logically binds clients with providers
+   * @param {string} version The version of the client (only used for metadata)
+   * @returns {Client} OpenFeature Client
+   */
+  getClient(domain, version) {
+    return new OpenFeatureClient(
+      // functions are passed here to make sure that these values are always up to date,
+      // and so we don't have to make these public properties on the API class.
+      () => this.getProviderForClient(domain),
+      () => this.getProviderStatus(domain),
+      () => this.buildAndCacheEventEmitterForClient(domain),
+      () => this._logger,
+      { domain, version }
+    );
+  }
+  /**
+   * Clears all registered providers and resets the default provider.
+   * @returns {Promise<void>}
+   */
+  async clearProviders() {
+    await super.clearProvidersAndSetDefault(NOOP_PROVIDER);
+    this._domainScopedContext.clear();
+  }
+  async runProviderContextChangeHandler(domain, wrapper, oldContext, newContext) {
+    const providerName = wrapper.provider?.metadata?.name || "unnamed-provider";
+    try {
+      if (typeof wrapper.provider.onContextChange === "function") {
+        const maybePromise = wrapper.provider.onContextChange(oldContext, newContext);
+        if (typeof maybePromise?.then === "function") {
+          wrapper.incrementPendingContextChanges();
+          wrapper.status = this._statusEnumType.RECONCILING;
+          this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+            emitter?.emit(import_core3.ClientProviderEvents.Reconciling, { domain, providerName });
+          });
+          this._apiEmitter?.emit(import_core3.ClientProviderEvents.Reconciling, { domain, providerName });
+          await maybePromise;
+          wrapper.decrementPendingContextChanges();
+        }
+      }
+      wrapper.status = this._statusEnumType.READY;
+      if (wrapper.allContextChangesSettled) {
+        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+          emitter?.emit(import_core3.ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
+        });
+        this._apiEmitter?.emit(import_core3.ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
+      }
+    } catch (err) {
+      wrapper.decrementPendingContextChanges();
+      wrapper.status = this._statusEnumType.ERROR;
+      if (wrapper.allContextChangesSettled) {
+        const error = err;
+        const message = `Error running ${providerName}'s context change handler: ${error?.message}`;
+        this._logger?.error(`${message}`, err);
+        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+          emitter?.emit(import_core3.ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+        });
+        this._apiEmitter?.emit(import_core3.ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+      }
+    }
+  }
+};
+var OpenFeature = OpenFeatureAPI.getInstance();
+
 // src/index.ts
 __reExport(src_exports, require("@openfeature/core"), module.exports);
 //# sourceMappingURL=index.js.map