@kwiz/common 1.0.1

package/src/utils/rest.ts

@@ -0,0 +1,465 @@
+import { AllRestCacheOptionsKeys, IDictionary, IJsonSyncResult, IRequestBody, IRequestObjects, IRestCacheOptions, IRestError, IRestOptions, IRestRequestOptions, assign, getGlobal, hasOwnProperty, isNullOrEmptyString, isNullOrUndefined, isNumber, isObject, isPrimitiveValue, isString, jsonClone, jsonParse, jsonTypes } from "./_dependencies";
+import { ConsoleLogger } from "./consolelogger";
+import { getCacheItem, setCacheItem } from "./localstoragecache";
+import { getFormDigest } from "./sharepoint.rest/web";
+
+var logger = ConsoleLogger.get("kwizcom.rest.module");
+const supressDebugMessages = true;
+
+/** cache for 1 day */
+export const noLocalCache: IRestOptions = { allowCache: false };
+/** cache for 1 days */
+export const longLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 1 } };
+/** cache for 2 days */
+export const extraLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 2 } };
+/** cache for 7 days */
+export const weeekLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 7 } };
+/** cache for 30 days */
+export const monthLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 30 } };
+/** cache for 5 minutes */
+export const shortLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { minutes: 5 } };
+/** cache for 15 minutes */
+export const mediumLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { minutes: 15 } };
+
+interface IPendingRequest<T> {
+    objects: IRequestObjects;
+    /**the main promise */
+    promise: Promise<T>;
+    /**additional listeners
+     * must add a separate promise, so that I can make a full(not shallow) copy of the result.
+     * this way if the first caller changes the object, the second caller gets it unchanged.
+     */
+    listeners: {
+        resolve: (result: T) => void;
+        reject: (reason: any) => void;
+    }[];
+}
+
+//if allowCache is true, results will be stored/returned from here
+var _cachedResults = getGlobal<{ [key: string]: IJsonSyncResult<any>; }>("utils_restmodule_cachedResults");
+//cannot use from top window, example: DVP, if you open view item popup and close it too fast, there might be a pending request that never resolves since the handler code was unloaded from the window.
+var _pendingRequests = getGlobal<IDictionary<IPendingRequest<any>>>("utils_restmodule_pendingRequests", undefined, true);
+
+function getDefaultOptions(): IRestOptions {
+    return {
+        includeDigestInPost: true,
+        headers: {
+        }
+    };
+}
+
+function fillHeaders(xhr: XMLHttpRequest, headers: { [key: string]: string; }) {
+    for (let header in headers)
+        if (hasOwnProperty(headers, header)) {
+            let val = headers[header];
+            if (!isNullOrEmptyString(val))
+                xhr.setRequestHeader(header, val);
+        }
+}
+
+function getXhr(url: string, body?: IRequestBody, options?: IRestOptions, async = true): IRequestObjects {
+    var optionsWithDefaults = assign<IRestOptions>({}, getDefaultOptions(), options);
+    let myCacheOptions: IRestCacheOptions & { cacheKey?: string; } = {};
+    Object.keys(AllRestCacheOptionsKeys).forEach(key => {
+        if (hasOwnProperty(optionsWithDefaults, key)) {
+            myCacheOptions[key] = optionsWithDefaults[key];
+            delete optionsWithDefaults[key];
+        }
+    });
+    let myOptions: IRestRequestOptions = { ...optionsWithDefaults };
+
+    var xhr: XMLHttpRequest = new XMLHttpRequest();
+
+    let jsonType = myOptions.jsonMetadata || jsonTypes.verbose;
+
+    if (myOptions.cors) {
+        xhr.withCredentials = true;
+    }
+
+    if (isNullOrUndefined(myOptions.headers)) myOptions.headers = {};//issue 660 in case the sender sent headers as null
+    if (isNullOrUndefined(myOptions.headers["Accept"])) {
+        myOptions.headers["Accept"] = jsonType;
+    }
+
+    let method = myOptions.method;
+    if (isNullOrEmptyString(method)) {
+        method = isNullOrUndefined(body) ? "GET" : "POST";
+    }
+
+    myOptions.method = method;
+    xhr.open(method, url, async !== false);
+    if (method === "GET") {
+        if (myOptions.includeDigestInGet === true) {//by default don't add it, unless explicitly asked in options
+            xhr.setRequestHeader("X-RequestDigest", getFormDigest(myOptions.spWebUrl));
+        }
+    }
+    else if (method === "POST") {
+        if (isNullOrUndefined(myOptions.headers["content-type"])) {
+            myOptions.headers["content-type"] = jsonType;
+        }
+
+        if (myOptions.includeDigestInPost !== false) {//if explicitly set to false - don't include it
+            xhr.setRequestHeader("X-RequestDigest", getFormDigest(myOptions.spWebUrl));
+        }
+    }
+
+    if (!isNullOrEmptyString(myOptions.xHttpMethod)) {
+        myOptions.headers["X-HTTP-Method"] = myOptions.xHttpMethod;
+
+        if (myOptions.xHttpMethod === "MERGE" || myOptions.xHttpMethod === "DELETE" || myOptions.xHttpMethod === "PUT") {
+            myOptions.headers["If-Match"] = "*";// update regadless of other user changes
+        }
+    }
+
+    fillHeaders(xhr, myOptions.headers);
+
+    if (!isNullOrEmptyString(myOptions.responseType) && myOptions.responseType !== "text") {
+        if (myCacheOptions.allowCache === true &&
+            (myOptions.responseType === "blob" || myOptions.responseType === "arraybuffer" || myOptions.responseType === "document")) {
+            logger.warn("When allowCache is true, Blob, ArrayBuffer and Document response types will only be stored in runtime memory and not committed to local storage.");
+        }
+        xhr.responseType = myOptions.responseType;
+    }
+
+    //we do not support cache if there is a request body
+    //postCacheKey - allow cache on post request for stuff like get item by CamlQuery
+    if (isNullOrUndefined(body) || !isNullOrEmptyString(myOptions.postCacheKey)) {
+        myCacheOptions.cacheKey = (url + '|' + JSON.stringify(myOptions)).trim().toLowerCase();
+    }
+
+    return {
+        xhr: xhr,
+        options: myOptions,
+        cacheOptions: myCacheOptions
+    };
+}
+
+function getCachedResult<T>(objects: IRequestObjects): IJsonSyncResult<T> {
+    var cacheKey = objects.cacheOptions.cacheKey;
+    if (objects.cacheOptions.allowCache === true && objects.cacheOptions.forceCacheUpdate !== true) {
+        if (isNullOrEmptyString(cacheKey)) {
+            logger.warn('cache is not supported for this type of request.');
+            return null;
+        }
+
+        if (isNullOrUndefined(_cachedResults[cacheKey])) {
+            //try to load from local storage
+            let result = getCacheItem<IJsonSyncResult<T>>('jsr_' + cacheKey);
+
+            if (!isNullOrUndefined(result) && (result.success === true || result.status === 404)) {
+                if (!result.cachedTime) {
+                    let now = new Date();
+                    now.setDate(-1);
+                    result.cachedTime = now.getTime();
+                }
+
+                _cachedResults[cacheKey] = result;
+            }
+        }
+
+        if (!isNullOrUndefined(_cachedResults[cacheKey])) {
+            let result = _cachedResults[cacheKey];
+
+            var maxAge = isNumber(objects.cacheOptions.maxAge) && objects.cacheOptions.maxAge > 0 ? objects.cacheOptions.maxAge : null;
+
+            if (maxAge && result.cachedTime) {
+                let now = new Date().getTime();
+                var cachedTime = result.cachedTime;
+                var validUntil = cachedTime + (maxAge * 1000);
+
+                if (now > validUntil) {
+                    logger.debug("getCachedResult - entry has out lived max age");
+                    return null;
+                }
+            }
+
+            return {
+                ..._cachedResults[cacheKey],
+                result: _canSafelyStringify(_cachedResults[cacheKey].result) ?
+                    jsonClone(_cachedResults[cacheKey].result) :
+                    _cachedResults[cacheKey].result
+            };
+        }
+    }
+    return null;
+}
+
+function setCachedResult<T>(cacheOptions: IRestCacheOptions & { cacheKey?: string; }, response: IJsonSyncResult<T>) {
+    if (isNullOrEmptyString(cacheOptions.cacheKey)) {
+        return;
+    }
+    response.cachedTime = new Date().getTime();
+    let isResultSerializable = _canSafelyStringify(response.result);
+
+    _cachedResults[cacheOptions.cacheKey] = {
+        ...response,
+        result: isResultSerializable ? jsonClone(response.result) : response.result
+    };
+
+    if (!isResultSerializable) {
+        logger.warn("When allowCache is true, Blob, ArrayBuffer and Document response types will only be stored in runtime memory and not committed to local storage.");
+    }
+
+    if (isResultSerializable && !isNullOrUndefined(cacheOptions.localStorageExpiration) && response && response.success === true) {
+        setCacheItem('jsr_' + cacheOptions.cacheKey, response, cacheOptions.localStorageExpiration as any);
+    }
+}
+
+function getPendingRequest<T = any>(objects: IRequestObjects): IPendingRequest<T> {
+    var cacheKey = objects.cacheOptions.cacheKey;
+    if (isNullOrEmptyString(cacheKey)) {
+        logger.warn('cache is not supported for this type of request.');
+    } else if (!isNullOrUndefined(_pendingRequests[cacheKey])) {
+        //returned from cache
+        return _pendingRequests[cacheKey];
+    }
+    return null;
+}
+
+function getParsedResponse<T>(objects: IRequestObjects) {
+    let parsedResponse: T = null;
+    if (!isNullOrEmptyString(objects.options.responseType) && objects.options.responseType !== "text") {
+        parsedResponse = objects.xhr.response;
+    } else {
+        //maybe its not JSON?
+        parsedResponse = jsonParse(objects.xhr.responseText);
+        if (isNullOrUndefined(parsedResponse)) {
+            parsedResponse = objects.xhr.responseText as any;
+        }
+    }
+
+    return parsedResponse;
+}
+
+function setPendingRequest<T = any>(cacheKey: string, objects: IRequestObjects, promise: Promise<T>): IPendingRequest<T> {
+    if (isNullOrEmptyString(cacheKey)) {
+        return null;
+    }
+
+    _pendingRequests[cacheKey] = { objects: objects, promise: promise, listeners: [] };
+    return _pendingRequests[cacheKey];
+}
+
+function removePendingRequest(cacheKey: string) {
+    if (isNullOrEmptyString(cacheKey)) {
+        return;
+    }
+
+    try {
+        _pendingRequests[cacheKey] = null;
+        delete _pendingRequests[cacheKey];
+    } catch (ex) {
+    }
+}
+
+function _getRestErrorMessage(xhr: XMLHttpRequest) {
+    try {
+        //issue 245, external datasource might return error.code as a number with a plain text message.
+        if (!isNullOrUndefined(xhr) && !isNullOrEmptyString(xhr.responseText)) {
+            let error = jsonParse<{ code: string | number; message: string; }>(xhr.responseText);
+            if (!isNullOrUndefined(error) && !isNullOrEmptyString(error.code)) {
+                if (isString(error.code) && error.code.indexOf("SPQueryThrottledException") !== -1) {
+                    return !isNullOrEmptyString(error.message) ? `${error.message} (SPQueryThrottledException)` : `an error occured (SPQueryThrottledException)`;
+                }
+                if (!isNullOrEmptyString(error.message)) return error.message;
+            }
+        }
+    } catch (e) { }
+    return `an error occured`;
+}
+
+function _canSafelyStringify(result: any) {
+    //this would return false positives on some response strings
+    //return isObject(result) && !(result instanceof ArrayBuffer || result instanceof Blob || result instanceof Document);
+
+    if (isPrimitiveValue(result)) return true;
+    else if (isObject(result)) {
+        return !(result instanceof ArrayBuffer) && !(result instanceof Blob) && !(result instanceof Document);
+    }
+    else return false;//shouldn't get here... since result should either be primitive value or an object
+}
+
+export function GetJsonSync<T>(url: string, body?: IRequestBody, options?: IRestOptions): IJsonSyncResult<T> {
+    let xhr: XMLHttpRequest = null;
+    let syncResult: IJsonSyncResult<T> = null;
+    let objects = getXhr(url, body, options, false);
+    try {
+        var cachedResult = getCachedResult<T>(objects);
+        if (!isNullOrUndefined(cachedResult)) {
+            return cachedResult;
+        }
+
+        xhr = objects.xhr;
+
+        if (objects.options.method === "GET") {
+            objects.xhr.send();
+        }
+        else {
+            objects.xhr.send(body);
+        }
+
+        if (objects.options.returnXhrObject === true) {
+            return {
+                status: xhr.status,
+                success: xhr.status >= 200 && xhr.status < 400,
+                result: xhr as any as T
+            } as any;
+        }
+
+        // status < 300 leaves out 304 responses which are successful responses so we should use < 400
+        if (objects.xhr.status >= 200 && objects.xhr.status < 400) {
+            let result: T = getParsedResponse<T>(objects);
+
+            syncResult = {
+                status: xhr.status,
+                success: true,
+                result: result
+            };
+
+            setCachedResult(objects.cacheOptions, syncResult);
+        } else {
+            throw new Error("Error code: " + objects.xhr.status);
+        }
+    } catch (e) {
+        //make sure errors get here and not returned without catch...
+        let responseText = xhr.responseText;
+        let errorData: any;
+        if (!isNullOrEmptyString(responseText)) {
+            errorData = jsonParse(responseText);
+            if (isNullOrUndefined(errorData)) {
+                errorData = responseText;
+            }
+        }
+
+        let errorMessage = _getRestErrorMessage(xhr);
+
+        syncResult = {
+            status: xhr && xhr.status || -1,
+            success: false,
+            errorData: errorData,
+            errorMessage: errorMessage
+        };
+        setCachedResult(objects.cacheOptions, syncResult);
+    }
+    return syncResult;
+}
+
+export function GetJson<T>(url: string, body?: IRequestBody, options?: IRestOptions): Promise<T> {
+    try {
+        let objects = getXhr(url, body, options);
+
+        var cachedResult = getCachedResult<T>(objects);
+        if (!isNullOrUndefined(cachedResult)) {
+            if (!supressDebugMessages) {
+                logger.debug(`GetJson - request fulfilled by cached results: ${url}`);
+            }
+            if (cachedResult.success) {
+                return Promise.resolve(cachedResult.result);
+            }
+            else {
+                return Promise.reject({
+                    message: isNullOrEmptyString(cachedResult.errorMessage) ? "an error occured in cached results" : cachedResult.errorMessage,
+                    errorData: cachedResult.errorData
+                } as IRestError);
+            }
+        }
+
+        var pendingRequest = getPendingRequest(objects);
+        var xhrPromise: Promise<T> = null;
+
+        if (isNullOrUndefined(pendingRequest)) {
+            if (!supressDebugMessages) {
+                logger.debug(`GetJson - request fulfilled by new request: ${url}`);
+            }
+            xhrPromise = new Promise((resolve, reject) => {
+                let promiseResolved = false;
+
+                objects.xhr.addEventListener("readystatechange", () => {
+                    if (objects.xhr.readyState === XMLHttpRequest.DONE) {
+                        try {
+                            if (!supressDebugMessages) {
+                                logger.debug(`readystate changed: ${url}`);
+                            }
+                            if (objects.options.returnXhrObject === true) {
+                                promiseResolved = true;
+                                resolve(objects.xhr as any as T);
+                            }
+
+                            let parsedResponse: T = getParsedResponse<T>(objects);
+
+                            // status < 300 leaves out 304 responses which are successful responses so we should use < 400
+                            if (objects.xhr.status >= 200 && objects.xhr.status < 400) {
+                                setCachedResult(objects.cacheOptions, { status: objects.xhr.status, success: true, result: parsedResponse });
+                                promiseResolved = true;
+                                resolve(parsedResponse);
+                                if (pendingRequest) {
+                                    pendingRequest.listeners.forEach(l => {
+                                        let listenerParsedResponse: T = getParsedResponse<T>(objects);
+                                        l.resolve(listenerParsedResponse);
+                                    });
+                                }
+                            } else {
+                                let errorMessage = _getRestErrorMessage(objects.xhr);
+                                setCachedResult(objects.cacheOptions, { status: objects.xhr.status, success: false, errorData: parsedResponse, errorMessage: errorMessage });
+                                promiseResolved = true;
+                                reject({ message: errorMessage, errorData: parsedResponse, xhr: objects.xhr } as IRestError);
+                                if (pendingRequest) {
+                                    pendingRequest.listeners.forEach(l => l.reject({ message: errorMessage, errorData: parsedResponse, xhr: objects.xhr } as IRestError));
+                                }
+                            }
+                        } catch (e) {
+                            if (!supressDebugMessages) {
+                                logger.error(`readystate error: ${e}: ${url}`);
+                            }
+                        }
+                        if (!promiseResolved) {
+                            if (!supressDebugMessages) {
+                                logger.debug(`promise NOT resolved. resoving myself...: ${url}`);
+                            }
+
+                            promiseResolved = true;
+                            reject({ message: "an unknown error occured", xhr: objects.xhr } as IRestError);
+                        }
+                        else if (!supressDebugMessages) {
+                            logger.debug(`promise resolved. removing pending request object: ${url}`);
+                        }
+
+                        removePendingRequest(objects.cacheOptions.cacheKey);
+                    }
+                });
+            });
+
+            if (objects.xhr.readyState === XMLHttpRequest.OPENED) {
+                //only set this if our request is on the way
+                pendingRequest = setPendingRequest(objects.cacheOptions.cacheKey, objects, xhrPromise);
+
+                if (!supressDebugMessages) {
+                    logger.debug(`${url}: sending request, setPendingRequest`);
+                }
+
+                if (objects.options.method === "GET") {
+                    objects.xhr.send();
+                } else {
+                    objects.xhr.send(body);
+                }
+            }
+            else logger.error('xhr not opened');
+        } else if (pendingRequest) {
+            if (!supressDebugMessages) {
+                logger.debug(`GetJson - request fulfilled by pending requests: ${url}`);
+            }
+            //must add a separate promise, so that I can make a full(not shallow) copy of the result.
+            //this way if the first caller changes the object, the second caller gets it unchanged.
+            xhrPromise = new Promise<T>((resolve, reject) => {
+                pendingRequest.listeners.push({
+                    resolve: (result: T) => resolve(result),
+                    reject: (reason) => reject(reason)
+                });
+            });
+        }
+
+        return xhrPromise;
+    } catch (e) {
+        return Promise.reject({ message: "an error occured" });
+    }
+}

