@kwiz/common 1.0.132 → 1.0.133

package/src/helpers/strings.test.js

@@ -1,123 +0,0 @@
-import assert from 'assert/strict';
-import test from 'node:test';
-import { ReplaceTokensInDictionary, capitalizeFirstLetter, escapeXml, maskString, replaceAll, replaceRegex, splitString } from './strings';
-
-test('replaceAll', t => {
-    assert.strictEqual(replaceAll("hello old#@! world old#@! !", "old#@!", "new!@$"), "hello new!@$ world new!@$ !");
-
-    //this failed since the input find included protected regex characters.
-    //escapeRegExp needs to fix that
-    let string = "string with special regex[:(s:) chars";
-    let find = "regex[:(s:)";
-    let replace = "regex[~~(s~~)";
-    let result = "string with special regex[~~(s~~) chars";
-    assert.strictEqual(replaceAll(string, find, replace), result);
-
-    string = `To activate the KWIZ Forms feature in your list you should click the "KWIZ Forms Display Mode" button:
-
-![](https://kwizcom.sharepoint.com/sites/Docs/CMSResources/CMS365/Screenshot 2024-06-18 123120.jpg)
-
-Now select one "Side Panel" or "Full Page" for the display mode:`;
-    find = "https://kwizcom.sharepoint.com/sites/Docs/CMSResources/CMS365/Screenshot 2024-06-18 123120.jpg";
-    replace = "/sites/Docs/CMSResources/CMS365/Screenshot 2024-06-18 123120.jpg";
-    result = `To activate the KWIZ Forms feature in your list you should click the "KWIZ Forms Display Mode" button:
-
-![](/sites/Docs/CMSResources/CMS365/Screenshot 2024-06-18 123120.jpg)
-
-Now select one "Side Panel" or "Full Page" for the display mode:`;
-    assert.strictEqual(replaceAll(string, find, replace, true), result);
-
-});
-
-test('capitalizeFirstLetter', async t => {
-    assert.strictEqual(capitalizeFirstLetter(), "");
-    assert.strictEqual(capitalizeFirstLetter("a"), "A");
-    assert.strictEqual(capitalizeFirstLetter("hello"), "Hello");
-    assert.strictEqual(capitalizeFirstLetter("hello world!"), "Hello world!");
-    assert.strictEqual(capitalizeFirstLetter("helloworld"), "Helloworld");
-    assert.strictEqual(capitalizeFirstLetter(""), "");
-});
-
-test('escapeXml', async t => {
-    assert.strictEqual(escapeXml(), "");
-    assert.strictEqual(escapeXml(""), "");
-    assert.strictEqual(escapeXml(" "), " ");
-    assert.strictEqual(escapeXml("<test />"), "&lt;test /&gt;");
-    assert.strictEqual(escapeXml(`full scope: <>&'"`), `full scope: &lt;&gt;&amp;'"`);
-    assert.strictEqual(escapeXml(undefined, true), "");
-    assert.strictEqual(escapeXml("", true), "");
-    assert.strictEqual(escapeXml(" ", true), " ");
-    assert.strictEqual(escapeXml("<test />", true), "&lt;test /&gt;");
-    assert.strictEqual(escapeXml(`full scope: <>&'"`, true), `full scope: &lt;&gt;&amp;&apos;&quot;`);
-});
-
-test('replaceRegex', t => {
-    /** Match anything between {zone:*} */
-    var match = /{zone:\w+}/gi;
-
-    var source = `text {zone:one} {zone:two}
-more text
-{zone:three}`;
-    var result = `text ONE TWO
-more text
-THREE`;
-
-    assert.strictEqual(replaceRegex(source, match, m => m.slice(1, m.length - 1).split(':')[1].toLocaleUpperCase()), result);
-
-    /** match: "](______)" */
-    match = /]\(.+\)/gi;
-    source = '[name:root](https://kwizcom.sharepoint.com/:fl:/g/contentstorage)';
-    result = '[name:root](https~~~~//kwizcom.sharepoint.com/~~~~fl~~~~/g/contentstorage)';
-    assert.strictEqual(replaceRegex(source, match, m => m.replace(/:/gi, "~~~~")), result);
-});
-
-test('maskString', async t => {
-    assert.strictEqual(maskString("abcdefg"), "ab*****fg");
-    assert.strictEqual(maskString("ab"), "ab*****ab");
-    assert.strictEqual(maskString(""), "*****");
-    assert.strictEqual(maskString("abcdefg", { mask: "..." }), "ab...fg");
-    assert.strictEqual(maskString("abcdefg", { mask: "...", start: 0, end: 0 }), "...");
-    assert.strictEqual(maskString("abcdefg", { mask: "...", start: 1, end: 1 }), "a...g");
-});
-
-test('ReplaceTokensInDictionary', async t => {
-    const tokens = { "t1": "token1", "t2": "token 2" };
-    let dic = {};
-    let expected = {};
-
-    dic = { a: "hello" };
-    expected = { a: "hello" };
-    ReplaceTokensInDictionary(dic, tokens);
-    assert.strictEqual(JSON.stringify(dic), JSON.stringify(expected));
-
-    dic = { a: "hello", b: "hello [t1]" };
-    expected = { a: "hello", b: "hello token1" };
-    ReplaceTokensInDictionary(dic, tokens);
-    assert.strictEqual(JSON.stringify(dic), JSON.stringify(expected));
-
-    dic = { a: "hello", b: "hello [t1] [t2]", c: "[t2]" };
-    expected = { a: "hello", b: "hello token1 token 2", c: "token 2" };
-    ReplaceTokensInDictionary(dic, tokens);
-    assert.strictEqual(JSON.stringify(dic), JSON.stringify(expected));
-});
-
-test('splitString', async t => {
-    const str = "abcd|1234|efgh|5678";
-    let expected = [
-        'abc', 'd|1',
-        '234', '|ef',
-        'gh|', '567',
-        '8'
-    ];
-    assert.strictEqual(JSON.stringify(splitString(str, { maxLength: 3 })), JSON.stringify(expected));
-    expected = [
-        'abcd', '1234',
-        'efgh', '5678'
-    ];
-    assert.strictEqual(JSON.stringify(splitString(str, { marker: "|" })), JSON.stringify(expected));
-    expected = [
-        'ab', 'cd', '12', '34',
-        'ef', 'gh', '56', '78'
-    ];
-    assert.strictEqual(JSON.stringify(splitString(str, { marker: "|", maxLength: 2 })), JSON.stringify(expected));
-});

