@openfeature/web-sdk 0.4.8 → 0.4.10

package/README.md

@@ -16,8 +16,8 @@
     <img alt="Specification" src="https://img.shields.io/static/v1?label=specification&message=v0.7.0&color=yellow&style=for-the-badge" />
   </a>
   <!-- x-release-please-start-version -->
-  <a href="https://github.com/open-feature/js-sdk/releases/tag/web-sdk-v0.4.8">
-    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.4.8&color=blue&style=for-the-badge" />
+  <a href="https://github.com/open-feature/js-sdk/releases/tag/web-sdk-v0.4.10">
+    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.4.10&color=blue&style=for-the-badge" />
   </a>
   <!-- x-release-please-end -->
   <br/>

package/dist/cjs/index.js

@@ -450,18 +450,36 @@ __export(src_exports, {
   OpenFeature: () => OpenFeature,
   OpenFeatureAPI: () => OpenFeatureAPI,
   OpenFeatureClient: () => OpenFeatureClient,
-  OpenFeatureEventEmitter: () => OpenFeatureEventEmitter
+  OpenFeatureEventEmitter: () => OpenFeatureEventEmitter,
+  ProviderEvents: () => import_core2.ClientProviderEvents
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/client/open-feature-client.ts
-var import_core6 = require("@openfeature/core");
+var import_core7 = require("@openfeature/core");
 
 // src/open-feature.ts
-var import_core5 = require("@openfeature/core");
+var import_core6 = require("@openfeature/core");
 
-// src/provider/no-op-provider.ts
+// src/events/open-feature-event-emitter.ts
 var import_core = require("@openfeature/core");
+var import_events = __toESM(require_events());
+var OpenFeatureEventEmitter = class extends import_core.GenericEventEmitter {
+  constructor() {
+    super();
+    this.eventEmitter = new import_events.default({ captureRejections: true });
+    this.eventEmitter.on("error", (err) => {
+      var _a;
+      (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
+    });
+  }
+};
+
+// src/events/events.ts
+var import_core2 = require("@openfeature/core");
+
+// src/provider/no-op-provider.ts
+var import_core3 = require("@openfeature/core");
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
   constructor() {
@@ -470,7 +488,7 @@ var NoopFeatureProvider = class {
     };
   }
   get status() {
-    return import_core.ProviderStatus.NOT_READY;
+    return import_core3.ProviderStatus.NOT_READY;
   }
   resolveBooleanEvaluation(_, defaultValue) {
     return this.noOp(defaultValue);
@@ -494,30 +512,16 @@ var NoopFeatureProvider = class {
 var NOOP_PROVIDER = new NoopFeatureProvider();
 
 // src/provider/in-memory-provider/in-memory-provider.ts
-var import_core4 = require("@openfeature/core");
-
-// src/events/open-feature-event-emitter.ts
-var import_core2 = require("@openfeature/core");
-var import_events = __toESM(require_events());
-var OpenFeatureEventEmitter = class extends import_core2.GenericEventEmitter {
-  constructor() {
-    super();
-    this.eventEmitter = new import_events.default({ captureRejections: true });
-    this.eventEmitter.on("error", (err) => {
-      var _a;
-      (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
-    });
-  }
-};
+var import_core5 = require("@openfeature/core");
 
 // src/provider/in-memory-provider/variant-not-found-error.ts
-var import_core3 = require("@openfeature/core");
-var VariantNotFoundError = class extends import_core3.OpenFeatureError {
+var import_core4 = require("@openfeature/core");
+var VariantNotFoundError = class extends import_core4.OpenFeatureError {
   constructor(message) {
     super(message);
     Object.setPrototypeOf(this, VariantNotFoundError.prototype);
     this.name = "VariantNotFoundError";
-    this.code = import_core3.ErrorCode.GENERAL;
+    this.code = import_core4.ErrorCode.GENERAL;
   }
 };
 
@@ -526,7 +530,7 @@ var InMemoryProvider = class {
   constructor(flagConfiguration = {}) {
     this.events = new OpenFeatureEventEmitter();
     this.runsOn = "client";
-    this.status = import_core4.ProviderStatus.NOT_READY;
+    this.status = import_core5.ProviderStatus.NOT_READY;
     this.metadata = {
       name: "in-memory"
     };
@@ -539,9 +543,9 @@ var InMemoryProvider = class {
           this.resolveFlagWithReason(key, context);
         }
         this._context = context;
-        this.status = import_core4.ProviderStatus.READY;
+        this.status = import_core5.ProviderStatus.READY;
       } catch (error) {
-        this.status = import_core4.ProviderStatus.ERROR;
+        this.status = import_core5.ProviderStatus.ERROR;
         throw error;
       }
     });
@@ -553,15 +557,15 @@ var InMemoryProvider = class {
   putConfiguration(flagConfiguration) {
     return __async(this, null, function* () {
       const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
-      this.status = import_core4.ProviderStatus.STALE;
-      this.events.emit(import_core4.ProviderEvents.Stale);
+      this.status = import_core5.ProviderStatus.STALE;
+      this.events.emit(import_core2.ClientProviderEvents.Stale);
       this._flagConfiguration = __spreadValues({}, flagConfiguration);
-      this.events.emit(import_core4.ProviderEvents.ConfigurationChanged, { flagsChanged });
+      this.events.emit(import_core2.ClientProviderEvents.ConfigurationChanged, { flagsChanged });
       try {
         yield this.initialize(this._context);
-        this.events.emit(import_core4.ProviderEvents.Ready);
+        this.events.emit(import_core2.ClientProviderEvents.Ready);
       } catch (err) {
-        this.events.emit(import_core4.ProviderEvents.Error);
+        this.events.emit(import_core2.ClientProviderEvents.Error);
         throw err;
       }
     });
@@ -582,10 +586,10 @@ var InMemoryProvider = class {
     if (!(flagKey in this._flagConfiguration)) {
       const message = `no flag found with key ${flagKey}`;
       logger == null ? void 0 : logger.debug(message);
-      throw new import_core4.FlagNotFoundError(message);
+      throw new import_core5.FlagNotFoundError(message);
     }
     if (this._flagConfiguration[flagKey].disabled) {
-      return { value: defaultValue, reason: import_core4.StandardResolutionReasons.DISABLED };
+      return { value: defaultValue, reason: import_core5.StandardResolutionReasons.DISABLED };
     }
     const resolvedFlag = this.resolveFlagWithReason(flagKey, context);
     if (resolvedFlag.value === void 0) {
@@ -594,7 +598,7 @@ var InMemoryProvider = class {
       throw new VariantNotFoundError(message);
     }
     if (typeof resolvedFlag.value != typeof defaultValue) {
-      throw new import_core4.TypeMismatchError();
+      throw new import_core5.TypeMismatchError();
     }
     return resolvedFlag;
   }
@@ -603,8 +607,8 @@ var InMemoryProvider = class {
       const resolutionResult = this.lookupFlagValue(flagKey, ctx);
       return resolutionResult;
     } catch (error) {
-      if (!(error instanceof import_core4.OpenFeatureError)) {
-        throw new import_core4.GeneralError((error == null ? void 0 : error.message) || "unknown error");
+      if (!(error instanceof import_core5.OpenFeatureError)) {
+        throw new import_core5.GeneralError((error == null ? void 0 : error.message) || "unknown error");
       }
       throw error;
     }
@@ -615,8 +619,8 @@ var InMemoryProvider = class {
     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 evalReason = isContextEval ? import_core4.StandardResolutionReasons.TARGETING_MATCH : import_core4.StandardResolutionReasons.STATIC;
-    const reason = this.status === import_core4.ProviderStatus.STALE ? import_core4.StandardResolutionReasons.CACHED : evalReason;
+    const evalReason = isContextEval ? import_core5.StandardResolutionReasons.TARGETING_MATCH : import_core5.StandardResolutionReasons.STATIC;
+    const reason = this.status === import_core5.ProviderStatus.STALE ? import_core5.StandardResolutionReasons.CACHED : evalReason;
     return __spreadProps(__spreadValues({
       value
     }, variant && { variant }), {
@@ -628,7 +632,7 @@ var InMemoryProvider = class {
 // src/open-feature.ts
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
 var _globalThis = globalThis;
-var OpenFeatureAPI = class extends import_core5.OpenFeatureCommonAPI {
+var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
   constructor() {
     super("client");
     this._events = new OpenFeatureEventEmitter();
@@ -653,33 +657,39 @@ var OpenFeatureAPI = class extends import_core5.OpenFeatureCommonAPI {
   setContext(nameOrContext, contextOrUndefined) {
     return __async(this, null, function* () {
       var _a, _b;
-      const clientName = (0, import_core5.stringOrUndefined)(nameOrContext);
-      const context = (_b = (_a = (0, import_core5.objectOrUndefined)(nameOrContext)) != null ? _a : (0, import_core5.objectOrUndefined)(contextOrUndefined)) != null ? _b : {};
+      const clientName = (0, import_core6.stringOrUndefined)(nameOrContext);
+      const context = (_b = (_a = (0, import_core6.objectOrUndefined)(nameOrContext)) != null ? _a : (0, import_core6.objectOrUndefined)(contextOrUndefined)) != null ? _b : {};
       if (clientName) {
         const provider = this._clientProviders.get(clientName);
         if (provider) {
           const oldContext = this.getContext(clientName);
           this._namedProviderContext.set(clientName, context);
-          yield this.runProviderContextChangeHandler(provider, oldContext, context);
+          yield this.runProviderContextChangeHandler(clientName, provider, oldContext, context);
         } else {
           this._namedProviderContext.set(clientName, context);
         }
       } else {
         const oldContext = this._context;
         this._context = context;
-        const providersWithoutContextOverride = Array.from(this._clientProviders.entries()).filter(([name]) => !this._namedProviderContext.has(name)).reduce((acc, [, provider]) => {
-          acc.push(provider);
+        const defaultContextNameProviders = Array.from(this._clientProviders.entries()).filter(([name]) => !this._namedProviderContext.has(name)).reduce((acc, [name, provider]) => {
+          acc.push({ name, provider });
           return acc;
         }, []);
-        const allProviders = [this._defaultProvider, ...providersWithoutContextOverride];
+        const allProviders = [
+          // add in the default (no name)
+          { name: void 0, provider: this._defaultProvider },
+          ...defaultContextNameProviders
+        ];
         yield Promise.all(
-          allProviders.map((provider) => this.runProviderContextChangeHandler(provider, oldContext, context))
+          allProviders.map(
+            (tuple) => this.runProviderContextChangeHandler(tuple.name, tuple.provider, oldContext, context)
+          )
         );
       }
     });
   }
   getContext(nameOrUndefined) {
-    const clientName = (0, import_core5.stringOrUndefined)(nameOrUndefined);
+    const clientName = (0, import_core6.stringOrUndefined)(nameOrUndefined);
     if (clientName) {
       const context = this._namedProviderContext.get(clientName);
       if (context) {
@@ -692,14 +702,14 @@ var OpenFeatureAPI = class extends import_core5.OpenFeatureCommonAPI {
   }
   clearContext(nameOrUndefined) {
     return __async(this, null, function* () {
-      const clientName = (0, import_core5.stringOrUndefined)(nameOrUndefined);
+      const clientName = (0, import_core6.stringOrUndefined)(nameOrUndefined);
       if (clientName) {
         const provider = this._clientProviders.get(clientName);
         if (provider) {
           const oldContext = this.getContext(clientName);
           this._namedProviderContext.delete(clientName);
           const newContext = this.getContext();
-          yield this.runProviderContextChangeHandler(provider, oldContext, newContext);
+          yield this.runProviderContextChangeHandler(clientName, provider, oldContext, newContext);
         } else {
           this._namedProviderContext.delete(clientName);
         }
@@ -749,13 +759,24 @@ var OpenFeatureAPI = class extends import_core5.OpenFeatureCommonAPI {
       this._namedProviderContext.clear();
     });
   }
-  runProviderContextChangeHandler(provider, oldContext, newContext) {
+  runProviderContextChangeHandler(clientName, provider, oldContext, newContext) {
     return __async(this, null, function* () {
-      var _a, _b;
+      var _a, _b, _c, _d, _e;
+      const providerName = provider.metadata.name;
       try {
-        return yield (_a = provider.onContextChange) == null ? void 0 : _a.call(provider, oldContext, newContext);
+        yield (_a = provider.onContextChange) == null ? void 0 : _a.call(provider, oldContext, newContext);
+        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+          emitter == null ? void 0 : emitter.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
+        });
+        (_b = this._events) == null ? void 0 : _b.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
       } catch (err) {
-        (_b = this._logger) == null ? void 0 : _b.error(`Error running ${provider.metadata.name}'s context change handler:`, err);
+        const error = err;
+        const message = `Error running ${(_c = provider == null ? void 0 : provider.metadata) == null ? void 0 : _c.name}'s context change handler: ${error == null ? void 0 : error.message}`;
+        (_d = this._logger) == null ? void 0 : _d.error(`${message}`, err);
+        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+          emitter == null ? void 0 : emitter.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message });
+        });
+        (_e = this._events) == null ? void 0 : _e.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message });
       }
     });
   }
@@ -780,12 +801,12 @@ var OpenFeatureClient = class {
   }
   get providerStatus() {
     var _a;
-    return ((_a = this.providerAccessor()) == null ? void 0 : _a.status) || import_core6.ProviderStatus.READY;
+    return ((_a = this.providerAccessor()) == null ? void 0 : _a.status) || import_core7.ProviderStatus.READY;
   }
   addHandler(eventType, handler) {
     var _a;
     this.emitterAccessor().addHandler(eventType, handler);
-    const shouldRunNow = (0, import_core6.statusMatchesEvent)(eventType, this._provider.status);
+    const shouldRunNow = (0, import_core7.statusMatchesEvent)(eventType, this._provider.status);
     if (shouldRunNow) {
       try {
         handler({ clientName: this.metadata.name, providerName: this._provider.metadata.name });
@@ -801,7 +822,7 @@ var OpenFeatureClient = class {
     return this.emitterAccessor().getHandlers(eventType);
   }
   setLogger(logger) {
-    this._clientLogger = new import_core6.SafeLogger(logger);
+    this._clientLogger = new import_core7.SafeLogger(logger);
     return this;
   }
   addHooks(...hooks) {
@@ -854,7 +875,7 @@ var OpenFeatureClient = class {
     return this.evaluate(flagKey, this._provider.resolveObjectEvaluation, defaultValue, "object", options);
   }
   evaluate(flagKey, resolver, defaultValue, flagType, options = {}) {
-    var _a;
+    var _a, _b;
     const allHooks = [
       ...OpenFeature.getHooks(),
       ...this.getHooks(),
@@ -862,7 +883,7 @@ var OpenFeatureClient = class {
       ...this._provider.hooks || []
     ];
     const allHooksReversed = [...allHooks].reverse();
-    const context = __spreadValues({}, OpenFeature.getContext());
+    const context = __spreadValues({}, OpenFeature.getContext((_a = this == null ? void 0 : this.options) == null ? void 0 : _a.name));
     const hookContext = {
       flagKey,
       defaultValue,
@@ -876,20 +897,20 @@ var OpenFeatureClient = class {
       this.beforeHooks(allHooks, hookContext, options);
       const resolution = resolver.call(this._provider, flagKey, defaultValue, context, this._logger);
       const evaluationDetails = __spreadProps(__spreadValues({}, resolution), {
-        flagMetadata: Object.freeze((_a = resolution.flagMetadata) != null ? _a : {}),
+        flagMetadata: Object.freeze((_b = resolution.flagMetadata) != null ? _b : {}),
         flagKey
       });
       this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
       return evaluationDetails;
     } catch (err) {
       const errorMessage = err == null ? void 0 : err.message;
-      const errorCode = (err == null ? void 0 : err.code) || import_core6.ErrorCode.GENERAL;
+      const errorCode = (err == null ? void 0 : err.code) || import_core7.ErrorCode.GENERAL;
       this.errorHooks(allHooksReversed, hookContext, err, options);
       return {
         errorCode,
         errorMessage,
         value: defaultValue,
-        reason: import_core6.StandardResolutionReasons.ERROR,
+        reason: import_core7.StandardResolutionReasons.ERROR,
         flagMetadata: Object.freeze({}),
         flagKey
       };