@kwiz/common 1.0.1

package/src/helpers/date.test.js

@@ -0,0 +1,97 @@
+import assert from 'assert/strict';
+import test from 'node:test';
+import { shiftMonths, getTotalDaysInMonth, getDateFromToken, isISODate, isISODateUTC, isNowToken, isStandardDate, isTodayToken } from "./date";
+
+test('isTodayToken', t => {
+    assert.strictEqual(isTodayToken(''), false);
+    assert.strictEqual(isTodayToken('today'), false);
+    assert.strictEqual(isTodayToken('[ to day]'), false);
+    assert.strictEqual(isTodayToken('[today ]'), false);
+    assert.strictEqual(isTodayToken('asd[today]'), false);
+    assert.strictEqual(isTodayToken('[today]adsd'), true);
+    assert.strictEqual(isTodayToken('[today] asd'), true);
+    assert.strictEqual(isTodayToken('[today]'), true);
+});
+
+test('isNowToken', t => {
+    assert.strictEqual(isNowToken(''), false);
+    assert.strictEqual(isNowToken('now'), false);
+    assert.strictEqual(isNowToken('[ now]'), false);
+    assert.strictEqual(isNowToken('[now ]'), false);
+    assert.strictEqual(isNowToken('asd[now]'), false);
+    assert.strictEqual(isNowToken('[now]adsd'), true);
+    assert.strictEqual(isNowToken('[now] asd'), true);
+    assert.strictEqual(isNowToken('[now]'), true);
+});
+
+test('getDateFromToken', t => {
+    let now = new Date();
+    assert.strictEqual(getDateFromToken('[today]+1', { now: now }).getTime(), (now.getTime() + (24 * 60 * 60 * 1000)));
+    assert.strictEqual(getDateFromToken('[today]-1', { now: now }).getTime(), (now.getTime() + (-24 * 60 * 60 * 1000)));
+    assert.strictEqual(getDateFromToken('[now]+15', { now: now }).getTime(), (now.getTime() + (+15 * 60 * 1000)));
+    assert.strictEqual(getDateFromToken('[now]-15', { now: now }).getTime(), (now.getTime() + (-15 * 60 * 1000)));
+
+    let test = new Date(now.getTime());
+    test.setHours(0, 0, 0, 0);
+    assert.strictEqual(getDateFromToken('[today]+1', { now: now, zeroTimeForToday: true }).getTime(), (test.getTime() + (24 * 60 * 60 * 1000)));
+    assert.strictEqual(getDateFromToken('[today]-1', { now: now, zeroTimeForToday: true }).getTime(), (test.getTime() + (-24 * 60 * 60 * 1000)));
+
+});
+
+test('isStandardDate', t => {   
+    assert.strictEqual(isStandardDate(''), false);
+    assert.strictEqual(isStandardDate('2023-08-21T15:54:14.954Z'), false);
+    assert.strictEqual(isStandardDate('2023-08-21T15:54:14.954'), false);
+    assert.strictEqual(isStandardDate('2023-08-21T15:54:14Z'), false);
+    assert.strictEqual(isStandardDate('2023-08-21T15:54:14'), false);
+    assert.strictEqual(isStandardDate('2023-08-21T15:54'), true);    
+});
+
+test('isISODate', t => {   
+    assert.strictEqual(isISODate(''), false);
+    assert.strictEqual(isISODate('2023-08-21T15:54:14.954Z'), true);
+    assert.strictEqual(isISODate('2023-08-21T15:54:14.954'), true);
+    assert.strictEqual(isISODate('2023-08-21T15:54:14Z'), true);
+    assert.strictEqual(isISODate('2023-08-21T15:54:14'), true);
+    assert.strictEqual(isISODate('2023-08-21T15:54'), false);    
+});
+
+test('isISODateUTC', t => {   
+    assert.strictEqual(isISODateUTC(''), false);
+    assert.strictEqual(isISODateUTC('2023-08-21T15:54:14.954Z'), true);
+    assert.strictEqual(isISODateUTC('2023-08-21T15:54:14.954'), false);
+    assert.strictEqual(isISODateUTC('2023-08-21T15:54:14Z'), true);
+    assert.strictEqual(isISODateUTC('2023-08-21T15:54:14'), false);
+    assert.strictEqual(isISODateUTC('2023-08-21T15:54'), false);    
+});
+
+test('getTotalDaysInMonth', t => {   
+    var d = new Date("01-01-2023");    
+    assert.strictEqual(getTotalDaysInMonth(d), 31);
+    
+    d = new Date("09-01-2023");
+    assert.strictEqual(getTotalDaysInMonth(d), 30);
+    
+    d = new Date("02-01-2023");
+    assert.strictEqual(getTotalDaysInMonth(d), 28);
+    
+    d = new Date("02-01-2024"); //leap year
+    assert.strictEqual(getTotalDaysInMonth(d), 29);
+});
+
+test('shiftMonths', t => {   
+    var d = new Date("01-31-2023");    
+    shiftMonths(d, 1)
+    assert.strictEqual(d.getMonth() + 1, 2);
+    assert.strictEqual(d.getDate(), 28);
+    
+    d = new Date("01-31-2023");    
+    shiftMonths(d, 13)
+    assert.strictEqual(d.getMonth() + 1, 2);
+    assert.strictEqual(d.getDate(), 29); //leap year
+
+    d = new Date("01-31-2023");    
+    shiftMonths(d, -11)
+    assert.strictEqual(d.getMonth() + 1, 2);
+    assert.strictEqual(d.getDate(), 28);
+});

