@microsoft/feature-management 2.1.0 → 2.3.0

package/dist/umd/index.js

@@ -4,6 +4,419 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FeatureManagement = {}));
 })(this, (function (exports) { 'use strict';
 
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    const VALUE_OUT_OF_RANGE_ERROR_MESSAGE = "The value is out of the accepted range.";
+    const UNRECOGNIZABLE_VALUE_ERROR_MESSAGE = "The value is unrecognizable.";
+    const REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE = "Value cannot be undefined or empty.";
+    function buildInvalidParameterErrorMessage(parameterName, additionalInfo) {
+        return `The ${parameterName} parameter is not valid. ` + (additionalInfo ?? "");
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    const DAYS_PER_WEEK = 7;
+    const ONE_DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000;
+    var DayOfWeek;
+    (function (DayOfWeek) {
+        DayOfWeek[DayOfWeek["Sunday"] = 0] = "Sunday";
+        DayOfWeek[DayOfWeek["Monday"] = 1] = "Monday";
+        DayOfWeek[DayOfWeek["Tuesday"] = 2] = "Tuesday";
+        DayOfWeek[DayOfWeek["Wednesday"] = 3] = "Wednesday";
+        DayOfWeek[DayOfWeek["Thursday"] = 4] = "Thursday";
+        DayOfWeek[DayOfWeek["Friday"] = 5] = "Friday";
+        DayOfWeek[DayOfWeek["Saturday"] = 6] = "Saturday";
+    })(DayOfWeek || (DayOfWeek = {}));
+    /**
+     * The recurrence pattern describes the frequency by which the time window repeats
+     */
+    var RecurrencePatternType;
+    (function (RecurrencePatternType) {
+        /**
+         * The pattern where the time window will repeat based on the number of days specified by interval between occurrences
+         */
+        RecurrencePatternType[RecurrencePatternType["Daily"] = 0] = "Daily";
+        /**
+         * The pattern where the time window will repeat on the same day or days of the week, based on the number of weeks between each set of occurrences
+         */
+        RecurrencePatternType[RecurrencePatternType["Weekly"] = 1] = "Weekly";
+    })(RecurrencePatternType || (RecurrencePatternType = {}));
+    /**
+     * The recurrence range specifies the date range over which the time window repeats
+     */
+    var RecurrenceRangeType;
+    (function (RecurrenceRangeType) {
+        /**
+         * The recurrence has no end and repeats on all the days that fit the corresponding pattern
+         */
+        RecurrenceRangeType[RecurrenceRangeType["NoEnd"] = 0] = "NoEnd";
+        /**
+         * The recurrence repeats on all the days that fit the corresponding pattern until or on the specified end date
+         */
+        RecurrenceRangeType[RecurrenceRangeType["EndDate"] = 1] = "EndDate";
+        /**
+         * The recurrence repeats for the specified number of occurrences that match the pattern
+         */
+        RecurrenceRangeType[RecurrenceRangeType["Numbered"] = 2] = "Numbered";
+    })(RecurrenceRangeType || (RecurrenceRangeType = {}));
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    /**
+     * Calculates the offset in days between two given days of the week.
+     * @param day1 A day of week
+     * @param day2 A day of week
+     * @returns The number of days to be added to day2 to reach day1
+     */
+    function calculateWeeklyDayOffset(day1, day2) {
+        return (day1 - day2 + DAYS_PER_WEEK) % DAYS_PER_WEEK;
+    }
+    /**
+     * Sorts a collection of days of week based on their offsets from a specified first day of week.
+     * @param daysOfWeek A collection of days of week
+     * @param firstDayOfWeek The first day of week which will be the first element in the sorted result
+     * @returns The sorted days of week
+     */
+    function sortDaysOfWeek(daysOfWeek, firstDayOfWeek) {
+        const sortedDaysOfWeek = daysOfWeek.slice();
+        sortedDaysOfWeek.sort((x, y) => calculateWeeklyDayOffset(x, firstDayOfWeek) - calculateWeeklyDayOffset(y, firstDayOfWeek));
+        return sortedDaysOfWeek;
+    }
+    /**
+     * Gets the day of week of a given date based on the timezone offset.
+     * @param date A UTC date
+     * @param timezoneOffsetInMs The timezone offset in milliseconds
+     * @returns The day of week (0 for Sunday, 1 for Monday, ..., 6 for Saturday)
+     */
+    function getDayOfWeek(date, timezoneOffsetInMs) {
+        const alignedDate = new Date(date.getTime() + timezoneOffsetInMs);
+        return alignedDate.getUTCDay();
+    }
+    /**
+     * Adds a specified number of days to a given date.
+     * @param date The date to add days to
+     * @param days The number of days to add
+     * @returns The new date
+     */
+    function addDays(date, days) {
+        const result = new Date(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    const START_NOT_MATCHED_ERROR_MESSAGE = "Start date is not a valid first occurrence.";
+    const TIME_WINDOW_DURATION_OUT_OF_RANGE_ERROR_MESSAGE = "Time window duration cannot be longer than how frequently it occurs or be longer than 10 years.";
+    const PATTERN = "Recurrence.Pattern";
+    const PATTERN_TYPE = "Recurrence.Pattern.Type";
+    const INTERVAL = "Recurrence.Pattern.Interval";
+    const DAYS_OF_WEEK = "Recurrence.Pattern.DaysOfWeek";
+    const FIRST_DAY_OF_WEEK = "Recurrence.Pattern.FirstDayOfWeek";
+    const RANGE = "Recurrence.Range";
+    const RANGE_TYPE = "Recurrence.Range.Type";
+    const END_DATE = "Recurrence.Range.EndDate";
+    const NUMBER_OF_OCCURRENCES = "Recurrence.Range.NumberOfOccurrences";
+    /**
+     * Parses @see RecurrenceParameters into a @see RecurrenceSpec object. If the parameter is invalid, an error will be thrown.
+     * @param startTime The start time of the base time window
+     * @param day2 The end time of the base time window
+     * @param recurrenceParameters The @see RecurrenceParameters to parse
+     * @param TimeZoneOffset The time zone offset in milliseconds, by default 0
+     * @returns A @see RecurrenceSpec object
+     */
+    function parseRecurrenceParameter(startTime, endTime, recurrenceParameters, TimeZoneOffset = 0) {
+        if (startTime === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage("Start", REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE));
+        }
+        if (endTime === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage("End", REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE));
+        }
+        if (startTime >= endTime) {
+            throw new Error(buildInvalidParameterErrorMessage("End", VALUE_OUT_OF_RANGE_ERROR_MESSAGE));
+        }
+        const timeWindowDuration = endTime.getTime() - startTime.getTime();
+        if (timeWindowDuration > 10 * 365 * ONE_DAY_IN_MILLISECONDS) { // time window duration cannot be longer than 10 years
+            throw new Error(buildInvalidParameterErrorMessage("End", TIME_WINDOW_DURATION_OUT_OF_RANGE_ERROR_MESSAGE));
+        }
+        return {
+            startTime: startTime,
+            duration: timeWindowDuration,
+            pattern: parseRecurrencePattern(startTime, endTime, recurrenceParameters, TimeZoneOffset),
+            range: parseRecurrenceRange(startTime, recurrenceParameters),
+            timezoneOffset: TimeZoneOffset
+        };
+    }
+    function parseRecurrencePattern(startTime, endTime, recurrenceParameters, timeZoneOffset) {
+        const rawPattern = recurrenceParameters.Pattern;
+        if (rawPattern === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage(PATTERN, REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE));
+        }
+        if (rawPattern.Type === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage(PATTERN_TYPE, REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE));
+        }
+        const patternType = RecurrencePatternType[rawPattern.Type];
+        if (patternType === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage(PATTERN_TYPE, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+        }
+        let interval = rawPattern.Interval;
+        if (interval !== undefined) {
+            if (typeof interval !== "number") {
+                throw new Error(buildInvalidParameterErrorMessage(INTERVAL, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+            }
+            else if (interval <= 0 || !Number.isInteger(interval)) {
+                throw new Error(buildInvalidParameterErrorMessage(INTERVAL, VALUE_OUT_OF_RANGE_ERROR_MESSAGE));
+            }
+        }
+        else {
+            interval = 1;
+        }
+        const parsedPattern = {
+            type: patternType,
+            interval: interval
+        };
+        const timeWindowDuration = endTime.getTime() - startTime.getTime();
+        if (patternType === RecurrencePatternType.Daily) {
+            if (timeWindowDuration > interval * ONE_DAY_IN_MILLISECONDS) {
+                throw new Error(buildInvalidParameterErrorMessage("End", TIME_WINDOW_DURATION_OUT_OF_RANGE_ERROR_MESSAGE));
+            }
+        }
+        else if (patternType === RecurrencePatternType.Weekly) {
+            let firstDayOfWeek;
+            if (rawPattern.FirstDayOfWeek !== undefined) {
+                firstDayOfWeek = DayOfWeek[rawPattern.FirstDayOfWeek];
+                if (firstDayOfWeek === undefined) {
+                    throw new Error(buildInvalidParameterErrorMessage(FIRST_DAY_OF_WEEK, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+                }
+            }
+            else {
+                firstDayOfWeek = DayOfWeek.Sunday;
+            }
+            parsedPattern.firstDayOfWeek = firstDayOfWeek;
+            if (rawPattern.DaysOfWeek === undefined || rawPattern.DaysOfWeek.length === 0) {
+                throw new Error(buildInvalidParameterErrorMessage(DAYS_OF_WEEK, REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE));
+            }
+            if (!Array.isArray(rawPattern.DaysOfWeek)) {
+                throw new Error(buildInvalidParameterErrorMessage(DAYS_OF_WEEK, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+            }
+            const daysOfWeek = [...new Set(rawPattern.DaysOfWeek.map(day => DayOfWeek[day]))]; // dedup array
+            if (daysOfWeek.some(day => day === undefined)) {
+                throw new Error(buildInvalidParameterErrorMessage(DAYS_OF_WEEK, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+            }
+            if (timeWindowDuration > interval * DAYS_PER_WEEK * ONE_DAY_IN_MILLISECONDS ||
+                !isDurationCompliantWithDaysOfWeek(timeWindowDuration, interval, daysOfWeek, firstDayOfWeek)) {
+                throw new Error(buildInvalidParameterErrorMessage("End", TIME_WINDOW_DURATION_OUT_OF_RANGE_ERROR_MESSAGE));
+            }
+            parsedPattern.daysOfWeek = daysOfWeek;
+            // check whether "Start" is a valid first occurrence
+            const alignedStartDay = getDayOfWeek(startTime, timeZoneOffset);
+            if (!daysOfWeek.find(day => day === alignedStartDay)) {
+                throw new Error(buildInvalidParameterErrorMessage("Start", START_NOT_MATCHED_ERROR_MESSAGE));
+            }
+        }
+        return parsedPattern;
+    }
+    function parseRecurrenceRange(startTime, recurrenceParameters) {
+        const rawRange = recurrenceParameters.Range;
+        if (rawRange === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage(RANGE, REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE));
+        }
+        if (rawRange.Type === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage(RANGE_TYPE, REQUIRED_PARAMETER_MISSING_ERROR_MESSAGE));
+        }
+        const rangeType = RecurrenceRangeType[rawRange.Type];
+        if (rangeType === undefined) {
+            throw new Error(buildInvalidParameterErrorMessage(RANGE_TYPE, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+        }
+        const parsedRange = { type: rangeType };
+        if (rangeType === RecurrenceRangeType.EndDate) {
+            let endDate;
+            if (rawRange.EndDate !== undefined) {
+                endDate = new Date(rawRange.EndDate);
+                if (isNaN(endDate.getTime())) {
+                    throw new Error(buildInvalidParameterErrorMessage(END_DATE, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+                }
+                if (endDate < startTime) {
+                    throw new Error(buildInvalidParameterErrorMessage(END_DATE, VALUE_OUT_OF_RANGE_ERROR_MESSAGE));
+                }
+            }
+            else {
+                endDate = new Date(8.64e15); // the maximum date in ECMAScript: https://262.ecma-international.org/5.1/#sec-15.9.1.1
+            }
+            parsedRange.endDate = endDate;
+        }
+        else if (rangeType === RecurrenceRangeType.Numbered) {
+            let numberOfOccurrences = rawRange.NumberOfOccurrences;
+            if (numberOfOccurrences !== undefined) {
+                if (typeof numberOfOccurrences !== "number") {
+                    throw new Error(buildInvalidParameterErrorMessage(NUMBER_OF_OCCURRENCES, UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+                }
+                else if (numberOfOccurrences <= 0 || !Number.isInteger(numberOfOccurrences)) {
+                    throw new Error(buildInvalidParameterErrorMessage(NUMBER_OF_OCCURRENCES, VALUE_OUT_OF_RANGE_ERROR_MESSAGE));
+                }
+            }
+            else {
+                numberOfOccurrences = Number.MAX_SAFE_INTEGER;
+            }
+            parsedRange.numberOfOccurrences = numberOfOccurrences;
+        }
+        return parsedRange;
+    }
+    function isDurationCompliantWithDaysOfWeek(duration, interval, daysOfWeek, firstDayOfWeek) {
+        if (daysOfWeek.length === 1) {
+            return true;
+        }
+        const sortedDaysOfWeek = sortDaysOfWeek(daysOfWeek, firstDayOfWeek);
+        let prev = sortedDaysOfWeek[0]; // the closest occurrence day to the first day of week
+        let minGap = DAYS_PER_WEEK * ONE_DAY_IN_MILLISECONDS;
+        for (let i = 1; i < sortedDaysOfWeek.length; i++) { // skip the first day
+            const gap = calculateWeeklyDayOffset(sortedDaysOfWeek[i], prev) * ONE_DAY_IN_MILLISECONDS;
+            minGap = gap < minGap ? gap : minGap;
+            prev = sortedDaysOfWeek[i];
+        }
+        // It may across weeks. Check the next week if the interval is one week.
+        if (interval == 1) {
+            const gap = calculateWeeklyDayOffset(sortedDaysOfWeek[0], prev) * ONE_DAY_IN_MILLISECONDS;
+            minGap = gap < minGap ? gap : minGap;
+        }
+        return minGap >= duration;
+    }
+
+    // Copyright (c) Microsoft Corporation.
+    // Licensed under the MIT license.
+    /**
+     * Checks if a provided datetime is within any recurring time window specified by the recurrence information
+     * @param time A datetime
+     * @param recurrenceSpec The recurrence spcification
+     * @returns True if the given time is within any recurring time window; otherwise, false
+     */
+    function matchRecurrence(time, recurrenceSpec) {
+        const recurrenceState = findPreviousRecurrence(time, recurrenceSpec);
+        if (recurrenceState) {
+            return time.getTime() < recurrenceState.previousOccurrence.getTime() + recurrenceSpec.duration;
+        }
+        return false;
+    }
+    /**
+     * Finds the closest previous recurrence occurrence before the given time according to the recurrence information
+     * @param time A datetime
+     * @param recurrenceSpec The recurrence specification
+     * @returns The recurrence state if any previous occurrence is found; otherwise, undefined
+     */
+    function findPreviousRecurrence(time, recurrenceSpec) {
+        if (time < recurrenceSpec.startTime) {
+            return undefined;
+        }
+        let result;
+        const pattern = recurrenceSpec.pattern;
+        if (pattern.type === RecurrencePatternType.Daily) {
+            result = findPreviousDailyRecurrence(time, recurrenceSpec);
+        }
+        else if (pattern.type === RecurrencePatternType.Weekly) {
+            result = findPreviousWeeklyRecurrence(time, recurrenceSpec);
+        }
+        else {
+            throw new Error("Unsupported recurrence pattern type.");
+        }
+        const { previousOccurrence, numberOfOccurrences } = result;
+        const range = recurrenceSpec.range;
+        if (range.type === RecurrenceRangeType.EndDate) {
+            if (previousOccurrence > range.endDate) {
+                return undefined;
+            }
+        }
+        else if (range.type === RecurrenceRangeType.Numbered) {
+            if (numberOfOccurrences > range.numberOfOccurrences) {
+                return undefined;
+            }
+        }
+        return result;
+    }
+    function findPreviousDailyRecurrence(time, recurrenceSpec) {
+        const startTime = recurrenceSpec.startTime;
+        const timeGap = time.getTime() - startTime.getTime();
+        const pattern = recurrenceSpec.pattern;
+        const numberOfIntervals = Math.floor(timeGap / (pattern.interval * ONE_DAY_IN_MILLISECONDS));
+        return {
+            previousOccurrence: addDays(startTime, numberOfIntervals * pattern.interval),
+            numberOfOccurrences: numberOfIntervals + 1
+        };
+    }
+    function findPreviousWeeklyRecurrence(time, recurrenceSpec) {
+        /*
+         * Algorithm:
+         * 1. first find day 0 (d0), it's the day representing the start day on the week of `Start`.
+         * 2. find start day of the most recent occurring week d0 + floor((time - d0) / (interval * 7)) * (interval * 7)
+         * 3. if that's over 7 days ago, then previous occurence is the day with the max offset of the last occurring week
+         * 4. if gotten this far, then the current week is the most recent occurring week:
+             i. if time > day with min offset, then previous occurence is the day with max offset less than current
+            ii. if time < day with min offset, then previous occurence is the day with the max offset of previous occurring week
+         */
+        const startTime = recurrenceSpec.startTime;
+        const startDay = getDayOfWeek(startTime, recurrenceSpec.timezoneOffset);
+        const pattern = recurrenceSpec.pattern;
+        const sortedDaysOfWeek = sortDaysOfWeek(pattern.daysOfWeek, pattern.firstDayOfWeek);
+        /*
+         * Example:
+         * startTime = 2024-12-11 (Tue)
+         * pattern.interval = 2 pattern.firstDayOfWeek = Sun pattern.daysOfWeek = [Wed, Sun]
+         * sortedDaysOfWeek = [Sun, Wed]
+         * firstDayofStartWeek = 2024-12-08 (Sun)
+         *
+         * time = 2024-12-23 (Mon) timeGap = 15 days
+         * the most recent occurring week: 2024-12-22 ~ 2024-12-28
+         * number of intervals before the most recent occurring week = 15 / (2 * 7) = 1 (2024-12-08 ~ 2023-12-21)
+         * number of occurrences before the most recent occurring week = 1 * 2 - 1 = 1 (2024-12-11)
+         * firstDayOfLastOccurringWeek = 2024-12-22
+         */
+        const firstDayofStartWeek = addDays(startTime, -calculateWeeklyDayOffset(startDay, pattern.firstDayOfWeek));
+        const timeGap = time.getTime() - firstDayofStartWeek.getTime();
+        // number of intervals before the most recent occurring week
+        const numberOfIntervals = Math.floor(timeGap / (pattern.interval * DAYS_PER_WEEK * ONE_DAY_IN_MILLISECONDS));
+        // number of occurrences before the most recent occurring week, it is possible to be negative
+        let numberOfOccurrences = numberOfIntervals * sortedDaysOfWeek.length - sortedDaysOfWeek.indexOf(startDay);
+        const firstDayOfLatestOccurringWeek = addDays(firstDayofStartWeek, numberOfIntervals * pattern.interval * DAYS_PER_WEEK);
+        // the current time is out of the last occurring week
+        if (time > addDays(firstDayOfLatestOccurringWeek, DAYS_PER_WEEK)) {
+            numberOfOccurrences += sortDaysOfWeek.length;
+            // day with max offset in the last occurring week
+            const previousOccurrence = addDays(firstDayOfLatestOccurringWeek, calculateWeeklyDayOffset(sortedDaysOfWeek.at(-1), pattern.firstDayOfWeek));
+            return {
+                previousOccurrence: previousOccurrence,
+                numberOfOccurrences: numberOfOccurrences
+            };
+        }
+        let dayWithMinOffset = addDays(firstDayOfLatestOccurringWeek, calculateWeeklyDayOffset(sortedDaysOfWeek[0], pattern.firstDayOfWeek));
+        if (dayWithMinOffset < startTime) {
+            numberOfOccurrences = 0;
+            dayWithMinOffset = startTime;
+        }
+        let previousOccurrence;
+        if (time >= dayWithMinOffset) {
+            // the previous occurence is the day with max offset less than current
+            previousOccurrence = dayWithMinOffset;
+            numberOfOccurrences += 1;
+            const dayWithMinOffsetIndex = sortedDaysOfWeek.indexOf(getDayOfWeek(dayWithMinOffset, recurrenceSpec.timezoneOffset));
+            for (let i = dayWithMinOffsetIndex + 1; i < sortedDaysOfWeek.length; i++) {
+                const day = addDays(firstDayOfLatestOccurringWeek, calculateWeeklyDayOffset(sortedDaysOfWeek[i], pattern.firstDayOfWeek));
+                if (time < day) {
+                    break;
+                }
+                previousOccurrence = day;
+                numberOfOccurrences += 1;
+            }
+        }
+        else {
+            const firstDayOfPreviousOccurringWeek = addDays(firstDayOfLatestOccurringWeek, -pattern.interval * DAYS_PER_WEEK);
+            // the previous occurence is the day with the max offset of previous occurring week
+            previousOccurrence = addDays(firstDayOfPreviousOccurringWeek, calculateWeeklyDayOffset(sortedDaysOfWeek.at(-1), pattern.firstDayOfWeek));
+        }
+        return {
+            previousOccurrence: previousOccurrence,
+            numberOfOccurrences: numberOfOccurrences
+        };
+    }
+
     // Copyright (c) Microsoft Corporation.
     // Licensed under the MIT license.
     class TimeWindowFilter {
@@ -12,13 +425,36 @@
             const { featureName, parameters } = context;
             const startTime = parameters.Start !== undefined ? new Date(parameters.Start) : undefined;
             const endTime = parameters.End !== undefined ? new Date(parameters.End) : undefined;
+            const baseErrorMessage = `The ${this.name} feature filter is not valid for feature ${featureName}. `;
             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.`);
+                console.warn(baseErrorMessage + "It must specify either 'Start', 'End', or both.");
+                return false;
+            }
+            if (startTime !== undefined && isNaN(startTime.getTime())) {
+                console.warn(baseErrorMessage + buildInvalidParameterErrorMessage("Start", UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
+                return false;
+            }
+            if (endTime !== undefined && isNaN(endTime.getTime())) {
+                console.warn(baseErrorMessage + buildInvalidParameterErrorMessage("End", UNRECOGNIZABLE_VALUE_ERROR_MESSAGE));
                 return false;
             }
             const now = new Date();
-            return (startTime === undefined || startTime <= now) && (endTime === undefined || now < endTime);
+            if ((startTime === undefined || startTime <= now) && (endTime === undefined || now < endTime)) {
+                return true;
+            }
+            if (parameters.Recurrence !== undefined) {
+                let recurrence;
+                try {
+                    recurrence = parseRecurrenceParameter(startTime, endTime, parameters.Recurrence);
+                }
+                catch (error) {
+                    console.warn(baseErrorMessage + error.message);
+                    return false;
+                }
+                return matchRecurrence(now, recurrence);
+            }
+            return false;
         }
     }
 
@@ -696,7 +1132,7 @@
 
     // Copyright (c) Microsoft Corporation.
     // Licensed under the MIT license.
-    const VERSION$1 = "2.1.0";
+    const VERSION$1 = "2.3.0";
     const EVALUATION_EVENT_VERSION = "1.0.0";
 
     // Copyright (c) Microsoft Corporation.