@mergedapp/feature-flags 0.1.3

package/dist/nestjs.d.ts

@@ -0,0 +1,10 @@
+export { createTypedNestjsBindings, } from "./nestjs/bindings.js";
+export { FeatureFlagContext, FeatureFlagGate, RequireFeatureFlag, } from "./nestjs/decorators.js";
+export { FeatureFlagsRequestContextStore, resolveFeatureFlagContext } from "./nestjs/context.js";
+export { FeatureFlagDisabledHttpException, FeatureFlagGateError } from "./nestjs/errors.js";
+export { NativeNestFeatureFlagsEvaluator, type FeatureFlagsEvaluationRequest, type NestFeatureFlagsEvaluator, } from "./nestjs/evaluator.js";
+export { FeatureFlagGuard, evaluateGate, type RequireFeatureFlagMetadata } from "./nestjs/guard.js";
+export { FeatureFlagContextInterceptor } from "./nestjs/interceptor.js";
+export { FeatureFlagsModule, } from "./nestjs/module.js";
+export { FeatureFlagsService } from "./nestjs/service.js";
+export type { BooleanFlagKey, ComparableFlagKey, FeatureFlagContextFactory, FeatureFlagEvaluationDetails, FeatureFlagEvaluationMetadata, FeatureFlagEvaluationReason, FlagKey, NativeFeatureFlagsModuleAsyncOptions, NativeFeatureFlagsModuleOptions, NonBooleanComparableFlagKey, ObjectFlagKey, RawFeatureFlagGateOptions, RawRequireFeatureFlagOptions, ScalarFlagKey, StringFlagKey, NumberFlagKey, TypedFeatureFlagGateOptions, TypedFeatureFlagsModuleAsyncOptions, TypedFeatureFlagsModuleFacade, TypedFeatureFlagsModuleOptions, TypedNestjsBindings, TypedRequireFeatureFlagOptions, } from "./nestjs/types.js";

package/dist/nestjs.js

@@ -0,0 +1,9 @@
+export { createTypedNestjsBindings, } from "./nestjs/bindings.js";
+export { FeatureFlagContext, FeatureFlagGate, RequireFeatureFlag, } from "./nestjs/decorators.js";
+export { FeatureFlagsRequestContextStore, resolveFeatureFlagContext } from "./nestjs/context.js";
+export { FeatureFlagDisabledHttpException, FeatureFlagGateError } from "./nestjs/errors.js";
+export { NativeNestFeatureFlagsEvaluator, } from "./nestjs/evaluator.js";
+export { FeatureFlagGuard, evaluateGate } from "./nestjs/guard.js";
+export { FeatureFlagContextInterceptor } from "./nestjs/interceptor.js";
+export { FeatureFlagsModule, } from "./nestjs/module.js";
+export { FeatureFlagsService } from "./nestjs/service.js";

package/dist/openfeature/context.d.ts

@@ -0,0 +1,10 @@
+import type { EvaluationContext, EvaluationContextValue } from "@openfeature/core";
+import type { FeatureFlagEvaluationContext, FeatureFlagEvaluationContextValue } from "@repo/types-v2";
+export type OpenFeatureContextMapper = (context: EvaluationContext) => FeatureFlagEvaluationContext | null;
+export type MergeableFeatureFlagContext = FeatureFlagEvaluationContext | null | undefined;
+export declare const DEFAULT_TARGETING_KEY_ATTRIBUTE = "subject.key";
+export declare function mapOpenFeatureContextValue(value: EvaluationContextValue, visited?: WeakSet<object>): FeatureFlagEvaluationContextValue;
+export declare function createDefaultOpenFeatureContextMapper(params?: {
+    targetingKeyAttribute?: string;
+}): OpenFeatureContextMapper;
+export declare function mergeFeatureFlagEvaluationContexts(...contexts: MergeableFeatureFlagContext[]): FeatureFlagEvaluationContext | null;

package/dist/openfeature/context.js

