@8ms/helpers 1.41.0 → 1.42.0

package/dist/esm/crypto/getEncrypt.js

@@ -0,0 +1,11 @@
+/**
+ * Encrypt an encoding string using a salt
+ * Library: crypto-js
+ */
+const getEncrypt = ({ appSalt, input, salt }) => {
+    const { AES } = require('crypto-js');
+    const customSalt = `${appSalt}-${salt}`;
+    return AES.encrypt(input, customSalt)
+        .toString();
+};
+export default getEncrypt;

package/dist/esm/crypto/getRandom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create a random string and return a number of characters from it.
+ * Library: crypto-js
+ */
+declare const getRandom: ({ length }: {
+    length: number;
+}) => string;
+export default getRandom;

package/dist/esm/crypto/getRandom.js

@@ -0,0 +1,10 @@
+/**
+ * Create a random string and return a number of characters from it.
+ * Library: crypto-js
+ */
+const getRandom = ({ length }) => {
+    return Math.random()
+        .toString(36)
+        .substr(0, length);
+};
+export default getRandom;

package/dist/esm/crypto/getSha256.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Encrypt a string using sha256
+ * Library: crypto-js
+ */
+declare const getSha256: ({ input }: {
+    input: any;
+}) => string;
+export default getSha256;

package/dist/esm/crypto/getSha256.js

@@ -0,0 +1,12 @@
+import getString from '../string/getString';
+/**
+ * Encrypt a string using sha256
+ * Library: crypto-js
+ */
+const getSha256 = ({ input }) => {
+    const { SHA256 } = require('crypto-js');
+    const inputString = getString({ input });
+    return SHA256(inputString)
+        .toString();
+};
+export default getSha256;

package/dist/esm/crypto/tests/getEncryptDecrypt.test.d.ts

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

package/dist/esm/crypto/tests/getEncryptDecrypt.test.js

@@ -0,0 +1,18 @@
+import getDecrypt from '../getDecrypt';
+import getEncrypt from '../getEncrypt';
+test('getEncrypt and getDecrypt', () => {
+    const input = 'this is a test';
+    // Value changes based on the time, cannot verify
+    const encrypted = getEncrypt({
+        appSalt: 'abc',
+        input,
+        salt: '123',
+    });
+    const decrypted = getDecrypt({
+        appSalt: 'abc',
+        input: encrypted,
+        salt: '123',
+    });
+    expect(input)
+        .toBe(decrypted);
+});

package/dist/esm/crypto/tests/getSha256.test.d.ts

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

package/dist/esm/crypto/tests/getSha256.test.js

@@ -0,0 +1,10 @@
+import getSha256 from '../getSha256';
+test('getSha256', () => {
+    const input = 'this is a test';
+    const expected = '2e99758548972a8e8822ad47fa1017ff72f06f3ff6a016851f45c398732bc50c';
+    const encrypted = getSha256({
+        input,
+    });
+    expect(encrypted)
+        .toBe(expected);
+});

package/dist/esm/date/format.d.ts

@@ -0,0 +1,10 @@
+import { GetDate } from "./getDate";
+type Format = GetDate & {
+    dateFormat?: string;
+};
+/**
+ * Convert a (number | string | Date) into a "yyyy-MM-dd" string or a specified format.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ */
+declare const format: (props: Format) => string;
+export default format;

package/dist/esm/date/format.js

@@ -0,0 +1,16 @@
+import { format as dateFnsFormat } from "date-fns";
+import getDate from "./getDate";
+/**
+ * Convert a (number | string | Date) into a "yyyy-MM-dd" string or a specified format.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ */
+const format = (props) => {
+    const dateInstance = getDate({
+        input: props.input,
+        isUtc: props.isUtc,
+        setMidnight: props?.setMidnight,
+        setTimeZone: props?.setTimeZone,
+    });
+    return dateFnsFormat(dateInstance, props?.dateFormat || "yyyy-MM-dd");
+};
+export default format;

package/dist/esm/date/getDate.d.ts

@@ -0,0 +1,14 @@
+import { DateType } from "./";
+import { GetMidnight } from "./getMidnight";
+import { GetTimeZoned } from "./getTimeZoned";
+export type GetDate = GetTimeZoned & GetMidnight & {
+    input: DateType;
+    isUtc?: boolean;
+};
+/**
+ * Convert a (number | string | Date) into a Date object.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ * By default assumption is that the input is UTC, however it can be switched to timezoned time.
+ */
+declare const getDate: (props: GetDate) => Date;
+export default getDate;

