@akadenia/helpers 1.2.2

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { convertCamelToSnakeCase, convertSnakeToCamelCase, fileNameFromPath, formatPosition, handleNullDisplay, pluralizeOnCondition, replaceSpacesWithUnderscore, replaceUnderscoreWithSpaces, truncateText, uuidv4, enforceCharacterLimit, capitalizeText, generateIDFromWord, generateWordFromId, convertCamelToKebabCase, convertKebabToCamelCase, isAcronym, acronymToKebabCase } from "./text";
+import * as DateHelpers from "./date";
+import * as ObjectHelpers from "./object";
+import * as MapHelpers from "./map";
+import * as GenericHelpers from "./generic";
+import * as FileHelpers from "./file";
+declare const TextHelpers: {
+    convertCamelToSnakeCase: typeof convertCamelToSnakeCase;
+    convertSnakeToCamelCase: typeof convertSnakeToCamelCase;
+    fileNameFromPath: typeof fileNameFromPath;
+    formatPosition: typeof formatPosition;
+    handleNullDisplay: typeof handleNullDisplay;
+    pluralizeOnCondition: typeof pluralizeOnCondition;
+    replaceSpacesWithUnderscore: typeof replaceSpacesWithUnderscore;
+    replaceUnderscoreWithSpaces: typeof replaceUnderscoreWithSpaces;
+    truncateText: typeof truncateText;
+    uuidv4: typeof uuidv4;
+    enforceCharacterLimit: typeof enforceCharacterLimit;
+    capitalizeText: typeof capitalizeText;
+    convertCamelToKebabCase: typeof convertCamelToKebabCase;
+    convertKebabToCamelCase: typeof convertKebabToCamelCase;
+    isAcronym: typeof isAcronym;
+    acronymToKebabCase: typeof acronymToKebabCase;
+    generateIDFromWord: typeof generateIDFromWord;
+    generateWordFromId: typeof generateWordFromId;
+};
+export { ObjectHelpers, DateHelpers, MapHelpers, TextHelpers, GenericHelpers, FileHelpers };

package/dist/index.js

@@ -0,0 +1,58 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHelpers = exports.GenericHelpers = exports.TextHelpers = exports.MapHelpers = exports.DateHelpers = exports.ObjectHelpers = void 0;
+const text_1 = require("./text");
+const DateHelpers = __importStar(require("./date"));
+exports.DateHelpers = DateHelpers;
+const ObjectHelpers = __importStar(require("./object"));
+exports.ObjectHelpers = ObjectHelpers;
+const MapHelpers = __importStar(require("./map"));
+exports.MapHelpers = MapHelpers;
+const GenericHelpers = __importStar(require("./generic"));
+exports.GenericHelpers = GenericHelpers;
+const FileHelpers = __importStar(require("./file"));
+exports.FileHelpers = FileHelpers;
+const TextHelpers = {
+    convertCamelToSnakeCase: text_1.convertCamelToSnakeCase,
+    convertSnakeToCamelCase: text_1.convertSnakeToCamelCase,
+    fileNameFromPath: text_1.fileNameFromPath,
+    formatPosition: text_1.formatPosition,
+    handleNullDisplay: text_1.handleNullDisplay,
+    pluralizeOnCondition: text_1.pluralizeOnCondition,
+    replaceSpacesWithUnderscore: text_1.replaceSpacesWithUnderscore,
+    replaceUnderscoreWithSpaces: text_1.replaceUnderscoreWithSpaces,
+    truncateText: text_1.truncateText,
+    uuidv4: text_1.uuidv4,
+    enforceCharacterLimit: text_1.enforceCharacterLimit,
+    capitalizeText: text_1.capitalizeText,
+    convertCamelToKebabCase: text_1.convertCamelToKebabCase,
+    convertKebabToCamelCase: text_1.convertKebabToCamelCase,
+    isAcronym: text_1.isAcronym,
+    acronymToKebabCase: text_1.acronymToKebabCase,
+    generateIDFromWord: text_1.generateIDFromWord,
+    generateWordFromId: text_1.generateWordFromId,
+};
+exports.TextHelpers = TextHelpers;

package/dist/map.d.ts

@@ -0,0 +1,7 @@
+export declare const getDistanceBetweenPoints: (point1: number[] | undefined, point2: number[] | undefined) => number | null;
+export declare const compareLocations: (location1: number[] | undefined, location2: number[] | undefined, precision?: number) => boolean;
+export interface IGetBearingToCoordinate {
+    startCoordinate: number[] | undefined;
+    endCoordinate: number[] | undefined;
+}
+export declare const getBearingToCoordinate: ({ startCoordinate, endCoordinate }: IGetBearingToCoordinate) => number;

