@openfeature/web-sdk 1.0.3 → 1.2.0

package/dist/esm/index.js

@@ -1,9 +1,27 @@
 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;
 };
@@ -23,6 +41,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   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/eventemitter3/index.js
 var require_eventemitter3 = __commonJS({
@@ -206,50 +245,17 @@ var require_eventemitter3 = __commonJS({
   }
 });
 
-// src/client/open-feature-client.ts
-import {
-  ErrorCode as ErrorCode2,
-  ProviderFatalError,
-  ProviderNotReadyError,
-  SafeLogger,
-  StandardResolutionReasons as StandardResolutionReasons2,
-  statusMatchesEvent
-} from "@openfeature/core";
-
-// src/open-feature.ts
-import {
-  OpenFeatureCommonAPI,
-  ProviderWrapper,
-  objectOrUndefined,
-  stringOrUndefined
-} from "@openfeature/core";
-
-// src/events/open-feature-event-emitter.ts
-import { GenericEventEmitter } from "@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 GenericEventEmitter {
-  eventEmitter = new import_index.default();
-  constructor() {
-    super();
-  }
-};
-
-// src/events/events.ts
-import { ClientProviderEvents } from "@openfeature/core";
-
 // src/provider/provider.ts
 import { ClientProviderStatus } from "@openfeature/core";
 
 // src/provider/no-op-provider.ts
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
-  metadata = {
-    name: "No-op Provider"
-  };
+  constructor() {
+    this.metadata = {
+      name: "No-op Provider"
+    };
+  }
   resolveBooleanEvaluation(_, defaultValue) {
     return this.noOp(defaultValue);
   }
@@ -280,10 +286,26 @@ import {
   TypeMismatchError
 } from "@openfeature/core";
 
