@becollective/utils 1.10.2 → 2.0.0

package/lib/rrule.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recurrencesBetweenV2 = exports.recurrencesBetween = exports.recurrenceToTextInTimezone = exports.recurrenceToText = exports.isValidRrule = exports.buildBcRruleString = exports.validateRruleConfigV2 = exports.validateRruleConfig = exports.parse = exports.toRruleStr = exports.toRruleObj = void 0;
+const rrule_1 = require("rrule");
+const luxon_1 = require("luxon");
+const index_1 = require("./rrule/index");
+Object.defineProperty(exports, "toRruleObj", { enumerable: true, get: function () { return index_1.toRruleObj; } });
+Object.defineProperty(exports, "toRruleStr", { enumerable: true, get: function () { return index_1.toRruleStr; } });
+const date_1 = require("./rrule/date");
+const isEmpty = (obj) => {
+    if (Array.isArray(obj) || typeof obj === 'string') {
+        return obj.length === 0;
+    }
+    return !obj;
+};
+const omit = (obj, keys) => {
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+};
+const omitBy = (obj, predicate) => {
+    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => !predicate(value, key)));
+};
+const logError = (...args) => {
+    const logger = console.error || console.log;
+    logger(...args);
+};
+// Customised recurrenceRule parser for BeCollective
+// We store DURATION in our rules, which are not supported by rrule
+// We need to return this data and also remove it from our rrule configuration before parsing it
+const parse = function parse(str) {
+    const icalObj = (0, index_1.toRruleObj)(str);
+    const duration = (0, index_1.getDuration)(icalObj);
+    // TODO delete unused?
+    // const until = icalObj.UNTIL;
+    const dtend = icalObj.DTEND;
+    const nondurationItems = omit(icalObj, ['DURATION', 'DTEND']);
+    const rrule = (0, rrule_1.rrulestr)((0, index_1.toRruleStr)(omitBy(nondurationItems, isEmpty)));
+    return { duration, durationString: icalObj.DURATION, rrule, dtend };
+};
+exports.parse = parse;
+const validateRruleConfig = (obj) => {
+    const config = obj || {};
+    const REQUIRED_FIELDS = [
+        { field: 'DTSTART', name: 'Start time' },
+        { field: 'RRULE:FREQ', name: 'Frequency (Month/Weekly)' },
+        { field: 'INTERVAL', name: 'Interval' },
+        { field: 'UNTIL', name: 'Until' },
+        { field: 'Duration', name: 'Duration' },
+    ];
+    const errors = [];
+    REQUIRED_FIELDS.forEach((fieldConfig) => {
+        if (!config[fieldConfig.field]) {
+            errors.push(`Please enter a ${fieldConfig.name}`);
+        }
+    });
+    if (config.DTSTART && config.UNTIL && luxon_1.DateTime.fromISO(config.DTSTART) > luxon_1.DateTime.fromISO(config.UNTIL)) {
+        errors.push('DTSTART must be earlier than or equal to UNTIL');
+    }
+    return errors;
+};
+exports.validateRruleConfig = validateRruleConfig;
+const validateRruleConfigV2 = (bcRruleInstance) => {
+    const rruleInstance = bcRruleInstance.rrule;
+    const REQUIRED_RRULE_FIELDS = [
+        { field: 'dtstart', name: 'Start time' },
+        { field: 'interval', name: 'Interval' },
+        { field: 'until', name: 'Until' },
+    ];
+    const REQUIRED_BC_FIELDS = [{ field: 'duration', name: 'Duration' }];
+    const REQUIRED_BC_FREQ = {
+        field: 'freq',
+        name: 'Frequency (Month/Weekly/Yearly)',
+        values: [rrule_1.RRule.YEARLY, rrule_1.RRule.WEEKLY, rrule_1.RRule.MONTHLY],
+    };
+    const errors = [];
+    REQUIRED_RRULE_FIELDS.forEach((fieldConfig) => {
+        if (!rruleInstance.options[fieldConfig.field]) {
+            errors.push(`Please enter a ${fieldConfig.name}`);
+        }
+    });
+    if (!REQUIRED_BC_FREQ.values.includes(rruleInstance.options[REQUIRED_BC_FREQ.field])) {
+        errors.push(`Please enter a ${REQUIRED_BC_FREQ.name}`);
+    }
+    REQUIRED_BC_FIELDS.forEach((fieldConfig) => {
+        if (!bcRruleInstance[fieldConfig.field]) {
+            errors.push(`Please enter a ${fieldConfig.name}`);
+        }
+    });
+    if (rruleInstance.options.dtstart &&
+        rruleInstance.options.until &&
+        luxon_1.DateTime.fromISO(rruleInstance.options.dtstart) > luxon_1.DateTime.fromISO(rruleInstance.options.until)) {
+        errors.push('DTSTART must be earlier than or equal to UNTIL');
+    }
+    return errors;
+};
+exports.validateRruleConfigV2 = validateRruleConfigV2;
+/**
+ * a helper function that put offical rrule and becollective rrule fields together
+ * @param {Object} rruleInstance an RRule instance.
+ * @param {*} duration non rrule standard duration field.
+ */
+const buildBcRruleString = (rruleInstance, duration = '0H') => {
+    let rruleString = rruleInstance.toString();
+    if (duration) {
+        rruleString = `${rruleString};DURATION=${duration}`;
+    }
+    const bcRrule = (0, exports.parse)(rruleString);
+    const errors = (0, exports.validateRruleConfigV2)(bcRrule);
+    if (errors.length === 0) {
+        return rruleString;
+    }
+    else {
+        throw new Error(JSON.stringify(errors));
+    }
+};
+exports.buildBcRruleString = buildBcRruleString;
+const isValidRrule = (obj) => (0, exports.validateRruleConfig)(obj).length === 0;
+exports.isValidRrule = isValidRrule;
+/* === TIMEZONE ISSUES WITH RRULE ===
+
+The rrule library does not store, use or account for timezone. The timezone information is lost and this leads to bugs displaying times and with
+generating recurrences. This happens because rrule determines the start time by interpreting DTSTART in the timezone of the runtime
+environment. This is fine when the runtime and an opportunity share the same timezone. However, inconsistencies occur when they
+differ, and daylight savings is introduced.
+
+INCONSISTENT START & END TIMES
+-------------------------------------------
+We want to specify a start and end time (5pm - 7pm)
+Technically we need to express this start and end time as UTC timestamps (2017-07-03 T07:00 - 2017-07-03 T09:00)
+
+This presents a problem when we interpret rrule strings to display and generate recurrences.
+
+Consider that we want a recurrenceRule to apply for ‘Asia/Taipei (+0800 UTC)’ and start at 1500 hours, we would have the following
+UTC timestamp:
+
+2017-07-03 T07:00
+
+If our runtime is using Australia/Melbourne time, rrule would determine the start time of each recurrence to be at T17:00
+
+In Asia/Taipei time, that is T15:00 which is correct
+
+However, fast forward to October when daylight savings kicks in for Australia/Melbourne, and suddenly T17:00 translates to T14:00
+in Asia/Taipei.
+
+As illustrated above, we need to workaround the rrule library by incorporating timezone information in the way we display and
+generate recurrences.
+
+OFF BY ONE DATES
+———————————
+This bug occurs because the start time is determined using runtime’s timezone. When finding recurrences between a set of dates,
+the correct dates and times are found for the runtime’s local timezone. But when the client uses these dates, the timezone
+conversion could cause the date to change.
+
+Example generated start time: 2017-10-10 T20:30 UTC
+If a Melbourne client interprets this timestamp, it would translate to: 2017-10-11 T:07:30 AEST
+
+So time is correct but date is WRONG
+
+
+--- SUMMARY & TLDR ---;
+The rrule spec causes us to lose timezone information and leads to inconsistent interpretations of DTSTART and UNTIL times. This is
+further complicated by the fact that a rule is parsed and interpreted based on code runtime’s timezone, which means we are
+potentially shuffling and converting things between 3 timezones: UTC -> runtime -> opportunity. Hence we must implement several
+“tricks” so that we ignore the time portion from dates and the date portion from times.
+
+***********************************************************/
+// Return correct and consistent human readable values for a recurrenceRule
+// We need to ignore DTSTART date component and use only the time component so start time is updated according to daylight
+// savings
+const recurrenceToText = (recurrenceRule, timezone, isFlexible = false) => {
+    const TIME_FORMAT = 'h:mm a';
+    try {
+        const { duration, rrule: rule } = (0, exports.parse)(recurrenceRule);
+        const dtstartToTimezone = luxon_1.DateTime.fromJSDate(rule.origOptions.dtstart).setZone(timezone);
+        const untilToTimezone = luxon_1.DateTime.fromJSDate(rule.origOptions.until).setZone(timezone);
+        const rrule = new rrule_1.RRule({
+            ...rule.origOptions,
+            dtstart: luxon_1.DateTime.utc(dtstartToTimezone.year, dtstartToTimezone.month, dtstartToTimezone.day, dtstartToTimezone.hour, dtstartToTimezone.minute, dtstartToTimezone.second)
+                .toJSDate(),
+            tzid: timezone,
+            until: luxon_1.DateTime.utc(untilToTimezone.year, untilToTimezone.month, untilToTimezone.day, untilToTimezone.hour, untilToTimezone.minute, untilToTimezone.second)
+                .toJSDate(),
+        });
+        if (isFlexible) {
+            const hours = duration / 1000 / 60 / 60;
+            let ruleText = rrule.toText();
+            if (rule.origOptions.count === 1) {
+                // When it is not a repeating rule
+                ruleText = ruleText.replace(/every year until/i, 'in total by');
+                ruleText = ruleText.replace(/ \(~ approximate\)/i, '');
+            }
+            return {
+                text: `${hours} hours ${ruleText}`,
+                timezone,
+            };
+        }
+        // Get today's start time in the recurrenceRule's timezone, then convert that timestamp to our local time
+        const end = dtstartToTimezone.plus(duration);
+        return {
+            text: rrule.toText().charAt(0).toUpperCase() + rrule.toText().slice(1),
+            time: `${dtstartToTimezone.toFormat(TIME_FORMAT)} to ${end.toFormat(TIME_FORMAT)}`,
+            timezone,
+        };
+    }
+    catch (e) {
+        return { text: '', time: '', timezone };
+    }
+};
+exports.recurrenceToText = recurrenceToText;
+// Return the text based on the specified timezone
+// This method doesn't convert rrule to it's owner opportunity's timezone
+const recurrenceToTextInTimezone = (recurrenceRule, timezone) => {
+    const TIME_FORMAT = 'h:mm A';
+    const localTimezone = timezone || 'UTC';
+    try {
+        const { duration, rrule: rule } = (0, exports.parse)(recurrenceRule);
+        const start = luxon_1.DateTime.fromISO((0, index_1.getStartTime)(recurrenceRule, localTimezone), 'HHmm').setZone(localTimezone);
+        const end = luxon_1.DateTime.fromISO((0, index_1.getEndTime)(start.toJSDate(), duration)).setZone(localTimezone);
+        return {
+            text: rule.toText().charAt(0).toUpperCase() + rule.toText().slice(1),
+            time: `${start.toFormat(TIME_FORMAT)} to ${end.toFormat(TIME_FORMAT)}`,
+            localTimezone,
+        };
+    }
+    catch (e) {
+        return { text: '', time: '', localTimezone };
+    }
+};
+exports.recurrenceToTextInTimezone = recurrenceToTextInTimezone;
+const recurrencesBetween = (fromDate, toDate, recurrenceRule, timezone) => {
+    try {
+        // We need to deal with time and dates separately because timestamps will be converted and lead to errors
+        const time = (0, index_1.getStartTime)(recurrenceRule, timezone);
+        const { duration, rrule: rule } = (0, exports.parse)(recurrenceRule);
+        const recurrences = rule.between(fromDate, toDate);
+        return recurrences.map((start) => {
+            // eslint-disable-next-line no-undef
+            const fixed = (0, date_1.transpose)(start, time, timezone);
+            return {
+                from: fixed,
+                to: (0, index_1.getEndTime)(fixed, duration),
+            };
+        });
+    }
+    catch (e) {
+        logError('Error while generating recurrences between', fromDate.toString(), 'to', toDate.toString());
+        logError('RRULE:', recurrenceRule, 'TIMEZONE:', timezone);
+        logError('***\n\n', e, '\n\n***');
+        return [];
+    }
+};
+exports.recurrencesBetween = recurrencesBetween;
+/**
+ *
+ * @param {*} rrule
+ * @param {*} timezone
+ * @param {*} from
+ * @param {*} isFlexible
+ * @returns an array of date in true utc (DST offset is considered)
+ */
+const recurrencesBetweenV2 = (rrule, timezone, from = new Date(), isFlexible = false) => {
+    const { duration, rrule: rule } = (0, exports.parse)(rrule);
+    const dtstartToTimezone = luxon_1.DateTime.fromJSDate(rule.origOptions.dtstart).setZone(timezone);
+    const untilToTimezone = luxon_1.DateTime.fromJSDate(rule.origOptions.until).setZone(timezone);
+    const rruleToConvert = new rrule_1.RRule({
+        ...rule.origOptions,
+        dtstart: luxon_1.DateTime.utc(dtstartToTimezone.year, dtstartToTimezone.month, dtstartToTimezone.day, dtstartToTimezone.hour, dtstartToTimezone.minute, dtstartToTimezone.second).toJSDate(),
+        tzid: timezone,
+        until: luxon_1.DateTime.utc(untilToTimezone.year, untilToTimezone.month, untilToTimezone.day, untilToTimezone.hour, untilToTimezone.minute, untilToTimezone.second).toJSDate(),
+    });
+    const occurrences = rruleToConvert
+        .all()
+        .map((date) => luxon_1.DateTime.fromJSDate(date).toUTC().setZone('local', { keepLocalTime: true }));
+    if (!occurrences.length) {
+        return [];
+    }
+    const output = [];
+    if (isFlexible) {
+        let i = 0;
+        occurrences.map(o => {
+            output.push({ from: o.toJSDate(), to: o.toJSDate() });
+            // update "to" field
+            if (i > 0) {
+                output[i - 1].to = o.toUTC().minus({ seconds: 1 }).toJSDate();
+            }
+            if (i === occurrences.length - 1) {
+                output[i].to = luxon_1.DateTime.fromJSDate(rule.options.until).toUTC().minus({ seconds: 1 }).toJSDate();
+            }
+            i++;
+        });
+        return output.filter(((o) => from ? luxon_1.DateTime.fromJSDate(o.to) > luxon_1.DateTime.fromJSDate(from) : luxon_1.DateTime.fromJSDate(o.to) < luxon_1.DateTime.fromJSDate(rule.options.until)));
+    }
+    else {
+        const output = [];
+        occurrences.map(o => {
+            output.push({
+                from: o.toJSDate(),
+                to: o.toUTC().plus(duration).toJSDate(),
+            });
+        });
+        return output.filter(((o) => from ? luxon_1.DateTime.fromJSDate(o.to) > luxon_1.DateTime.fromJSDate(from) : luxon_1.DateTime.fromJSDate(o.to) < luxon_1.DateTime.fromJSDate(rule.options.until)));
+    }
+};
+exports.recurrencesBetweenV2 = recurrencesBetweenV2;