package/src/helpers/date.ts

@@ -0,0 +1,163 @@
+/** 
+ * a date helper that is not relying on SharePoint or any utils at all
+ * can be synced to the server code and external projects
+ * do not add code that needs SP or utils -> move it to utils/date
+ */
+
+import { endsWith } from "./strings";
+import { isDate, isNullOrUndefined, isString } from "./typecheckers";
+
+export function isISODateUTC(d: string) {
+    //2023-08-21T15:54:14.954Z = true
+    //2023-08-21T15:54:14.954 = false
+    //2023-08-21T15:54:14Z = true
+    //2023-08-21T15:54:14 = false
+    //2023-08-21T15:54 = false
+    return isISODate(d) && endsWith(d, "Z", true);
+}
+
+export function isISODate(d: string) {
+    //2023-08-21T15:54:14.954Z = true
+    //2023-08-21T15:54:14.954 = true
+    //2023-08-21T15:54:14Z = true
+    //2023-08-21T15:54:14 = true
+    //2023-08-21T15:54 = false
+    return isString(d) && /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)((-(\d{2}):(\d{2})|Z)?)$/.test(d);
+}
+
+export function isStandardDate(d: string) {
+    //2023-08-21T15:54:14.954Z = false
+    //2023-08-21T15:54:14.954 = false
+    //2023-08-21T15:54:14Z = false
+    //2023-08-21T15:54:14 = false
+    //2023-08-21T15:54 = true
+    return isString(d) && /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/.test(d);
+}
+
+export function parseISODate(a: string): Date | null {
+    if (!Date.prototype.toISOString) {
+        if (a.length < 19) {
+            return null;
+        }
+        var i = Number(a.substr(0, 4)),
+            f = Number(a.substr(5, 2)),
+            d = Number(a.substr(8, 2)),
+            h = Number(a.substr(11, 2)),
+            e = Number(a.substr(14, 2)),
+            g = Number(a.substr(17, 2));
+        if (isNaN(i) || isNaN(f) || isNaN(d) || isNaN(h) || isNaN(e) || isNaN(g)) {
+            return null;
+        }
+        // b = new Date(Date.UTC(i, f - 1, d, h, e, g));
+        return new Date(Date.UTC(i, f - 1, d, h, e, g));
+    } else {
+        return new Date(a);
+    }
+}
+
+/** Get now date, without seconds or milliseconds. */
+export function getNow() {
+    let now = new Date();
+    now.setSeconds(0, 0);
+    return now;
+}
+/** Get today date, without hours, minutes, seconds or milliseconds. */
+export function getToday() {
+    let today = new Date();
+    today.setHours(0, 0, 0, 0);
+    return today;
+}
+
+// eslint-disable-next-line no-shadow
+export enum DateFormats {
+    YMD = "yyyy-MM-dd"
+}
+export function changeDate(options: { years?: number; months?: number; days?: number; hours?: number; minutes?: number; }, startDate?: Date): Date {
+    let newDate = isDate(startDate) ? new Date(startDate.getTime()) : new Date();//today, or the day that was passed
+
+    if (options) {
+        if (!isNullOrUndefined(options.years))
+            newDate.setFullYear(newDate.getFullYear() + options.years);
+
+        if (!isNullOrUndefined(options.months))
+            newDate.setMonth(newDate.getMonth() + options.months);
+
+        if (!isNullOrUndefined(options.days))
+            options.hours = (isNullOrUndefined(options.hours) ? 0 : options.hours) + (options.days * 24);
+
+        if (!isNullOrUndefined(options.hours))
+            options.minutes = (isNullOrUndefined(options.minutes) ? 0 : options.minutes) + (options.hours * 60);
+        if (!isNullOrUndefined(options.minutes) && options.minutes !== 0)
+            newDate = new Date(newDate.getTime() + (options.minutes * 60 * 1000));
+    }
+
+    return newDate;
+}
+
+export function cloneDate(date: Date) {
+    return new Date(date.getTime());
+}
+
+/** Returns a new date object adjusted for the time format */
+export function getDateFromToken(str: string, options?: { now?: Date; zeroTimeForToday?: boolean; }) {
+    let now = options && options.now ? new Date(options.now.getTime()) : new Date();
+
+    if (!isTodayToken(str) && !isNowToken(str)) return now;
+    let token: "Now" | "Today" = isTodayToken(str) ? "Today" : "Now";
+    var includeTime = token === "Now";
+    if (!includeTime && options && options.zeroTimeForToday) {
+        now.setHours(0, 0, 0, 0);
+    }
+
+    var n = str.replace(new RegExp(`\\[${token}\\]`, "im"), "");
+    n = n.replace(/\s/g, "");
+    var offset = n && n !== "" ? Number(n) : 0;
+
+    if (includeTime) {
+        now.setMinutes(now.getMinutes() + offset);
+    } else {
+        now.setDate(now.getDate() + offset);
+    }
+
+    return now;
+}
+
+export function isTodayToken(str: string) {
+    return str.match(/^\[today\]/im) !== null;
+}
+export function isNowToken(str: string) {
+    return str.match(/^\[now\]/im) !== null;
+}
+
+/** Get the number of seconds from date (in the past) to now */
+export function getSecondsElapsed(from: Date) {
+    let secondsElapsed = (new Date().getTime() - from.getTime()) / 1000;
+    return secondsElapsed;
+}
+
+/** Get the total number of days in a given month specified by a date object  */
+export function getTotalDaysInMonth(obj: Date) {
+    if (isDate(obj)) {
+        let d = new Date(obj.getFullYear(), obj.getMonth() + 1, 0);
+        return d.getDate();
+    }
+    return 0;
+}
+
+/** Shifts the date by a certain number of months and takes into account the total number of days in the new month. 
+ * For example, if you shift January 31st by one month it will return February 28th (29th for a leap year) instead of March 3rd (2nd in leap year)
+  */
+export function shiftMonths(obj: Date, months: number) {
+    let desiredDate = obj.getDate();
+    //move to first day to avoid skipping months (ie. Jan 31 -> March 3)
+    obj.setDate(1);
+    obj.setMonth(obj.getMonth() + months);
+    obj.setDate(Math.min(desiredDate, getTotalDaysInMonth(obj)));
+}
+
+/** 
+ * Gets last day of month given a date
+  */
+export function getLastDayOfMomth(obj: Date) {
+    return new Date(obj.getFullYear(), obj.getMonth() + 1, 0);
+}