package/dist/esm/date/getDate.js

@@ -0,0 +1,133 @@
+import getMidnight from "./getMidnight";
+/**
+ * Convert a (number | string | Date) into a Date object.
+ * As the user would be providing the input we don't want to change the timezone typically.
+ * By default assumption is that the input is UTC, however it can be switched to timezoned time.
+ */
+const getDate = (props) => {
+    let date;
+    let isUtc = undefined === props?.isUtc ? true : props.isUtc;
+    // Already date instance - no change
+    if (props.input instanceof Date) {
+        date = new Date(props.input.valueOf());
+    }
+    else if ("string" === typeof props.input || "number" === typeof props.input) {
+        // Convert the input into string
+        const dateString = props.input.toString();
+        const regexes = {
+            ymdDash: new RegExp("^[0-9]{4}-[0-9]{2}-[0-9]{2}$"),
+            ymdNumber: new RegExp("^[0-9]{8}$"),
+            ymdHisDash: new RegExp("^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}$"),
+            ymdHisNumber: new RegExp("^[0-9]{14}$"),
+        };
+        //	console.log('regexes.ymdHisDash.test(dateString) ',regexes.ymdHisDash.test(dateString));
+        // 20220412
+        if (regexes.ymdNumber.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(4, 6)) - 1;
+            const day = Number(dateString.substring(6, 8));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(0, 0, 0, 0);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(0, 0, 0, 0);
+            }
+        }
+        // 2022-04-12
+        else if (regexes.ymdDash.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(5, 7)) - 1;
+            const day = Number(dateString.substring(8, 10));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            // Finalise date
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(0, 0, 0, 0);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(0, 0, 0, 0);
+            }
+        }
+        // 2022-04-12 01:01:01
+        else if (regexes.ymdHisDash.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(5, 7)) - 1;
+            const day = Number(dateString.substring(8, 10));
+            const hours = Number(dateString.substring(11, 13));
+            const minutes = Number(dateString.substring(14, 16));
+            const seconds = Number(dateString.substring(17, 19));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            // Finalise date
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(hours, minutes, seconds);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(hours, minutes, seconds);
+            }
+        }
+        // 20220412010101
+        else if (regexes.ymdHisNumber.test(dateString)) {
+            const year = Number(dateString.substring(0, 4));
+            const month = Number(dateString.substring(4, 6)) - 1;
+            const day = Number(dateString.substring(6, 8));
+            const hours = Number(dateString.substring(8, 10));
+            const minutes = Number(dateString.substring(10, 12));
+            const seconds = Number(dateString.substring(12, 14));
+            date = new Date();
+            // Reset the date to the 1st initially at 1am
+            date.setUTCDate(1);
+            date.setUTCHours(1, 0, 0, 0);
+            // Finalise date
+            if (isUtc) {
+                date.setUTCFullYear(year);
+                date.setUTCMonth(month);
+                date.setUTCDate(day);
+                date.setUTCHours(hours, minutes, seconds);
+            }
+            else {
+                date.setFullYear(year);
+                date.setMonth(month);
+                date.setDate(day);
+                date.setHours(hours, minutes, seconds);
+            }
+        }
+        // Unsure date format, try anything
+        else {
+            date = new Date(dateString);
+        }
+    }
+    // Reset to midnight
+    date = getMidnight({
+        input: date,
+        setMidnight: props?.setMidnight,
+    });
+    return date;
+};
+export default getDate;

package/dist/esm/date/getDatesBetween.d.ts

@@ -0,0 +1,13 @@
+import { DateType } from "./";
+type GetDatesBetween = {
+    end: DateType;
+    start: DateType;
+    isUtc?: boolean;
+};
+/**
+ * Similar to date-fns' eachDayOfInterval, however the timezone messes this function up.
+ * https://date-fns.org/v2.28.0/docs/eachDayOfInterval
+ * https://www.gov.uk/when-do-the-clocks-change
+ */
+declare const getDatesBetween: (props: GetDatesBetween) => Date[];
+export default getDatesBetween;

package/dist/esm/date/getDatesBetween.js

