@openfeature/web-sdk 1.6.2 → 1.7.1

package/dist/cjs/index.js

@@ -235,13 +235,22 @@ var require_eventemitter3 = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AggregateError: () => AggregateError,
+  BaseEvaluationStrategy: () => BaseEvaluationStrategy,
+  ComparisonStrategy: () => ComparisonStrategy,
+  ErrorWithCode: () => ErrorWithCode,
+  FirstMatchStrategy: () => FirstMatchStrategy,
+  FirstSuccessfulStrategy: () => FirstSuccessfulStrategy,
   InMemoryProvider: () => InMemoryProvider,
+  MultiProvider: () => MultiProvider,
   NOOP_PROVIDER: () => NOOP_PROVIDER,
   OpenFeature: () => OpenFeature,
   OpenFeatureAPI: () => OpenFeatureAPI,
   OpenFeatureEventEmitter: () => OpenFeatureEventEmitter,
   ProviderEvents: () => import_core3.ClientProviderEvents,
-  ProviderStatus: () => import_core.ClientProviderStatus
+  ProviderStatus: () => import_core.ClientProviderStatus,
+  constructAggregateError: () => constructAggregateError,
+  throwAggregateErrorFromPromiseResults: () => throwAggregateErrorFromPromiseResults
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -392,11 +401,520 @@ var InMemoryProvider = class {
   }
 };
 