package/src/utils/script.ts

@@ -0,0 +1,168 @@
+import { IKnownScript, isDebug, isNotEmptyArray, isNullOrEmptyString, isNullOrUndefined, ksGlobal, noop } from "./_dependencies";
+import Sod from "./sod";
+
+export interface IScriptUtils {
+    /** @deprecated - use wrapFunction instead from helpers/functions */
+    wrapFunction3?: (originalFunction: () => void, instance: any, doBefore: () => void, doAfter: () => void) => void;
+    loadKnownScript: (script: IKnownScript) => void;
+    loadKnownScript_Sync: (script: IKnownScript) => void;
+    ensureScript: (scriptUrl: string, global: ksGlobal, callback: () => void, sodName: string) => void;
+    ensureScripts: (scripts: { scriptUrl: string; global: ksGlobal; sodName: string; }[], callback: () => void) => void;
+}
+
+export default class script implements IScriptUtils {
+    private static instance: script = null;
+    public isRtl = false;
+    public static get Instance() {
+        if (script.instance === null) {
+            //share single instance between all imports
+            if (typeof (window as any).kSingleScripts !== 'undefined')
+                script.instance = (window as any).kSingleScripts;//a global instance already exists, use it
+            else {
+                script.instance = new script();
+                (window as any).kSingleScripts = script.instance;//place this instance in the global namespace for others to reuse
+            }
+        }
+        return script.instance;
+    }
+
+    public async loadKnownScript(knownScript: IKnownScript) {
+        var promisesDependencies: Promise<any>[] = [];
+        (knownScript.dependencies || []).forEach(dep => {
+            promisesDependencies.push(this.loadKnownScript(dep));
+        });
+
+        if (promisesDependencies.length > 0)
+            await Promise.all(promisesDependencies);
+
+        return new Promise((resolve, reject) => {
+            this.ensureKnownScriptInternal(knownScript, () => {
+                resolve(Sod.getGlobal(knownScript.global));
+            });
+        });
+    }
+    public loadKnownScript_Sync(knownScript: IKnownScript) {
+        try {
+            if (isNotEmptyArray(knownScript.dependencies)) {
+                (knownScript.dependencies || []).forEach(dep => {
+                    this.loadKnownScript_Sync(dep)
+                });
+            }
+        } catch {
+        }
+
+        this.ensureKnownScriptInternal(knownScript, noop, true);
+        return Sod.getGlobal(knownScript.global);
+    }
+
+    private ensureKnownScriptInternal(knownScript: IKnownScript, callback: () => void, sync = false) {
+        let url = isDebug() && !knownScript.forceMin ? knownScript.url.replace('.min.js', '.js') : knownScript.url;
+        if (url[0] === '/') url = "https://apps.kwizcom.com" + url;
+
+        if (sync === true)
+            this.ensureScriptSync(url, knownScript.global, callback, knownScript.sodName);
+        else
+            this.ensureScript(url, knownScript.global, callback, knownScript.sodName);
+
+        let cssFiles = this.isRtl === true && !isNullOrUndefined(knownScript.rtlCss) ? knownScript.rtlCss : knownScript.css;
+        if (!isNullOrUndefined(cssFiles))
+            cssFiles.forEach(css => {
+                if (!isNullOrEmptyString(css)) {
+                    let cssurl = isDebug() && !knownScript.forceMin ? css.replace('.min.css', '.css') : css;
+                    if (cssurl[0] === '/') cssurl = "https://apps.kwizcom.com" + cssurl;
+
+                    let knownStyles = document.getElementsByClassName("kwizcom_known_css");
+                    let found = false;
+                    for (let si = 0; si < knownStyles.length; si++) {
+                        let elm: HTMLLinkElement = knownStyles[si] as HTMLLinkElement;
+                        if (elm.href && elm.href.toLowerCase() === cssurl.toLowerCase()) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        let link = document.createElement("link");
+                        link.rel = "stylesheet";
+                        link.className = "kwizcom_known_css";
+                        link.type = "text/css";
+                        link.href = cssurl;
+                        document.head.appendChild(link);
+                    }
+                }
+            });
+    }
+
+    public loadCss(cssUrl: string) {
+        let knownStyles = document.getElementsByClassName("kwizcom_known_css");
+        let found = false;
+        for (let si = 0; si < knownStyles.length; si++) {
+            let elm: HTMLLinkElement = knownStyles[si] as HTMLLinkElement;
+            if (elm.href && elm.href.toLowerCase() === cssUrl.toLowerCase()) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            let link = document.createElement("link");
+            link.rel = "stylesheet";
+            link.className = "kwizcom_known_css";
+            link.type = "text/css";
+            link.href = cssUrl;
+            document.head.appendChild(link);
+        }
+    }
+
+    public ensureScriptSync(scriptUrl: string, global: ksGlobal, callback?: () => void, sodName?: string) {
+        //in IE there is no promise, we cannot use any async functions
+        return Sod.ensureScriptNoPromise(scriptUrl, global, callback, sodName, true);
+    }
+    public async ensureScript(scriptUrl: string, global: ksGlobal, callback?: () => void, sodName?: string) {
+        return Sod.ensureScript(scriptUrl, global, callback, sodName, false);
+    }
+    /** ensure a collection of scripts and call the callback when they are all done */
+    public async ensureScripts(scripts: { scriptUrl: string; global: ksGlobal; sodName: string; }[], callback: () => void) {
+        let promises: Promise<void>[] = [];
+        let length = scripts.length;
+        let finished = 0;
+        let onFinished = typeof (callback) !== "function" ? null : () => {
+            finished++;
+            if (finished === length)//all finished
+                callback();
+        };
+        scripts.forEach(scr => {
+            promises.push(Sod.ensureScript(scr.scriptUrl, scr.global, onFinished, scr.sodName));
+        });
+
+        return Promise.all(promises);
+    }
+
+    private _WrapFunctionArr: any[] = [];
+
+    /** @deprecated - use wrapFunction instead from helpers/functions */
+    public wrapFunction3(originalFunction: () => void, instance: any, doBefore: () => void, doAfter: () => void) {
+        try {
+            if (instance !== null) {
+                originalFunction.bind(instance);
+            }
+            var idx = this._WrapFunctionArr.length;
+            this._WrapFunctionArr[idx] = originalFunction;
+
+            originalFunction = function (...args: any[]) {
+                if (typeof (doBefore) === "function") {
+                    doBefore.apply(instance, args);
+                }
+                var returnValue = this._WrapFunctionArr[idx].apply(instance, args);
+                if (typeof (doAfter) === "function") {
+                    doAfter.apply(instance, args);
+                }
+
+                return returnValue;
+            };
+            if (instance !== null) {
+                originalFunction.bind(instance);
+            }
+        } catch (e) {
+            if (isDebug()) console.log('unhandled error in wrapFunction3');
+        }
+    }
+}