@@ -0,0 +1,160 @@
+export const DEFAULT_TARGETING_KEY_ATTRIBUTE = "subject.key";
+const UNSAFE_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const CYCLIC_CONTEXT_ERROR_MESSAGE = "Cyclic feature flag evaluation context is not allowed.";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isSafeObjectKey(key) {
+    return !UNSAFE_OBJECT_KEYS.has(key);
+}
+function createAttributeRecord() {
+    return Object.create(null);
+}
+function beginTraversal(value, visited) {
+    if (visited.has(value)) {
+        throw new TypeError(CYCLIC_CONTEXT_ERROR_MESSAGE);
+    }
+    visited.add(value);
+}
+function assertAcyclicFeatureFlagContextValue(value, visited = new WeakSet()) {
+    if (Array.isArray(value)) {
+        beginTraversal(value, visited);
+        try {
+            for (const entry of value) {
+                assertAcyclicFeatureFlagContextValue(entry, visited);
+            }
+        }
+        finally {
+            visited.delete(value);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    beginTraversal(value, visited);
+    try {
+        for (const [key, entry] of Object.entries(value)) {
+            if (!isSafeObjectKey(key)) {
+                continue;
+            }
+            assertAcyclicFeatureFlagContextValue(entry, visited);
+        }
+    }
+    finally {
+        visited.delete(value);
+    }
+}
+function setNestedAttribute(target, path, value) {
+    const segments = path.split(".").filter(Boolean);
+    const head = segments[0];
+    if (!head || !isSafeObjectKey(head)) {
+        return;
+    }
+    const tail = segments.slice(1);
+    if (tail.length === 0) {
+        target[head] = value;
+        return;
+    }
+    const nextTarget = isRecord(target[head]) ? target[head] : createAttributeRecord();
+    target[head] = nextTarget;
+    setNestedAttribute(nextTarget, tail.join("."), value);
+}
+function mergeAttributeValue(left, right, visited = new WeakSet()) {
+    if (isRecord(left) && isRecord(right)) {
+        beginTraversal(left, visited);
+        if (right !== left) {
+            beginTraversal(right, visited);
+        }
+        const merged = createAttributeRecord();
+        try {
+            for (const [key, value] of Object.entries(left)) {
+                if (!isSafeObjectKey(key)) {
+                    continue;
+                }
+                merged[key] = value;
+            }
+            for (const [key, value] of Object.entries(right)) {
+                if (!isSafeObjectKey(key)) {
+                    continue;
+                }
+                merged[key] = typeof merged[key] === "undefined" ? value : mergeAttributeValue(merged[key], value, visited);
+            }
+        }
+        finally {
+            visited.delete(left);
+            if (right !== left) {
+                visited.delete(right);
+            }
+        }
+        return merged;
+    }
+    return right;
+}
+export function mapOpenFeatureContextValue(value, visited = new WeakSet()) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        beginTraversal(value, visited);
+        try {
+            return value.map((entry) => mapOpenFeatureContextValue(entry, visited));
+        }
+        finally {
+            visited.delete(value);
+        }
+    }
+    if (value && typeof value === "object") {
+        beginTraversal(value, visited);
+        const mapped = createAttributeRecord();
+        try {
+            for (const [key, entry] of Object.entries(value)) {
+                if (!isSafeObjectKey(key)) {
+                    continue;
+                }
+                mapped[key] = mapOpenFeatureContextValue(entry, visited);
+            }
+        }
+        finally {
+            visited.delete(value);
+        }
+        return mapped;
+    }
+    return value;
+}
+export function createDefaultOpenFeatureContextMapper(params) {
+    const targetingKeyAttribute = params?.targetingKeyAttribute ?? DEFAULT_TARGETING_KEY_ATTRIBUTE;
+    return (context) => {
+        const attributes = createAttributeRecord();
+        if (context.targetingKey) {
+            setNestedAttribute(attributes, targetingKeyAttribute, context.targetingKey);
+        }
+        for (const [key, value] of Object.entries(context)) {
+            if (key === "targetingKey" || typeof value === "undefined") {
+                continue;
+            }
+            if (!isSafeObjectKey(key)) {
+                continue;
+            }
+            attributes[key] = mapOpenFeatureContextValue(value);
+        }
+        return Object.keys(attributes).length > 0 ? { attributes } : null;
+    };
+}
+export function mergeFeatureFlagEvaluationContexts(...contexts) {
+    const mergedAttributes = createAttributeRecord();
+    for (const context of contexts) {
+        if (!context?.attributes) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(context.attributes)) {
+            if (!isSafeObjectKey(key)) {
+                continue;
+            }
+            assertAcyclicFeatureFlagContextValue(value);
+            mergedAttributes[key] =
+                typeof mergedAttributes[key] === "undefined" ? value : mergeAttributeValue(mergedAttributes[key], value);
+        }
+    }
+    return Object.keys(mergedAttributes).length > 0 ? { attributes: mergedAttributes } : null;
+}