-// src/open-feature.ts
+// src/provider/multi-provider/multi-provider-web.ts
+var import_core9 = require("@openfeature/core");
+
+// 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 import_core6 = require("@openfeature/core");
+var ErrorWithCode = class extends import_core6.OpenFeatureError {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var AggregateError = class extends import_core6.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 === import_core.ClientProviderStatus.NOT_READY || strategyContext.providerStatus === import_core.ClientProviderStatus.FATAL) {
+      return false;
+    }
+    return true;
+  }
+  shouldEvaluateNextProvider(_strategyContext, _context, _result) {
+    return true;
+  }
+  shouldTrackWithThisProvider(strategyContext, _context, _trackingEventName, _trackingEventDetails) {
+    if (strategyContext.providerStatus === import_core.ClientProviderStatus.NOT_READY || strategyContext.providerStatus === import_core.ClientProviderStatus.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 import_core7 = require("@openfeature/core");
+var FirstMatchStrategy = class extends BaseEvaluationStrategy {
+  shouldEvaluateNextProvider(strategyContext, context, result) {
+    if (this.hasErrorWithCode(result, import_core7.ErrorCode.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 import_core8 = require("@openfeature/core");
+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 import_core8.GeneralError("Fallback provider not found in resolution results");
+    }
+    if (!finalResolution) {
+      throw new import_core8.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(import_core3.ClientProviderEvents.Error, (details) => {
+      this.changeProviderStatus(providerEntry.name, import_core.ClientProviderStatus.ERROR, details);
+    });
+    (_b = provider.events) == null ? void 0 : _b.addHandler(import_core3.ClientProviderEvents.Stale, (details) => {
+      this.changeProviderStatus(providerEntry.name, import_core.ClientProviderStatus.STALE, details);
+    });
+    (_c = provider.events) == null ? void 0 : _c.addHandler(import_core3.ClientProviderEvents.ConfigurationChanged, (details) => {
+      this.events.emit(import_core3.ClientProviderEvents.ConfigurationChanged, details);
+    });
+    (_d = provider.events) == null ? void 0 : _d.addHandler(import_core3.ClientProviderEvents.Ready, (details) => {
+      this.changeProviderStatus(providerEntry.name, import_core.ClientProviderStatus.READY, details);
+    });
+    (_e = provider.events) == null ? void 0 : _e.addHandler(import_core3.ClientProviderEvents.Reconciling, (details) => {
+      this.changeProviderStatus(providerEntry.name, import_core.ClientProviderStatus.RECONCILING, details);
+    });
+  }
+  providerStatus(name) {
+    return this.providerStatuses[name];
+  }
+  getStatusFromProviderStatuses() {
+    const statuses = Object.values(this.providerStatuses);
+    if (statuses.includes(import_core.ClientProviderStatus.FATAL)) {
+      return import_core.ClientProviderStatus.FATAL;
+    } else if (statuses.includes(import_core.ClientProviderStatus.NOT_READY)) {
+      return import_core.ClientProviderStatus.NOT_READY;
+    } else if (statuses.includes(import_core.ClientProviderStatus.ERROR)) {
+      return import_core.ClientProviderStatus.ERROR;
+    } else if (statuses.includes(import_core.ClientProviderStatus.STALE)) {
+      return import_core.ClientProviderStatus.STALE;
+    } else if (statuses.includes(import_core.ClientProviderStatus.RECONCILING)) {
+      return import_core.ClientProviderStatus.RECONCILING;
+    }
+    return import_core.ClientProviderStatus.READY;
+  }
+  changeProviderStatus(name, status, details) {
+    const currentStatus = this.getStatusFromProviderStatuses();
+    this.providerStatuses[name] = status;
+    const newStatus = this.getStatusFromProviderStatuses();
+    if (currentStatus !== newStatus) {
+      if (newStatus === import_core.ClientProviderStatus.FATAL || newStatus === import_core.ClientProviderStatus.ERROR) {
+        this.events.emit(import_core3.ClientProviderEvents.Error, details);
+      } else if (newStatus === import_core.ClientProviderStatus.STALE) {
+        this.events.emit(import_core3.ClientProviderEvents.Stale, details);
+      } else if (newStatus === import_core.ClientProviderStatus.READY) {
+        this.events.emit(import_core3.ClientProviderEvents.Ready, details);
+      } else if (newStatus === import_core.ClientProviderStatus.RECONCILING) {
+        this.events.emit(import_core3.ClientProviderEvents.Reconciling, details);
+      }
+    }
+  }
+};
+
+// src/provider/multi-provider/multi-provider-web.ts
+var MultiProvider = class _MultiProvider {
+  constructor(constructorProviders, evaluationStrategy = new FirstMatchStrategy(), logger = new import_core9.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 import_core9.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 import_core9.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 import_core9.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) || import_core9.ErrorCode.GENERAL;
+    return {
+      errorCode,
+      errorMessage,
+      value: defaultValue,
+      reason: import_core9.StandardResolutionReasons.ERROR,
+      flagMetadata: Object.freeze(flagMetadata),
+      flagKey
+    };
+  }
+};
+
+// src/open-feature.ts
+var import_core11 = require("@openfeature/core");
 
 // src/client/internal/open-feature-client.ts
-var import_core6 = require("@openfeature/core");
+var import_core10 = require("@openfeature/core");
 var OpenFeatureClient = class {
   constructor(providerAccessor, providerStatusAccessor, emitterAccessor, apiContextAccessor, apiHooksAccessor, globalLogger, options) {
     this.providerAccessor = providerAccessor;
@@ -424,7 +942,7 @@ var OpenFeatureClient = class {
   addHandler(eventType, handler, options) {
     var _a;
     this.emitterAccessor().addHandler(eventType, handler);
-    const shouldRunNow = (0, import_core6.statusMatchesEvent)(eventType, this.providerStatus);
+    const shouldRunNow = (0, import_core10.statusMatchesEvent)(eventType, this.providerStatus);
     if (shouldRunNow) {
       try {
         handler({
@@ -449,7 +967,7 @@ var OpenFeatureClient = class {
     return this.emitterAccessor().getHandlers(eventType);
   }
   setLogger(logger) {
-    this._clientLogger = new import_core6.SafeLogger(logger);
+    this._clientLogger = new import_core10.SafeLogger(logger);
     return this;
   }
   addHooks(...hooks) {
@@ -534,7 +1052,7 @@ var OpenFeatureClient = class {
         providerMetadata: this._provider.metadata,
         context,
         logger: this._logger,
-        hookData: new import_core6.MapHookData()
+        hookData: new import_core10.MapHookData()
       })
     );
     let evaluationDetails;
@@ -547,7 +1065,7 @@ var OpenFeatureClient = class {
         flagKey
       });
       if (resolutionDetails.errorCode) {
-        const err = (0, import_core6.instantiateErrorByErrorCode)(resolutionDetails.errorCode, resolutionDetails.errorMessage);
+        const err = (0, import_core10.instantiateErrorByErrorCode)(resolutionDetails.errorCode, resolutionDetails.errorMessage);
         this.errorHooks(allHooksReversed, hookContexts, err, options);
         evaluationDetails = this.getErrorEvaluationDetails(flagKey, defaultValue, err, resolutionDetails.flagMetadata);
       } else {
@@ -616,19 +1134,19 @@ var OpenFeatureClient = class {
   }
   shortCircuitIfNotReady() {
     if (this.providerStatus === import_core.ClientProviderStatus.NOT_READY) {
-      throw new import_core6.ProviderNotReadyError("provider has not yet initialized");
+      throw new import_core10.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");
+      throw new import_core10.ProviderFatalError("provider is in an irrecoverable error state");
     }
   }
   getErrorEvaluationDetails(flagKey, defaultValue, err, flagMetadata = {}) {
     const errorMessage = err == null ? void 0 : err.message;
-    const errorCode = (err == null ? void 0 : err.code) || import_core6.ErrorCode.GENERAL;
+    const errorCode = (err == null ? void 0 : err.code) || import_core10.ErrorCode.GENERAL;
     return {
       errorCode,
       errorMessage,
       value: defaultValue,
-      reason: import_core6.StandardResolutionReasons.ERROR,
+      reason: import_core10.StandardResolutionReasons.ERROR,
       flagMetadata: Object.freeze(flagMetadata),
       flagKey
     };
@@ -638,12 +1156,12 @@ 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 {
+var OpenFeatureAPI = class _OpenFeatureAPI extends import_core11.OpenFeatureCommonAPI {
   constructor() {
     super("client");
     this._statusEnumType = import_core.ClientProviderStatus;
     this._apiEmitter = new OpenFeatureEventEmitter();
-    this._defaultProvider = new import_core7.ProviderWrapper(
+    this._defaultProvider = new import_core11.ProviderWrapper(
       NOOP_PROVIDER,
       import_core.ClientProviderStatus.NOT_READY,
       this._statusEnumType
@@ -674,9 +1192,9 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommo
   }
   setProviderAndWait(clientOrProvider, providerContextOrUndefined, contextOrUndefined) {
     return __async(this, null, function* () {
-      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);
+      const domain = (0, import_core11.stringOrUndefined)(clientOrProvider);
+      const provider = domain ? (0, import_core11.objectOrUndefined)(providerContextOrUndefined) : (0, import_core11.objectOrUndefined)(clientOrProvider);
+      const context = domain ? (0, import_core11.objectOrUndefined)(contextOrUndefined) : (0, import_core11.objectOrUndefined)(providerContextOrUndefined);
       if (context) {
         if (domain) {
           this._domainScopedContext.set(domain, context);
@@ -688,9 +1206,9 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommo
     });
   }
   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);
+    const domain = (0, import_core11.stringOrUndefined)(domainOrProvider);
+    const provider = domain ? (0, import_core11.objectOrUndefined)(providerContextOrUndefined) : (0, import_core11.objectOrUndefined)(domainOrProvider);
+    const context = domain ? (0, import_core11.objectOrUndefined)(contextOrUndefined) : (0, import_core11.objectOrUndefined)(providerContextOrUndefined);
     if (context) {
       if (domain) {
         this._domainScopedContext.set(domain, context);
@@ -710,8 +1228,8 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommo
   setContext(domainOrContext, contextOrUndefined) {
     return __async(this, null, function* () {
       var _a, _b;
-      const domain = (0, import_core7.stringOrUndefined)(domainOrContext);
-      const context = (_b = (_a = (0, import_core7.objectOrUndefined)(domainOrContext)) != null ? _a : (0, import_core7.objectOrUndefined)(contextOrUndefined)) != null ? _b : {};
+      const domain = (0, import_core11.stringOrUndefined)(domainOrContext);
+      const context = (_b = (_a = (0, import_core11.objectOrUndefined)(domainOrContext)) != null ? _a : (0, import_core11.objectOrUndefined)(contextOrUndefined)) != null ? _b : {};
       if (domain) {
         const wrapper = this._domainScopedProviders.get(domain);
         if (wrapper) {
@@ -740,7 +1258,7 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommo
     });
   }
   getContext(domainOrUndefined) {
-    const domain = (0, import_core7.stringOrUndefined)(domainOrUndefined);
+    const domain = (0, import_core11.stringOrUndefined)(domainOrUndefined);
     if (domain) {
       const context = this._domainScopedContext.get(domain);
       if (context) {
@@ -753,7 +1271,7 @@ var OpenFeatureAPI = class _OpenFeatureAPI extends import_core7.OpenFeatureCommo
   }
   clearContext(domainOrUndefined) {
     return __async(this, null, function* () {
-      const domain = (0, import_core7.stringOrUndefined)(domainOrUndefined);
+      const domain = (0, import_core11.stringOrUndefined)(domainOrUndefined);
       if (domain) {
         const wrapper = this._domainScopedProviders.get(domain);
         if (wrapper) {