@@ -0,0 +1,49 @@
+import { addDays } from "date-fns";
+import format from "./format";
+import getDate from "./getDate";
+import { addHours } from "date-fns";
+/**
+ * Similar to date-fns' eachDayOfInterval, however the timezone messes this function up.
+ * https://date-fns.org/v2.28.0/docs/eachDayOfInterval
+ * https://www.gov.uk/when-do-the-clocks-change
+ */
+const getDatesBetween = (props) => {
+    let response = [];
+    let endDate = getDate({
+        input: props.end,
+        isUtc: props.isUtc,
+    });
+    // Increase the end date by 2 hours so it can handle the change in hours
+    endDate = addHours(endDate, 2);
+    // Use a string to ensure there's no changes with the timezone
+    let startString = format({
+        input: props.start,
+        isUtc: props.isUtc,
+    });
+    // Create a pointer Date instance
+    let pointer = getDate({
+        input: startString,
+        isUtc: props.isUtc,
+    });
+    // While we before the end
+    while (pointer <= endDate) {
+        // We need to create a new date entry so its always set to 00:00:00
+        const entry = getDate({
+            input: pointer,
+            isUtc: props.isUtc,
+            setMidnight: true,
+        });
+        // Add this new entry to our response
+        response.push(entry);
+        // Move to the next day
+        pointer = addDays(pointer, 1);
+        // Daylight saving (month is 0-base)
+        // -1 hour between March and September, add an hour if 0 hours
+        // +1 hour between October and February
+        if (pointer.getMonth() >= 2 && pointer.getMonth() < 8 && 0 === pointer.getHours()) {
+            pointer = addHours(pointer, 1);
+        }
+    }
+    return response;
+};
+export default getDatesBetween;

package/dist/esm/date/getDurationHours.d.ts

@@ -0,0 +1,9 @@
+type GetDurationHours = {
+    seconds: number;
+};
+/**
+ * Convert a number of seconds into HH:MM:SS
+ * https://www.codevertiser.com/convert-seconds-to-hours-and-minutes-javascript/
+ */
+declare const getDurationHours: (props: GetDurationHours) => string;
+export default getDurationHours;

package/dist/esm/date/getDurationHours.js

@@ -0,0 +1,22 @@
+/**
+ * Convert a number of seconds into HH:MM:SS
+ * https://www.codevertiser.com/convert-seconds-to-hours-and-minutes-javascript/
+ */
+const getDurationHours = (props) => {
+    let response = '00:00:00';
+    if (props.seconds > 0) {
+        const calculated = {
+            hours: Math.floor(props.seconds / 3600),
+            minutes: Math.floor((props.seconds % 3600) / 60),
+            seconds: props.seconds % 60,
+        };
+        const output = {
+            hours: calculated.hours < 10 ? '0' + calculated.hours : calculated.hours,
+            minutes: calculated.minutes < 10 ? '0' + calculated.minutes : calculated.minutes,
+            seconds: calculated.seconds < 10 ? '0' + calculated.seconds : calculated.seconds,
+        };
+        response = `${output.hours}:${output.minutes}:${output.seconds}`;
+    }
+    return response;
+};
+export default getDurationHours;

package/dist/esm/date/getDurationMinutes.d.ts

@@ -0,0 +1,9 @@
+type GetDurationMinutes = {
+    seconds: number;
+};
+/**
+ * Convert a number of seconds into MM:SS
+ * https://www.codevertiser.com/convert-seconds-to-hours-and-minutes-javascript/
+ */
+declare const getDurationMinutes: (props: GetDurationMinutes) => string;
+export default getDurationMinutes;

package/dist/esm/date/getDurationMinutes.js

@@ -0,0 +1,20 @@
+/**
+ * Convert a number of seconds into MM:SS
+ * https://www.codevertiser.com/convert-seconds-to-hours-and-minutes-javascript/
+ */
+const getDurationMinutes = (props) => {
+    let response = '00:00';
+    if (props.seconds > 0) {
+        const calculated = {
+            minutes: Math.floor((props.seconds % 3600) / 60),
+            seconds: props.seconds % 60,
+        };
+        const output = {
+            minutes: calculated.minutes < 10 ? '0' + calculated.minutes : calculated.minutes,
+            seconds: calculated.seconds < 10 ? '0' + calculated.seconds : calculated.seconds,
+        };
+        response = `${output.minutes}:${output.seconds}`;
+    }
+    return response;
+};
+export default getDurationMinutes;

package/dist/esm/date/getFinancialYear.d.ts