package/dist/openfeature/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { BaseHook, EvaluationContext } from "@openfeature/core";
+export declare function createStaticContextHook(context: EvaluationContext): BaseHook;
+export declare function createLoggingHook(params: {
+    logger: Pick<Console, "debug" | "error">;
+    prefix?: string;
+}): BaseHook;

package/dist/openfeature/hooks.js

@@ -0,0 +1,27 @@
+export function createStaticContextHook(context) {
+    return {
+        before() {
+            return context;
+        },
+    };
+}
+export function createLoggingHook(params) {
+    const prefix = params.prefix ?? "feature-flags";
+    return {
+        after(hookContext, evaluationDetails, hookHints) {
+            params.logger.debug(`[${prefix}] evaluated flag (${hookContext.flagKey})`, {
+                defaultValue: hookContext.defaultValue,
+                errorCode: evaluationDetails.errorCode,
+                hookHints,
+                reason: evaluationDetails.reason,
+                value: evaluationDetails.value,
+            });
+        },
+        error(hookContext, error, hookHints) {
+            params.logger.error(`[${prefix}] failed evaluating flag (${hookContext.flagKey})`, {
+                error,
+                hookHints,
+            });
+        },
+    };
+}

package/dist/openfeature/server-provider.d.ts

@@ -0,0 +1,20 @@
+import { OpenFeatureEventEmitter, type EvaluationContext, type JsonValue, type Logger, type Provider, type ProviderMetadata, type ResolutionDetails } from "@openfeature/server-sdk";
+import { type OpenFeatureAdapterConfig } from "./shared.js";
+export type OpenFeatureServerProviderConfig = OpenFeatureAdapterConfig;
+export declare class MergedOpenFeatureServerProvider implements Provider {
+    readonly events: OpenFeatureEventEmitter;
+    readonly metadata: ProviderMetadata;
+    readonly runsOn: "server";
+    private readonly config;
+    private readonly evaluator;
+    private readonly evaluationCache;
+    constructor(config: OpenFeatureServerProviderConfig);
+    initialize(): Promise<void>;
+    onClose(): Promise<void>;
+    resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<boolean>>;
+    resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<string>>;
+    resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<number>>;
+    resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext, logger: Logger): Promise<ResolutionDetails<T>>;
+    private resolveEvaluation;
+}
+export declare function createOpenFeatureServerProvider(config: OpenFeatureServerProviderConfig): MergedOpenFeatureServerProvider;

package/dist/openfeature/server-provider.js

