@openfeature/web-sdk 0.4.10 → 0.4.12

package/dist/esm/index.js

@@ -1,27 +1,9 @@
 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;
 };
@@ -41,27 +23,6 @@ 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/events/events.js
 var require_events = __commonJS({
@@ -455,12 +416,11 @@ import {
 var import_events = __toESM(require_events());
 import { GenericEventEmitter } from "@openfeature/core";
 var OpenFeatureEventEmitter = class extends GenericEventEmitter {
+  eventEmitter = new import_events.default({ captureRejections: true });
   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);
+      this._logger?.error("Error running event handler:", err);
     });
   }
 };
@@ -472,11 +432,9 @@ import { ClientProviderEvents } from "@openfeature/core";
 import { ProviderStatus } from "@openfeature/core";
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
-  constructor() {
-    this.metadata = {
-      name: "No-op Provider"
-    };
-  }
+  metadata = {
+    name: "No-op Provider"
+  };
   get status() {
     return ProviderStatus.NOT_READY;
   }
@@ -514,6 +472,7 @@ import {
 // src/provider/in-memory-provider/variant-not-found-error.ts
 import { ErrorCode, OpenFeatureError } from "@openfeature/core";
 var VariantNotFoundError = class extends OpenFeatureError {
+  code;
   constructor(message) {
     super(message);
     Object.setPrototypeOf(this, VariantNotFoundError.prototype);
@@ -524,48 +483,46 @@ var VariantNotFoundError = class extends OpenFeatureError {
 
 // src/provider/in-memory-provider/in-memory-provider.ts
 var InMemoryProvider = class {
+  events = new OpenFeatureEventEmitter();
+  runsOn = "client";
+  status = ProviderStatus2.NOT_READY;
+  metadata = {
+    name: "in-memory"
+  };
+  _flagConfiguration;
+  _context;
   constructor(flagConfiguration = {}) {
-    this.events = new OpenFeatureEventEmitter();
-    this.runsOn = "client";
-    this.status = ProviderStatus2.NOT_READY;
-    this.metadata = {
-      name: "in-memory"
-    };
-    this._flagConfiguration = __spreadValues({}, flagConfiguration);
+    this._flagConfiguration = { ...flagConfiguration };
   }
-  initialize(context) {
-    return __async(this, null, function* () {
-      try {
-        for (const key in this._flagConfiguration) {
-          this.resolveFlagWithReason(key, context);
-        }
-        this._context = context;
-        this.status = ProviderStatus2.READY;
-      } catch (error) {
-        this.status = ProviderStatus2.ERROR;
-        throw error;
+  async initialize(context) {
+    try {
+      for (const key in this._flagConfiguration) {
+        this.resolveFlagWithReason(key, context);
       }
-    });
+      this._context = context;
+      this.status = ProviderStatus2.READY;
+    } catch (error) {
+      this.status = ProviderStatus2.ERROR;
+      throw error;
+    }
   }
   /**
    * Overwrites the configured flags.
    * @param { FlagConfiguration } flagConfiguration new flag configuration
    */
-  putConfiguration(flagConfiguration) {
-    return __async(this, null, function* () {
-      const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
-      this.status = ProviderStatus2.STALE;
-      this.events.emit(ClientProviderEvents.Stale);
-      this._flagConfiguration = __spreadValues({}, flagConfiguration);
-      this.events.emit(ClientProviderEvents.ConfigurationChanged, { flagsChanged });
-      try {
-        yield this.initialize(this._context);
-        this.events.emit(ClientProviderEvents.Ready);
-      } catch (err) {
-        this.events.emit(ClientProviderEvents.Error);
-        throw err;
-      }
-    });
+  async putConfiguration(flagConfiguration) {
+    const flagsChanged = Object.entries(flagConfiguration).filter(([key, value]) => this._flagConfiguration[key] !== value).map(([key]) => key);
+    this.status = ProviderStatus2.STALE;
+    this.events.emit(ClientProviderEvents.Stale);
+    this._flagConfiguration = { ...flagConfiguration };
+    this.events.emit(ClientProviderEvents.ConfigurationChanged, { flagsChanged });
+    try {
+      await this.initialize(this._context);
+      this.events.emit(ClientProviderEvents.Ready);
+    } catch (err) {
+      this.events.emit(ClientProviderEvents.Error);
+      throw err;
+    }
   }
   resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
     return this.resolveAndCheckFlag(flagKey, defaultValue, context || this._context, logger);
@@ -582,7 +539,7 @@ var InMemoryProvider = class {
   resolveAndCheckFlag(flagKey, defaultValue, context, logger) {
     if (!(flagKey in this._flagConfiguration)) {
       const message = `no flag found with key ${flagKey}`;
-      logger == null ? void 0 : logger.debug(message);
+      logger?.debug(message);
       throw new FlagNotFoundError(message);
     }
     if (this._flagConfiguration[flagKey].disabled) {
@@ -591,7 +548,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 == null ? void 0 : logger.error(message);
+      logger?.error(message);
       throw new VariantNotFoundError(message);
     }
     if (typeof resolvedFlag.value != typeof defaultValue) {
@@ -605,24 +562,23 @@ var InMemoryProvider = class {
       return resolutionResult;
     } catch (error) {
       if (!(error instanceof OpenFeatureError2)) {
-        throw new GeneralError((error == null ? void 0 : error.message) || "unknown error");
+        throw new GeneralError(error?.message || "unknown error");
       }
       throw error;
     }
   }
   lookupFlagValue(flagKey, ctx) {
-    var _a;
     const flagSpec = this._flagConfiguration[flagKey];
-    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 isContextEval = ctx && flagSpec?.contextEvaluator;
+    const variant = isContextEval ? flagSpec.contextEvaluator?.(ctx) : flagSpec.defaultVariant;
+    const value = variant && flagSpec?.variants[variant];
     const evalReason = isContextEval ? StandardResolutionReasons.TARGETING_MATCH : StandardResolutionReasons.STATIC;
     const reason = this.status === ProviderStatus2.STALE ? StandardResolutionReasons.CACHED : evalReason;
-    return __spreadProps(__spreadValues({
-      value
-    }, variant && { variant }), {
+    return {
+      value,
+      ...variant && { variant },
       reason
-    });
+    };
   }
 };
 
@@ -630,12 +586,12 @@ var InMemoryProvider = class {
 var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
 var _globalThis = globalThis;
 var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
+  _events = new OpenFeatureEventEmitter();
+  _defaultProvider = NOOP_PROVIDER;
+  _createEventEmitter = () => new OpenFeatureEventEmitter();
+  _namedProviderContext = /* @__PURE__ */ new Map();
   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.
@@ -651,39 +607,36 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
     _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
     return instance;
   }
-  setContext(nameOrContext, contextOrUndefined) {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const clientName = stringOrUndefined(nameOrContext);
-      const context = (_b = (_a = objectOrUndefined(nameOrContext)) != null ? _a : 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);
-        }
+  async setContext(nameOrContext, contextOrUndefined) {
+    const clientName = stringOrUndefined(nameOrContext);
+    const context = objectOrUndefined(nameOrContext) ?? objectOrUndefined(contextOrUndefined) ?? {};
+    if (clientName) {
+      const provider = this._clientProviders.get(clientName);
+      if (provider) {
+        const oldContext = this.getContext(clientName);
+        this._namedProviderContext.set(clientName, context);
+        await this.runProviderContextChangeHandler(clientName, provider, oldContext, context);
       } else {
-        const oldContext = this._context;
-        this._context = context;
-        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 = [
-          // add in the default (no name)
-          { name: void 0, provider: this._defaultProvider },
-          ...defaultContextNameProviders
-        ];
-        yield Promise.all(
-          allProviders.map(
-            (tuple) => this.runProviderContextChangeHandler(tuple.name, tuple.provider, oldContext, context)
-          )
-        );
+        this._namedProviderContext.set(clientName, context);
       }
-    });
+    } else {
+      const oldContext = this._context;
+      this._context = context;
+      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 = [
+        // add in the default (no name)
+        { name: void 0, provider: this._defaultProvider },
+        ...defaultContextNameProviders
+      ];
+      await Promise.all(
+        allProviders.map(
+          (tuple) => this.runProviderContextChangeHandler(tuple.name, tuple.provider, oldContext, context)
+        )
+      );
+    }
   }
   getContext(nameOrUndefined) {
     const clientName = stringOrUndefined(nameOrUndefined);
@@ -697,33 +650,29 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
     }
     return this._context;
   }
-  clearContext(nameOrUndefined) {
-    return __async(this, null, function* () {
-      const clientName = 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);
-        }
+  async clearContext(nameOrUndefined) {
+    const clientName = 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();
+        await this.runProviderContextChangeHandler(clientName, provider, oldContext, newContext);
       } else {
-        return this.setContext({});
+        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)));
-    });
+  async clearContexts() {
+    await this.clearContext();
+    await Promise.allSettled(Array.from(this._clientProviders.keys()).map((name) => this.clearContext(name)));
   }
   /**
    * A factory function for creating new named OpenFeature clients. Clients can contain
@@ -750,32 +699,27 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
    * 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._namedProviderContext.clear();
-    });
+  async clearProviders() {
+    await super.clearProvidersAndSetDefault(NOOP_PROVIDER);
+    this._namedProviderContext.clear();
   }
-  runProviderContextChangeHandler(clientName, provider, oldContext, newContext) {
-    return __async(this, null, function* () {
-      var _a, _b, _c, _d, _e;
-      const providerName = provider.metadata.name;
-      try {
-        yield (_a = provider.onContextChange) == null ? void 0 : _a.call(provider, oldContext, newContext);
-        this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
-          emitter == null ? void 0 : emitter.emit(ClientProviderEvents.ContextChanged, { clientName, providerName });
-        });
-        (_b = this._events) == null ? void 0 : _b.emit(ClientProviderEvents.ContextChanged, { clientName, providerName });
-      } catch (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(ClientProviderEvents.Error, { clientName, providerName, message });
-        });
-        (_e = this._events) == null ? void 0 : _e.emit(ClientProviderEvents.Error, { clientName, providerName, message });
-      }
-    });
+  async runProviderContextChangeHandler(clientName, provider, oldContext, newContext) {
+    const providerName = provider.metadata.name;
+    try {
+      await provider.onContextChange?.(oldContext, newContext);
+      this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+        emitter?.emit(ClientProviderEvents.ContextChanged, { clientName, providerName });
+      });
+      this._events?.emit(ClientProviderEvents.ContextChanged, { clientName, providerName });
+    } catch (err) {
+      const error = err;
+      const message = `Error running ${provider?.metadata?.name}'s context change handler: ${error?.message}`;
+      this._logger?.error(`${message}`, err);
+      this.getAssociatedEventEmitters(clientName).forEach((emitter) => {
+        emitter?.emit(ClientProviderEvents.Error, { clientName, providerName, message });
+      });
+      this._events?.emit(ClientProviderEvents.Error, { clientName, providerName, message });
+    }
   }
 };
 var OpenFeature = OpenFeatureAPI.getInstance();
@@ -787,8 +731,9 @@ var OpenFeatureClient = class {
     this.emitterAccessor = emitterAccessor;
     this.globalLogger = globalLogger;
     this.options = options;
-    this._hooks = [];
   }
+  _hooks = [];
+  _clientLogger;
   get metadata() {
     return {
       name: this.options.name,
@@ -797,18 +742,16 @@ var OpenFeatureClient = class {
     };
   }
   get providerStatus() {
-    var _a;
-    return ((_a = this.providerAccessor()) == null ? void 0 : _a.status) || ProviderStatus3.READY;
+    return this.providerAccessor()?.status || ProviderStatus3.READY;
   }
   addHandler(eventType, handler) {
-    var _a;
     this.emitterAccessor().addHandler(eventType, handler);
     const shouldRunNow = statusMatchesEvent(eventType, this._provider.status);
     if (shouldRunNow) {
       try {
         handler({ clientName: this.metadata.name, providerName: this._provider.metadata.name });
       } catch (err) {
-        (_a = this._logger) == null ? void 0 : _a.error("Error running event handler:", err);
+        this._logger?.error("Error running event handler:", err);
       }
     }
   }
@@ -872,7 +815,6 @@ 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(),
@@ -880,7 +822,9 @@ var OpenFeatureClient = class {
       ...this._provider.hooks || []
     ];
     const allHooksReversed = [...allHooks].reverse();
-    const context = __spreadValues({}, OpenFeature.getContext((_a = this == null ? void 0 : this.options) == null ? void 0 : _a.name));
+    const context = {
+      ...OpenFeature.getContext(this?.options?.name)
+    };
     const hookContext = {
       flagKey,
       defaultValue,
@@ -893,15 +837,16 @@ var OpenFeatureClient = class {
     try {
       this.beforeHooks(allHooks, hookContext, options);
       const resolution = resolver.call(this._provider, flagKey, defaultValue, context, this._logger);
-      const evaluationDetails = __spreadProps(__spreadValues({}, resolution), {
-        flagMetadata: Object.freeze((_b = resolution.flagMetadata) != null ? _b : {}),
+      const evaluationDetails = {
+        ...resolution,
+        flagMetadata: Object.freeze(resolution.flagMetadata ?? {}),
         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) || ErrorCode2.GENERAL;
+      const errorMessage = err?.message;
+      const errorCode = err?.code || ErrorCode2.GENERAL;
       this.errorHooks(allHooksReversed, hookContext, err, options);
       return {
         errorCode,
@@ -916,44 +861,40 @@ var OpenFeatureClient = class {
     }
   }
   beforeHooks(hooks, hookContext, options) {
-    var _a;
     Object.freeze(hookContext);
     Object.freeze(hookContext.context);
     for (const hook of hooks) {
-      (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(options.hookHints));
+      hook?.before?.(hookContext, Object.freeze(options.hookHints));
     }
   }
   afterHooks(hooks, hookContext, evaluationDetails, options) {
-    var _a;
     for (const hook of hooks) {
-      (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, options.hookHints);
+      hook?.after?.(hookContext, evaluationDetails, options.hookHints);
     }
   }
   errorHooks(hooks, hookContext, err, options) {
-    var _a;
     for (const hook of hooks) {
       try {
-        (_a = hook == null ? void 0 : hook.error) == null ? void 0 : _a.call(hook, hookContext, err, options.hookHints);
+        hook?.error?.(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 == null ? void 0 : err2.stack);
+        this._logger.error(err2?.stack);
       }
     }
   }
   finallyHooks(hooks, hookContext, options) {
-    var _a;
     for (const hook of hooks) {
       try {
-        (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, hookContext, options.hookHints);
+        hook?.finally?.(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 == null ? void 0 : err.stack);
+        this._logger.error(err?.stack);
       }
     }
   }