package/lib/src/FeatureFlag.d.ts

@@ -0,0 +1,12 @@
+export declare class FeatureFlag {
+    ttl: number;
+    expiry: number;
+    constructor(ttl?: any);
+    isFeatureActive(feature: string, options: {
+        env: string;
+        region?: string;
+    }): Promise<boolean>;
+    clearCache(): void;
+    setCacheTtl(ttl: number): void;
+}
+export default FeatureFlag;

package/lib/src/FeatureFlag.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlag = void 0;
+const cache = {
+    store: new Map(),
+    memoize: async (feature, options) => {
+        const stringified = JSON.stringify({ feature, options });
+        const response = cache.store.get(stringified);
+        if (response) {
+            return JSON.parse(response);
+        }
+        const fetchResponse = await fetchFeatureActive(feature, options);
+        cache.store.set(stringified, JSON.stringify(fetchResponse));
+        return fetchResponse;
+    },
+};
+const fetchFeatureActive = async (feature, options) => {
+    const getFlagByFeatureUrl = `https://lb-central.becollective.com/api/v2/feature-flags/${feature}`;
+    let isFeatureActive = false;
+    const featureFlags = await fetch(getFlagByFeatureUrl, { method: 'get' });
+    const json = await featureFlags.json();
+    const environments = json.Environments;
+    if (environments) {
+        isFeatureActive = environments.includes(options.env);
+    }
+    return isFeatureActive;
+};
+class FeatureFlag {
+    constructor(ttl) {
+        this.ttl = ttl || 1000 * 60 * 5; // default to 5 minutes
+        this.expiry = Date.now() + ttl;
+    }
+    async isFeatureActive(feature, options) {
+        // Lazy expiration upon function call
+        const now = Date.now();
+        if (now >= this.expiry) {
+            cache.store.clear();
+            this.expiry = now + this.ttl;
+        }
+        return cache.memoize(feature, options);
+    }
+    clearCache() {
+        cache.store.clear();
+    }
+    setCacheTtl(ttl) {
+        this.ttl = ttl;
+        this.expiry = Date.now() + ttl;
+    }
+}
+exports.FeatureFlag = FeatureFlag;
+exports.default = FeatureFlag;