@@ -0,0 +1,102 @@
+import { OpenFeatureEventEmitter, } from "@openfeature/server-sdk";
+import { RemoteFeatureFlagEvaluator } from "../remote-evaluator.js";
+import { findEvaluatedFlag, matchesExpectedType, resolveMissingFlagEvaluation, resolveOpenFeatureContext, resolveSuccessfulEvaluation, resolveTypeMismatchEvaluation, } from "./shared.js";
+export class MergedOpenFeatureServerProvider {
+    events = new OpenFeatureEventEmitter();
+    metadata;
+    runsOn = "server";
+    config;
+    evaluator;
+    evaluationCache = new Map();
+    constructor(config) {
+        this.config = config;
+        this.evaluator = new RemoteFeatureFlagEvaluator(config);
+        this.metadata = {
+            name: config.metadataName ?? "@mergedapp/feature-flags/openfeature-server",
+        };
+    }
+    async initialize() {
+        this.events.emit("PROVIDER_READY");
+    }
+    async onClose() {
+        this.evaluationCache.clear();
+        return;
+    }
+    async resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "BOOLEAN",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveStringEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "STRING",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveNumberEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "NUMBER",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveObjectEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "OBJECT",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveEvaluation(params) {
+        try {
+            const mappedContext = resolveOpenFeatureContext({ config: this.config, context: params.context });
+            const cacheKey = JSON.stringify(mappedContext ?? null);
+            let evaluationPromise = this.evaluationCache.get(cacheKey);
+            if (!evaluationPromise) {
+                evaluationPromise = this.evaluator.evaluate(mappedContext).finally(() => {
+                    this.evaluationCache.delete(cacheKey);
+                });
+                this.evaluationCache.set(cacheKey, evaluationPromise);
+            }
+            const evaluation = await evaluationPromise;
+            const flag = findEvaluatedFlag(evaluation.flags, params.flagKey, this.config.flagIds);
+            if (!flag) {
+                return resolveMissingFlagEvaluation({
+                    defaultValue: params.defaultValue,
+                    flagKey: params.flagKey,
+                    logger: params.logger,
+                });
+            }
+            if (!matchesExpectedType(flag, params.expectedType)) {
+                return resolveTypeMismatchEvaluation({
+                    actualFlag: flag,
+                    defaultValue: params.defaultValue,
+                    expectedType: params.expectedType,
+                    logger: params.logger,
+                });
+            }
+            return resolveSuccessfulEvaluation({
+                defaultValue: params.defaultValue,
+                flag,
+            });
+        }
+        catch (error) {
+            params.logger.error(`Failed evaluating feature flag (${params.flagKey}).`, error);
+            throw error;
+        }
+    }
+}
+export function createOpenFeatureServerProvider(config) {
+    return new MergedOpenFeatureServerProvider(config);
+}

package/dist/openfeature/server.cjs

@@ -0,0 +1 @@
+module.exports = require("./cjs/openfeature/server.js")

package/dist/openfeature/server.d.ts

@@ -0,0 +1,3 @@
+export { createLoggingHook, createStaticContextHook } from "./hooks.js";
+export { DEFAULT_TARGETING_KEY_ATTRIBUTE, createDefaultOpenFeatureContextMapper, mergeFeatureFlagEvaluationContexts, type OpenFeatureContextMapper, } from "./context.js";
+export { createOpenFeatureServerProvider, MergedOpenFeatureServerProvider, type OpenFeatureServerProviderConfig, } from "./server-provider.js";

package/dist/openfeature/server.js

@@ -0,0 +1,3 @@
+export { createLoggingHook, createStaticContextHook } from "./hooks.js";
+export { DEFAULT_TARGETING_KEY_ATTRIBUTE, createDefaultOpenFeatureContextMapper, mergeFeatureFlagEvaluationContexts, } from "./context.js";
+export { createOpenFeatureServerProvider, MergedOpenFeatureServerProvider, } from "./server-provider.js";

package/dist/openfeature/shared.d.ts

