@kwiz/common 1.0.110 → 1.0.112

package/src/helpers/browser.ts

@@ -1401,57 +1401,83 @@ export function getCSSVariableValue(value: string, elm: HTMLElement = document.b
 }
 
 /** 
- * Converts an HTMLImageElement to base 64 and resizes the image to the exact dimensions of the HTMLImageElement
+ * Converts an HTMLImageElement/SVGImageElement to base 64 and resizes the image to the exact dimensions of the element.
+ * The following image types are supported: jpg, jpeg, gif, png, webp, bmp
  */
-export function convertImageToBase64(imgEle: HTMLImageElement, quality: ImageSmoothingQuality = "medium") {
+export async function convertImageToBase64(imgEle: HTMLImageElement | SVGImageElement, quality: ImageSmoothingQuality = "medium"): Promise<string> {
     if (!isElement(imgEle)
         || (isNullOrEmptyString(imgEle.src) && isNullOrEmptyString(imgEle.getAttribute("xlink:href")))) {
-        return;
+        return null;
     }
 
-    let xlinkHref = imgEle.getAttribute("xlink:href");
-    let useXlinkHref = !isNullOrEmptyString(xlinkHref);
-    let src = useXlinkHref ? xlinkHref : imgEle.src;
+    return new Promise((resolve) => {
+        let xlinkHref = imgEle.getAttribute("xlink:href");
+        let useXlinkHref = !isNullOrEmptyString(xlinkHref);
+        let src = useXlinkHref ? xlinkHref : imgEle.src;
+
+        let type = "image/png"
+        if (!isDataUrl(src)) {
+            let ext = getURLExtension(src);
+            if (!isNullOrEmptyString(ext)) {
+                ext = ext.toLowerCase();
+                if (ext !== "png") {
+                    type = "image/jpeg";
+                }
+            }
+        }
+        
+        let height = 0;
+        let width = 0;
 
-    let isCrossOrigin = !src.toLowerCase().startsWith(window.location.origin.toLowerCase());
-    let crossOriginImg: HTMLImageElement = null;
+        if (imgEle instanceof SVGImageElement || useXlinkHref || imgEle.tagName === "image") {
+            width = parseInt(imgEle.getAttribute("width"));
+            height = parseInt(imgEle.getAttribute("height"));
+        } else {
+            width = imgEle.width;
+            height = imgEle.height;
+        }
 
-    if (isCrossOrigin === true) {
-        crossOriginImg = new Image();
-        crossOriginImg.crossOrigin = "use-credentials";
-        crossOriginImg.src = src;
-    }
+        let canvas = document.createElement("canvas");
+        canvas.height = height;
+        canvas.width = width;
 
-    let canvas = document.createElement("canvas");
-    canvas.width = imgEle.width;
-    canvas.height = imgEle.height;
+        let ctx = canvas.getContext("2d");
+        ctx.imageSmoothingEnabled = true;
+        ctx.imageSmoothingQuality = quality;        
 
-    let ctx = canvas.getContext("2d");
-    ctx.imageSmoothingEnabled = true;
-    ctx.imageSmoothingQuality = quality;
-    ctx.drawImage(crossOriginImg || imgEle, 0, 0, imgEle.width, imgEle.height);
+        let isCrossOrigin = !src.toLowerCase().startsWith(window.location.origin.toLowerCase());
+        let crossOriginImg = new Image();
 
-    let type = "image/png"
-    if (!isDataUrl(src)) {
-        let ext = getURLExtension(src);
-        if (!isNullOrEmptyString(ext)) {
-            ext = ext.toLowerCase();
-            if (ext !== "png") {
-                type = "image/jpeg";
+        crossOriginImg.onload = () => {            
+            let dataURL: string = null;
+            try {
+                ctx.drawImage(crossOriginImg, 0, 0, width, height);
+                dataURL = canvas.toDataURL(type, quality === "high" ? 1 : quality === "medium" ? 0.75 : 0.5);
+            } catch {
+                dataURL = null;
             }
-        }
-    }
 
-    let dataURL: string = null;
-    try {
-        dataURL = canvas.toDataURL(type, quality === "high" ? 1 : quality === "medium" ? 0.75 : 0.5);        
-    } catch {
-        dataURL = null;
-    }
+            canvas = null;
+            ctx = null;
+            crossOriginImg = null;
+
+            resolve(dataURL);
+        };
 
-    canvas = null;
-    ctx = null;
-    crossOriginImg = null;
-    
-    return dataURL;
+        crossOriginImg.onerror = () => {
+            canvas = null;
+            ctx = null;
+            crossOriginImg = null;
+
+            resolve(null);
+        };
+
+        if (isCrossOrigin === true) {
+            crossOriginImg.crossOrigin = "anonymous";            
+        } else {
+            crossOriginImg.crossOrigin = "use-credentials";            
+        }
+
+        crossOriginImg.src = src;
+    });
 }

package/src/utils/sharepoint.rest/common.ts

@@ -79,6 +79,11 @@ export function DecodeFieldValuesAsTextKey(key: string): string {
     return key.replace(/_x005f_/g, "_").replace('OData__', '_');
 }
 
+/** Replaces _ with _x005f_, except OData_ at the start */
+export function EncodeFieldValuesAsTextKey(key: string): string {
+    return key.replace('OData_', '~').replace(/_/g, "_x005f_").replace('~', 'OData_');
+}
+
 /** Gets REST FieldValuesAsText or FieldValuesForEdit and fix their column names so that you can get a field value by its internal name */
 export function DecodeFieldValuesAsText(FieldValuesAsText: IDictionary<string>) {
     return DecodeFieldValuesForEdit(FieldValuesAsText);

package/src/utils/sharepoint.rest/file.folder.ts

@@ -1,5 +1,5 @@
 import { jsonStringify } from "../../helpers/json";
-import { isNotEmptyArray, isNullOrEmptyString, isNullOrUndefined, isNumber, isNumeric, newGuid } from "../../helpers/typecheckers";
+import { isNotEmptyArray, isNotEmptyString, isNullOrEmptyString, isNullOrUndefined, isNumber, isNumeric, isString, newGuid } from "../../helpers/typecheckers";
 import { encodeURIComponentEX, makeServerRelativeUrl, normalizeUrl } from "../../helpers/url";
 import { IDictionary } from "../../types/common.types";
 import { IRequestBody, IRestOptions, IRestResponseType, jsonTypes } from "../../types/rest.types";
@@ -176,7 +176,8 @@ async function _moderateFile(siteUrl: string, fileUrl: string, action: "publish"
     siteUrl = GetSiteUrl(siteUrl);
     let fileServerRelativeUrl = makeServerRelativeUrl(fileUrl, siteUrl);
     try {
-        let publishUrl = `${GetRestBaseUrl(siteUrl)}/Web/getFileByServerRelativeUrl('${fileServerRelativeUrl}')/${action}('${comment}')`;
+        let hasComments = !isNullOrEmptyString(comment);
+        let publishUrl = `${GetRestBaseUrl(siteUrl)}/Web/getFileByServerRelativeUrl('${fileServerRelativeUrl}')/${action}${hasComments ? `(@a1)?@a1=%27${encodeURIComponentEX(comment, { singleQuoteMultiplier: 2 })}%27` : '()'}`;
         let publishResult = await GetJson<{ "odata.null": boolean }>(publishUrl, null, {
             method: "POST",
             jsonMetadata: jsonTypes.nometadata,
@@ -185,7 +186,7 @@ async function _moderateFile(siteUrl: string, fileUrl: string, action: "publish"
         return !isNullOrUndefined(publishResult) && publishResult["odata.null"] === true;
     } catch {
     }
-    return null;
+    return false;
 }
 
 export function RecycleFile(siteUrl: string, fileServerRelativeUrl: string): Promise<boolean> {
@@ -257,29 +258,66 @@ export function GetFileSync<T>(siteUrl: string, fileServerRelativeUrl: string, r
         };
 }
 
+/** @deprecated use GetFileEx */
 export function GetFile<T>(siteUrl: string, fileServerRelativeUrl: string, allowCache?: boolean, responseType?: IRestResponseType): Promise<{ Exists: boolean; Content?: T; }> {
+    return GetFileEx(siteUrl, fileServerRelativeUrl, { allowCache, responseType });
+}
+
+export async function GetFileEx<T>(siteUrl: string, fileServerRelativeUrl: string, options?: {
+    allowCache?: boolean; responseType?: IRestResponseType;
+    /** version #.# or version ID as number */
+    version?: string | number;
+}): Promise<{ Exists: boolean; Content?: T; }> {
     siteUrl = GetSiteUrl(siteUrl);
 
-    let options: IRestOptions = { ...(allowCache === true ? shortLocalCache : noLocalCache), forceCacheUpdate: allowCache !== true };
-    if (!isNullOrUndefined(responseType)) {
-        options.responseType = responseType;
+    let restOptions: IRestOptions = { ...(options?.allowCache === true ? shortLocalCache : noLocalCache), forceCacheUpdate: options?.allowCache !== true };
+    if (!isNullOrUndefined(options?.responseType)) {
+        restOptions.responseType = options?.responseType;
     }
 
-    let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl);
-    if (!options.forceCacheUpdate && reloadCacheFileModifiedRecently(siteUrl, fileServerRelativeUrl)) {
-        options.forceCacheUpdate = true;
+    let version = options?.version;
+    if (isNumber(version) && version > 0 || isNotEmptyString(version)) {
+        //get content of specific version
+        let fileSiteRelativeUrl = fileServerRelativeUrl.slice(siteUrl.length - 1);
+        let versionUrl = `${siteUrl}/_vti_history/${FileVersionToVersionId(options.version)}${fileSiteRelativeUrl}`;
+        try {
+            let versionContent = await GetJson<T>(versionUrl, undefined, restOptions);
+            return { Exists: isString(versionContent), Content: versionContent };
+        } catch (e) {
+            return { Exists: false };
+        }
     }
+    else {
+        let fileRestUrl = GetFileRestUrl(siteUrl, fileServerRelativeUrl);
+        if (!restOptions.forceCacheUpdate && reloadCacheFileModifiedRecently(siteUrl, fileServerRelativeUrl)) {
+            restOptions.forceCacheUpdate = true;
+        }
 
-    return GetJson<T>(`${fileRestUrl}/$value`, null, options).then(r => {
-        return {
-            Exists: true,
-            Content: r
-        };
-    }).catch<{ Exists: boolean; Content?: T; }>(() => {
-        return {
-            Exists: false
-        };
-    });
+        return GetJson<T>(`${fileRestUrl}/$value`, null, restOptions).then(r => {
+            return {
+                Exists: true,
+                Content: r
+            };
+        }).catch<{ Exists: boolean; Content?: T; }>(() => {
+            return {
+                Exists: false
+            };
+        });
+    }
+}
+
+/** version: 1.5 >> version ID for history */
+export function FileVersionToVersionId(version: string | number) {
+    try {
+        if (isNumber(version)) return version;
+        const vSplit = version.split('.');
+        const major = parseInt(vSplit[0], 10);
+        const minor = parseInt(vSplit[1], 10);
+        let versionId = (major * 512) + minor;
+        return versionId;
+    }
+    catch (e) { }
+    return null;
 }
 
 var $reloadCacheFileModifiedRecentlyFlagged: string[] = [];
@@ -596,4 +634,4 @@ async function CopyOrMoveFile(siteUrl: string, currentServerRelativeUrl: string,
     // return UpdateItem(siteUrl, listIdOrTitle, itemId, {
     //     FileLeafRef: newFileName "hello.txt" >> "hello.md" won't work.
     // });
-}
+}