package/src/helpers/strings.ts

@@ -1,338 +0,0 @@
-import { IDictionary } from "../types/common.types";
-import { filterEmptyEntries, makeUniqueArray } from "./collections.base";
-import { isNullOrEmptyString, isNullOrUndefined, isNumber, isString } from "./typecheckers";
-
-export function endsWith(str: string, value: string, ignoreCase?: boolean): boolean {
-    let str1 = str;
-    let find = value;
-    if (ignoreCase) {
-        str1 = str1.toLowerCase();
-        find = find.toLowerCase();
-    }
-
-    return str1.substr(str1.length - find.length) === find;
-}
-
-export function startsWith(str: string, value: string, ignoreCase?: boolean): boolean {
-    let str1 = str;
-    let find = value;
-    if (ignoreCase) {
-        str1 = str1.toLowerCase();
-        find = find.toLowerCase();
-    }
-    return str1.substr(0, find.length) === find;
-}
-
-/** remove space at start or end */
-export function trim(str: string): string {
-    return str.replace(/^\s+|\s+$/g, '');
-}
-
-export function trimEnd(str: string): string {
-    return str.replace(/\s+$/, "");
-}
-
-export function trimStart(str: string): string {
-    return str.replace(/^\s+/, "");
-}
-
-export function splice(str: string, start: number, delCount: number, insert: string) {
-    return str.slice(0, start) + insert + str.slice(start + Math.abs(delCount));
-}
-
-export function padRight(value: string | number, length: number, fillString: string = "0") {
-    if (isNumber(value))
-        value = value.toString(10);
-    let pad = isNullOrEmptyString(fillString) ? "0" : fillString[0];
-    return value + Array(length - value.length + 1).join(pad);
-}
-
-export function padLeft(value: string | number, length: number, fillString: string = "0") {
-    if (isNumber(value))
-        value = value.toString(10);
-    let pad = isNullOrEmptyString(fillString) ? "0" : fillString[0];
-    return Array(length - String(value).length + 1).join(pad) + value;
-}
-
-/** returns array of [token] found inside the string 
- * supports token formats [Author??Created by {0}::Unknown author] will return "Author" as the token
- * */
-export function GetTokens(StringFormat: string): string[] {
-    let tokensResult: string[] = [];
-    if (isNullOrEmptyString(StringFormat)) return tokensResult;
-
-    let tokens = StringFormat.match(/\[[^\]]*\]/g);
-    if (tokens && tokens.length > 0) {
-        tokens.forEach(token => {
-            let key = token.slice(1, token.length - 1);
-            key = GetTokenInfo(key).tokenName;
-            if (tokensResult.indexOf(key) < 0)
-                tokensResult.push(key);
-        });
-    }
-
-    return tokensResult;
-}
-
-/** replaces a string with [token] and [otherToken] with their matched provided values
- * supports token formats [Author??Created by {0}::Unknown author]
- */
-export function ReplaceTokens(StringFormat: string, TokenValues: IDictionary<string>, options?: {
-    /**set to true if you want to keep "[token]" in the string when a token value wasn't provided */
-    keepMissingTokens?: boolean;
-}): string {
-
-    let skipMissingTokens = options && options.keepMissingTokens;
-
-    if (isNullOrUndefined(StringFormat)) return null;
-    if (StringFormat !== '') {
-        let tokens = StringFormat.match(/\[[^\]]*\]/g);
-        if (tokens && tokens.length > 0) {
-            if (isNullOrUndefined(TokenValues)) TokenValues = {};
-
-            tokens.forEach(token => {
-                let key = token.slice(1, token.length - 1);
-                let tokenInfo = GetTokenInfo(key);
-                let value = TokenValues[tokenInfo.tokenName];
-                let skip = false;
-                if (isNullOrUndefined(value)) {
-                    value = "";
-                    skip = skipMissingTokens;//if true we won't replace this one
-                }
-                if (!skip || tokenInfo.hasFormat)
-                    StringFormat = StringFormat.replace(token, tokenInfo.getValue(value));
-            });
-        }
-    }
-    return StringFormat;
-}
-
-/** calls replace tokens on every dictionary value, or set null keys to "". This function ignores null/empty dictionaries */
-export function ReplaceTokensInDictionary(Dictionary: IDictionary<string>, TokenValues: IDictionary<string>) {
-    if (!isNullOrUndefined(Dictionary)) {
-        Object.keys(Dictionary).forEach(key => {
-            Dictionary[key] = isNullOrEmptyString(Dictionary[key]) ? "" : ReplaceTokens(Dictionary[key], TokenValues);
-        });
-    }
-}
-
-/** Normalizes a guid string, lower case and removes {} */
-export function normalizeGuid(text: string, removeDashes?: boolean): string {
-    if (isNullOrEmptyString(text) || !isString(text)) {
-        return text;
-    }
-    var guid = text.toLowerCase().trim();
-
-    if (guid.startsWith("{")) {
-        guid = guid.substr(1);
-    }
-
-    if (guid.endsWith("}")) {
-        guid = guid.substr(0, guid.length - 1);
-    }
-
-    if (removeDashes) {
-        guid = guid.replace(/-/g, '');
-    }
-
-    return guid;
-}
-
-export function isEmptyGuid(guid: { toString(): string; }) {
-    if (isNullOrEmptyString(guid)) return true;
-    else if (Number(normalizeGuid(guid.toString(), true)) === 0) return true;
-    return false;
-}
-
-export function escapeRegExp(text: string) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-}
-
-export function isValidDomainLogin(login: string) {
-    return /^[A-Za-z0-9\\._-]{7,}$/.test(login);
-}
-
-export function stripRichTextWhitespace(value: string) {
-    // richText fields in have random markup even when field is empty
-    // \u200B zero width space
-    // \u200C zero width non-joiner Unicode code point
-    // \u200D zero width joiner Unicode code point
-    // \uFEFF zero width no-break space Unicode code point       
-    return isString(value) ? value.replace(/[\u200B-\u200D\uFEFF]/g, "") : value;
-}
-
-/** allows min length 1, letters, numbers underscore only */
-export function isValidVarName(text: string) {
-    return /^[A-Za-z0-9_]{1,}$/.test(text);
-}
-
-/** allows min length 1, letters, numbers underscore and hyphen only */
-export function isValidHeaderName(text: string) {
-    return /^[A-Za-z0-9_-]{1,}$/.test(text);
-}
-
-/** returns token info with format  */
-export function GetTokenInfo(text: string) {
-    let split = text.split('??');
-    let hasFormat = split.length > 0 && !isNullOrEmptyString(split[1]);
-    let formatSplit = hasFormat ? split[1].split('::') : [];
-    let valueIfEmpty = formatSplit.length > 1 ? formatSplit[1] : "";
-    let formatIfNotEmpty = formatSplit[0];
-    let info = {
-        tokenName: hasFormat ? split[0] : text,
-        hasFormat: hasFormat,
-        getValue: (value: string) => {
-            if (!hasFormat) return value;
-            else {
-                if (isNullOrEmptyString(value)) return valueIfEmpty;
-                else return formatIfNotEmpty.replace('{0}', value);
-            }
-        }
-    };
-    return info;
-}
-
-/** return true if both strings are the same, or both are empty/null/undefined */
-export function stringEqualsOrEmpty(str1: string, str2: string, ignoreCase?: boolean) {
-    if (isNullOrEmptyString(str1) && isNullOrEmptyString(str2)) return true;
-    if (ignoreCase) {
-        if (!isNullOrEmptyString(str1)) str1 = str1.toLowerCase();
-        if (!isNullOrEmptyString(str2)) str2 = str2.toLowerCase();
-    }
-
-    return str1 === str2;
-}
-
-/** return true if str1 contains str2 */
-export function stringContains(str1: string, str2: string, ignoreCase?: boolean) {
-    if (isNullOrEmptyString(str1) && isNullOrEmptyString(str2)) return true;
-
-    if (isNullOrEmptyString(str1))
-        str1 = "";
-    if (isNullOrEmptyString(str2))
-        str2 = "";
-
-    if (ignoreCase) {
-        str1 = str1.toLowerCase();
-        str2 = str2.toLowerCase();
-    }
-
-    return str1.indexOf(str2) >= 0;
-}
-
-export function cleanupString(str: string, options: {
-    replaceNewLines?: string;
-    collapseMultipleSpaces?: string;
-    collapseMultipleDashes?: string;
-    collapseMultipleUnderscore?: string;
-}) {
-    if (isString(options.replaceNewLines))
-        str = str.replace(/\r/g, '')//no returns
-            .replace(/\n/g, options.replaceNewLines);//no line breaks
-    if (isString(options.collapseMultipleDashes))
-        str = str.replace(/-+/g, options.collapseMultipleSpaces);//no extra spaces
-    if (isString(options.collapseMultipleUnderscore))
-        str = str.replace(/_+/g, options.collapseMultipleUnderscore);//no extra spaces
-
-    // do this last, so it will collapse spaces added by previous options
-    if (isString(options.collapseMultipleSpaces)) {
-        str = str.replace(new RegExp(String.fromCharCode(160), "g"), '')//get rid of non-breaking spaces
-            .replace(/ +/g, options.collapseMultipleSpaces);//no extra spaces
-    }
-
-    return str;
-}
-
-/** normalizes &#160; to &nbsp; see Issue 752 */
-export function normalizeHtmlSpace(html: string) {
-    if (isNullOrEmptyString(html)) return html;
-    return html.replace(/&#160;/i, "&nbsp;");
-}
-
-export function replaceAll(str: string, find: string, replace: string, ignoreCase = false) {
-    //must call escapeRegExp on find, to make sure it works when there are protected regex characters
-    return str.replace(new RegExp(escapeRegExp(find), `g${ignoreCase ? 'i' : ''}`), replace);
-}
-
-export function capitalizeFirstLetter(str: string) {
-    return isNullOrEmptyString(str)
-        ? ""
-        : `${str.charAt(0).toUpperCase()}${str.substring(1)}`;
-}
-
-export function escapeXml(unsafe: string, isAttribute = false) {
-    if (isNullOrEmptyString(unsafe)) return "";
-    return isAttribute
-        ? unsafe.replace(/[<>&'"]/g, (c) => {
-            switch (c) {
-                case '<': return '&lt;';
-                case '>': return '&gt;';
-                case '&': return '&amp;';
-                case '\'': return '&apos;';
-                case '"': return '&quot;';
-            }
-            return c;
-        })
-        : unsafe.replace(/[<>&]/g, (c) => {
-            switch (c) {
-                case '<': return '&lt;';
-                case '>': return '&gt;';
-                case '&': return '&amp;';
-            }
-            return c;
-        });
-}
-
-/** uses regex str.match to replace each match by calling the replacer function (imported from CMS) */
-export function replaceRegex(str: string, regex: RegExp, replacer: (match: string) => string | null) {
-    let matches = str.match(regex);
-    if (!matches || matches.length < 1) return str;
-    //replace each found token only once
-    let unique = makeUniqueArray(matches);
-    //todo: this has a bug where tokens matched contain each other, example, match numbers and prefix with #: 10, 100 will match both and produce #10 ##100
-    unique.forEach(m => {
-        let replacement = replacer(m);
-        if (!isNullOrUndefined(replacement))//ignore nulls
-            str = replaceAll(str, m, replacement);
-    });
-    return str;
-}
-
-/** masks a long string, keeping X number for characters at the start/end and replacing the middle with the mask string (default: CC*****CCC) */
-export function maskString(str: string, options?: {
-    /** mask string, default ***** */
-    mask?: string;
-    /** characters to keep at start, default 2 */
-    start?: number;
-    /** characters to keep at end, default 2 */
-    end?: number;
-}) {
-    const mask = options && options.mask || "*****";
-    const start = options && isNumber(options.start) ? options.start : 2;
-    const end = options && isNumber(options.end) ? options.end : 2;
-    const prefix = start >= 0 ? str.slice(0, start) : str;
-    const sliceEnd = str.length - end;
-    const suffix = sliceEnd >= 0 ? str.slice(sliceEnd) : str;
-
-    return `${prefix}${mask}${suffix}`;
-}
-
-export function splitString(str: string, options: { maxLength?: number; marker?: string | RegExp; clearEmptyEntries?: boolean }) {
-    let strArr: string[] = [str];
-    if (!isNullOrUndefined(options.marker)) strArr = str.split(options.marker);
-    if (isNumber(options.maxLength) && options.maxLength > 0) {
-        let splitted: string[] = [];
-        strArr.forEach(currentStr => {
-            while (currentStr.length > 0) {
-                splitted.push(currentStr.slice(0, options.maxLength));
-                currentStr = currentStr.slice(options.maxLength);
-            }
-        });
-
-        strArr = splitted;
-    }
-
-    if (options.clearEmptyEntries)
-        strArr = filterEmptyEntries(strArr);
-    return strArr;
-}

package/src/helpers/typecheckers.test.js

@@ -1,35 +0,0 @@
-import assert from 'assert/strict';
-import test from 'node:test';
-import { isEmptyObject, isNullOrEmptyString, isPrimitiveValue } from './typecheckers';
-
-test('isNullOrEmptyString', async t => {
-    // This test passes because it does not throw an exception.
-    await t.test("null", t => assert.strictEqual(isNullOrEmptyString(null), true));
-    await t.test("undefined", t => assert.strictEqual(isNullOrEmptyString(undefined), true));
-    await t.test("empty string", t => assert.strictEqual(isNullOrEmptyString(""), true));
-    await t.test("space", t => assert.strictEqual(isNullOrEmptyString(" "), false));
-    await t.test("0", t => assert.strictEqual(isNullOrEmptyString(0), false));
-    await t.test("1", t => assert.strictEqual(isNullOrEmptyString(1), false));
-});
-
-test('isEmptyObject', async t => {
-    await t.test("null", t => assert.strictEqual(isEmptyObject(null), true));
-    await t.test("undefined", t => assert.strictEqual(isEmptyObject(undefined), true));
-    await t.test("[]", t => assert.strictEqual(isEmptyObject([]), true));
-    await t.test("{}", t => assert.strictEqual(isEmptyObject({}), true));
-    await t.test("ignore keys", t => assert.strictEqual(isEmptyObject({ test: 1 }, { ignoreKeys: ["test"] }), true));
-    await t.test("[1]", t => assert.strictEqual(isEmptyObject([1]), false));
-    await t.test("non empty object", t => assert.strictEqual(isEmptyObject({ test: 1 }), false));
-    await t.test("non empty object with ignored key", t => assert.strictEqual(isEmptyObject({ test: 1, test2: 2 }, { ignoreKeys: ["test"] }), false));
-});
-
-test('isPrimitiveValue', async t => {
-    assert.strictEqual(isPrimitiveValue(1.42), true);
-    assert.strictEqual(isPrimitiveValue(new Date()), true);
-    assert.strictEqual(isPrimitiveValue({ title: "hello" }), false);
-    assert.strictEqual(isPrimitiveValue("hello"), true);
-    assert.strictEqual(isPrimitiveValue(() => { }), false);
-    assert.strictEqual(isPrimitiveValue([1, 2, 3]), false);
-    assert.strictEqual(isPrimitiveValue([]), false);
-    assert.strictEqual(isPrimitiveValue(), true);
-});