package/lib/src/date-time.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Get current age based on the given birth date
+ * @param {string} dateOfBirth
+ * @param {string} unit the measurement of the the difference
+ *  The supported measurements are:
+ *  years, months, weeks, days, hours, minutes, and seconds.
+ * @returns {number} age
+ */
+export declare const getAge: (dateOfBirth: any, unit?: string) => number;
+/**
+ * Check if a user requires parent(guardian) consent
+ * i.e. Is under the age of 16 years, based on GDPR
+ * https://gdpr-info.eu/art-8-gdpr/
+ * @param {string} dateOfBirth moment.js compatible date time
+ * @returns {boolean}
+ * NOTE:
+ * We used to not allow child (under 16) to register,
+ * and birthdate is not a required field for ghost user
+ * So an existing user could have no birthdate, we assume these users are adults
+ * TODO:
+ * Remove above logic after we migrated all legacy
+ * data to have a consistent birthdate property.
+ * Then we should throw error if birthdate is not valid
+ */
+export declare const isUnderSixteen: (dateOfBirth: any) => boolean;
+export declare const isUnderAge: (dateOfBirth: any, limit: any, maxAcknowledgedAge?: number | null) => boolean;
+export declare const datesByThemselves: (a: any, b: any) => number;
+export declare const getShiftText: (from: any, to: any, timezone: any) => string;

