@becollective/utils 1.10.3 → 2.0.1

package/lib/locality.d.ts

@@ -0,0 +1,5 @@
+/**
+ *
+ * @param {Array} locationList
+ */
+export declare const getHomeLocalityFromLocationList: (locationList: any) => any;

package/lib/locality.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHomeLocalityFromLocationList = void 0;
+/**
+ *
+ * @param {Array} locationList
+ */
+const getHomeLocalityFromLocationList = (locationList) => {
+    const homeLocation = Array.isArray(locationList) && locationList.find((location) => location.name === 'Home');
+    if (homeLocation && homeLocation.locality && homeLocation.locality.long) {
+        return homeLocation.locality.long;
+    }
+    return null;
+};
+exports.getHomeLocalityFromLocationList = getHomeLocalityFromLocationList;

package/lib/money.d.ts

@@ -0,0 +1,7 @@
+export declare const getCurrencyFromCurrencyCode: (currencyCode: any) => any;
+export declare const makeMoneyString: ({ amount: inputAmount, currencyCode, rounded, showCurrencyCode }: {
+    amount: any;
+    currencyCode: any;
+    rounded?: boolean | undefined;
+    showCurrencyCode?: boolean | undefined;
+}) => string;

package/lib/money.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMoneyString = exports.getCurrencyFromCurrencyCode = void 0;
+const { currencies } = require('@becollective/constants');
+// We should probably throw and error on bad input instead of falling back to a default.
+// We're making an assumption that whoever is calling this function can safely work
+// with AUD. But this assumption removes a lot of error handling elsewhere.
+const getCurrencyFromCurrencyCode = (currencyCode) => {
+    if (typeof currencyCode !== 'string' || !currencies[currencyCode]) {
+        console.error(new Error(`Invalid currencyCode: ${currencyCode}. Falling back to 'AUD'.`));
+        return currencies.AUD;
+    }
+    return currencies[currencyCode];
+};
+exports.getCurrencyFromCurrencyCode = getCurrencyFromCurrencyCode;
+const makeMoneyString = ({ amount: inputAmount, currencyCode, rounded = false, showCurrencyCode = false }) => {
+    let amount = Number(inputAmount);
+    if (isNaN(amount)) {
+        console.error(new Error(`Invalid amount: ${inputAmount}. Falling back to 0.`));
+        amount = 0;
+    }
+    const currency = (0, exports.getCurrencyFromCurrencyCode)(currencyCode);
+    const { minorUnit, symbol } = currency;
+    const decimalPlaces = rounded ? 0 : minorUnit;
+    const localeAmount = amount.toLocaleString(undefined, {
+        minimumFractionDigits: decimalPlaces,
+        maximumFractionDigits: decimalPlaces,
+    });
+    const currencyCodeString = showCurrencyCode ? ` ${currency.code}` : '';
+    return `${symbol}${localeAmount}${currencyCodeString}`;
+};
+exports.makeMoneyString = makeMoneyString;

package/lib/opportunity.d.ts

@@ -0,0 +1 @@
+export declare const readableOpportunityType: (type: any) => string | null;

package/lib/opportunity.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readableOpportunityType = void 0;
+const { opportunities } = require('@becollective/constants');
+const { typesMapV2: opportunityTypes } = opportunities;
+const TYPE_MAP = {
+    [opportunityTypes.shift]: 'Shifts',
+    [opportunityTypes.flexible]: 'Flexible',
+};
+const readableOpportunityType = (type) => TYPE_MAP[type] || null;
+exports.readableOpportunityType = readableOpportunityType;

package/lib/opportunityUser.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {*} opportunityUser
+ * @param {*} opportunity
+ */
+export declare const getTimeInfo: (opportunityUser: any, opportunity?: null) => {
+    [k: string]: unknown;
+};

