@mikezimm/fps-core-v7/lib/logic/Strings/getWordsFromString.js

Library of reusable core interfaces, types and constants migrated from fps-library-v2

import { sortStringArrayCollator } from "../../logic/Arrays/sorting/strings";
import { getStringArrayBasic } from "./getStringArrayBasic";
/**
 *
 * Originally used in Compliance to get list of words from a string
 * Updated 2023-03-28
 *
 * @param str
 * @param removeDigits
 * @returns array of words found
 */
export function mergeArrayOfWordsFromString(str, intoThese, removeDigits, removeDups, ignoreCase, order, localLanguage = 'en') {
    if (!str)
        return [];
    const theseWords = getArrayOfWordsFromString(str, removeDigits, removeDups, ignoreCase, order, localLanguage);
    const results = mergeWordArrays(theseWords, intoThese, ignoreCase, order, localLanguage);
    return results;
}
/**
 * getArrayOfWordsFromString is a more advanced variation of getStringArrayBasic
 * This will check for duplicates and also allow for using or ignoring case.
 * Finally it also provides a built in option to sort.
 *
 * You can use getStringArrayBasic if you do not need any of those advanced options but to just split into words.
 * @param str
 * @param removeDigits
 * @param removeDups
 * @param ignoreCase
 * @param order
 * @param localLanguage
 * @returns
 */
export function getArrayOfWordsFromString(str, removeDigits, removeDups, ignoreCase, order, localLanguage = 'en') {
    const results = [];
    if (!str)
        return results;
    // let baseStr = `${str}`;
    // if ( removeDigits === true ) baseStr = baseStr.replace(/[0-9]/g, ' ');
    // baseStr = baseStr.replace( /[-_,&[\]]+/g, ' ' ); // Replace most common special characters
    // baseStr = baseStr.replace( /[()]+/g, ' ' ); // Replace most common special characters
    // baseStr = baseStr.replace( /[/\\]+/g, ' ' ); // Replace most common special characters
    // baseStr = baseStr.replace( /[']+/g, ' ' ); // Replace most common special characters
    // baseStr = baseStr.replace(/\s\s+/g, ' '); // Replace multiple spaces with just one
    // // get array of original trimmed words and exclude empties
    // const originalWords: string[] = baseStr.split(/\b([a-z]+)\b/gi).map( word => { return word.trim() } ).filter( word => { return word } );
    const originalWords = getStringArrayBasic(`${str}`, removeDigits);
    // Correct case of compare array of strings from str
    let originalCompareWords = ignoreCase === true ? originalWords.map(item => { return item.toLocaleLowerCase(); }) : originalWords;
    originalCompareWords = removeDups === true ? originalCompareWords.filter(item => { return item.toLocaleLowerCase(); }) : originalCompareWords;
    let finalVals = [];
    // finalCompare is used as a comparison for when case is important
    // const finalCompare: string[] = ignoreCase === true ? finalVals.map( item => { return item.toLowerCase() } ) : finalVals;
    if (removeDups !== true) {
        // NOTE:  If you do not remove dups, it currently does not check for ignoreCase
        finalVals = [...finalVals, ...originalWords];
    }
    else {
        const filteredCompareWords = []; // These are the same words but in lower case for comparison for duplicates
        // only save unique words found in this str
        originalWords.map((item, index) => {
            const itemTest = originalCompareWords[index];
            // First see if it's a duplicate in the original string str
            if (filteredCompareWords.indexOf(itemTest) === -1) {
                finalVals.push(item);
                filteredCompareWords.push(itemTest);
            }
        });
    }
    if (order !== 'asis')
        finalVals = sortStringArrayCollator(finalVals, order, false, localLanguage);
    return finalVals;
}
export function mergeWordArrays(mergeThese, intoThese, ignoreCase, order, localLanguage = 'en') {
    let finalWords = intoThese;
    const finalCompareWords = ignoreCase === true ? finalWords.map(item => { return item.toLocaleLowerCase(); }) : finalWords;
    const mergeTheseCompare = ignoreCase === true ? mergeThese.map(item => { return item.toLocaleLowerCase(); }) : mergeThese;
    // Now compare the filteredNewWords with the finalWords and only add ones that are not a duplicate.
    mergeTheseCompare.map((compareWord, index) => {
        if (finalCompareWords.indexOf(compareWord) === -1) {
            finalWords.push(mergeThese[index]);
            finalCompareWords.push(compareWord);
        }
    });
    if (order !== 'asis')
        finalWords = sortStringArrayCollator(finalWords, order, false, localLanguage);
    return finalWords;
}
//# sourceMappingURL=getWordsFromString.js.map