@microsoft/feature-management 1.0.0-preview.1 → 2.0.0-preview.1

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/esm/model.js

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+// Feature Management Section fed into feature manager.
+// Converted from https://github.com/Azure/AppConfiguration/blob/main/docs/FeatureManagement/FeatureManagement.v1.0.0.schema.json
+const FEATURE_MANAGEMENT_KEY = "feature_management";
+const FEATURE_FLAGS_KEY = "feature_flags";
+
+export { FEATURE_FLAGS_KEY, FEATURE_MANAGEMENT_KEY };
+//# sourceMappingURL=model.js.map

package/dist/esm/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sources":["../../src/model.ts"],"sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\n// Converted from:\n// https://github.com/Azure/AppConfiguration/blob/6e544296a5607f922a423df165f60801717c7800/docs/FeatureManagement/FeatureFlag.v2.0.0.schema.json\n\n/**\n * A feature flag is a named property that can be toggled to enable or disable some feature of an application.\n */\nexport interface FeatureFlag {\n  /**\n   * An ID used to uniquely identify and reference the feature.\n   */\n  id: string;\n  /**\n   * A description of the feature.\n   */\n  description?: string;\n  /**\n   * A display name for the feature to use for display rather than the ID.\n   */\n  display_name?: string;\n  /**\n   * A feature is OFF if enabled is false. If enabled is true, then the feature is ON if there are no conditions (null or empty) or if the conditions are satisfied.\n   */\n  enabled?: boolean;\n  /**\n   * The declaration of conditions used to dynamically enable the feature.\n   */\n  conditions?: FeatureEnablementConditions;\n  /**\n   * The list of variants defined for this feature. A variant represents a configuration value of a feature flag that can be a string, a number, a boolean, or a JSON object.\n   */\n  variants?: VariantDefinition[];\n  /**\n   * Determines how variants should be allocated for the feature to various users.\n   */\n  allocation?: VariantAllocation;\n  /**\n   * The declaration of options used to configure telemetry for this feature.\n   */\n  telemetry?: TelemetryOptions\n}\n\n/**\n* The declaration of conditions used to dynamically enable the feature\n*/\ninterface FeatureEnablementConditions {\n  /**\n   * Determines whether any or all registered client filters must be evaluated as true for the feature to be considered enabled.\n   */\n  requirement_type?: RequirementType;\n  /**\n   * Filters that must run on the client and be evaluated as true for the feature to be considered enabled.\n   */\n  client_filters?: ClientFilter[];\n}\n\nexport type RequirementType = \"Any\" | \"All\";\n\ninterface ClientFilter {\n  /**\n   * The name used to refer to a client filter.\n   */\n  name: string;\n  /**\n   * Parameters for a given client filter. A client filter can require any set of parameters of any type.\n   */\n  parameters?: Record<string, unknown>;\n}\n\nexport interface VariantDefinition {\n  /**\n   * The name used to refer to a feature variant.\n   */\n  name: string;\n  /**\n   * The configuration value for this feature variant.\n   */\n  configuration_value?: unknown;\n  /**\n   * Overrides the enabled state of the feature if the given variant is assigned. Does not override the state if value is None.\n   */\n  status_override?: \"None\" | \"Enabled\" | \"Disabled\";\n}\n\n/**\n* Determines how variants should be allocated for the feature to various users.\n*/\ninterface VariantAllocation {\n  /**\n   * Specifies which variant should be used when the feature is considered disabled.\n   */\n  default_when_disabled?: string;\n  /**\n   * Specifies which variant should be used when the feature is considered enabled and no other allocation rules are applicable.\n   */\n  default_when_enabled?: string;\n  /**\n   * A list of objects, each containing a variant name and list of users for whom that variant should be used.\n   */\n  user?: UserAllocation[];\n  /**\n   * A list of objects, each containing a variant name and list of groups for which that variant should be used.\n   */\n  group?: GroupAllocation[];\n  /**\n   * A list of objects, each containing a variant name and percentage range for which that variant should be used.\n   */\n  percentile?: PercentileAllocation[]\n  /**\n   * The value percentile calculations are based on. The calculated percentile is consistent across features for a given user if the same nonempty seed is used.\n   */\n  seed?: string;\n}\n\ninterface UserAllocation {\n  /**\n   * The name of the variant to use if the user allocation matches the current user.\n   */\n  variant: string;\n  /**\n   * Collection of users where if any match the current user, the variant specified in the user allocation is used.\n   */\n  users: string[];\n}\n\ninterface GroupAllocation {\n  /**\n   * The name of the variant to use if the group allocation matches a group the current user is in.\n   */\n  variant: string;\n  /**\n   * Collection of groups where if the current user is in any of these groups, the variant specified in the group allocation is used.\n   */\n  groups: string[];\n}\n\ninterface PercentileAllocation {\n  /**\n   * The name of the variant to use if the calculated percentile for the current user falls in the provided range.\n   */\n  variant: string;\n  /**\n   * The lower end of the percentage range for which this variant will be used.\n   */\n  from: number;\n  /**\n   * The upper end of the percentage range for which this variant will be used.\n   */\n  to: number;\n}\n\n/**\n* The declaration of options used to configure telemetry for this feature.\n*/\ninterface TelemetryOptions {\n  /**\n   * Indicates if telemetry is enabled.\n   */\n  enabled?: boolean;\n  /**\n   * A container for metadata that should be bundled with flag telemetry.\n   */\n  metadata?: Record<string, string>;\n}\n\n// Feature Management Section fed into feature manager.\n// Converted from https://github.com/Azure/AppConfiguration/blob/main/docs/FeatureManagement/FeatureManagement.v1.0.0.schema.json\n\nexport const FEATURE_MANAGEMENT_KEY = \"feature_management\";\nexport const FEATURE_FLAGS_KEY = \"feature_flags\";\n\nexport interface FeatureManagementConfiguration {\n  feature_management: FeatureManagement\n}\n\n/**\n * Declares feature management configuration.\n */\nexport interface FeatureManagement {\n  feature_flags: FeatureFlag[];\n}\n"],"names":[],"mappings":"AAAA;AACA;AAsKA;AACA;AAEO,MAAM,sBAAsB,GAAG,qBAAqB;AACpD,MAAM,iBAAiB,GAAG;;;;"}