package/lib/opportunityUser.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeInfo = void 0;
+const pick = (obj, keysToPick = []) => {
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => keysToPick.includes(key)));
+};
+/**
+ *
+ * @param {*} opportunityUser
+ * @param {*} opportunity
+ */
+const getTimeInfo = (opportunityUser, opportunity = null) => {
+    const opp = opportunity || opportunityUser.opportunity;
+    const isEoi = (opportunityUser && opportunityUser.eoi) || (opp && opp.eoi);
+    const record = isEoi ? opportunityUser : opp;
+    const fields = pick(record, [
+        'startDate',
+        'endDate',
+        'type',
+        'dates',
+        'recurrenceRule',
+        'timezone',
+        'location',
+        'locationOther',
+        'locationVirtual',
+    ]);
+    return fields;
+};
+exports.getTimeInfo = getTimeInfo;

package/lib/password.d.ts

@@ -0,0 +1,8 @@
+export declare const password: {
+    hasUppercase: (input: any) => boolean;
+    hasLowerCase: (input: any) => boolean;
+    hasNumeral: (input: any) => boolean;
+    validate: (input: any) => boolean;
+    isValid: (input: any) => boolean;
+};
+export default password;

package/lib/password.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.password = void 0;
+exports.password = {
+    hasUppercase: (input) => {
+        return !!input.match(/[A-Z]/);
+    },
+    hasLowerCase: (input) => {
+        return !!input.match(/[a-z]/);
+    },
+    hasNumeral: (input) => {
+        return !!input.match(/[0-9]/);
+    },
+    validate: (input) => {
+        if (typeof input !== 'string') {
+            throw new Error('not-string');
+        }
+        else if (input.length < 12) {
+            throw new Error('invalid-length');
+        }
+        let rules = 0;
+        if (exports.password.hasUppercase(input))
+            rules++;
+        if (exports.password.hasLowerCase(input))
+            rules++;
+        if (exports.password.hasNumeral(input))
+            rules++;
+        if (rules < 3) {
+            throw new Error('invalid-minimum-rules');
+        }
+        return true;
+    },
+    isValid: (input) => {
+        try {
+            exports.password.validate(input);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    },
+};
+exports.default = exports.password;

package/lib/rrule/date.d.ts

@@ -0,0 +1,4 @@
+export declare const getEndTime: (start: any, duration: any) => Date;
+export declare const munge: (date: any, time: any) => string;
+export declare const transpose: (date: any, time: any, timezone: any) => any;
+export declare const getStartTime: (rule: any, timezone: any) => any;

package/lib/rrule/date.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStartTime = exports.transpose = exports.munge = exports.getEndTime = void 0;
+const luxon_1 = require("luxon");
+const rrule_1 = __importDefault(require("rrule"));
+const parsing_1 = require("./parsing");
+// Given a start (Date object) and a duration in milliseconds, return a new Date object specifying the end time
+const getEndTime = (start, duration) => new Date(start.getTime() + duration);
+exports.getEndTime = getEndTime;
+// Combine a date and time string in formats: YYYYMMDD, HHss
+const munge = (date, time) => {
+    const datePart = luxon_1.DateTime.fromISO(date).toFormat('YYYYMMDD');
+    return `${datePart}${time}`;
+};
+exports.munge = munge;
+// Return a date object representing the given date and time string in the timezone specified
+const transpose = (date, time, timezone) => {
+    return luxon_1.DateTime.fromISO((0, exports.munge)(date, time)).setZone(timezone).toDate();
+};
+exports.transpose = transpose;
+// Gets the start time (HHmm format) in the timezone specified for an rrule
+const getStartTime = (rule, timezone) => {
+    // eslint-disable-next-line no-undef
+    const obj = typeof rule === 'object' ? rrule_1.default : (0, parsing_1.toRruleObj)(rule);
+    return luxon_1.DateTime.fromISO(obj.DTSTART).setZone(timezone).toFormat('HHmm');
+};
+exports.getStartTime = getStartTime;

package/lib/rrule/index.d.ts

@@ -0,0 +1,2 @@
+export * from './parsing';
+export * from './date';

package/lib/rrule/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parsing"), exports);
+__exportStar(require("./date"), exports);

package/lib/rrule/parsing.d.ts

@@ -0,0 +1,6 @@
+export declare const toRruleObj: (str: any) => {
+    [k: string]: unknown;
+};
+export declare const toRruleStr: (obj: any) => string;
+export declare const parseDuration: (duration: any) => number;
+export declare const getDuration: (icalObj: any) => any;

package/lib/rrule/parsing.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDuration = exports.parseDuration = exports.toRruleStr = exports.toRruleObj = void 0;
+const luxon_1 = require("luxon");
+const omitBy = (obj, predicate) => {
+    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => !predicate(value, key)));
+};
+const toRruleObj = function toRruleObj(str) {
+    const config = (str || '')
+        .split(';')
+        .map((component) => component.split('=', 2))
+        .reduce((all, [k, v]) => {
+        all[k] = v;
+        return all;
+    }, {});
+    return omitBy(config, (value, key) => !key || value === null);
+};
+exports.toRruleObj = toRruleObj;
+const toRruleStr = function toRruleStr(obj) {
+    const filter = Object.keys(obj).filter((k) => obj[k] !== null && obj[k] !== undefined);
+    const map = filter.map((key) => `${key}=${obj[key]}`);
+    const join = map.join(';');
+    return Object.keys(obj)
+        .filter((k) => obj[k] !== null && obj[k] !== undefined)
+        .map((key) => `${key}=${obj[key]}`)
+        .join(';');
+};
+exports.toRruleStr = toRruleStr;
+const TOKEN_TYPES = {
+    SIGN: 'SIGN',
+    DAYS: 'DAYS',
+    TIME_START: 'TIME_START',
+    HOURS: 'HOURS',
+    MINUTES: 'MINUTES',
+    SECONDS: 'SECONDS',
+    WEEKS: 'WEEKS',
+    UNKNOWN: 'UNKNOWN',
+};
+const parseDuration = (duration) => {
+    // --- lexer
+    // follows https://tools.ietf.org/html/rfc5545#section-3.3.6
+    let windowStart = 0;
+    const tokens = [];
+    for (let windowEnd = 1; windowEnd <= duration.length; windowEnd++) {
+        const token = duration.slice(windowStart, windowEnd);
+        if (/^[+-]?P$/.test(token)) {
+            const val = token[0] === '-' ? -1 : 1;
+            tokens.push({ type: TOKEN_TYPES.SIGN, val: val });
+            windowStart = windowEnd;
+        }
+        else if (/^[0-9]*W$/.test(token)) {
+            const val = parseInt(token.slice(0, -1), 10);
+            tokens.push({ type: TOKEN_TYPES.WEEKS, val: val });
+            windowStart = windowEnd;
+        }
+        else if (/^[0-9]*D$/.test(token)) {
+            const val = parseInt(token.slice(0, -1), 10);
+            tokens.push({ type: TOKEN_TYPES.DAYS, val: val });
+            windowStart = windowEnd;
+        }
+        else if (token === 'T') {
+            tokens.push({ type: TOKEN_TYPES.TIME_START, val: -1 });
+            windowStart = windowEnd;
+        }
+        else if (/^[0-9]*\.?[0-9]*H$/.test(token)) {
+            const val = parseFloat(token.slice(0, -1));
+            tokens.push({ type: TOKEN_TYPES.HOURS, val: val });
+            windowStart = windowEnd;
+        }
+        else if (/^[0-9]*M$/.test(token)) {
+            const val = parseInt(token.slice(0, -1), 10);
+            tokens.push({ type: TOKEN_TYPES.MINUTES, val: val });
+            windowStart = windowEnd;
+        }
+        else if (/^[0-9]*S$/.test(token)) {
+            const val = parseInt(token.slice(0, -1), 10);
+            tokens.push({ type: TOKEN_TYPES.SECONDS, val: val });
+            windowStart = windowEnd;
+        }
+        else if (windowEnd === duration.length) {
+            tokens.push({ type: TOKEN_TYPES.UNKNOWN, val: token });
+            windowStart = windowEnd;
+        }
+    }
+    // --- parser
+    // this parser is very permissive and doesn't care about token order, repetitions, etc.
+    let parsedDurationValue = 0;
+    // for token type of hours, because we made it support fractions, apply parseInt
+    // to round it up to integer
+    for (const token of tokens) {
+        if (token.type === TOKEN_TYPES.SIGN)
+            parsedDurationValue = token.val;
+        else if (token.type === TOKEN_TYPES.WEEKS)
+            parsedDurationValue = token.val * 7 * 24 * 60 * 60 * 1000;
+        else if (token.type === TOKEN_TYPES.DAYS)
+            parsedDurationValue = token.val * 24 * 60 * 60 * 1000;
+        else if (token.type === TOKEN_TYPES.HOURS)
+            parsedDurationValue = token.val * 60 * 60 * 1000, 10;
+        else if (token.type === TOKEN_TYPES.MINUTES)
+            parsedDurationValue = token.val * 60 * 1000;
+        else if (token.type === TOKEN_TYPES.SECONDS)
+            parsedDurationValue = token.val * 1000;
+        // TODO check if we use this, MILLISECONDS is no longer supported
+        // else if (token.type === TOKEN_TYPES.MILLISECONDS) parsedDurationValue = token.val;
+    }
+    return parsedDurationValue;
+};
+exports.parseDuration = parseDuration;
+const getDuration = (icalObj) => {
+    const duration = icalObj.DURATION;
+    // make it v1 backward compatible
+    const dtend = icalObj.DTEND;
+    const dtstart = icalObj.DTSTART;
+    if (duration && dtend) {
+        return 0;
+    }
+    if (duration) {
+        return (0, exports.parseDuration)(duration);
+    }
+    if (dtstart && dtend) {
+        const start = luxon_1.DateTime.fromISO(dtstart);
+        const end = luxon_1.DateTime.fromISO(dtend);
+        const difference = end.diff(start);
+        if (!difference.isValid)
+            return 0;
+        return difference.toMillis();
+    }
+    return 0;
+};
+exports.getDuration = getDuration;