package/lib/src/date-time.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShiftText = exports.datesByThemselves = exports.isUnderAge = exports.isUnderSixteen = exports.getAge = void 0;
+const luxon_1 = require("luxon");
+/**
+ * Get current age based on the given birth date
+ * @param {string} dateOfBirth
+ * @param {string} unit the measurement of the the difference
+ *  The supported measurements are:
+ *  years, months, weeks, days, hours, minutes, and seconds.
+ * @returns {number} age
+ */
+const getAge = (dateOfBirth, unit = 'years') => {
+    if (!dateOfBirth) {
+        throw new Error('Invalid date');
+    }
+    const dob = luxon_1.DateTime.fromJSDate(new Date(dateOfBirth));
+    if (!dob.isValid) {
+        throw new Error('Invalid date');
+    }
+    const age = dob.diffNow(unit);
+    const ageUnit = -age.as(unit);
+    // Note: luxon returns scientific notation, ie 6.976154236428209e-9
+    return Number(ageUnit.toString().split('.').shift());
+};
+exports.getAge = getAge;
+/**
+ * Check if a user requires parent(guardian) consent
+ * i.e. Is under the age of 16 years, based on GDPR
+ * https://gdpr-info.eu/art-8-gdpr/
+ * @param {string} dateOfBirth moment.js compatible date time
+ * @returns {boolean}
+ * NOTE:
+ * We used to not allow child (under 16) to register,
+ * and birthdate is not a required field for ghost user
+ * So an existing user could have no birthdate, we assume these users are adults
+ * TODO:
+ * Remove above logic after we migrated all legacy
+ * data to have a consistent birthdate property.
+ * Then we should throw error if birthdate is not valid
+ */
+const isUnderSixteen = (dateOfBirth) => {
+    if (!dateOfBirth || !luxon_1.DateTime.fromJSDate(new Date(dateOfBirth)).isValid) {
+        return false;
+    }
+    const age = (0, exports.getAge)(dateOfBirth);
+    return isNaN(age) ? false : age < 16;
+};
+exports.isUnderSixteen = isUnderSixteen;
+const isUnderAge = (dateOfBirth, limit, maxAcknowledgedAge = null) => {
+    if ((!dateOfBirth || !luxon_1.DateTime.fromJSDate(new Date(dateOfBirth)).isValid) && !maxAcknowledgedAge) {
+        return false;
+    }
+    if (dateOfBirth) {
+        const age = (0, exports.getAge)(dateOfBirth);
+        return isNaN(age) ? true : age < limit;
+    }
+    return maxAcknowledgedAge ? maxAcknowledgedAge < limit : true;
+};
+exports.isUnderAge = isUnderAge;
+const datesByThemselves = (a, b) => {
+    if (!a.from)
+        return 1;
+    return new Date(a.from).getTime() - new Date(b.from).getTime();
+};
+exports.datesByThemselves = datesByThemselves;
+const getShiftText = (from, to, timezone) => {
+    try {
+        if (!from || !to || !timezone)
+            return '';
+        const startToTimezone = luxon_1.DateTime.fromJSDate(from).setZone(timezone);
+        const endToTimezone = luxon_1.DateTime.fromJSDate(to).setZone(timezone);
+        return `${startToTimezone.toFormat('cccc, DD, h:mma')}-${endToTimezone.toFormat('h:mma')}`;
+    }
+    catch (e) {
+        return '';
+    }
+};
+exports.getShiftText = getShiftText;

package/lib/src/forms.d.ts

@@ -0,0 +1 @@
+export {};