@openfeature/web-sdk 0.4.7 → 0.4.9

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.7">
-    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.4.7&color=blue&style=for-the-badge" />
+  <a href="https://github.com/open-feature/js-sdk/releases/tag/web-sdk-v0.4.9">
+    <img alt="Release" src="https://img.shields.io/static/v1?label=release&message=v0.4.9&color=blue&style=for-the-badge" />
   </a>
   <!-- x-release-please-end -->
   <br/>

package/dist/cjs/index.js

@@ -9,6 +9,7 @@ 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 = {}))
@@ -47,6 +48,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -448,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() {
@@ -468,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);
@@ -492,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;
   }
 };
 
@@ -524,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"
     };
@@ -537,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;
       }
     });
@@ -551,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;
       }
     });
@@ -580,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) {
@@ -592,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;
   }
@@ -601,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;
     }
@@ -613,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 }), {
@@ -626,13 +632,13 @@ 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 {
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
+var OpenFeatureAPI = class extends import_core6.OpenFeatureCommonAPI {
   constructor() {
     super("client");
     this._events = new OpenFeatureEventEmitter();
     this._defaultProvider = NOOP_PROVIDER;
     this._createEventEmitter = () => new OpenFeatureEventEmitter();
+    this._namedProviderContext = /* @__PURE__ */ new Map();
   }
   /**
    * Gets a singleton instance of the OpenFeature API.
@@ -648,26 +654,74 @@ var OpenFeatureAPI = class extends import_core5.OpenFeatureCommonAPI {
     _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
     return instance;
   }
-  setContext(context) {
+  setContext(nameOrContext, contextOrUndefined) {
     return __async(this, null, function* () {
-      const oldContext = this._context;
-      this._context = context;
-      const allProviders = [this._defaultProvider, ...this._clientProviders.values()];
-      yield Promise.all(
-        allProviders.map((provider) => __async(this, null, function* () {
-          var _a, _b;
-          try {
-            return yield (_a = provider.onContextChange) == null ? void 0 : _a.call(provider, oldContext, context);
-          } catch (err) {
-            (_b = this._logger) == null ? void 0 : _b.error(`Error running context change handler of provider ${provider.metadata.name}:`, err);
-          }
-        }))
-      );
+      var _a, _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(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);
+          return acc;
+        }, []);
+        const allProviders = [this._defaultProvider, ...providersWithoutContextOverride];
+        yield Promise.all(
+          allProviders.map((provider) => this.runProviderContextChangeHandler(void 0, provider, oldContext, context))
+        );
+      }
     });
   }
-  getContext() {
+  getContext(nameOrUndefined) {
+    const clientName = (0, import_core6.stringOrUndefined)(nameOrUndefined);
+    if (clientName) {
+      const context = this._namedProviderContext.get(clientName);
+      if (context) {
+        return context;
+      } else {
+        this._logger.debug(`Unable to find context for '${clientName}'.`);
+      }
+    }
     return this._context;
   }
+  clearContext(nameOrUndefined) {
+    return __async(this, null, function* () {
+      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(clientName, provider, oldContext, newContext);
+        } else {
+          this._namedProviderContext.delete(clientName);
+        }
+      } else {
+        return this.setContext({});
+      }
+    });
+  }
+  /**
+   * Resets the global evaluation context and removes the evaluation context for
+   * all named clients.
+   */
+  clearContexts() {
+    return __async(this, null, function* () {
+      yield this.clearContext();
+      yield Promise.allSettled(Array.from(this._clientProviders.keys()).map((name) => this.clearContext(name)));
+    });
+  }
   /**
    * 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
@@ -694,7 +748,30 @@ var OpenFeatureAPI = class extends import_core5.OpenFeatureCommonAPI {
    * @returns {Promise<void>}
    */
   clearProviders() {
-    return super.clearProvidersAndSetDefault(NOOP_PROVIDER);
+    return __async(this, null, function* () {
+      yield __superGet(OpenFeatureAPI.prototype, this, "clearProvidersAndSetDefault").call(this, NOOP_PROVIDER);
+      this._namedProviderContext.clear();
+    });
+  }
+  runProviderContextChangeHandler(clientName, provider, oldContext, newContext) {
+    return __async(this, null, function* () {
+      var _a;
+      const providerName = provider.metadata.name;
+      return (_a = provider.onContextChange) == null ? void 0 : _a.call(provider, oldContext, newContext).then(() => {
+        var _a2;
+        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+          emitter == null ? void 0 : emitter.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
+        });
+        (_a2 = this._events) == null ? void 0 : _a2.emit(import_core2.ClientProviderEvents.ContextChanged, { clientName, providerName });
+      }).catch((err) => {
+        var _a2, _b;
+        (_a2 = this._logger) == null ? void 0 : _a2.error(`Error running ${provider.metadata.name}'s context change handler:`, err);
+        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+          emitter == null ? void 0 : emitter.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message: err == null ? void 0 : err.message });
+        });
+        (_b = this._events) == null ? void 0 : _b.emit(import_core2.ClientProviderEvents.Error, { clientName, providerName, message: err == null ? void 0 : err.message });
+      });
+    });
   }
 };
 var OpenFeature = OpenFeatureAPI.getInstance();
@@ -715,11 +792,15 @@ var OpenFeatureClient = class {
       providerMetadata: this.providerAccessor().metadata
     };
   }
+  get providerStatus() {
+    var _a;
+    return ((_a = this.providerAccessor()) == null ? void 0 : _a.status) || import_core7.ProviderStatus.READY;
+  }
   addHandler(eventType, handler) {
     var _a;
     this.emitterAccessor().addHandler(eventType, handler);
-    const providerReady = !this._provider.status || this._provider.status === import_core6.ProviderStatus.READY;
-    if (eventType === import_core6.ProviderEvents.Ready && providerReady) {
+    const shouldRunNow = (0, import_core7.statusMatchesEvent)(eventType, this._provider.status);
+    if (shouldRunNow) {
       try {
         handler({ clientName: this.metadata.name, providerName: this._provider.metadata.name });
       } catch (err) {
@@ -734,7 +815,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) {
@@ -816,13 +897,13 @@ var OpenFeatureClient = class {
       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
       };