@openfeature/web-sdk 1.0.2 → 1.1.0

package/dist/esm/index.js

@@ -206,41 +206,6 @@ var require_eventemitter3 = __commonJS({
   }
 });
 
-// src/client/open-feature-client.ts
-import {
-  ErrorCode as ErrorCode2,
-  ProviderFatalError,
-  ProviderNotReadyError,
-  SafeLogger,
-  StandardResolutionReasons as StandardResolutionReasons2,
-  statusMatchesEvent
-} from "@openfeature/core";
-
-// src/open-feature.ts
-import {
-  OpenFeatureCommonAPI,
-  ProviderWrapper,
-  objectOrUndefined,
-  stringOrUndefined
-} from "@openfeature/core";
-
-// src/events/open-feature-event-emitter.ts
-import { GenericEventEmitter } from "@openfeature/core";
-
-// ../../node_modules/eventemitter3/index.mjs
-var import_index = __toESM(require_eventemitter3(), 1);
-
-// src/events/open-feature-event-emitter.ts
-var OpenFeatureEventEmitter = class extends GenericEventEmitter {
-  eventEmitter = new import_index.default();
-  constructor() {
-    super();
-  }
-};
-
-// src/events/events.ts
-import { ClientProviderEvents } from "@openfeature/core";
-
 // src/provider/provider.ts
 import { ClientProviderStatus } from "@openfeature/core";
 
@@ -280,6 +245,23 @@ import {
   TypeMismatchError
 } from "@openfeature/core";
 