package/dist/esm/variant/Variant.js

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+class Variant {
+    name;
+    configuration;
+    constructor(name, configuration) {
+        this.name = name;
+        this.configuration = configuration;
+    }
+}
+
+export { Variant };
+//# sourceMappingURL=Variant.js.map

package/dist/esm/variant/Variant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Variant.js","sources":["../../../src/variant/Variant.ts"],"sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nexport class Variant {\n    constructor(\n        public name: string,\n        public configuration: unknown\n    ) {}\n}\n"],"names":[],"mappings":"AAAA;AACA;MAEa,OAAO,CAAA;AAEL,IAAA,IAAA,CAAA;AACA,IAAA,aAAA,CAAA;IAFX,WACW,CAAA,IAAY,EACZ,aAAsB,EAAA;QADtB,IAAI,CAAA,IAAA,GAAJ,IAAI,CAAQ;QACZ,IAAa,CAAA,aAAA,GAAb,aAAa,CAAS;KAC7B;AACP;;;;"}

package/dist/esm/version.js

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+const VERSION = "2.0.0-preview.1";
+
+export { VERSION };
+//# sourceMappingURL=version.js.map

package/dist/esm/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sources":["../../src/version.ts"],"sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nexport const VERSION = \"2.0.0-preview.1\";\n"],"names":[],"mappings":"AAAA;AACA;AAEO,MAAM,OAAO,GAAG;;;;"}

package/dist/umd/index.js