@@ -0,0 +1,9 @@
+import { FinancialYear } from "./";
+type GetFinancialYearType = {
+    year?: number;
+};
+/**
+ * Get the current financial year.
+ */
+declare const getFinancialYear: (props?: GetFinancialYearType) => FinancialYear;
+export default getFinancialYear;

package/dist/esm/date/getFinancialYear.js

@@ -0,0 +1,47 @@
+import { isMonday, isSunday, nextSunday, previousMonday } from "date-fns";
+import getDate from "./getDate";
+import getToday from "./getToday";
+/**
+ * Get the current financial year.
+ */
+const getFinancialYear = (props = {}) => {
+    // Either use the current year or a specified year
+    let financialYear = props.year;
+    if (undefined === props.year) {
+        // As this isn't provided by the suer, we want to ensure its London timezone
+        const today = getToday();
+        // If today is before 1st of April, then use last year
+        if (today < new Date(today.getFullYear(), 3, 1)) {
+            financialYear = today.getFullYear() - 1;
+        }
+        // On or after 1st of April, use this year
+        else {
+            financialYear = today.getFullYear();
+        }
+    }
+    // The year-end needs to be 31st March next year
+    // We are specifying the date, so don't change the timezone
+    let yearEnd = getDate({
+        input: `${financialYear + 1}-03-31`,
+        isUtc: true,
+    });
+    // The year start needs to be 1st April this year
+    // We are specifying the date, so don't change the timezone
+    let yearStart = getDate({
+        input: `${financialYear}-04-01`,
+        isUtc: true,
+    });
+    // Get the previous Monday if the 1st of April isn't a Monday
+    if (!isMonday(yearStart)) {
+        yearStart = previousMonday(yearStart);
+    }
+    // Get the next Sunday if the 31st of March isn't a Sunday
+    if (!isSunday(yearEnd)) {
+        yearEnd = nextSunday(yearEnd);
+    }
+    return {
+        end: yearEnd,
+        start: yearStart,
+    };
+};
+export default getFinancialYear;

package/dist/esm/date/getFinancialYearToDate.d.ts

@@ -0,0 +1,7 @@
+import { FinancialYear } from './';
+/**
+ * Return the current financial year up to today.
+ * Timezone should always be London based
+ */
+declare const getFinancialYearToDate: () => FinancialYear;
+export default getFinancialYearToDate;

package/dist/esm/date/getFinancialYearToDate.js

@@ -0,0 +1,15 @@
+import getFinancialYear from './getFinancialYear';
+import getToday from './getToday';
+/**
+ * Return the current financial year up to today.
+ * Timezone should always be London based
+ */
+const getFinancialYearToDate = () => {
+    const today = getToday();
+    const thisFinancialYear = getFinancialYear();
+    return {
+        end: today,
+        start: thisFinancialYear.start,
+    };
+};
+export default getFinancialYearToDate;

package/dist/esm/date/getFinancialYearToYesterday.d.ts

@@ -0,0 +1,7 @@
+import { FinancialYear } from './';
+/**
+ * Return the current financial year up to yesterday.
+ * Timezone should always be London based
+ */
+declare const getFinancialYearToYesterday: () => FinancialYear;
+export default getFinancialYearToYesterday;

package/dist/esm/date/getFinancialYearToYesterday.js

@@ -0,0 +1,15 @@
+import getFinancialYear from './getFinancialYear';
+import getYesterday from './getYesterday';
+/**
+ * Return the current financial year up to yesterday.
+ * Timezone should always be London based
+ */
+const getFinancialYearToYesterday = () => {
+    const yesterday = getYesterday();
+    const thisFinancialYear = getFinancialYear();
+    return {
+        end: yesterday,
+        start: thisFinancialYear.start,
+    };
+};
+export default getFinancialYearToYesterday;

package/dist/esm/date/getFinancialYearWeeks.d.ts

@@ -0,0 +1,9 @@
+import { FinancialYearWeekType } from "./";
+type GetFinancialYearWeeks = {
+    year?: number;
+};
+/**
+ * Get the current financial year.
+ */
+declare const getFinancialYearWeeks: (props?: GetFinancialYearWeeks) => FinancialYearWeekType[];
+export default getFinancialYearWeeks;

package/dist/esm/date/getFinancialYearWeeks.js