+// src/events/open-feature-event-emitter.ts
+import { GenericEventEmitter } from "@openfeature/core";
+
+// ../../node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+
+// src/events/open-feature-event-emitter.ts
+var OpenFeatureEventEmitter = class extends GenericEventEmitter {
+  eventEmitter = new import_index.default();
+  constructor() {
+    super();
+  }
+};
+
+// src/events/events.ts
+import { ClientProviderEvents } from "@openfeature/core";
+
 // src/provider/in-memory-provider/variant-not-found-error.ts
 import { ErrorCode, OpenFeatureError } from "@openfeature/core";
 var VariantNotFoundError = class _VariantNotFoundError extends OpenFeatureError {
@@ -387,172 +369,23 @@ var InMemoryProvider = class {
 };
 
 // src/open-feature.ts
-var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/web-sdk/api");
-var _globalThis = globalThis;
-var OpenFeatureAPI = class _OpenFeatureAPI extends OpenFeatureCommonAPI {
-  _statusEnumType = ClientProviderStatus;
-  _apiEmitter = new OpenFeatureEventEmitter();
-  _defaultProvider = new ProviderWrapper(NOOP_PROVIDER, ClientProviderStatus.NOT_READY, this._statusEnumType);
-  _domainScopedProviders = /* @__PURE__ */ new Map();
-  _createEventEmitter = () => new OpenFeatureEventEmitter();
-  constructor() {
-    super("client");
-  }
-  /**
-   * Gets a singleton instance of the OpenFeature API.
-   * @ignore
-   * @returns {OpenFeatureAPI} OpenFeature API
-   */
-  static getInstance() {
-    const globalApi = _globalThis[GLOBAL_OPENFEATURE_API_KEY];
-    if (globalApi) {
-      return globalApi;
-    }
-    const instance = new _OpenFeatureAPI();
-    _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
-    return instance;
-  }
-  getProviderStatus(domain) {
-    if (!domain) {
-      return this._defaultProvider.status;
-    }
-    return this._domainScopedProviders.get(domain)?.status ?? this._defaultProvider.status;
-  }
-  async setContext(domainOrContext, contextOrUndefined) {
-    const domain = stringOrUndefined(domainOrContext);
-    const context = objectOrUndefined(domainOrContext) ?? objectOrUndefined(contextOrUndefined) ?? {};
-    if (domain) {
-      const wrapper = this._domainScopedProviders.get(domain);
-      if (wrapper) {
-        const oldContext = this.getContext(domain);
-        this._domainScopedContext.set(domain, context);
-        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, context);
-      } else {
-        this._domainScopedContext.set(domain, context);
-      }
-    } else {
-      const oldContext = this._context;
-      this._context = context;
-      const unboundProviders = Array.from(this._domainScopedProviders.entries()).filter(([domain2]) => !this._domainScopedContext.has(domain2)).reduce((acc, [domain2, wrapper]) => {
-        acc.push({ domain: domain2, wrapper });
-        return acc;
-      }, []);
-      const allDomainRecords = [
-        // add in the default (no domain)
-        { domain: void 0, wrapper: this._defaultProvider },
-        ...unboundProviders
-      ];
-      await Promise.all(
-        allDomainRecords.map(
-          (dm) => this.runProviderContextChangeHandler(dm.domain, dm.wrapper, oldContext, context)
-        )
-      );
-    }
-  }
-  getContext(domainOrUndefined) {
-    const domain = stringOrUndefined(domainOrUndefined);
-    if (domain) {
-      const context = this._domainScopedContext.get(domain);
-      if (context) {
-        return context;
-      } else {
-        this._logger.debug(`Unable to find context for '${domain}'.`);
-      }
-    }
-    return this._context;
-  }
-  async clearContext(domainOrUndefined) {
-    const domain = stringOrUndefined(domainOrUndefined);
-    if (domain) {
-      const wrapper = this._domainScopedProviders.get(domain);
-      if (wrapper) {
-        const oldContext = this.getContext(domain);
-        this._domainScopedContext.delete(domain);
-        const newContext = this.getContext();
-        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, newContext);
-      } else {
-        this._domainScopedContext.delete(domain);
-      }
-    } else {
-      return this.setContext({});
-    }
-  }
-  /**
-   * Resets the global evaluation context and removes the evaluation context for
-   * all domains.
-   */
-  async clearContexts() {
-    await this.clearContext();
-    await Promise.allSettled(Array.from(this._domainScopedProviders.keys()).map((domain) => this.clearContext(domain)));
-  }
-  /**
-   * 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} domain An identifier which logically binds clients with providers
-   * @param {string} version The version of the client (only used for metadata)
-   * @returns {Client} OpenFeature Client
-   */
-  getClient(domain, 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.getProviderForClient(domain),
-      () => this.getProviderStatus(domain),
-      () => this.buildAndCacheEventEmitterForClient(domain),
-      () => this._logger,
-      { domain, version }
-    );
-  }
-  /**
-   * Clears all registered providers and resets the default provider.
-   * @returns {Promise<void>}
-   */
-  async clearProviders() {
-    await super.clearProvidersAndSetDefault(NOOP_PROVIDER);
-    this._domainScopedContext.clear();
-  }
-  async runProviderContextChangeHandler(domain, wrapper, oldContext, newContext) {
-    const providerName = wrapper.provider?.metadata?.name || "unnamed-provider";
-    try {
-      if (typeof wrapper.provider.onContextChange === "function") {
-        wrapper.incrementPendingContextChanges();
-        wrapper.status = this._statusEnumType.RECONCILING;
-        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
-          emitter?.emit(ClientProviderEvents.Reconciling, { domain, providerName });
-        });
-        this._apiEmitter?.emit(ClientProviderEvents.Reconciling, { domain, providerName });
-        await wrapper.provider.onContextChange(oldContext, newContext);
-        wrapper.decrementPendingContextChanges();
-      }
-      wrapper.status = this._statusEnumType.READY;
-      if (wrapper.allContextChangesSettled) {
-        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
-          emitter?.emit(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
-        });
-        this._apiEmitter?.emit(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
-      }
-    } catch (err) {
-      wrapper.decrementPendingContextChanges();
-      wrapper.status = this._statusEnumType.ERROR;
-      if (wrapper.allContextChangesSettled) {
-        const error = err;
-        const message = `Error running ${providerName}'s context change handler: ${error?.message}`;
-        this._logger?.error(`${message}`, err);
-        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
-          emitter?.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
-        });
-        this._apiEmitter?.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
-      }
-    }
-  }
-};
-var OpenFeature = OpenFeatureAPI.getInstance();
+import {
+  OpenFeatureCommonAPI,
+  ProviderWrapper,
+  objectOrUndefined,
+  stringOrUndefined
+} from "@openfeature/core";
 