@@ -0,0 +1,37 @@
+import type { EvaluationContext, Logger } from "@openfeature/core";
+import { type FlagMetadata, type JsonValue, type ResolutionDetails } from "@openfeature/core";
+import type { EvaluatedFlag, FeatureFlagEvaluationContext } from "@repo/types-v2";
+import type { FeatureFlagClientConfig, FeatureFlagRuntimeStatus } from "../types.js";
+import { type OpenFeatureContextMapper } from "./context.js";
+export type OpenFeatureAdapterConfig = Pick<FeatureFlagClientConfig, "apiUrl" | "clientKey" | "environmentId" | "evaluationContext" | "flagIds" | "organizationId" | "publicKey" | "refreshInterval" | "teamId"> & {
+    contextMapper?: OpenFeatureContextMapper;
+    metadataName?: string;
+    targetingKeyAttribute?: string;
+};
+export type FeatureFlagPrimitive = boolean | number | string | JsonValue;
+export declare function resolveOpenFeatureContext(params: {
+    config: OpenFeatureAdapterConfig;
+    context: EvaluationContext | null | undefined;
+}): FeatureFlagEvaluationContext | null;
+export declare function createOpenFeatureMetadata(params: {
+    flag: EvaluatedFlag;
+    runtimeStatus?: FeatureFlagRuntimeStatus | null;
+}): FlagMetadata;
+export declare function findEvaluatedFlag(flags: EvaluatedFlag[], flagKey: string, flagIds?: Record<string, string>): EvaluatedFlag | undefined;
+export declare function resolveSuccessfulEvaluation<T extends FeatureFlagPrimitive>(params: {
+    defaultValue: T;
+    flag: EvaluatedFlag;
+    runtimeStatus?: FeatureFlagRuntimeStatus | null;
+}): ResolutionDetails<T>;
+export declare function resolveMissingFlagEvaluation<T extends FeatureFlagPrimitive>(params: {
+    defaultValue: T;
+    flagKey: string;
+    logger?: Logger;
+}): ResolutionDetails<T>;
+export declare function resolveTypeMismatchEvaluation<T extends FeatureFlagPrimitive>(params: {
+    actualFlag: EvaluatedFlag;
+    defaultValue: T;
+    expectedType: "BOOLEAN" | "NUMBER" | "OBJECT" | "STRING";
+    logger?: Logger;
+}): ResolutionDetails<T>;
+export declare function matchesExpectedType(flag: EvaluatedFlag, expectedType: "BOOLEAN" | "NUMBER" | "OBJECT" | "STRING"): boolean;

package/dist/openfeature/shared.js

@@ -0,0 +1,74 @@
+import { ErrorCode, StandardResolutionReasons, } from "@openfeature/core";
+import { createDefaultOpenFeatureContextMapper, mergeFeatureFlagEvaluationContexts, } from "./context.js";
+export function resolveOpenFeatureContext(params) {
+    const mapper = params.config.contextMapper ??
+        createDefaultOpenFeatureContextMapper({
+            targetingKeyAttribute: params.config.targetingKeyAttribute,
+        });
+    return mergeFeatureFlagEvaluationContexts(params.config.evaluationContext ?? null, params.context ? mapper(params.context) : null);
+}
+export function createOpenFeatureMetadata(params) {
+    return {
+        id: params.flag.id,
+        name: params.flag.name,
+        type: params.flag.type,
+        teamId: params.flag.teamId ?? "",
+        enabled: params.flag.enabled,
+        source: params.runtimeStatus?.source ?? "network",
+        isStale: params.runtimeStatus?.isStale ?? false,
+    };
+}
+export function findEvaluatedFlag(flags, flagKey, flagIds) {
+    const resolvedId = flagIds?.[flagKey];
+    if (resolvedId) {
+        const matchedByResolvedId = flags.find((flag) => flag.id === resolvedId);
+        if (matchedByResolvedId) {
+            return matchedByResolvedId;
+        }
+    }
+    return flags.find((flag) => flag.id === flagKey) ?? flags.find((flag) => flag.name === flagKey);
+}
+export function resolveSuccessfulEvaluation(params) {
+    return {
+        value: params.flag.value,
+        variant: params.flag.name,
+        flagMetadata: createOpenFeatureMetadata(params),
+        reason: resolveResolutionReason(params),
+    };
+}
+function resolveResolutionReason(params) {
+    if (!params.flag.enabled) {
+        return StandardResolutionReasons.DISABLED;
+    }
+    if (params.runtimeStatus?.isStale) {
+        return StandardResolutionReasons.STALE;
+    }
+    if (params.runtimeStatus?.source === "persisted") {
+        return StandardResolutionReasons.CACHED;
+    }
+    return StandardResolutionReasons.TARGETING_MATCH;
+}
+export function resolveMissingFlagEvaluation(params) {
+    params.logger?.warn(`Feature flag (${params.flagKey}) was not found.`);
+    return {
+        value: params.defaultValue,
+        reason: StandardResolutionReasons.ERROR,
+        errorCode: ErrorCode.FLAG_NOT_FOUND,
+        errorMessage: `Feature flag (${params.flagKey}) was not found.`,
+    };
+}
+export function resolveTypeMismatchEvaluation(params) {
+    const message = `Feature flag (${params.actualFlag.name}) resolved as ${params.actualFlag.type}, expected ${params.expectedType}.`;
+    params.logger?.warn(message);
+    return {
+        value: params.defaultValue,
+        variant: params.actualFlag.name,
+        flagMetadata: createOpenFeatureMetadata({ flag: params.actualFlag }),
+        reason: StandardResolutionReasons.ERROR,
+        errorCode: ErrorCode.TYPE_MISMATCH,
+        errorMessage: message,
+    };
+}
+export function matchesExpectedType(flag, expectedType) {
+    return flag.type === expectedType;
+}