package/src/helpers/debug.ts

@@ -0,0 +1,187 @@
+import { IsLocalDev } from "./_dependencies";
+import { deleteCookie, getCookie, setCookie } from "./cookies";
+import { getKWizComGlobal } from "./objects";
+import { sleepAsync } from "./promises";
+import { isFunction, isNotEmptyArray, isNullOrEmptyString, isNullOrUndefined } from "./typecheckers";
+
+interface IKWizComGlobalDebug {
+    _debug: boolean;
+    _consoleLoggerFilter: string[];
+    On: (Permanent?: boolean) => void;
+    Off: () => void;
+    ToggleLogs: (categoryName: string, silent?: boolean) => void;
+    /** purge all cache storage (SPFx may keep scripts cached)  */
+    PurgeCache: (options?: {
+        skipCookies?: boolean;
+        skipStorage?: boolean;
+        onlyKWizComCaches?: boolean;
+    }) => Promise<{ success: boolean; error?: any; message?: string; }>;
+}
+
+/** Get the global debug object. it will only be on the top window so don't put it in the IKWizComGlobals */
+export function GetGlobalDebug() {
+    return getKWizComGlobal(true) as { Debug?: IKWizComGlobalDebug; } & IKWizComGlobals;
+}
+function SetGlobalDebugFunction() {
+    var kGlobal = GetGlobalDebug();
+
+    if (isNullOrUndefined(kGlobal.Debug)) {
+        kGlobal.Debug = {
+            _debug: null,
+            _consoleLoggerFilter: null,
+            On: (Permanent?: boolean) => {
+                kGlobal.Debug._debug = true;
+                setCookie("KWizComDebug", "true", Permanent === true ? 365 : 1);
+                console.log("KWIZ Debug Mode: On");
+            },
+            Off: () => {
+                kGlobal.Debug._debug = false;
+                deleteCookie("KWizComDebug");
+                console.log("KWIZ Debug Mode: Off");
+            },
+            ToggleLogs: (categoryName: string, silent?: boolean) => {
+                if (silent === true) {
+                    if (kGlobal.Debug._consoleLoggerFilter === null)
+                        kGlobal.Debug._consoleLoggerFilter = [categoryName];
+                    else if (!kGlobal.Debug._consoleLoggerFilter.includes(categoryName))
+                        kGlobal.Debug._consoleLoggerFilter.push(categoryName);
+                }
+                else {
+                    if (kGlobal.Debug._consoleLoggerFilter === null)
+                        kGlobal.Debug._consoleLoggerFilter = [];
+                    else if (kGlobal.Debug._consoleLoggerFilter.includes(categoryName))
+                        kGlobal.Debug._consoleLoggerFilter = kGlobal.Debug._consoleLoggerFilter.filter(c => c !== categoryName);
+                }
+
+                setCookie("KWizComDebugFilter", kGlobal.Debug._consoleLoggerFilter.join('~'), 365);
+                console.log(`logs for ${categoryName} will ${silent === true ? 'not show up' : 'show up'}`);
+            },
+            PurgeCache: async (options?: {
+                skipCookies?: boolean;
+                skipStorage?: boolean;
+                onlyKWizComCaches?: boolean;
+            }) => {
+                options = options || {};
+
+                let result: { success: boolean; error?: any; message?: string; } = { success: true };
+                let failedKeys: string[] = [];
+                if (options.skipStorage !== true) {
+                    console.log(`purging local storage`);
+                    localStorage.clear();
+                    console.log(`purging session storage`);
+                    sessionStorage.clear();
+                }
+
+                if (options.skipCookies !== true) {
+                    console.log(`purging all cookies`);
+                    var cookies = document.cookie.split(";");
+                    cookies.forEach(cookie => { document.cookie = cookie.split("=")[0] + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT"; });
+                }
+
+                console.log(`purging caches`);
+                try {
+                    let keys = await caches.keys();
+                    for (let i1 = 0; i1 < keys.length; i1++) {
+                        let key = keys[i1];
+                        try {
+                            let cache = await caches.open(key);
+                            if (cache) {
+                                let subKeys = await cache.keys();
+                                if (subKeys && subKeys.length) {
+                                    let keysToRemove = options.onlyKWizComCaches !== true ? subKeys : subKeys.filter(k => k.url.toLowerCase().indexOf('apps.kwizcom.com/') >= 0);
+                                    for (let i2 = 0; i2 < keysToRemove.length; i2++) {
+                                        let success = await cache.delete(keysToRemove[i2]);
+                                        if (!success)//failed
+                                            failedKeys.push(keysToRemove[i2].url);
+                                    }
+                                }
+                            }
+                        } catch (b) {
+                            failedKeys.push(key);
+                        }
+                    }
+                } catch (e) {
+                    result.success = false;
+                    result.error = e;
+                    result.message = (e.message || "Something went wrong.");
+                }
+
+                if (isNotEmptyArray(failedKeys)) {
+                    result.success = false;
+                    result.message = (isNullOrEmptyString(result.message) ? '' : ' ') + `Failed keys: ${failedKeys.join()}`;
+                }
+
+                console.group('PurgeCache complete');
+                console.dir(result);
+                console.groupEnd();
+
+                return result;
+            }
+        };
+        //no need to do this anymore, once we added max-age cache to our response headers, the SP Service worker now clears
+        //the cache of our SPFx controls on its own.
+        // //by default - DO NOT clear cookies/storage and non-KWIZ caches!
+        // window.setTimeout(() => kGlobal.Debug.PurgeCache({
+        //     skipCookies: true,
+        //     skipStorage: true,
+        //     onlyKWizComCaches: true
+        // }), 3000);
+    }
+}
+
+SetGlobalDebugFunction();
+
+export function isDebug() {
+    var kGlobal = GetGlobalDebug();
+
+    if (isNullOrUndefined(kGlobal.Debug._debug)) {
+        kGlobal.Debug._debug = IsLocalDev ||
+            window.location.href.indexOf('kwdebug=true') > 0 ||
+            window.location.href.indexOf('/workbench.aspx') > 0 ||
+            getCookie("KWizComDebug") === "true";
+    }
+    return kGlobal.Debug._debug === true;
+}
+/** returns true if this is a kwizcom production/test tenant */
+export function isKWizComTenant() {
+    return window.location.host === "kwizcom.sharepoint.com" || window.location.host === "kwizcomqa.sharepoint.com";
+}
+export function isDebugOnKWizComTenant() {
+    return isKWizComTenant() && isDebug();
+}
+
+export function consoleLoggerFilter() {
+    var kGlobal = GetGlobalDebug();
+
+    if (isNullOrUndefined(kGlobal.Debug._consoleLoggerFilter)) {
+        let KWizComDebugFilter = getCookie("KWizComDebugFilter");
+        if (!isNullOrEmptyString(KWizComDebugFilter))
+            kGlobal.Debug._consoleLoggerFilter = KWizComDebugFilter.split('~');
+        else kGlobal.Debug._consoleLoggerFilter = [];
+    }
+    return kGlobal.Debug._consoleLoggerFilter;
+}
+
+export async function waitIfDebug(seconds?: number): Promise<void> {
+    if (isDebug())
+        await sleepAsync(seconds);
+}
+
+export function trackChangesToObject<T>(parent: unknown, objectName: string, tracker: {
+    onBeforeGet?: (v: T) => void;
+    onBeforeSet?: (v: T) => void;
+    onAfterSet?: (v: T) => void;
+}) {
+    let originalValue: T = parent[objectName];
+    Object.defineProperty(parent, objectName, {
+        set: (newValue: T) => {
+            if (isFunction(tracker.onBeforeSet)) tracker.onBeforeSet(newValue);
+            originalValue = newValue;
+            if (isFunction(tracker.onAfterSet)) tracker.onAfterSet(newValue);
+        },
+        get: () => {
+            if (isFunction(tracker.onBeforeGet)) tracker.onBeforeGet(originalValue);
+            return originalValue;
+        }
+    });
+}

package/src/helpers/emails.ts

@@ -0,0 +1,7 @@
+import { isNullOrEmptyString } from "./typecheckers";
+
+export function isValidEmail(email: string) {
+    return !isNullOrEmptyString(email) && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+export const freeEmailNotAllowedMessage = "Please use a work email, free emails are not allowed";

package/src/helpers/eval.ts

@@ -0,0 +1,5 @@
+//eval breaks treeshaking for the entire module it is in, so keep it in separate
+export function eval2(str: string) {
+    // eslint-disable-next-line no-eval
+    return eval(str);
+}

package/src/helpers/file.test.js

@@ -0,0 +1,51 @@
+import assert from 'assert/strict';
+import test from 'node:test';
+import { validateFilename, validateFoldername } from './file'
+
+test('validateFilename', t => {
+    '"*:<>?/\\|'.split("").forEach((char) => {
+        let result = validateFilename(`random${char}filename.txt`);
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.hasIllegalCharacter, true);
+    });
+
+    ".lock|CON|PRN|AUX|NUL|COM3|COM9|COM0|LPT8|LPT2|LPT6|random_VTI_filename|~$randomfilename".split("|").forEach((name) => {
+        let result = validateFilename(`${name}.txt`);
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.hasIllegalName, true);
+    });
+
+    let result = validateFilename(`desktop.ini`);
+    assert.strictEqual(result.valid, false);
+    assert.strictEqual(result.hasIllegalName, true);
+
+    ["filename.txt", "test.jpg", "image.png", "worddocument.doc"].forEach((name) => {
+        result = validateFilename(name);
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.hasIllegalName, false);
+    });
+});
+
+test('validateFoldername', t => {
+    '"*:<>?/\\|'.split("").forEach((char) => {
+        let result = validateFoldername(`random${char}folder`);
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.hasIllegalCharacter, true);
+    });
+
+    ".lock|CON|PRN|AUX|NUL|COM3|COM9|COM0|LPT8|LPT2|LPT6|random_VTI_folder|~$randomfolder".split("|").forEach((name) => {
+        let result = validateFoldername(`${name}`);
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.hasIllegalName, true);
+    });
+
+    let result = validateFoldername(`desktop.ini`);
+    assert.strictEqual(result.valid, false);
+    assert.strictEqual(result.hasIllegalName, true);
+
+    ["folder1", "imagesfolder", "assets", "kwizcom"].forEach((name) => {
+        result = validateFoldername(name);
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.hasIllegalName, false);
+    });
+});

