@openfeature/web-sdk 0.3.2-experimental → 0.3.4-experimental

package/dist/cjs/index.js

@@ -94,22 +94,22 @@ var require_events = __commonJS({
     var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
       return value !== value;
     };
-    function EventEmitter() {
-      EventEmitter.init.call(this);
+    function EventEmitter2() {
+      EventEmitter2.init.call(this);
     }
-    module2.exports = EventEmitter;
+    module2.exports = EventEmitter2;
     module2.exports.once = once;
-    EventEmitter.EventEmitter = EventEmitter;
-    EventEmitter.prototype._events = void 0;
-    EventEmitter.prototype._eventsCount = 0;
-    EventEmitter.prototype._maxListeners = void 0;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    EventEmitter2.prototype._events = void 0;
+    EventEmitter2.prototype._eventsCount = 0;
+    EventEmitter2.prototype._maxListeners = void 0;
     var defaultMaxListeners = 10;
     function checkListener(listener) {
       if (typeof listener !== "function") {
         throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
       }
     }
-    Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+    Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
       enumerable: true,
       get: function() {
         return defaultMaxListeners;
@@ -121,14 +121,14 @@ var require_events = __commonJS({
         defaultMaxListeners = arg;
       }
     });
-    EventEmitter.init = function() {
+    EventEmitter2.init = function() {
       if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
         this._events = /* @__PURE__ */ Object.create(null);
         this._eventsCount = 0;
       }
       this._maxListeners = this._maxListeners || void 0;
     };
-    EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+    EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n) {
       if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
         throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
       }
@@ -137,13 +137,13 @@ var require_events = __commonJS({
     };
     function _getMaxListeners(that) {
       if (that._maxListeners === void 0)
-        return EventEmitter.defaultMaxListeners;
+        return EventEmitter2.defaultMaxListeners;
       return that._maxListeners;
     }
-    EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+    EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
       return _getMaxListeners(this);
     };
-    EventEmitter.prototype.emit = function emit(type) {
+    EventEmitter2.prototype.emit = function emit(type) {
       var args = [];
       for (var i = 1; i < arguments.length; i++)
         args.push(arguments[i]);
@@ -221,11 +221,11 @@ var require_events = __commonJS({
       }
       return target;
     }
-    EventEmitter.prototype.addListener = function addListener(type, listener) {
+    EventEmitter2.prototype.addListener = function addListener(type, listener) {
       return _addListener(this, type, listener, false);
     };
-    EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-    EventEmitter.prototype.prependListener = function prependListener(type, listener) {
+    EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
+    EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
       return _addListener(this, type, listener, true);
     };
     function onceWrapper() {
@@ -244,17 +244,17 @@ var require_events = __commonJS({
       state.wrapFn = wrapped;
       return wrapped;
     }
-    EventEmitter.prototype.once = function once2(type, listener) {
+    EventEmitter2.prototype.once = function once2(type, listener) {
       checkListener(listener);
       this.on(type, _onceWrap(this, type, listener));
       return this;
     };
-    EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+    EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
       checkListener(listener);
       this.prependListener(type, _onceWrap(this, type, listener));
       return this;
     };
-    EventEmitter.prototype.removeListener = function removeListener(type, listener) {
+    EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
       var list, events, position, i, originalListener;
       checkListener(listener);
       events = this._events;
@@ -294,8 +294,8 @@ var require_events = __commonJS({
       }
       return this;
     };
-    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-    EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
       var listeners, events, i;
       events = this._events;
       if (events === void 0)
@@ -347,20 +347,20 @@ var require_events = __commonJS({
         return unwrap ? [evlistener.listener || evlistener] : [evlistener];
       return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
     }
-    EventEmitter.prototype.listeners = function listeners(type) {
+    EventEmitter2.prototype.listeners = function listeners(type) {
       return _listeners(this, type, true);
     };
-    EventEmitter.prototype.rawListeners = function rawListeners(type) {
+    EventEmitter2.prototype.rawListeners = function rawListeners(type) {
       return _listeners(this, type, false);
     };
-    EventEmitter.listenerCount = function(emitter, type) {
+    EventEmitter2.listenerCount = function(emitter, type) {
       if (typeof emitter.listenerCount === "function") {
         return emitter.listenerCount(type);
       } else {
         return listenerCount.call(emitter, type);
       }
     };
-    EventEmitter.prototype.listenerCount = listenerCount;
+    EventEmitter2.prototype.listenerCount = listenerCount;
     function listenerCount(type) {
       var events = this._events;
       if (events !== void 0) {
@@ -373,7 +373,7 @@ var require_events = __commonJS({
       }
       return 0;
     }
-    EventEmitter.prototype.eventNames = function eventNames() {
+    EventEmitter2.prototype.eventNames = function eventNames() {
       return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
     };
     function arrayClone(arr, n) {
@@ -442,7 +442,6 @@ var require_events = __commonJS({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ApiEvents: () => ApiEvents,
   DefaultLogger: () => DefaultLogger,
   ErrorCode: () => ErrorCode,
   FlagNotFoundError: () => FlagNotFoundError,
@@ -455,9 +454,10 @@ __export(src_exports, {
   OpenFeatureClient: () => OpenFeatureClient,
   OpenFeatureCommonAPI: () => OpenFeatureCommonAPI,
   OpenFeatureError: () => OpenFeatureError,
-  OpenFeatureEventEmitter: () => import_events.EventEmitter,
+  OpenFeatureEventEmitter: () => OpenFeatureEventEmitter,
   ParseError: () => ParseError,
   ProviderEvents: () => ProviderEvents,
+  ProviderStatus: () => ProviderStatus,
   SafeLogger: () => SafeLogger,
   StandardResolutionReasons: () => StandardResolutionReasons,
   TargetingKeyMissingError: () => TargetingKeyMissingError,
@@ -480,7 +480,7 @@ var StandardResolutionReasons = {
    */
   DISABLED: "DISABLED",
   /**
-   * 	The resolved value was configured statically, or otherwise fell back to a pre-configured value.
+   *  The resolved value was configured statically, or otherwise fell back to a pre-configured value.
    */
   DEFAULT: "DEFAULT",
   /**
@@ -512,6 +512,12 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2["GENERAL"] = "GENERAL";
   return ErrorCode2;
 })(ErrorCode || {});
+var ProviderStatus = /* @__PURE__ */ ((ProviderStatus2) => {
+  ProviderStatus2["NOT_READY"] = "NOT_READY";
+  ProviderStatus2["READY"] = "READY";
+  ProviderStatus2["ERROR"] = "ERROR";
+  return ProviderStatus2;
+})(ProviderStatus || {});
 
 // ../shared/src/errors/open-feature-error-abstract.ts
 var OpenFeatureError = class extends Error {
@@ -644,16 +650,217 @@ var NoopTransactionContextPropagator = class {
 };
 var NOOP_TRANSACTION_CONTEXT_PROPAGATOR = new NoopTransactionContextPropagator();
 
+// ../shared/src/events.ts
+var import_events = __toESM(require_events());
+var ProviderEvents = /* @__PURE__ */ ((ProviderEvents2) => {
+  ProviderEvents2["Ready"] = "PROVIDER_READY";
+  ProviderEvents2["Error"] = "PROVIDER_ERROR";
+  ProviderEvents2["ConfigurationChanged"] = "PROVIDER_CONFIGURATION_CHANGED";
+  ProviderEvents2["Stale"] = "PROVIDER_STALE";
+  return ProviderEvents2;
+})(ProviderEvents || {});
+var OpenFeatureEventEmitter = class {
+  constructor(globalLogger) {
+    this.globalLogger = globalLogger;
+    this._handlers = /* @__PURE__ */ new WeakMap();
+    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);
+    });
+  }
+  emit(eventType, context) {
+    this.eventEmitter.emit(eventType, context);
+  }
+  addHandler(eventType, handler) {
+    const asyncHandler = (context) => __async(this, null, function* () {
+      yield handler(context);
+    });
+    this._handlers.set(handler, asyncHandler);
+    this.eventEmitter.on(eventType, asyncHandler);
+  }
+  removeHandler(eventType, handler) {
+    const asyncHandler = this._handlers.get(handler);
+    if (!asyncHandler) {
+      return;
+    }
+    this.eventEmitter.removeListener(eventType, asyncHandler);
+  }
+  removeAllHandlers(eventType) {
+    if (eventType) {
+      this.eventEmitter.removeAllListeners(eventType);
+    } else {
+      this.eventEmitter.removeAllListeners();
+    }
+  }
+  getHandlers(eventType) {
+    return this.eventEmitter.listeners(eventType);
+  }
+  setLogger(logger) {
+    this._eventLogger = new SafeLogger(logger);
+    return this;
+  }
+  get _logger() {
+    var _a;
+    return this._eventLogger || ((_a = this.globalLogger) == null ? void 0 : _a.call(this));
+  }
+};
+
+// ../shared/src/type-guards.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function stringOrUndefined(value) {
+  return isString(value) ? value : void 0;
+}
+function isObject(value) {
+  return typeof value === "object";
+}
+function objectOrUndefined(value) {
+  return isObject(value) ? value : void 0;
+}
+
 // ../shared/src/open-feature.ts
 var OpenFeatureCommonAPI = class {
   constructor() {
     this._transactionContextPropagator = NOOP_TRANSACTION_CONTEXT_PROPAGATOR;
     this._context = {};
     this._logger = new DefaultLogger();
+    this._events = new OpenFeatureEventEmitter(() => this._logger);
+    this._clientProviders = /* @__PURE__ */ new Map();
+    this._clientEvents = /* @__PURE__ */ new Map();
+  }
+  setLogger(logger) {
+    this._logger = new SafeLogger(logger);
+    return this;
+  }
+  /**
+   * Get metadata about registered provider.
+   * @returns {ProviderMetadata} Provider Metadata
+   */
+  get providerMetadata() {
+    return this._defaultProvider.metadata;
   }
   getContext() {
     return this._context;
   }
+  /**
+   * Adds a handler for the given provider event type.
+   * The handlers are called in the order they have been added.
+   * When changing the provider, the currently attached handlers will listen to the events of the new provider.
+   * @param {ProviderEvents} eventType The provider event type to listen to
+   * @param {EventHandler} handler The handler to run on occurrence of the event type
+   */
+  addHandler(eventType, handler) {
+    this._events.addHandler(eventType, handler);
+  }
+  /**
+   * Removes a handler for the given provider event type.
+   * @param {ProviderEvents} eventType The provider event type to remove the listener for
+   * @param {EventHandler} handler The handler to remove for the provider event type
+   */
+  removeHandler(eventType, handler) {
+    this._events.removeHandler(eventType, handler);
+  }
+  /**
+   * Gets the current handlers for the given provider event type.
+   * @param {ProviderEvents} eventType The provider event type to get the current handlers for
+   * @returns {EventHandler[]} The handlers currently attached to the given provider event type
+   */
+  getHandlers(eventType) {
+    return this._events.getHandlers(eventType);
+  }
+  setProvider(clientOrProvider, providerOrUndefined) {
+    var _a, _b, _c, _d, _e, _f;
+    const clientName = stringOrUndefined(clientOrProvider);
+    const provider = (_a = objectOrUndefined(clientOrProvider)) != null ? _a : objectOrUndefined(providerOrUndefined);
+    if (!provider) {
+      return this;
+    }
+    const oldProvider = this.getProviderForClient(clientName);
+    if (oldProvider === provider) {
+      return this;
+    }
+    const clientEmitter = this.getEventEmitterForClient(clientName);
+    if (typeof provider.initialize === "function") {
+      (_d = (_c = (_b = provider.initialize) == null ? void 0 : _b.call(provider, this._context)) == null ? void 0 : _c.then(() => {
+        var _a2;
+        clientEmitter.emit("PROVIDER_READY" /* Ready */, { clientName });
+        (_a2 = this._events) == null ? void 0 : _a2.emit("PROVIDER_READY" /* Ready */, { clientName });
+      })) == null ? void 0 : _d.catch((error) => {
+        var _a2;
+        clientEmitter.emit("PROVIDER_ERROR" /* Error */, { clientName, message: error.message });
+        (_a2 = this._events) == null ? void 0 : _a2.emit("PROVIDER_ERROR" /* Error */, { clientName, message: error.message });
+      });
+    } else {
+      clientEmitter.emit("PROVIDER_READY" /* Ready */, { clientName });
+      (_e = this._events) == null ? void 0 : _e.emit("PROVIDER_READY" /* Ready */, { clientName });
+    }
+    if (clientName) {
+      this._clientProviders.set(clientName, provider);
+    } else {
+      this._defaultProvider = provider;
+    }
+    this.transferListeners(oldProvider, provider, clientName, clientEmitter);
+    if (![...this._clientProviders.values(), this._defaultProvider].includes(oldProvider)) {
+      (_f = oldProvider == null ? void 0 : oldProvider.onClose) == null ? void 0 : _f.call(oldProvider);
+    }
+    return this;
+  }
+  getProviderForClient(name) {
+    var _a;
+    if (!name) {
+      return this._defaultProvider;
+    }
+    return (_a = this._clientProviders.get(name)) != null ? _a : this._defaultProvider;
+  }
+  getEventEmitterForClient(name) {
+    const emitter = this._clientEvents.get(name);
+    if (emitter) {
+      return emitter;
+    }
+    const newEmitter = new OpenFeatureEventEmitter(() => this._logger);
+    this._clientEvents.set(name, newEmitter);
+    return newEmitter;
+  }
+  transferListeners(oldProvider, newProvider, clientName, clientEmitter) {
+    var _a;
+    (_a = oldProvider.events) == null ? void 0 : _a.removeAllHandlers();
+    Object.values(ProviderEvents).forEach(
+      (eventType) => {
+        var _a2;
+        return (_a2 = newProvider.events) == null ? void 0 : _a2.addHandler(eventType, (details) => __async(this, null, function* () {
+          clientEmitter.emit(eventType, __spreadProps(__spreadValues({}, details), { clientName }));
+          this._events.emit(eventType, __spreadProps(__spreadValues({}, details), { clientName }));
+        }));
+      }
+    );
+  }
+  close() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      try {
+        yield (_b = (_a = this == null ? void 0 : this._defaultProvider) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
+      } catch (err) {
+        this.handleShutdownError(this._defaultProvider, err);
+      }
+      const providers = Array.from(this._clientProviders);
+      yield Promise.all(
+        providers.map((_0) => __async(this, [_0], function* ([, provider]) {
+          var _a2;
+          try {
+            yield (_a2 = provider.onClose) == null ? void 0 : _a2.call(provider);
+          } catch (err) {
+            this.handleShutdownError(this._defaultProvider, err);
+          }
+        }))
+      );
+    });
+  }
+  handleShutdownError(provider, err) {
+    this._logger.error(`Error during shutdown of provider ${provider.metadata.name}: ${err}`);
+    this._logger.error(err == null ? void 0 : err.stack);
+  }
   setTransactionContextPropagator(transactionContextPropagator) {
     const baseMessage = "Invalid TransactionContextPropagator, will not be set: ";
     if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.getTransactionContext) !== "function") {
@@ -688,6 +895,9 @@ var NoopFeatureProvider = class {
       name: "No-op Provider"
     };
   }
+  get status() {
+    return "NOT_READY" /* NOT_READY */;
+  }
   resolveBooleanEvaluation(_, defaultValue) {
     return this.noOp(defaultValue);
   }
@@ -709,35 +919,18 @@ var NoopFeatureProvider = class {
 };
 var NOOP_PROVIDER = new NoopFeatureProvider();
 
-// src/types.ts
-var import_events = __toESM(require_events());
-var ProviderEvents = /* @__PURE__ */ ((ProviderEvents2) => {
-  ProviderEvents2["Ready"] = "PROVIDER_READY";
-  ProviderEvents2["Error"] = "PROVIDER_ERROR";
-  ProviderEvents2["ConfigurationChanged"] = "PROVIDER_CONFIGURATION_CHANGED";
-  ProviderEvents2["Stale"] = "PROVIDER_STALE";
-  return ProviderEvents2;
-})(ProviderEvents || {});
-var ApiEvents = /* @__PURE__ */ ((ApiEvents2) => {
-  ApiEvents2["ProviderChanged"] = "providerChanged";
-  return ApiEvents2;
-})(ApiEvents || {});
-
 // src/open-feature.ts
-var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/js.api");
+var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
 var _globalThis = globalThis;
 var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   constructor() {
     super();
-    this._apiEvents = new import_events.EventEmitter();
-    this._providerReady = false;
     this._hooks = [];
-    this._provider = NOOP_PROVIDER;
+    this._defaultProvider = NOOP_PROVIDER;
   }
   /**
    * Gets a singleton instance of the OpenFeature API.
-   *
    * @ignore
    * @returns {OpenFeatureAPI} OpenFeature API
    */
@@ -750,14 +943,6 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
     _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
     return instance;
   }
-  /**
-   * Get metadata about registered provider.
-   *
-   * @returns {ProviderMetadata} Provider Metadata
-   */
-  get providerMetadata() {
-    return this._provider.metadata;
-  }
   setLogger(logger) {
     this._logger = new SafeLogger(logger);
     return this;
@@ -778,49 +963,26 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
       var _a, _b;
       const oldContext = this._context;
       this._context = context;
-      yield (_b = (_a = this._provider) == null ? void 0 : _a.onContextChange) == null ? void 0 : _b.call(_a, oldContext, context);
-    });
-  }
-  setProvider(provider) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    if (this._provider !== provider) {
-      const oldProvider = this._provider;
-      this._provider = provider;
-      this._providerReady = false;
-      if (!this._provider.events) {
-        this._provider.events = new import_events.EventEmitter();
-      }
-      if (typeof ((_a = this._provider) == null ? void 0 : _a.initialize) === "function") {
-        (_e = (_d = (_c = (_b = this._provider).initialize) == null ? void 0 : _c.call(_b, this._context)) == null ? void 0 : _d.then(() => {
-          var _a2;
-          this._providerReady = true;
-          (_a2 = this._provider.events) == null ? void 0 : _a2.emit("PROVIDER_READY" /* Ready */);
-        })) == null ? void 0 : _e.catch(() => {
-          var _a2;
-          (_a2 = this._provider.events) == null ? void 0 : _a2.emit("PROVIDER_ERROR" /* Error */);
-        });
-      } else {
-        this._providerReady = true;
-        (_f = this._provider.events) == null ? void 0 : _f.emit("PROVIDER_READY" /* Ready */);
-      }
-      this._apiEvents.emit("providerChanged" /* ProviderChanged */);
-      (_g = oldProvider == null ? void 0 : oldProvider.onClose) == null ? void 0 : _g.call(oldProvider);
-    }
-    return this;
-  }
-  close() {
-    return __async(this, null, function* () {
-      var _a, _b;
-      yield (_b = (_a = this == null ? void 0 : this._provider) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
+      yield (_b = (_a = this._defaultProvider) == null ? void 0 : _a.onContextChange) == null ? void 0 : _b.call(_a, oldContext, context);
     });
   }
+  /**
+   * 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} name The name of the client
+   * @param {string} version The version of the client (only used for metadata)
+   * @returns {Client} OpenFeature Client
+   */
   getClient(name, 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._provider,
-      () => this._providerReady,
-      () => this._apiEvents,
+      () => this.getProviderForClient(name),
+      () => this.getEventEmitterForClient(name),
       () => this._logger,
       { name, version }
     );
@@ -830,27 +992,33 @@ var OpenFeature = OpenFeatureAPI.getInstance();
 
 // src/client.ts
 var OpenFeatureClient = class {
-  constructor(providerAccessor, providerReady, apiEvents, globalLogger, options) {
+  constructor(providerAccessor, events, globalLogger, options) {
     this.providerAccessor = providerAccessor;
-    this.providerReady = providerReady;
+    this.events = events;
     this.globalLogger = globalLogger;
+    this.options = options;
     this._hooks = [];
-    this._handlerWrappers = [];
-    this.metadata = {
-      name: options.name,
-      version: options.version
+  }
+  get metadata() {
+    return {
+      name: this.options.name,
+      version: this.options.version,
+      providerMetadata: this.providerAccessor().metadata
     };
-    this.attachListeners();
-    apiEvents().on("providerChanged" /* ProviderChanged */, () => {
-      this.attachListeners();
-    });
   }
   addHandler(eventType, handler) {
-    this._handlerWrappers.push({ eventType, handler });
-    if (eventType === "PROVIDER_READY" /* Ready */ && this.providerReady()) {
-      handler();
+    this.events().addHandler(eventType, handler);
+    const providerReady = !this._provider.status || this._provider.status === "READY" /* READY */;
+    if (eventType === "PROVIDER_READY" /* Ready */ && providerReady) {
+      handler({ clientName: this.metadata.name });
     }
   }
+  removeHandler(notificationType, handler) {
+    this.events().removeHandler(notificationType, handler);
+  }
+  getHandlers(eventType) {
+    return this.events().getHandlers(eventType);
+  }
   setLogger(logger) {
     this._clientLogger = new SafeLogger(logger);
     return this;
@@ -870,13 +1038,7 @@ var OpenFeatureClient = class {
     return this.getBooleanDetails(flagKey, defaultValue, options).value;
   }
   getBooleanDetails(flagKey, defaultValue, options) {
-    return this.evaluate(
-      flagKey,
-      this._provider.resolveBooleanEvaluation,
-      defaultValue,
-      "boolean",
-      options
-    );
+    return this.evaluate(flagKey, this._provider.resolveBooleanEvaluation, defaultValue, "boolean", options);
   }
   getStringValue(flagKey, defaultValue, options) {
     return this.getStringDetails(flagKey, defaultValue, options).value;
@@ -911,6 +1073,7 @@ var OpenFeatureClient = class {
     return this.evaluate(flagKey, this._provider.resolveObjectEvaluation, defaultValue, "object", options);
   }
   evaluate(flagKey, resolver, defaultValue, flagType, options = {}) {
+    var _a;
     const allHooks = [
       ...OpenFeature.getHooks(),
       ...this.getHooks(),
@@ -932,6 +1095,7 @@ 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 : {}),
         flagKey
       });
       this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
@@ -945,6 +1109,7 @@ var OpenFeatureClient = class {
         errorMessage,
         value: defaultValue,
         reason: StandardResolutionReasons.ERROR,
+        flagMetadata: Object.freeze({}),
         flagKey
       };
     } finally {
@@ -999,13 +1164,5 @@ var OpenFeatureClient = class {
   get _logger() {
     return this._clientLogger || this.globalLogger();
   }
-  attachListeners() {
-    Object.values(ProviderEvents).forEach((eventType) => {
-      var _a;
-      return (_a = this._provider.events) == null ? void 0 : _a.on(eventType, () => {
-        this._handlerWrappers.filter((wrapper) => wrapper.eventType === eventType).forEach((wrapper) => wrapper.handler());
-      });
-    });
-  }
 };
 //# sourceMappingURL=index.js.map