package/dist/openfeature/web-provider.d.ts

@@ -0,0 +1,27 @@
+import { OpenFeatureEventEmitter, type EvaluationContext, type JsonValue, type Provider, type ProviderMetadata, type ResolutionDetails } from "@openfeature/web-sdk";
+import { MergedFeatureFlags } from "../client.js";
+import type { FlagRegistry } from "../types.js";
+import { type OpenFeatureAdapterConfig } from "./shared.js";
+export type OpenFeatureWebProviderConfig<TFlags extends FlagRegistry = FlagRegistry> = OpenFeatureAdapterConfig & {
+    client?: MergedFeatureFlags<TFlags>;
+};
+export declare class MergedOpenFeatureWebProvider<TFlags extends FlagRegistry = FlagRegistry> implements Provider {
+    readonly events: OpenFeatureEventEmitter;
+    readonly metadata: ProviderMetadata;
+    readonly runsOn: "client";
+    private readonly client;
+    private readonly ownsClient;
+    private readonly config;
+    private currentFlagsSignature;
+    private unsubscribe;
+    constructor(config: OpenFeatureWebProviderConfig<TFlags>);
+    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>;
+    private resolveEvaluation;
+}
+export declare function createOpenFeatureWebProvider<TFlags extends FlagRegistry = FlagRegistry>(config: OpenFeatureWebProviderConfig<TFlags>): MergedOpenFeatureWebProvider<TFlags>;

package/dist/openfeature/web-provider.js