package/lib/rrule/parsing.test.d.ts

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

package/lib/rrule/parsing.test.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parsing_1 = require("./parsing");
+it('removes null or undefined fields', () => {
+    expect((0, parsing_1.toRruleStr)({
+        DTSTART: '20120201T023000Z',
+        DURATION: '1h',
+        COUNT: null,
+        UNTIL: undefined,
+    })).toEqual('DTSTART=20120201T023000Z;DURATION=1h');
+});

package/lib/rrule.d.ts

@@ -0,0 +1,49 @@
+import { RRule } from 'rrule';
+import { toRruleObj, toRruleStr } from './rrule/index';
+type ToFrom = {
+    from: Date;
+    to: Date;
+};
+export { toRruleObj, toRruleStr };
+export declare const parse: (str: any) => {
+    duration: any;
+    durationString: unknown;
+    rrule: RRule | import("rrule").RRuleSet;
+    dtend: unknown;
+};
+export declare const validateRruleConfig: (obj: any) => string[];
+export declare const validateRruleConfigV2: (bcRruleInstance: any) => string[];
+/**
+ * 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.
+ */
+export declare const buildBcRruleString: (rruleInstance: any, duration?: string) => any;
+export declare const isValidRrule: (obj: any) => boolean;
+export declare const recurrenceToText: (recurrenceRule: any, timezone: any, isFlexible?: boolean) => {
+    text: string;
+    timezone: any;
+    time?: undefined;
+} | {
+    text: string;
+    time: string;
+    timezone: any;
+};
+export declare const recurrenceToTextInTimezone: (recurrenceRule: any, timezone: any) => {
+    text: string;
+    time: string;
+    localTimezone: any;
+};
+export declare const recurrencesBetween: (fromDate: any, toDate: any, recurrenceRule: any, timezone: any) => {
+    from: any;
+    to: Date;
+}[];
+/**
+ *
+ * @param {*} rrule
+ * @param {*} timezone
+ * @param {*} from
+ * @param {*} isFlexible
+ * @returns an array of date in true utc (DST offset is considered)
+ */
+export declare const recurrencesBetweenV2: (rrule: any, timezone: any, from?: Date, isFlexible?: boolean) => ToFrom[];