@@ -0,0 +1,504 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FeatureManagement = {}));
+})(this, (function (exports) { 'use strict';
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    class TimeWindowFilter {
+        name = "Microsoft.TimeWindow";
+        evaluate(context) {
+            const { featureName, parameters } = context;
+            const startTime = parameters.Start !== undefined ? new Date(parameters.Start) : undefined;
+            const endTime = parameters.End !== undefined ? new Date(parameters.End) : undefined;
+            if (startTime === undefined && endTime === undefined) {
+                // If neither start nor end time is specified, then the filter is not applicable.
+                console.warn(`The ${this.name} feature filter is not valid for feature ${featureName}. It must specify either 'Start', 'End', or both.`);
+                return false;
+            }
+            const now = new Date();
+            return (startTime === undefined || startTime <= now) && (endTime === undefined || now < endTime);
+        }
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    /**
+     * Determines if the user is part of the audience, based on the user id and the percentage range.
+     *
+     * @param userId user id from app context
+     * @param hint hint string to be included in the context id
+     * @param from percentage range start
+     * @param to percentage range end
+     * @returns true if the user is part of the audience, false otherwise
+     */
+    async function isTargetedPercentile(userId, hint, from, to) {
+        if (from < 0 || from > 100) {
+            throw new Error("The 'from' value must be between 0 and 100.");
+        }
+        if (to < 0 || to > 100) {
+            throw new Error("The 'to' value must be between 0 and 100.");
+        }
+        if (from > to) {
+            throw new Error("The 'from' value cannot be larger than the 'to' value.");
+        }
+        const audienceContextId = constructAudienceContextId(userId, hint);
+        // Cryptographic hashing algorithms ensure adequate entropy across hash values.
+        const contextMarker = await stringToUint32(audienceContextId);
+        const contextPercentage = (contextMarker / 0xFFFFFFFF) * 100;
+        // Handle edge case of exact 100 bucket
+        if (to === 100) {
+            return contextPercentage >= from;
+        }
+        return contextPercentage >= from && contextPercentage < to;
+    }
+    /**
+     * Determines if the user is part of the audience, based on the groups they belong to.
+     *
+     * @param sourceGroups user groups from app context
+     * @param targetedGroups targeted groups from feature configuration
+     * @returns true if the user is part of the audience, false otherwise
+     */
+    function isTargetedGroup(sourceGroups, targetedGroups) {
+        if (sourceGroups === undefined) {
+            return false;
+        }
+        return sourceGroups.some(group => targetedGroups.includes(group));
+    }
+    /**
+     * Determines if the user is part of the audience, based on the user id.
+     * @param userId user id from app context
+     * @param users targeted users from feature configuration
+     * @returns true if the user is part of the audience, false otherwise
+     */
+    function isTargetedUser(userId, users) {
+        if (userId === undefined) {
+            return false;
+        }
+        return users.includes(userId);
+    }
+    /**
+     * Constructs the context id for the audience.
+     * The context id is used to determine if the user is part of the audience for a feature.
+     *
+     * @param userId userId from app context
+     * @param hint hint string to be included in the context id
+     * @returns a string that represents the context id for the audience
+     */
+    function constructAudienceContextId(userId, hint) {
+        return `${userId ?? ""}\n${hint}`;
+    }
+    /**
+     * Converts a string to a uint32 in little-endian encoding.
+     * @param str the string to convert.
+     * @returns a uint32 value.
+     */
+    async function stringToUint32(str) {
+        let crypto;
+        // Check for browser environment
+        if (typeof window !== "undefined" && window.crypto && window.crypto.subtle) {
+            crypto = window.crypto;
+        }
+        // Check for Node.js environment
+        else if (typeof global !== "undefined" && global.crypto) {
+            crypto = global.crypto;
+        }
+        // Fallback to native Node.js crypto module
+        else {
+            try {
+                if (typeof module !== "undefined" && module.exports) {
+                    crypto = require("crypto");
+                }
+                else {
+                    crypto = await import('crypto');
+                }
+            }
+            catch (error) {
+                console.error("Failed to load the crypto module:", error.message);
+                throw error;
+            }
+        }
+        // In the browser, use crypto.subtle.digest
+        if (crypto.subtle) {
+            const data = new TextEncoder().encode(str);
+            const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+            const dataView = new DataView(hashBuffer);
+            const uint32 = dataView.getUint32(0, true);
+            return uint32;
+        }
+        // In Node.js, use the crypto module's hash function
+        else {
+            const hash = crypto.createHash("sha256").update(str).digest();
+            const uint32 = hash.readUInt32LE(0);
+            return uint32;
+        }
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    class TargetingFilter {
+        name = "Microsoft.Targeting";
+        async evaluate(context, appContext) {
+            const { featureName, parameters } = context;
+            TargetingFilter.#validateParameters(parameters);
+            if (appContext === undefined) {
+                throw new Error("The app context is required for targeting filter.");
+            }
+            if (parameters.Audience.Exclusion !== undefined) {
+                // check if the user is in the exclusion list
+                if (appContext?.userId !== undefined &&
+                    parameters.Audience.Exclusion.Users !== undefined &&
+                    parameters.Audience.Exclusion.Users.includes(appContext.userId)) {
+                    return false;
+                }
+                // check if the user is in a group within exclusion list
+                if (appContext?.groups !== undefined &&
+                    parameters.Audience.Exclusion.Groups !== undefined) {
+                    for (const excludedGroup of parameters.Audience.Exclusion.Groups) {
+                        if (appContext.groups.includes(excludedGroup)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            // check if the user is being targeted directly
+            if (appContext?.userId !== undefined &&
+                parameters.Audience.Users !== undefined &&
+                parameters.Audience.Users.includes(appContext.userId)) {
+                return true;
+            }
+            // check if the user is in a group that is being targeted
+            if (appContext?.groups !== undefined &&
+                parameters.Audience.Groups !== undefined) {
+                for (const group of parameters.Audience.Groups) {
+                    if (appContext.groups.includes(group.Name)) {
+                        const hint = `${featureName}\n${group.Name}`;
+                        if (await isTargetedPercentile(appContext.userId, hint, 0, group.RolloutPercentage)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            // check if the user is being targeted by a default rollout percentage
+            const hint = featureName;
+            return isTargetedPercentile(appContext?.userId, hint, 0, parameters.Audience.DefaultRolloutPercentage);
+        }
+        static #validateParameters(parameters) {
+            if (parameters.Audience.DefaultRolloutPercentage < 0 || parameters.Audience.DefaultRolloutPercentage > 100) {
+                throw new Error("Audience.DefaultRolloutPercentage must be a number between 0 and 100.");
+            }
+            // validate RolloutPercentage for each group
+            if (parameters.Audience.Groups !== undefined) {
+                for (const group of parameters.Audience.Groups) {
+                    if (group.RolloutPercentage < 0 || group.RolloutPercentage > 100) {
+                        throw new Error(`RolloutPercentage of group ${group.Name} must be a number between 0 and 100.`);
+                    }
+                }
+            }
+        }
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    class Variant {
+        name;
+        configuration;
+        constructor(name, configuration) {
+            this.name = name;
+            this.configuration = configuration;
+        }
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    class FeatureManager {
+        #provider;
+        #featureFilters = new Map();
+        #onFeatureEvaluated;
+        constructor(provider, options) {
+            this.#provider = provider;
+            const builtinFilters = [new TimeWindowFilter(), new TargetingFilter()];
+            // If a custom filter shares a name with an existing filter, the custom filter overrides the existing one.
+            for (const filter of [...builtinFilters, ...(options?.customFilters ?? [])]) {
+                this.#featureFilters.set(filter.name, filter);
+            }
+            this.#onFeatureEvaluated = options?.onFeatureEvaluated;
+        }
+        async listFeatureNames() {
+            const features = await this.#provider.getFeatureFlags();
+            const featureNameSet = new Set(features.map((feature) => feature.id));
+            return Array.from(featureNameSet);
+        }
+        // If multiple feature flags are found, the first one takes precedence.
+        async isEnabled(featureName, context) {
+            const result = await this.#evaluateFeature(featureName, context);
+            return result.enabled;
+        }
+        async getVariant(featureName, context) {
+            const result = await this.#evaluateFeature(featureName, context);
+            return result.variant;
+        }
+        async #assignVariant(featureFlag, context) {
+            // user allocation
+            if (featureFlag.allocation?.user !== undefined) {
+                for (const userAllocation of featureFlag.allocation.user) {
+                    if (isTargetedUser(context.userId, userAllocation.users)) {
+                        return getVariantAssignment(featureFlag, userAllocation.variant, exports.VariantAssignmentReason.User);
+                    }
+                }
+            }
+            // group allocation
+            if (featureFlag.allocation?.group !== undefined) {
+                for (const groupAllocation of featureFlag.allocation.group) {
+                    if (isTargetedGroup(context.groups, groupAllocation.groups)) {
+                        return getVariantAssignment(featureFlag, groupAllocation.variant, exports.VariantAssignmentReason.Group);
+                    }
+                }
+            }
+            // percentile allocation
+            if (featureFlag.allocation?.percentile !== undefined) {
+                for (const percentileAllocation of featureFlag.allocation.percentile) {
+                    const hint = featureFlag.allocation.seed ?? `allocation\n${featureFlag.id}`;
+                    if (await isTargetedPercentile(context.userId, hint, percentileAllocation.from, percentileAllocation.to)) {
+                        return getVariantAssignment(featureFlag, percentileAllocation.variant, exports.VariantAssignmentReason.Percentile);
+                    }
+                }
+            }
+            return { variant: undefined, reason: exports.VariantAssignmentReason.None };
+        }
+        async #isEnabled(featureFlag, context) {
+            if (featureFlag.enabled !== true) {
+                // If the feature is not explicitly enabled, then it is disabled by default.
+                return false;
+            }
+            const clientFilters = featureFlag.conditions?.client_filters;
+            if (clientFilters === undefined || clientFilters.length <= 0) {
+                // If there are no client filters, then the feature is enabled.
+                return true;
+            }
+            const requirementType = featureFlag.conditions?.requirement_type ?? "Any"; // default to any.
+            /**
+             * While iterating through the client filters, we short-circuit the evaluation based on the requirement type.
+             * - When requirement type is "All", the feature is enabled if all client filters are matched. If any client filter is not matched, the feature is disabled, otherwise it is enabled. `shortCircuitEvaluationResult` is false.
+             * - When requirement type is "Any", the feature is enabled if any client filter is matched. If any client filter is matched, the feature is enabled, otherwise it is disabled. `shortCircuitEvaluationResult` is true.
+             */
+            const shortCircuitEvaluationResult = requirementType === "Any";
+            for (const clientFilter of clientFilters) {
+                const matchedFeatureFilter = this.#featureFilters.get(clientFilter.name);
+                const contextWithFeatureName = { featureName: featureFlag.id, parameters: clientFilter.parameters };
+                if (matchedFeatureFilter === undefined) {
+                    console.warn(`Feature filter ${clientFilter.name} is not found.`);
+                    return false;
+                }
+                if (await matchedFeatureFilter.evaluate(contextWithFeatureName, context) === shortCircuitEvaluationResult) {
+                    return shortCircuitEvaluationResult;
+                }
+            }
+            // If we get here, then we have not found a client filter that matches the requirement type.
+            return !shortCircuitEvaluationResult;
+        }
+        async #evaluateFeature(featureName, context) {
+            const featureFlag = await this.#provider.getFeatureFlag(featureName);
+            const result = new EvaluationResult(featureFlag);
+            if (featureFlag === undefined) {
+                return result;
+            }
+            // Ensure that the feature flag is in the correct format. Feature providers should validate the feature flags, but we do it here as a safeguard.
+            // TODO: move to the feature flag provider implementation.
+            validateFeatureFlagFormat(featureFlag);
+            // Evaluate if the feature is enabled.
+            result.enabled = await this.#isEnabled(featureFlag, context);
+            const targetingContext = context;
+            result.targetingId = targetingContext?.userId;
+            // Determine Variant
+            let variantDef;
+            let reason = exports.VariantAssignmentReason.None;
+            // featureFlag.variant not empty
+            if (featureFlag.variants !== undefined && featureFlag.variants.length > 0) {
+                if (!result.enabled) {
+                    // not enabled, assign default if specified
+                    if (featureFlag.allocation?.default_when_disabled !== undefined) {
+                        variantDef = featureFlag.variants.find(v => v.name == featureFlag.allocation?.default_when_disabled);
+                        reason = exports.VariantAssignmentReason.DefaultWhenDisabled;
+                    }
+                    else {
+                        // no default specified
+                        variantDef = undefined;
+                        reason = exports.VariantAssignmentReason.DefaultWhenDisabled;
+                    }
+                }
+                else {
+                    // enabled, assign based on allocation
+                    if (context !== undefined && featureFlag.allocation !== undefined) {
+                        const variantAndReason = await this.#assignVariant(featureFlag, targetingContext);
+                        variantDef = variantAndReason.variant;
+                        reason = variantAndReason.reason;
+                    }
+                    // allocation failed, assign default if specified
+                    if (variantDef === undefined && reason === exports.VariantAssignmentReason.None) {
+                        if (featureFlag.allocation?.default_when_enabled !== undefined) {
+                            variantDef = featureFlag.variants.find(v => v.name == featureFlag.allocation?.default_when_enabled);
+                            reason = exports.VariantAssignmentReason.DefaultWhenEnabled;
+                        }
+                        else {
+                            variantDef = undefined;
+                            reason = exports.VariantAssignmentReason.DefaultWhenEnabled;
+                        }
+                    }
+                }
+            }
+            result.variant = variantDef !== undefined ? new Variant(variantDef.name, variantDef.configuration_value) : undefined;
+            result.variantAssignmentReason = reason;
+            // Status override for isEnabled
+            if (variantDef !== undefined && featureFlag.enabled) {
+                if (variantDef.status_override === "Enabled") {
+                    result.enabled = true;
+                }
+                else if (variantDef.status_override === "Disabled") {
+                    result.enabled = false;
+                }
+            }
+            // The callback will only be executed if telemetry is enabled for the feature flag
+            if (featureFlag.telemetry?.enabled && this.#onFeatureEvaluated !== undefined) {
+                this.#onFeatureEvaluated(result);
+            }
+            return result;
+        }
+    }
+    class EvaluationResult {
+        feature;
+        enabled;
+        targetingId;
+        variant;
+        variantAssignmentReason;
+        constructor(
+        // feature flag definition
+        feature, 
+        // enabled state
+        enabled = false, 
+        // variant assignment
+        targetingId = undefined, variant = undefined, variantAssignmentReason = exports.VariantAssignmentReason.None) {
+            this.feature = feature;
+            this.enabled = enabled;
+            this.targetingId = targetingId;
+            this.variant = variant;
+            this.variantAssignmentReason = variantAssignmentReason;
+        }
+    }
+    exports.VariantAssignmentReason = void 0;
+    (function (VariantAssignmentReason) {
+        /**
+         * Variant allocation did not happen. No variant is assigned.
+         */
+        VariantAssignmentReason["None"] = "None";
+        /**
+         * The default variant is assigned when a feature flag is disabled.
+         */
+        VariantAssignmentReason["DefaultWhenDisabled"] = "DefaultWhenDisabled";
+        /**
+         * The default variant is assigned because of no applicable user/group/percentile allocation when a feature flag is enabled.
+         */
+        VariantAssignmentReason["DefaultWhenEnabled"] = "DefaultWhenEnabled";
+        /**
+         * The variant is assigned because of the user allocation when a feature flag is enabled.
+         */
+        VariantAssignmentReason["User"] = "User";
+        /**
+         * The variant is assigned because of the group allocation when a feature flag is enabled.
+         */
+        VariantAssignmentReason["Group"] = "Group";
+        /**
+         * The variant is assigned because of the percentile allocation when a feature flag is enabled.
+         */
+        VariantAssignmentReason["Percentile"] = "Percentile";
+    })(exports.VariantAssignmentReason || (exports.VariantAssignmentReason = {}));
+    /**
+     * Validates the format of the feature flag definition.
+     *
+     * FeatureFlag data objects are from IFeatureFlagProvider, depending on the implementation.
+     * Thus the properties are not guaranteed to have the expected types.
+     *
+     * @param featureFlag The feature flag definition to validate.
+     */
+    function validateFeatureFlagFormat(featureFlag) {
+        if (featureFlag.enabled !== undefined && typeof featureFlag.enabled !== "boolean") {
+            throw new Error(`Feature flag ${featureFlag.id} has an invalid 'enabled' value.`);
+        }
+        // TODO: add more validations.
+        // TODO: should be moved to the feature flag provider.
+    }
+    /**
+     * Try to get the variant assignment for the given variant name. If the variant is not found, override the reason with VariantAssignmentReason.None.
+     *
+     * @param featureFlag feature flag definition
+     * @param variantName variant name
+     * @param reason variant assignment reason
+     * @returns variant assignment containing the variant definition and the reason
+     */
+    function getVariantAssignment(featureFlag, variantName, reason) {
+        const variant = featureFlag.variants?.find(v => v.name == variantName);
+        if (variant !== undefined) {
+            return { variant, reason };
+        }
+        else {
+            console.warn(`Variant ${variantName} not found for feature ${featureFlag.id}.`);
+            return { variant: undefined, reason: exports.VariantAssignmentReason.None };
+        }
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    // Feature Management Section fed into feature manager.
+    // Converted from https://github.com/Azure/AppConfiguration/blob/main/docs/FeatureManagement/FeatureManagement.v1.0.0.schema.json
+    const FEATURE_MANAGEMENT_KEY = "feature_management";
+    const FEATURE_FLAGS_KEY = "feature_flags";
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    /**
+     * A feature flag provider that uses a map-like configuration to provide feature flags.
+     */
+    class ConfigurationMapFeatureFlagProvider {
+        #configuration;
+        constructor(configuration) {
+            this.#configuration = configuration;
+        }
+        async getFeatureFlag(featureName) {
+            const featureConfig = this.#configuration.get(FEATURE_MANAGEMENT_KEY);
+            return featureConfig?.[FEATURE_FLAGS_KEY]?.find((feature) => feature.id === featureName);
+        }
+        async getFeatureFlags() {
+            const featureConfig = this.#configuration.get(FEATURE_MANAGEMENT_KEY);
+            return featureConfig?.[FEATURE_FLAGS_KEY] ?? [];
+        }
+    }
+    /**
+     * A feature flag provider that uses an object-like configuration to provide feature flags.
+     */
+    class ConfigurationObjectFeatureFlagProvider {
+        #configuration;
+        constructor(configuration) {
+            this.#configuration = configuration;
+        }
+        async getFeatureFlag(featureName) {
+            const featureFlags = this.#configuration[FEATURE_MANAGEMENT_KEY]?.[FEATURE_FLAGS_KEY];
+            return featureFlags?.find((feature) => feature.id === featureName);
+        }
+        async getFeatureFlags() {
+            return this.#configuration[FEATURE_MANAGEMENT_KEY]?.[FEATURE_FLAGS_KEY] ?? [];
+        }
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    const VERSION = "2.0.0-preview.1";
+
+    exports.ConfigurationMapFeatureFlagProvider = ConfigurationMapFeatureFlagProvider;
+    exports.ConfigurationObjectFeatureFlagProvider = ConfigurationObjectFeatureFlagProvider;
+    exports.EvaluationResult = EvaluationResult;
+    exports.FeatureManager = FeatureManager;
+    exports.VERSION = VERSION;
+
+}));
+//# sourceMappingURL=index.js.map