-// src/client/open-feature-client.ts
+// src/client/internal/open-feature-client.ts
+import {
+  ErrorCode as ErrorCode2,
+  ProviderFatalError,
+  ProviderNotReadyError,
+  SafeLogger,
+  StandardResolutionReasons as StandardResolutionReasons2,
+  instantiateErrorByErrorCode,
+  statusMatchesEvent
+} from "@openfeature/core";
 var OpenFeatureClient = class {
   constructor(providerAccessor, providerStatusAccessor, emitterAccessor, globalLogger, options) {
     this.providerAccessor = providerAccessor;
@@ -682,6 +515,9 @@ var OpenFeatureClient = class {
         flagMetadata: Object.freeze(resolution.flagMetadata ?? {}),
         flagKey
       };
+      if (evaluationDetails.errorCode) {
+        throw instantiateErrorByErrorCode(evaluationDetails.errorCode);
+      }
       this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
       return evaluationDetails;
     } catch (err) {
@@ -746,6 +582,207 @@ 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 OpenFeatureCommonAPI {
+  _statusEnumType = ClientProviderStatus;
+  _apiEmitter = new OpenFeatureEventEmitter();
+  _defaultProvider = new ProviderWrapper(
+    NOOP_PROVIDER,
+    ClientProviderStatus.NOT_READY,
+    this._statusEnumType
+  );
+  _domainScopedProviders = /* @__PURE__ */ new Map();
+  _createEventEmitter = () => new OpenFeatureEventEmitter();
+  constructor() {
+    super("client");
+  }
+  /**
+   * Gets a singleton instance of the OpenFeature API.
+   * @ignore
+   * @returns {OpenFeatureAPI} OpenFeature API
+   */
+  static getInstance() {
+    const globalApi = _globalThis[GLOBAL_OPENFEATURE_API_KEY];
+    if (globalApi) {
+      return globalApi;
+    }
+    const instance = new _OpenFeatureAPI();
+    _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
+    return instance;
+  }
+  getProviderStatus(domain) {
+    if (!domain) {
+      return this._defaultProvider.status;
+    }
+    return this._domainScopedProviders.get(domain)?.status ?? this._defaultProvider.status;
+  }
+  async setProviderAndWait(clientOrProvider, providerContextOrUndefined, contextOrUndefined) {
+    const domain = stringOrUndefined(clientOrProvider);
+    const provider = domain ? objectOrUndefined(providerContextOrUndefined) : objectOrUndefined(clientOrProvider);
+    const context = domain ? objectOrUndefined(contextOrUndefined) : objectOrUndefined(providerContextOrUndefined);
+    if (context) {
+      if (domain) {
+        this._domainScopedContext.set(domain, context);
+      } else {
+        this._context = context;
+      }
+    }
+    await this.setAwaitableProvider(domain, provider);
+  }
+  setProvider(domainOrProvider, providerContextOrUndefined, contextOrUndefined) {
+    const domain = stringOrUndefined(domainOrProvider);
+    const provider = domain ? objectOrUndefined(providerContextOrUndefined) : objectOrUndefined(domainOrProvider);
+    const context = domain ? objectOrUndefined(contextOrUndefined) : objectOrUndefined(providerContextOrUndefined);
+    if (context) {
+      if (domain) {
+        this._domainScopedContext.set(domain, context);
+      } else {
+        this._context = context;
+      }
+    }
+    const maybePromise = this.setAwaitableProvider(domain, provider);
+    Promise.resolve(maybePromise).catch((err) => {
+      this._logger.error("Error during provider initialization:", err);
+    });
+    return this;
+  }
+  async setContext(domainOrContext, contextOrUndefined) {
+    const domain = stringOrUndefined(domainOrContext);
+    const context = objectOrUndefined(domainOrContext) ?? objectOrUndefined(contextOrUndefined) ?? {};
+    if (domain) {
+      const wrapper = this._domainScopedProviders.get(domain);
+      if (wrapper) {
+        const oldContext = this.getContext(domain);
+        this._domainScopedContext.set(domain, context);
+        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, context);
+      } else {
+        this._domainScopedContext.set(domain, context);
+      }
+    } else {
+      const oldContext = this._context;
+      this._context = context;
+      const unboundProviders = Array.from(this._domainScopedProviders.entries()).filter(([domain2]) => !this._domainScopedContext.has(domain2)).reduce((acc, [domain2, wrapper]) => {
+        acc.push({ domain: domain2, wrapper });
+        return acc;
+      }, []);
+      const allDomainRecords = [
+        // add in the default (no domain)
+        { domain: void 0, wrapper: this._defaultProvider },
+        ...unboundProviders
+      ];
+      await Promise.all(
+        allDomainRecords.map((dm) => this.runProviderContextChangeHandler(dm.domain, dm.wrapper, oldContext, context))
+      );
+    }
+  }
+  getContext(domainOrUndefined) {
+    const domain = stringOrUndefined(domainOrUndefined);
+    if (domain) {
+      const context = this._domainScopedContext.get(domain);
+      if (context) {
+        return context;
+      } else {
+        this._logger.debug(`Unable to find context for '${domain}'.`);
+      }
+    }
+    return this._context;
+  }
+  async clearContext(domainOrUndefined) {
+    const domain = stringOrUndefined(domainOrUndefined);
+    if (domain) {
+      const wrapper = this._domainScopedProviders.get(domain);
+      if (wrapper) {
+        const oldContext = this.getContext(domain);
+        this._domainScopedContext.delete(domain);
+        const newContext = this.getContext();
+        await this.runProviderContextChangeHandler(domain, wrapper, oldContext, newContext);
+      } else {
+        this._domainScopedContext.delete(domain);
+      }
+    } else {
+      return this.setContext({});
+    }
+  }
+  /**
+   * Resets the global evaluation context and removes the evaluation context for
+   * all domains.
+   */
+  async clearContexts() {
+    await this.clearContext();
+    await Promise.allSettled(Array.from(this._domainScopedProviders.keys()).map((domain) => this.clearContext(domain)));
+  }
+  /**
+   * 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} domain An identifier which logically binds clients with providers
+   * @param {string} version The version of the client (only used for metadata)
+   * @returns {Client} OpenFeature Client
+   */
+  getClient(domain, 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.getProviderForClient(domain),
+      () => this.getProviderStatus(domain),
+      () => this.buildAndCacheEventEmitterForClient(domain),
+      () => this._logger,
+      { domain, version }
+    );
+  }
+  /**
+   * Clears all registered providers and resets the default provider.
+   * @returns {Promise<void>}
+   */
+  async clearProviders() {
+    await super.clearProvidersAndSetDefault(NOOP_PROVIDER);
+    this._domainScopedContext.clear();
+  }
+  async runProviderContextChangeHandler(domain, wrapper, oldContext, newContext) {
+    const providerName = wrapper.provider?.metadata?.name || "unnamed-provider";
+    try {
+      if (typeof wrapper.provider.onContextChange === "function") {
+        const maybePromise = wrapper.provider.onContextChange(oldContext, newContext);
+        if (typeof maybePromise?.then === "function") {
+          wrapper.incrementPendingContextChanges();
+          wrapper.status = this._statusEnumType.RECONCILING;
+          this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+            emitter?.emit(ClientProviderEvents.Reconciling, { domain, providerName });
+          });
+          this._apiEmitter?.emit(ClientProviderEvents.Reconciling, { domain, providerName });
+          await maybePromise;
+          wrapper.decrementPendingContextChanges();
+        }
+      }
+      wrapper.status = this._statusEnumType.READY;
+      if (wrapper.allContextChangesSettled) {
+        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+          emitter?.emit(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
+        });
+        this._apiEmitter?.emit(ClientProviderEvents.ContextChanged, { clientName: domain, domain, providerName });
+      }
+    } catch (err) {
+      wrapper.decrementPendingContextChanges();
+      wrapper.status = this._statusEnumType.ERROR;
+      if (wrapper.allContextChangesSettled) {
+        const error = err;
+        const message = `Error running ${providerName}'s context change handler: ${error?.message}`;
+        this._logger?.error(`${message}`, err);
+        this.getAssociatedEventEmitters(domain).forEach((emitter) => {
+          emitter?.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+        });
+        this._apiEmitter?.emit(ClientProviderEvents.Error, { clientName: domain, domain, providerName, message });
+      }
+    }
+  }
+};
+var OpenFeature = OpenFeatureAPI.getInstance();
+
 // src/index.ts
 export * from "@openfeature/core";
 export {
@@ -753,7 +790,6 @@ export {
   NOOP_PROVIDER,
   OpenFeature,
   OpenFeatureAPI,
-  OpenFeatureClient,
   OpenFeatureEventEmitter,
   ClientProviderEvents as ProviderEvents,
   ClientProviderStatus as ProviderStatus