@@ -0,0 +1,151 @@
+import { ClientProviderEvents, OpenFeatureEventEmitter, StandardResolutionReasons, } from "@openfeature/web-sdk";
+import { MergedFeatureFlags } from "../client.js";
+import { findEvaluatedFlag, matchesExpectedType, resolveMissingFlagEvaluation, resolveOpenFeatureContext, resolveSuccessfulEvaluation, resolveTypeMismatchEvaluation, } from "./shared.js";
+export class MergedOpenFeatureWebProvider {
+    events = new OpenFeatureEventEmitter();
+    metadata;
+    runsOn = "client";
+    client;
+    ownsClient;
+    config;
+    currentFlagsSignature = "";
+    unsubscribe = null;
+    constructor(config) {
+        this.config = config;
+        this.ownsClient = !config.client;
+        this.client =
+            config.client ??
+                new MergedFeatureFlags({
+                    apiUrl: config.apiUrl,
+                    clientKey: config.clientKey,
+                    environmentId: config.environmentId,
+                    organizationId: config.organizationId,
+                    teamId: config.teamId,
+                    publicKey: config.publicKey,
+                    evaluationContext: config.evaluationContext,
+                    refreshInterval: config.refreshInterval,
+                });
+        this.metadata = {
+            name: config.metadataName ?? "@mergedapp/feature-flags/openfeature-web",
+        };
+    }
+    async initialize(context) {
+        if (context) {
+            this.client.setEvaluationContext(resolveOpenFeatureContext({ config: this.config, context }));
+        }
+        await this.client.initialize();
+        let previousFlags = this.client.getAllFlags();
+        this.currentFlagsSignature = serializeFlags(previousFlags);
+        this.unsubscribe = this.client.subscribe(() => {
+            const nextFlags = this.client.getAllFlags();
+            const nextSignature = serializeFlags(nextFlags);
+            if (nextSignature !== this.currentFlagsSignature) {
+                this.currentFlagsSignature = nextSignature;
+                this.events.emit(ClientProviderEvents.ConfigurationChanged, {
+                    flagsChanged: getChangedFlagNames(previousFlags, nextFlags),
+                });
+                previousFlags = nextFlags;
+            }
+        });
+    }
+    async onClose() {
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        if (this.ownsClient) {
+            this.client.destroy();
+        }
+    }
+    async onContextChange(_oldContext, newContext) {
+        this.client.setEvaluationContext(resolveOpenFeatureContext({ config: this.config, context: newContext }));
+        await this.client.refresh();
+    }
+    resolveBooleanEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "BOOLEAN",
+            flagKey,
+        });
+    }
+    resolveStringEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "STRING",
+            flagKey,
+        });
+    }
+    resolveNumberEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "NUMBER",
+            flagKey,
+        });
+    }
+    resolveObjectEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "OBJECT",
+            flagKey,
+        });
+    }
+    resolveEvaluation(params) {
+        const flag = findEvaluatedFlag(this.client.getAllFlags(), params.flagKey, this.config.flagIds);
+        if (!flag) {
+            return {
+                ...resolveMissingFlagEvaluation(params),
+                reason: this.client.getStatus().source === "defaults" ? StandardResolutionReasons.DEFAULT : undefined,
+            };
+        }
+        if (!matchesExpectedType(flag, params.expectedType)) {
+            return resolveTypeMismatchEvaluation({
+                actualFlag: flag,
+                defaultValue: params.defaultValue,
+                expectedType: params.expectedType,
+            });
+        }
+        return {
+            ...resolveSuccessfulEvaluation({
+                defaultValue: params.defaultValue,
+                flag,
+                runtimeStatus: this.client.getStatus(),
+            }),
+        };
+    }
+}
+function serializeFlags(flags) {
+    return JSON.stringify(flags.map((flag) => ({
+        enabled: flag.enabled,
+        id: flag.id,
+        name: flag.name,
+        type: flag.type,
+        value: flag.value,
+    })));
+}
+function getChangedFlagNames(previousFlags, nextFlags) {
+    const previousById = new Map(previousFlags.map((flag) => [flag.id, serializeComparableFlag(flag)]));
+    const nextById = new Map(nextFlags.map((flag) => [flag.id, serializeComparableFlag(flag)]));
+    const changed = new Set();
+    for (const [id, nextEntry] of nextById) {
+        const previousEntry = previousById.get(id);
+        if (!previousEntry ||
+            previousEntry.flag.enabled !== nextEntry.flag.enabled ||
+            previousEntry.flag.name !== nextEntry.flag.name ||
+            previousEntry.serializedValue !== nextEntry.serializedValue) {
+            changed.add(nextEntry.flag.name);
+        }
+    }
+    for (const [id, previousEntry] of previousById) {
+        if (!nextById.has(id)) {
+            changed.add(previousEntry.flag.name);
+        }
+    }
+    return Array.from(changed);
+}
+function serializeComparableFlag(flag) {
+    return {
+        flag,
+        serializedValue: JSON.stringify(flag.value),
+    };
+}
+export function createOpenFeatureWebProvider(config) {
+    return new MergedOpenFeatureWebProvider(config);
+}

package/dist/openfeature/web.cjs

@@ -0,0 +1 @@
+module.exports = require("./cjs/openfeature/web.js")

package/dist/openfeature/web.d.ts

@@ -0,0 +1,3 @@
+export { createLoggingHook, createStaticContextHook } from "./hooks.js";
+export { DEFAULT_TARGETING_KEY_ATTRIBUTE, createDefaultOpenFeatureContextMapper, mergeFeatureFlagEvaluationContexts, type OpenFeatureContextMapper, } from "./context.js";
+export { createOpenFeatureWebProvider, MergedOpenFeatureWebProvider, type OpenFeatureWebProviderConfig, } from "./web-provider.js";