package/src/helpers/file.ts

@@ -0,0 +1,59 @@
+import { escapeRegExp } from "./strings";
+
+//https://support.microsoft.com/en-gb/office/restrictions-and-limitations-in-onedrive-and-sharepoint-64883a5d-228e-48f5-b3d2-eb39e07630fa
+//These names aren't allowed for files or folders: .lock, CON, PRN, AUX, NUL, COM0 - COM9, LPT0 - LPT9, _vti_, 
+//desktop.ini, any filename starting with ~$. "_vti_" can't appear anywhere in a file name.
+
+function _getRegexCollection() {
+    return {
+        IllegalCharsRegex: new RegExp("[" + escapeRegExp(`"*:<>?/\\|`) + "]", "gi"),
+        IllegalCharsExtraRegex: new RegExp("[" + escapeRegExp(`~"#%&*:<>?/\\|`) + "]", "gi"),
+        IllegalNamesRegex: /^(\.lock|CON|PRN|AUX|NUL|COM\d|LPT\d|.*_VTI_.*|~\$.*)$/gi,
+        IsDesktopIni: /^desktop\.ini$/gi
+    };
+}
+
+export function validateFilename(fileNameWithExtension: string) {
+    let filenameWithOutExtension = fileNameWithExtension;
+    let split = filenameWithOutExtension.split(".");
+    split.pop();
+    filenameWithOutExtension = split.join(".");
+
+    let regexCollection = _getRegexCollection();
+
+    let hasIllegalCharacter = regexCollection.IllegalCharsRegex.test(filenameWithOutExtension);
+    let hasIllegalName = regexCollection.IllegalNamesRegex.test(filenameWithOutExtension) || regexCollection.IsDesktopIni.test(fileNameWithExtension);
+
+    return {
+        hasIllegalCharacter,
+        hasIllegalName,
+        valid: !hasIllegalCharacter && !hasIllegalName
+    };
+}
+
+export function validateFoldername(folderName: string) {
+    let regexCollection = _getRegexCollection();
+
+    let hasIllegalCharacter = regexCollection.IllegalCharsRegex.test(folderName);
+    let hasIllegalName = regexCollection.IllegalNamesRegex.test(folderName) || regexCollection.IsDesktopIni.test(folderName);
+
+    return {
+        hasIllegalCharacter,
+        hasIllegalName,
+        valid: !hasIllegalCharacter && !hasIllegalName
+    };
+}
+
+export function validateAndSetFilename(fileNameWithExtension: string) {
+    let regexCollection = _getRegexCollection();
+
+    let validateFilenameChk = validateFilename(fileNameWithExtension);
+    if (!validateFilenameChk.valid || regexCollection.IllegalCharsExtraRegex.test(fileNameWithExtension)) {
+        fileNameWithExtension =
+            fileNameWithExtension.replace(regexCollection.IllegalCharsRegex, "")
+                .replace(regexCollection.IllegalCharsExtraRegex, "")
+                .replace(regexCollection.IllegalNamesRegex, "")
+                .replace(regexCollection.IsDesktopIni, "");
+    }
+    return fileNameWithExtension;
+}