package/dist/map.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBearingToCoordinate = exports.compareLocations = exports.getDistanceBetweenPoints = void 0;
+const DEFAULT_COMPARE_LOCATIONS_PRECISION = 6;
+// This function implements the Haversine formula to calculate distance between two points
+// https://en.wikipedia.org/wiki/Haversine_formula
+const getDistanceBetweenPoints = (point1, point2) => {
+    if (!point1 || !point2)
+        return null;
+    const [lat1, lon1] = point1;
+    const [lat2, lon2] = point2;
+    const earthRadius = 6371e3; // in metres
+    const lat1InRadians = (lat1 * Math.PI) / 180; // φ, λ in radians
+    const lat2InRadians = (lat2 * Math.PI) / 180;
+    const long1InRadians = ((lat2 - lat1) * Math.PI) / 180;
+    const long2InRadians = ((lon2 - lon1) * Math.PI) / 180;
+    const a = Math.sin(long1InRadians / 2) * Math.sin(long1InRadians / 2) +
+        Math.cos(lat1InRadians) * Math.cos(lat2InRadians) * Math.sin(long2InRadians / 2) * Math.sin(long2InRadians / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return earthRadius * c; // distance in metres
+};
+exports.getDistanceBetweenPoints = getDistanceBetweenPoints;
+const compareLocations = (location1, location2, precision = DEFAULT_COMPARE_LOCATIONS_PRECISION) => {
+    if (!location1 || !location2) {
+        throw new Error("location1 and location2 are required");
+    }
+    return (location1[0].toFixed(precision) === location2[0].toFixed(precision) &&
+        location1[1].toFixed(precision) === location2[1].toFixed(precision));
+};
+exports.compareLocations = compareLocations;
+const getBearingToCoordinate = ({ startCoordinate, endCoordinate }) => {
+    if (!startCoordinate || !endCoordinate) {
+        throw new Error("startCoordinate and endCoordinate are required");
+    }
+    // Converts from degrees to radians
+    const toRadians = (degrees) => {
+        return (degrees * Math.PI) / 180;
+    };
+    // Converts from radians to degrees
+    const toDegrees = (radians) => {
+        return (radians * 180) / Math.PI;
+    };
+    const startLatitude = toRadians(startCoordinate[1]);
+    const startLongitude = toRadians(startCoordinate[0]);
+    const endLatitude = toRadians(endCoordinate[1]);
+    const endLongitude = toRadians(endCoordinate[0]);
+    const y = Math.sin(endLongitude - startLongitude) * Math.cos(endLatitude);
+    const x = Math.cos(startLatitude) * Math.sin(endLatitude) -
+        Math.sin(startLatitude) * Math.cos(endLatitude) * Math.cos(endLongitude - startLongitude);
+    const bearing = Math.atan2(y, x);
+    return (toDegrees(bearing) + 360) % 360;
+};
+exports.getBearingToCoordinate = getBearingToCoordinate;

package/dist/object.d.ts

@@ -0,0 +1,76 @@
+/**
+ *
+ * @function
+ * @param {any} object - The object to check if it is a pure object (not an array, date, or function)
+ * @returns {boolean} - Whether or not the provided object is a pure object
+ */
+export declare const isPureObject: (object: any) => boolean;
+/**
+ * @function
+ * @param {string} str - The string of cookies to parse
+ * @returns {Object} - The object containing key-value pairs of the parsed cookies
+ */
+export declare const parseCookie: (str: string) => Object;
+/**
+ * Filters an array of objects based on a specified property and value.
+ * @template T extends Record<string, any> - The type of objects in the array.
+ * @param {T[]} array - The array of objects to filter.
+ * @param {keyof T} propertyName - The name of the property to filter on.
+ * @param {T[keyof T]} propertyValue - The value of the property to filter on.
+ * @returns {T[]} - The filtered array of objects.
+ */
+export declare function filterObjectsByProperty<T extends Record<string, any>>(array: T[], propertyName: keyof T, propertyValue: T[keyof T]): T[];
+/**
+ * Checks if the main object contains the sub object.
+ * @template T extends Record<string, any> - The type of the main object.
+ * @param {T} mainObject - The main object to check.
+ * @param {Partial<T>} subObject - The sub object to look for in the main object.
+ * @returns {boolean} - True if the main object contains the sub object, false otherwise.
+ */
+export declare function containsSubObject<T extends Record<string, any>>(mainObject: T, subObject: Partial<T>): boolean;
+/**
+ * Finds the object containing the given sub object in the array.
+ * @template T extends Record<string, any> - The type of objects in the array.
+ * @param {T[]} array - The array of objects.
+ * @param {Partial<T>} subObject - The sub object used to search the array.
+ * @returns {T | null} - The object containing the given sub object or null.
+ */
+export declare function findObjectBySubObject<T extends Record<string, any>>(array: T[], subObject: Partial<T>): T | null;
+/**
+ * Filters an array of objects based on the objects containing the given sub object
+ * @template T extends Record<string, any>
+ * @param {T[]} array - The array of objects
+ * @param {Partial<T>} subObject - The sub object used to search the array
+ * @returns {Object | null} - An array of objects containing the given sub object
+ */
+export declare function filterObjectsBySubObject<T extends Record<string, any>>(array: T[], subObject: Partial<T>): T[];
+/**
+ * Checks if the object has the key with the value.
+ * @param {Object} object - The object to check
+ * @param {string} key - The key to check
+ * @param {any} value - The value to check
+ * @returns {boolean} - Whether or not the object has the key with the value
+ * @example
+ * const object = { a: 1, b: 2, c: 3 }
+ * objectPropHasValue(object, 'a', 1) // true
+ * objectPropHasValue(object, 'b', 3) // false
+ */
+export declare const objectPropHasValue: <ObjectType>({ object, propName, value, }: {
+    object: ObjectType;
+    propName: keyof ObjectType;
+    value: ObjectType[keyof ObjectType];
+}) => boolean;
+/**
+ * Finds the first entry in the array that satisfies the predicate.
+ * @template EntryType - The type of the entries in the array.
+ * @callback PredicateFunction - The predicate function to use to search the array.
+ * @param {EntryType} item - The entry in the array to search.
+ * @returns {boolean} - True if the entry satisfies the predicate, false otherwise.
+ * @param {EntryType[]} array - The array of entries to search.
+ * @param {PredicateFunction} predicate - The predicate function to use to search the array.
+ * @returns {EntryType | null} - The first entry that satisfies the predicate, or null if not found.
+ */
+export declare const findEntry: <EntryType>(array: EntryType[], predicate: (item: EntryType) => boolean) => EntryType | null;
+export declare function convertArrayToMap<T extends object>(arrayData: T[], keyProp: keyof T): {
+    [key: string]: T;
+};

package/dist/object.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertArrayToMap = exports.findEntry = exports.objectPropHasValue = exports.filterObjectsBySubObject = exports.findObjectBySubObject = exports.containsSubObject = exports.filterObjectsByProperty = exports.parseCookie = exports.isPureObject = void 0;
+/**
+ *
+ * @function
+ * @param {any} object - The object to check if it is a pure object (not an array, date, or function)
+ * @returns {boolean} - Whether or not the provided object is a pure object
+ */
+const isPureObject = function (object) {
+    const isDateObject = object instanceof Date;
+    return object === Object(object) && !Array.isArray(object) && typeof object !== "function" && !isDateObject;
+};
+exports.isPureObject = isPureObject;
+/**
+ * @function
+ * @param {string} str - The string of cookies to parse
+ * @returns {Object} - The object containing key-value pairs of the parsed cookies
+ */
+const parseCookie = (str) => str
+    .split(";")
+    .map((v) => v.split("="))
+    .reduce((acc, v) => {
+    if (v.length > 1) {
+        acc[decodeURIComponent(v[0].trim())] = decodeURIComponent(v[1].trim());
+    }
+    return acc;
+}, {});
+exports.parseCookie = parseCookie;
+/**
+ * Filters an array of objects based on a specified property and value.
+ * @template T extends Record<string, any> - The type of objects in the array.
+ * @param {T[]} array - The array of objects to filter.
+ * @param {keyof T} propertyName - The name of the property to filter on.
+ * @param {T[keyof T]} propertyValue - The value of the property to filter on.
+ * @returns {T[]} - The filtered array of objects.
+ */
+function filterObjectsByProperty(array, propertyName, propertyValue) {
+    const predicate = (obj) => Object.getOwnPropertyDescriptor(obj, propertyName) && obj[propertyName] === propertyValue;
+    return array.filter(predicate);
+}
+exports.filterObjectsByProperty = filterObjectsByProperty;
+/**
+ * Checks if the main object contains the sub object.
+ * @template T extends Record<string, any> - The type of the main object.
+ * @param {T} mainObject - The main object to check.
+ * @param {Partial<T>} subObject - The sub object to look for in the main object.
+ * @returns {boolean} - True if the main object contains the sub object, false otherwise.
+ */
+function containsSubObject(mainObject, subObject) {
+    if (!((0, exports.isPureObject)(mainObject) && (0, exports.isPureObject)(subObject))) {
+        return false;
+    }
+    for (let key of Object.keys(subObject)) {
+        if (!(Object.getOwnPropertyDescriptor(mainObject, key) && mainObject[key] === subObject[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.containsSubObject = containsSubObject;
+/**
+ * Finds the object containing the given sub object in the array.
+ * @template T extends Record<string, any> - The type of objects in the array.
+ * @param {T[]} array - The array of objects.
+ * @param {Partial<T>} subObject - The sub object used to search the array.
+ * @returns {T | null} - The object containing the given sub object or null.
+ */
+function findObjectBySubObject(array, subObject) {
+    const predicate = (obj) => containsSubObject(obj, subObject);
+    return array.find(predicate) || null;
+}
+exports.findObjectBySubObject = findObjectBySubObject;
+/**
+ * Filters an array of objects based on the objects containing the given sub object
+ * @template T extends Record<string, any>
+ * @param {T[]} array - The array of objects
+ * @param {Partial<T>} subObject - The sub object used to search the array
+ * @returns {Object | null} - An array of objects containing the given sub object
+ */
+function filterObjectsBySubObject(array, subObject) {
+    const predicate = (obj) => containsSubObject(obj, subObject);
+    return array.filter(predicate);
+}
+exports.filterObjectsBySubObject = filterObjectsBySubObject;
+/**
+ * Checks if the object has the key with the value.
+ * @param {Object} object - The object to check
+ * @param {string} key - The key to check
+ * @param {any} value - The value to check
+ * @returns {boolean} - Whether or not the object has the key with the value
+ * @example
+ * const object = { a: 1, b: 2, c: 3 }
+ * objectPropHasValue(object, 'a', 1) // true
+ * objectPropHasValue(object, 'b', 3) // false
+ */
+const objectPropHasValue = ({ object, propName, value, }) => object[propName] === value;
+exports.objectPropHasValue = objectPropHasValue;
+/**
+ * Finds the first entry in the array that satisfies the predicate.
+ * @template EntryType - The type of the entries in the array.
+ * @callback PredicateFunction - The predicate function to use to search the array.
+ * @param {EntryType} item - The entry in the array to search.
+ * @returns {boolean} - True if the entry satisfies the predicate, false otherwise.
+ * @param {EntryType[]} array - The array of entries to search.
+ * @param {PredicateFunction} predicate - The predicate function to use to search the array.
+ * @returns {EntryType | null} - The first entry that satisfies the predicate, or null if not found.
+ */
+const findEntry = (array, predicate) => array.find(predicate) || null;
+exports.findEntry = findEntry;
+function convertArrayToMap(arrayData, keyProp) {
+    if (typeof keyProp !== "string") {
+        throw new Error("keyProp can only be strings or numbers");
+    }
+    const dataAsObject = {};
+    arrayData.reduce((prev, curr) => {
+        const key = curr[keyProp];
+        prev[key] = curr;
+        return prev;
+    }, dataAsObject);
+    return dataAsObject;
+}
+exports.convertArrayToMap = convertArrayToMap;

package/dist/text.d.ts

@@ -0,0 +1,146 @@
+/**
+ *
+ * @function
+ * @param {T} input - The string, object, or array of objects that needs to have its casing changed
+ * @param {"toSnakeCase" | "toCamelCase"} type - The type of casing the string, object, or array of objects should be converted to (snake_case or camelCase)
+ * @returns {T} - A new string, object, or array of objects in the specified casing
+ */
+export declare const convertKeyCasing: <T extends string | Object | Object[]>(input: T, type: "toSnakeCase" | "toCamelCase") => T;
+/**
+ *
+ * @function
+ * @returns {string} - A randomly generated string.
+ */
+export declare const uuidv4: () => string;
+/**
+ *
+ * @function
+ * @param {number} position - A position number.
+ * @returns {string} - A string representing the position with the appropriate suffix (st, nd, rd, or th) e.g "1st", "2nd", "3rd", "4th", etc.
+ */
+export declare const formatPosition: (position: number) => string;
+/**
+ *
+ * @function
+ * @param {string} text - The text to be truncated
+ * @param {number} characterLimit - The maximum number of characters that the text can have
+ * @returns {string} - The truncated text with "..." added at the end if the text has exceeded the character limit
+ */
+export declare const truncateText: (text: string, characterLimit: number) => string;
+/**
+ *
+ * @function
+ * @param {string} path - The path of the file
+ * @returns {string} - The file name
+ */
+export declare const fileNameFromPath: (path: string) => string;
+/**
+ *
+ * @function
+ * @param {string} s - The string that needs to have spaces replaced with underscores
+ * @returns {string} - The string with spaces replaced with underscores
+ */
+export declare const replaceSpacesWithUnderscore: (s?: string) => string;
+/**
+ *
+ * @function
+ * @param {string} s - The string that needs to have underscores replaced with spaces
+ * @returns {string} - The string with underscores replaced with spaces
+ */
+export declare const replaceUnderscoreWithSpaces: (s?: string) => string;
+/**
+ *
+ * @function
+ * @param {string} word - The word that needs to be pluralized
+ * @param {boolean} condition - The condition that determines if the word needs to be pluralized
+ * @returns {string} - The word with "s" added to the end if the condition is true
+ */
+export declare const pluralizeOnCondition: (word: string, condition: boolean) => string;
+/**
+ * @function
+ * @param {Object | Array<Object> | string} data - The object or array of objects to convert key cases
+ * @returns {Object | Array<Object> | string} - The object or array of objects with the keys in camelCase
+ */
+export declare const convertSnakeToCamelCase: (data: string | Object | Array<Object>) => string | Object | Object[];
+/**
+ * @function
+ * @param {Object | Array<Object> | string} data - The object or array of objects to convert key cases
+ * @returns {Object | Array<Object> | string} - The object or array of objects with the keys in snake_case
+ */
+export declare const convertCamelToSnakeCase: (data: string | Object | Array<Object>) => string | Object | Object[];
+/**
+ * Convert camel case to kebab case
+ * @function
+ * @param {string} word - The word needed to be converted to kebab case from camel case
+ * @returns {string} - The word returned as kebab case
+ */
+export declare function convertCamelToKebabCase(word: string): string;
+/**
+ * Convert kebab case to camel case
+ * @function
+ * @param {string} word - The word needed to be converted from kebab case to camel case
+ * @returns {string} - The word returned as camel case
+ */
+export declare function convertKebabToCamelCase(word: string): string;
+/**
+ * Validate if a word is acronym
+ * @function
+ * @param {string} word - The word that is being validated as acronym
+ * @returns {string} - The boolean value when the condition is met
+ */
+export declare function isAcronym(word: string): boolean;
+/**
+ * Convert acronym to kebab case
+ * @function
+ * @param {string} word - The acronym to be converted to kebab case
+ * @returns {string} - The word returned as camel case
+ */
+export declare function acronymToKebabCase(word: string): string;
+/**
+ * @function
+ * @param  value The string to be displayed
+ * @returns The passed string or the default string if the passed string is null or undefined
+ */
+export declare const handleNullDisplay: (value: string | null | undefined, defaultValue?: string) => string;
+/**
+ * @function
+ * @param  text The string to be capitalized
+ * @returns The string in a capitalized form
+ */
+export declare const capitalizeText: (text: string | undefined) => string;
+/**
+ * Enforces a character limit on a given string.
+ * @function
+ * @param {object} options - The options for the function.
+ * @param {string} options.text - The text to limit.
+ * @param {number} options.characterLimit - The maximum number of characters allowed.
+ * @param {function} options.onCharacterLimit - The function to call when the character limit is exceeded.
+ * @returns {string} The original string if it is shorter than the character limit, or a truncated version of the string if it is longer.
+ */
+export declare const enforceCharacterLimit: ({ text, characterLimit, onCharacterLimit, }: {
+    text: string;
+    characterLimit: number;
+    onCharacterLimit: () => void;
+}) => string;
+/**
+ * Validate email if its a proper email or not
+ * @function
+ * @param email The email to be validated
+ * @returns The boolean value when the condition is met
+ */
+export declare const isValidEmail: (email: string) => boolean;
+/**
+ * Generate ID from word
+ * @function
+ * @param word The word needed to generate ID from
+ * @returns The generated ID from the word
+ */
+export declare function generateIDFromWord(text: string): string;
+/**
+ * Get the word from the generated ID
+ * @function
+ * @param id The id that is needed to get the word from.
+ * @param customList The word lists that are used to check the original words from.
+ * @returns The word that is got from the id
+ */
+export declare function generateWordFromId(id: string, customList?: Record<string, string>): string;