@openfeature/web-sdk 1.6.1 → 1.7.0

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseHook, HookHints, EvaluationDetails, JsonValue, FlagValue, CommonProvider, ClientProviderStatus, EvaluationContext, Logger, ResolutionDetails, ClientProviderEvents, GenericEventEmitter, TrackingEventDetails, EvaluationLifeCycle, ManageLogger, Eventing, ClientMetadata, OpenFeatureCommonAPI, ManageContext, ProviderWrapper } from '@openfeature/core';
+import { BaseHook, HookHints, EvaluationDetails, JsonValue, FlagValue, CommonProvider, ClientProviderStatus, EvaluationContext, Logger, ResolutionDetails, ClientProviderEvents, GenericEventEmitter, FlagValueType, TrackingEventDetails, ErrorCode, ProviderMetadata, OpenFeatureError, GeneralError, EvaluationLifeCycle, ManageLogger, Eventing, ClientMetadata, OpenFeatureCommonAPI, ManageContext, ProviderWrapper } from '@openfeature/core';
 export * from '@openfeature/core';
 export { ClientProviderEvents as ProviderEvents, ClientProviderStatus as ProviderStatus } from '@openfeature/core';
 
@@ -357,6 +357,148 @@ declare class InMemoryProvider implements Provider {
     private lookupFlagValue;
 }
 