+// src/events/open-feature-event-emitter.ts
+import { GenericEventEmitter } from "@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 GenericEventEmitter {
+  constructor() {
+    super();
+    this.eventEmitter = new import_index.default();
+  }
+};
+
+// src/events/events.ts
+import { ClientProviderEvents } from "@openfeature/core";
+
 // src/provider/in-memory-provider/variant-not-found-error.ts
 import { ErrorCode, OpenFeatureError } from "@openfeature/core";
 var VariantNotFoundError = class _VariantNotFoundError extends OpenFeatureError {
-  code;
   constructor(message) {
     super(message);
     Object.setPrototypeOf(this, _VariantNotFoundError.prototype);
@@ -294,40 +316,42 @@ var VariantNotFoundError = class _VariantNotFoundError extends OpenFeatureError
 
 // src/provider/in-memory-provider/in-memory-provider.ts
 var InMemoryProvider = class {
-  events = new OpenFeatureEventEmitter();
-  runsOn = "client";
-  metadata = {
-    name: "in-memory"
-  };
-  _flagConfiguration;
-  _context;
   constructor(flagConfiguration = {}) {
-    this._flagConfiguration = { ...flagConfiguration };
+    this.events = new OpenFeatureEventEmitter();
+    this.runsOn = "client";
+    this.metadata = {
+      name: "in-memory"
+    };
+    this._flagConfiguration = __spreadValues({}, flagConfiguration);
   }
-  async initialize(context) {
-    try {
-      for (const key in this._flagConfiguration) {
-        this.resolveFlagWithReason(key, context);
+  initialize(context) {
+    return __async(this, null, function* () {
+      try {
+        for (const key in this._flagConfiguration) {
+          this.resolveFlagWithReason(key, context);
+        }
+        this._context = context;
+      } catch (err) {
+        throw new GeneralError("initialization failure", { cause: err });
       }
-      this._context = context;
-    } catch (err) {
-      throw new Error("initialization failure", { cause: err });
-    }
+    });
   }
   /**
    * Overwrites the configured flags.
    * @param { FlagConfiguration } flagConfiguration new flag configuration
    */
-  async putConfiguration(flagConfiguration) {
-    const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
-    this._flagConfiguration = { ...flagConfiguration };
-    try {
-      await this.initialize(this._context);
-      this.events.emit(ClientProviderEvents.ConfigurationChanged, { flagsChanged });
-    } catch (err) {
-      this.events.emit(ClientProviderEvents.Error);
-      throw err;
-    }
+  putConfiguration(flagConfiguration) {
+    return __async(this, null, function* () {
+      const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
+      this._flagConfiguration = __spreadValues({}, flagConfiguration);
+      try {
+        yield this.initialize(this._context);
+        this.events.emit(ClientProviderEvents.ConfigurationChanged, { flagsChanged });
+      } catch (err) {
+        this.events.emit(ClientProviderEvents.Error);
+        throw err;
+      }
+    });
   }
   resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
     return this.resolveAndCheckFlag(flagKey, defaultValue, context || this._context, logger);
@@ -344,7 +368,7 @@ var InMemoryProvider = class {
   resolveAndCheckFlag(flagKey, defaultValue, context, logger) {
     if (!(flagKey in this._flagConfiguration)) {
       const message = `no flag found with key ${flagKey}`;
-      logger?.debug(message);
+      logger == null ? void 0 : logger.debug(message);
       throw new FlagNotFoundError(message);
     }
     if (this._flagConfiguration[flagKey].disabled) {
@@ -353,7 +377,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?.error(message);
+      logger == null ? void 0 : logger.error(message);
       throw new VariantNotFoundError(message);
     }
     if (typeof resolvedFlag.value != typeof defaultValue) {
@@ -367,192 +391,44 @@ var InMemoryProvider = class {
       return resolutionResult;
     } catch (error) {
       if (!(error instanceof OpenFeatureError2)) {
-        throw new GeneralError(error?.message || "unknown error");
+        throw new GeneralError((error == null ? void 0 : error.message) || "unknown error");
       }
       throw error;
     }
   }
   lookupFlagValue(flagKey, ctx) {
+    var _a;
     const flagSpec = this._flagConfiguration[flagKey];
-    const isContextEval = ctx && flagSpec?.contextEvaluator;
-    const variant = isContextEval ? flagSpec.contextEvaluator?.(ctx) : flagSpec.defaultVariant;
-    const value = variant && flagSpec?.variants[variant];
+    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 reason = isContextEval ? StandardResolutionReasons.TARGETING_MATCH : StandardResolutionReasons.STATIC;
-    return {
-      value,
-      ...variant && { variant },
+    return __spreadProps(__spreadValues({
+      value
+    }, variant && { variant }), {
       reason
-    };
+    });
   }
 };
 
 // src/open-feature.ts
-var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
-var _globalThis = globalThis;
-var OpenFeatureAPI = class _OpenFeatureAPI extends OpenFeatureCommonAPI {
-  _statusEnumType = ClientProviderStatus;
-  _apiEmitter = new OpenFeatureEventEmitter();
-  _defaultProvider = new ProviderWrapper(NOOP_PROVIDER, 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 = stringOrUndefined(domainOrContext);
-    const context = objectOrUndefined(domainOrContext) ?? 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 = 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 = 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(ClientProviderEvents.Reconciling, { domain, providerName });
-        });
-        this._apiEmitter?.emit(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(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
-        });
-        this._apiEmitter?.emit(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(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
-        });
-        this._apiEmitter?.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
-      }
-    }
-  }
-};
-var OpenFeature = OpenFeatureAPI.getInstance();
+import {
+  OpenFeatureCommonAPI,
+  ProviderWrapper,
+  objectOrUndefined,
+  stringOrUndefined
+} from "@openfeature/core";
 
-// src/client/open-feature-client.ts
+// src/client/internal/open-feature-client.ts
+import {
+  ErrorCode as ErrorCode2,
+  ProviderFatalError,
+  ProviderNotReadyError,
+  SafeLogger,
+  StandardResolutionReasons as StandardResolutionReasons2,
+  instantiateErrorByErrorCode,
+  statusMatchesEvent
+} from "@openfeature/core";
 var OpenFeatureClient = class {
   constructor(providerAccessor, providerStatusAccessor, emitterAccessor, globalLogger, options) {
     this.providerAccessor = providerAccessor;
@@ -560,14 +436,14 @@ var OpenFeatureClient = class {
     this.emitterAccessor = emitterAccessor;
     this.globalLogger = globalLogger;
     this.options = options;
+    this._hooks = [];
   }
-  _hooks = [];
-  _clientLogger;
   get metadata() {
+    var _a, _b;
     return {
       // Use domain if name is not provided
-      name: this.options.domain ?? this.options.name,
-      domain: this.options.domain ?? this.options.name,
+      name: (_a = this.options.domain) != null ? _a : this.options.name,
+      domain: (_b = this.options.domain) != null ? _b : this.options.name,
       version: this.options.version,
       providerMetadata: this.providerAccessor().metadata
     };
@@ -576,6 +452,7 @@ var OpenFeatureClient = class {
     return this.providerStatusAccessor();
   }
   addHandler(eventType, handler) {
+    var _a;
     this.emitterAccessor().addHandler(eventType, handler);
     const shouldRunNow = statusMatchesEvent(eventType, this.providerStatus);
     if (shouldRunNow) {
@@ -586,7 +463,7 @@ var OpenFeatureClient = class {
           providerName: this._provider.metadata.name
         });
       } catch (err) {
-        this._logger?.error("Error running event handler:", err);
+        (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
       }
     }
   }
@@ -650,6 +527,7 @@ 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(),
@@ -657,9 +535,7 @@ var OpenFeatureClient = class {
       ...this._provider.hooks || []
     ];
     const allHooksReversed = [...allHooks].reverse();
-    const context = {
-      ...OpenFeature.getContext(this?.options?.domain)
-    };
+    const context = __spreadValues({}, OpenFeature.getContext((_a = this == null ? void 0 : this.options) == null ? void 0 : _a.domain));
     const hookContext = {
       flagKey,
       defaultValue,
@@ -677,16 +553,18 @@ var OpenFeatureClient = class {
         throw new ProviderFatalError("provider is in an irrecoverable error state");
       }
       const resolution = resolver.call(this._provider, flagKey, defaultValue, context, this._logger);
-      const evaluationDetails = {
-        ...resolution,
-        flagMetadata: Object.freeze(resolution.flagMetadata ?? {}),
+      const evaluationDetails = __spreadProps(__spreadValues({}, resolution), {
+        flagMetadata: Object.freeze((_b = resolution.flagMetadata) != null ? _b : {}),
         flagKey
-      };
+      });
+      if (evaluationDetails.errorCode) {
+        throw instantiateErrorByErrorCode(evaluationDetails.errorCode);
+      }
       this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
       return evaluationDetails;
     } catch (err) {
-      const errorMessage = err?.message;
-      const errorCode = err?.code || ErrorCode2.GENERAL;
+      const errorMessage = err == null ? void 0 : err.message;
+      const errorCode = (err == null ? void 0 : err.code) || ErrorCode2.GENERAL;
       this.errorHooks(allHooksReversed, hookContext, err, options);
       return {
         errorCode,
@@ -701,40 +579,44 @@ var OpenFeatureClient = class {
     }
   }
   beforeHooks(hooks, hookContext, options) {
+    var _a;
     Object.freeze(hookContext);
     Object.freeze(hookContext.context);
     for (const hook of hooks) {
-      hook?.before?.(hookContext, Object.freeze(options.hookHints));
+      (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(options.hookHints));
     }
   }
   afterHooks(hooks, hookContext, evaluationDetails, options) {
+    var _a;
     for (const hook of hooks) {
-      hook?.after?.(hookContext, evaluationDetails, options.hookHints);
+      (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, options.hookHints);
     }
   }
   errorHooks(hooks, hookContext, err, options) {
+    var _a;
     for (const hook of hooks) {
       try {
-        hook?.error?.(hookContext, err, options.hookHints);
+        (_a = hook == null ? void 0 : hook.error) == null ? void 0 : _a.call(hook, 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?.stack);
+        this._logger.error(err2 == null ? void 0 : err2.stack);
       }
     }
   }
   finallyHooks(hooks, hookContext, options) {
+    var _a;
     for (const hook of hooks) {
       try {
-        hook?.finally?.(hookContext, options.hookHints);
+        (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, 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?.stack);
+        this._logger.error(err == null ? void 0 : err.stack);
       }
     }
   }
@@ -746,6 +628,222 @@ 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 OpenFeatureCommonAPI {
+  constructor() {
+    super("client");
+    this._statusEnumType = ClientProviderStatus;
+    this._apiEmitter = new OpenFeatureEventEmitter();
+    this._defaultProvider = new ProviderWrapper(
+      NOOP_PROVIDER,
+      ClientProviderStatus.NOT_READY,
+      this._statusEnumType
+    );
+    this._domainScopedProviders = /* @__PURE__ */ new Map();
+    this._createEventEmitter = () => new OpenFeatureEventEmitter();
+  }
+  /**
+   * 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) {
+    var _a, _b;
+    if (!domain) {
+      return this._defaultProvider.status;
+    }
+    return (_b = (_a = this._domainScopedProviders.get(domain)) == null ? void 0 : _a.status) != null ? _b : this._defaultProvider.status;
+  }
+  setProviderAndWait(clientOrProvider, providerContextOrUndefined, contextOrUndefined) {
+    return __async(this, null, function* () {
+      const domain = stringOrUndefined(clientOrProvider);
+      const provider = domain ? objectOrUndefined(providerContextOrUndefined) : objectOrUndefined(clientOrProvider);
+      const context = domain ? objectOrUndefined(contextOrUndefined) : objectOrUndefined(providerContextOrUndefined);
+      if (context) {
+        if (domain) {
+          this._domainScopedContext.set(domain, context);
+        } else {
+          this._context = context;
+        }
+      }
+      yield this.setAwaitableProvider(domain, provider);
+    });
+  }
+  setProvider(domainOrProvider, providerContextOrUndefined, contextOrUndefined) {
+    const domain = stringOrUndefined(domainOrProvider);
+    const provider = domain ? objectOrUndefined(providerContextOrUndefined) : objectOrUndefined(domainOrProvider);
+    const context = domain ? objectOrUndefined(contextOrUndefined) : 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;
+  }
+  setContext(domainOrContext, contextOrUndefined) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const domain = stringOrUndefined(domainOrContext);
+      const context = (_b = (_a = objectOrUndefined(domainOrContext)) != null ? _a : objectOrUndefined(contextOrUndefined)) != null ? _b : {};
+      if (domain) {
+        const wrapper = this._domainScopedProviders.get(domain);
+        if (wrapper) {
+          const oldContext = this.getContext(domain);
+          this._domainScopedContext.set(domain, context);
+          yield 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
+        ];
+        yield Promise.all(
+          allDomainRecords.map((dm) => this.runProviderContextChangeHandler(dm.domain, dm.wrapper, oldContext, context))
+        );
+      }
+    });
+  }
+  getContext(domainOrUndefined) {
+    const domain = 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;
+  }
+  clearContext(domainOrUndefined) {
+    return __async(this, null, function* () {
+      const domain = 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();
+          yield 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.
+   */
+  clearContexts() {
+    return __async(this, null, function* () {
+      yield this.clearContext();
+      yield 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>}
+   */
+  clearProviders() {
+    return __async(this, null, function* () {
+      yield __superGet(_OpenFeatureAPI.prototype, this, "clearProvidersAndSetDefault").call(this, NOOP_PROVIDER);
+      this._domainScopedContext.clear();
+    });
+  }
+  runProviderContextChangeHandler(domain, wrapper, oldContext, newContext) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f;
+      const providerName = ((_b = (_a = wrapper.provider) == null ? void 0 : _a.metadata) == null ? void 0 : _b.name) || "unnamed-provider";
+      try {
+        if (typeof wrapper.provider.onContextChange === "function") {
+          const maybePromise = wrapper.provider.onContextChange(oldContext, newContext);
+          if (typeof (maybePromise == null ? void 0 : maybePromise.then) === "function") {
+            wrapper.incrementPendingContextChanges();
+            wrapper.status = this._statusEnumType.RECONCILING;
+            this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+              emitter == null ? void 0 : emitter.emit(ClientProviderEvents.Reconciling, { domain, providerName });
+            });
+            (_c = this._apiEmitter) == null ? void 0 : _c.emit(ClientProviderEvents.Reconciling, { domain, providerName });
+            yield maybePromise;
+            wrapper.decrementPendingContextChanges();
+          }
+        }
+        wrapper.status = this._statusEnumType.READY;
+        if (wrapper.allContextChangesSettled) {
+          this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+            emitter == null ? void 0 : emitter.emit(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
+          });
+          (_d = this._apiEmitter) == null ? void 0 : _d.emit(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 == null ? void 0 : error.message}`;
+          (_e = this._logger) == null ? void 0 : _e.error(`${message}`, err);
+          this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+            emitter == null ? void 0 : emitter.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+          });
+          (_f = this._apiEmitter) == null ? void 0 : _f.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+        }
+      }
+    });
+  }
+};
+var OpenFeature = OpenFeatureAPI.getInstance();
+
 // src/index.ts
 export * from "@openfeature/core";
 export {
@@ -753,7 +851,6 @@ export {
   NOOP_PROVIDER,
   OpenFeature,
   OpenFeatureAPI,
-  OpenFeatureClient,
   OpenFeatureEventEmitter,
   ClientProviderEvents as ProviderEvents,
   ClientProviderStatus as ProviderStatus