@@ -0,0 +1,28 @@
+import { addDays, eachWeekOfInterval } from "date-fns";
+import getFinancialYear from "./getFinancialYear";
+import getTimeZoned from "./getTimeZoned";
+/**
+ * Get the current financial year.
+ */
+const getFinancialYearWeeks = (props = {}) => {
+    const financialYear = getFinancialYear({
+        year: props.year
+    });
+    const weeks = eachWeekOfInterval(financialYear, {
+        weekStartsOn: 1
+    });
+    let response = weeks.map((week, index) => {
+        let weekStart = new Date(week.getTime());
+        weekStart = getTimeZoned({ input: weekStart });
+        let weekEnd = addDays(weekStart, 6);
+        weekEnd = getTimeZoned({ input: weekEnd });
+        return {
+            start: weekStart,
+            end: weekEnd,
+            financialWeek: (index + 1),
+            financialYear: props.year,
+        };
+    });
+    return response;
+};
+export default getFinancialYearWeeks;

package/dist/esm/date/getLastWeek.d.ts

@@ -0,0 +1,10 @@
+import { GetMidnight } from "./getMidnight";
+import { GetTimeZoned } from "./getTimeZoned";
+import { Timeframe } from "./";
+type GetLastWeek = GetTimeZoned & GetMidnight;
+/**
+ * Return an object of start/end predefined date of Last Week.
+ * Creating a date from scratch (no user input), thus needs to be London time.
+ */
+declare const getLastWeek: ({ setMidnight, setTimeZone }?: GetLastWeek) => Timeframe;
+export default getLastWeek;

package/dist/esm/date/getLastWeek.js

@@ -0,0 +1,29 @@
+import getMonday from "./getMonday";
+import getNumber from "./getNumber";
+import getSunday from "./getSunday";
+import { timeZoneLondon } from "./getTimeZoned";
+/**
+ * Return an object of start/end predefined date of Last Week.
+ * Creating a date from scratch (no user input), thus needs to be London time.
+ */
+const getLastWeek = ({ setMidnight = true, setTimeZone = timeZoneLondon } = { setMidnight: true, setTimeZone: timeZoneLondon }) => {
+    const sunday = getSunday({
+        weeksAgo: 0,
+        setMidnight,
+        setTimeZone,
+    });
+    const monday = getMonday({
+        weeksAgo: 1,
+        setMidnight,
+        setTimeZone,
+    });
+    return {
+        end: getNumber({
+            input: sunday
+        }),
+        start: getNumber({
+            input: monday
+        }),
+    };
+};
+export default getLastWeek;

package/dist/esm/date/getMax.d.ts

@@ -0,0 +1,13 @@
+import { DateType } from "./";
+import { GetMidnight } from "./getMidnight";
+import { GetTimeZoned } from "./getTimeZoned";
+type GetMax = GetTimeZoned & GetMidnight & {
+    input: DateType;
+    isUtc: boolean;
+    max: DateType;
+};
+/**
+ * If a given date is beyond the maximum, return the maximum.
+ */
+declare const getMax: (props: GetMax) => Date;
+export default getMax;

package/dist/esm/date/getMax.js

@@ -0,0 +1,19 @@
+import { isAfter } from "date-fns";
+import getDate from "./getDate";
+/**
+ * If a given date is beyond the maximum, return the maximum.
+ */
+const getMax = (props) => {
+    const parsedMax = getDate({
+        input: props.max,
+        isUtc: props.isUtc,
+        setMidnight: props?.setMidnight || true,
+    });
+    const parsedInput = getDate({
+        input: props.input,
+        isUtc: props.isUtc,
+        setMidnight: props?.setMidnight || true,
+    });
+    return isAfter(parsedInput, parsedMax) ? parsedMax : parsedInput;
+};
+export default getMax;

package/dist/esm/date/getMidnight.d.ts

@@ -0,0 +1,10 @@
+export type GetMidnight = {
+    setMidnight?: boolean;
+};
+/**
+ * Set a date's time to 0 hours, 0 minutes, 0 seconds, 0 milliseconds
+ */
+declare const getMidnight: (props: GetMidnight & {
+    input: Date;
+}) => Date;
+export default getMidnight;

package/dist/esm/date/getMidnight.js

@@ -0,0 +1,11 @@
+/**
+ * Set a date's time to 0 hours, 0 minutes, 0 seconds, 0 milliseconds
+ */
+const getMidnight = (props) => {
+    let dateInstance = props.input;
+    if (true === props?.setMidnight) {
+        dateInstance.setUTCHours(0, 0, 0, 0);
+    }
+    return dateInstance;
+};
+export default getMidnight;