+type StrategyEvaluationContext = {
+    flagKey: string;
+    flagType: FlagValueType;
+};
+type StrategyProviderContext = {
+    provider: Provider;
+    providerName: string;
+    providerStatus: ClientProviderStatus;
+};
+type StrategyPerProviderContext = StrategyEvaluationContext & StrategyProviderContext;
+type ProviderResolutionResultBase = {
+    provider: Provider;
+    providerName: string;
+};
+type ProviderResolutionSuccessResult<T extends FlagValue> = ProviderResolutionResultBase & {
+    details: ResolutionDetails<T>;
+};
+type ProviderResolutionErrorResult = ProviderResolutionResultBase & {
+    thrownError: unknown;
+};
+type ProviderResolutionResult<T extends FlagValue> = ProviderResolutionSuccessResult<T> | ProviderResolutionErrorResult;
+type FinalResult<T extends FlagValue> = {
+    details?: ResolutionDetails<T>;
+    provider?: Provider;
+    providerName?: string;
+    errors?: {
+        providerName: string;
+        error: unknown;
+    }[];
+};
+/**
+ * Base strategy to inherit from. Not directly usable, as strategies must implement the "determineResult" method
+ * Contains default implementations for `shouldEvaluateThisProvider` and `shouldEvaluateNextProvider`
+ */
+declare abstract class BaseEvaluationStrategy {
+    shouldEvaluateThisProvider(strategyContext: StrategyPerProviderContext, _evalContext: EvaluationContext): boolean;
+    shouldEvaluateNextProvider<T extends FlagValue>(_strategyContext: StrategyPerProviderContext, _context: EvaluationContext, _result: ProviderResolutionResult<T>): boolean;
+    shouldTrackWithThisProvider(strategyContext: StrategyProviderContext, _context: EvaluationContext, _trackingEventName: string, _trackingEventDetails: TrackingEventDetails): boolean;
+    abstract determineFinalResult<T extends FlagValue>(strategyContext: StrategyEvaluationContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
+    protected hasError(resolution: ProviderResolutionResult<FlagValue>): resolution is ProviderResolutionErrorResult | (ProviderResolutionSuccessResult<FlagValue> & {
+        details: ResolutionDetails<FlagValue> & {
+            errorCode: ErrorCode;
+        };
+    });
+    protected hasErrorWithCode(resolution: ProviderResolutionResult<FlagValue>, code: ErrorCode): boolean;
+    protected collectProviderErrors<T extends FlagValue>(resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
+    protected resolutionToFinalResult<T extends FlagValue>(resolution: ProviderResolutionSuccessResult<T>): {
+        details: ResolutionDetails<T>;
+        provider: Provider;
+        providerName: string;
+    };
+}
+
+/**
+ * Return the first result that did not indicate "flag not found".
+ * If any provider in the course of evaluation returns or throws an error, throw that error
+ */
+declare class FirstMatchStrategy extends BaseEvaluationStrategy {
+    shouldEvaluateNextProvider<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, result: ProviderResolutionResult<T>): boolean;
+    determineFinalResult<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
+}
+
+/**
+ * Return the first result that did NOT result in an error
+ * If any provider in the course of evaluation returns or throws an error, ignore it as long as there is a successful result
+ * If there is no successful result, throw all errors
+ */
+declare class FirstSuccessfulStrategy extends BaseEvaluationStrategy {
+    shouldEvaluateNextProvider<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, result: ProviderResolutionResult<T>): boolean;
+    determineFinalResult<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
+}
+
+/**
+ * Evaluate all providers and compare the results.
+ * If the values agree, return the value
+ * If the values disagree, return the value from the configured "fallback provider" and execute the "onMismatch"
+ * callback if defined
+ */
+declare class ComparisonStrategy extends BaseEvaluationStrategy {
+    private fallbackProvider;
+    private onMismatch?;
+    constructor(fallbackProvider: Provider, onMismatch?: ((resolutions: ProviderResolutionResult<FlagValue>[]) => void) | undefined);
+    determineFinalResult<T extends FlagValue>(strategyContext: StrategyPerProviderContext, context: EvaluationContext, resolutions: ProviderResolutionResult<T>[]): FinalResult<T>;
+}
+
+type ProviderEntryInput = {
+    provider: Provider;
+    name?: string;
+};
+type RegisteredProvider = Required<ProviderEntryInput>;
+
+declare class MultiProvider implements Provider {
+    readonly constructorProviders: ProviderEntryInput[];
+    private readonly evaluationStrategy;
+    private readonly logger;
+    readonly runsOn = "client";
+    readonly events: OpenFeatureEventEmitter;
+    private hookContexts;
+    private hookHints;
+    metadata: ProviderMetadata;
+    providerEntries: RegisteredProvider[];
+    private providerEntriesByName;
+    private hookExecutor;
+    private statusTracker;
+    constructor(constructorProviders: ProviderEntryInput[], evaluationStrategy?: BaseEvaluationStrategy, logger?: Logger);
+    private registerProviders;
+    initialize(context?: EvaluationContext): Promise<void>;
+    onClose(): Promise<void>;
+    onContextChange(oldContext: EvaluationContext, newContext: EvaluationContext): Promise<void>;
+    resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext): ResolutionDetails<boolean>;
+    resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext): ResolutionDetails<string>;
+    resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext): ResolutionDetails<number>;
+    resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): ResolutionDetails<T>;
+    track(trackingEventName: string, context: EvaluationContext, trackingEventDetails: TrackingEventDetails): void;
+    private flagResolutionProxy;
+    private evaluateProviderEntry;
+    private evaluateProviderAndHooks;
+    private callProviderResolve;
+    get hooks(): Hook[];
+    private getErrorEvaluationDetails;
+}
+
+declare class ErrorWithCode extends OpenFeatureError {
+    code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+}
+declare class AggregateError extends GeneralError {
+    originalErrors: {
+        source: string;
+        error: unknown;
+    }[];
+    constructor(message: string, originalErrors: {
+        source: string;
+        error: unknown;
+    }[]);
+}
+declare const constructAggregateError: (providerErrors: {
+    error: unknown;
+    providerName: string;
+}[]) => AggregateError;
+declare const throwAggregateErrorFromPromiseResults: (result: PromiseSettledResult<unknown>[], providerEntries: RegisteredProvider[]) => void;
+
 interface Tracking {
     /**
      * Track a user action or application state, usually representing a business objective or outcome.
@@ -549,5 +691,5 @@ declare class OpenFeatureAPI extends OpenFeatureCommonAPI<ClientProviderStatus,
  */
 declare const OpenFeature: OpenFeatureAPI;
 
-export { InMemoryProvider, NOOP_PROVIDER, OpenFeature, OpenFeatureAPI, OpenFeatureEventEmitter };
-export type { Client, Features, FlagEvaluationOptions, Hook, Provider, ProviderEmittableEvents, Tracking };
+export { AggregateError, BaseEvaluationStrategy, ComparisonStrategy, ErrorWithCode, FirstMatchStrategy, FirstSuccessfulStrategy, InMemoryProvider, MultiProvider, NOOP_PROVIDER, OpenFeature, OpenFeatureAPI, OpenFeatureEventEmitter, constructAggregateError, throwAggregateErrorFromPromiseResults };
+export type { Client, Features, FinalResult, FlagEvaluationOptions, Hook, Provider, ProviderEmittableEvents, ProviderResolutionErrorResult, ProviderResolutionResult, ProviderResolutionSuccessResult, StrategyEvaluationContext, StrategyPerProviderContext, StrategyProviderContext, Tracking };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfeature/web-sdk",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "OpenFeature SDK for Web",
   "main": "./dist/cjs/index.js",
   "unpkg": "dist/global/index.min.js",