@olenbetong/appframe-core 2.10.2 → 2.11.1

package/es/index.js

@@ -2,7 +2,7 @@ import { UserSession } from "./UserSession.js";
 import "./errorHandler.js";
 import afLocalStorage from "./localStorage.js";
 export { default as mitt } from "mitt";
-export { toLocalISODate, toLocalISODateTime } from "./date.js";
+export { toLocalISODate, toLocalISODateTime, toLocalDateTime } from "./date.js";
 export { downloadBlob } from "./downloadBlob.js";
 export { downloadRequest } from "./downloadRequest.js";
 export { expose } from "./expose.js";
@@ -17,4 +17,4 @@ export { default as SessionHandler } from "./SessionHandler.js";
 export { UserSession };
 export { getSettings, saveSettings } from "./settings.js";
 export { alert, confirm, ConfirmButtons, openAlertDialog, waitForDialog } from "./alert.js";
-export const version = "2.10.2";
+export const version = "2.11.1";

package/es/invariant.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/invariant.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { invariant } from "./invariant";
+describe("invariant", () => {
+    test("should throw error when condition is false", () => {
+        expect(() => {
+            invariant(false, "Test message");
+        }).toThrowError("Test message");
+    });
+    test("should throw error when condition is false and message is a function", () => {
+        expect(() => {
+            invariant(false, () => "Test message");
+        }).toThrowError("Test message");
+    });
+    test("should not throw error when condition is true", () => {
+        expect(() => {
+            invariant(true, "Test message");
+        }).not.toThrowError();
+    });
+});

package/es/localStorage.js

@@ -2,9 +2,7 @@ function getLocalKey(key) {
     return [af?.article?.id || "", "common", key].join(".");
 }
 class LocalStorage {
-    constructor() {
-        this.isPersisted = () => true;
-    }
+    isPersisted = () => true;
     getLocalStorageKey(key, global) {
         return global ? ["common", key].join(".") : getLocalKey(key);
     }

package/es/parseFunc.js

@@ -3,5 +3,5 @@ const funcRegex = /^function(?:\s+([a-zA-Z$_][a-zA-Z0-9$_]*))?\s*\(((?:(?:\s*[a-
 export function parseFunc(func) {
     var match = func.toString().match(funcRegex);
     invariant(match, "Unable to parse function!");
-    return { name: match[1], args: match[2].split(","), body: match[3] };
+    return { name: func.name ?? match[1], args: match[2].split(",").map((a) => a.trim()), body: match[3] };
 }

package/es/parseFunc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/parseFunc.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "bun:test";
+import { parseFunc } from "./parseFunc";
+function testFunction(arg1, arg2) {
+    console.log(arg1, arg2);
+}
+describe("parseFunc", () => {
+    test("should parse function", () => {
+        expect(parseFunc(testFunction)).toEqual({
+            name: "testFunction",
+            args: ["arg1", "arg2"],
+            body: "\n  console.log(arg1, arg2);\n",
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@olenbetong/appframe-core",
-	"version": "2.10.2",
+	"version": "2.11.1",
 	"description": "Javascript libraries to utilize the Appframe framework",
 	"type": "module",
 	"sideEffects": [
@@ -14,7 +14,7 @@
 	},
 	"types": "./es/index.d.ts",
 	"scripts": {
-		"prepack": "pnpm run build",
+		"prepack": "bun test && pnpm run build",
 		"build": "pnpm run build:esbuild && pnpm run build:tsc",
 		"build:esbuild": "node --loader ts-node/esm.mjs ../../shared/esbuild.ts",
 		"build:tsc": " rm -rf ./es && tsc && node ./scripts/replace-version.js"
@@ -43,10 +43,12 @@
 		]
 	},
 	"dependencies": {
+		"@happy-dom/global-registrator": "^14.12.3",
 		"mitt": "^3.0.1"
 	},
 	"devDependencies": {
+		"@types/bun": "^1.1.5",
 		"chalk": "^5.3.0"
 	},
-	"gitHead": "6bc6864a7404ada9986223a0339906389b408030"
+	"gitHead": "14a3bb472e2ad0a25554eed531a4da53a76b428b"
 }

package/src/date.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+
+import { toLocalDateTime, toLocalISODate, toLocalISODateTime } from "./date.js";
+
+describe("date", () => {
+	test("toLocalISODate", () => {
+		expect(toLocalISODate(new Date("2020-01-01T12:00:00Z"))).toBe("2020-01-01");
+		expect(toLocalISODate(new Date("2020-01-01T23:00:00Z"))).toBe("2020-01-01");
+		expect(toLocalISODate(new Date("2020-01-01T01:00:00Z"))).toBe("2020-01-01");
+		expect(toLocalISODate(null)).toBe(null);
+	});
+
+	test("toLocalISODateTime", () => {
+		expect(toLocalISODateTime(new Date("2020-01-01T12:00:00.001Z"))).toBe("2020-01-01T12:00:00.001");
+		expect(toLocalISODateTime(new Date("2020-01-01T23:00:00.001Z"))).toBe("2020-01-01T23:00:00.001");
+		expect(toLocalISODateTime(new Date("2020-01-01T01:00:00.001Z"))).toBe("2020-01-01T01:00:00.001");
+		expect(toLocalISODateTime(null)).toBe(null);
+	});
+
+	test("toLocalDateTime", () => {
+		expect(toLocalDateTime(new Date("2020-01-01T12:00:00.001Z"))).toBe("2020-01-01T12:00");
+		expect(toLocalDateTime(new Date("2020-01-01T23:00:00.001Z"))).toBe("2020-01-01T23:00");
+		expect(toLocalDateTime(new Date("2020-01-01T01:00:00.001Z"))).toBe("2020-01-01T01:00");
+		expect(toLocalDateTime(new Date("2020-01-01T12:00:00Z"))).toBe("2020-01-01T12:00");
+		expect(toLocalDateTime(null)).toBe("");
+	});
+});

package/src/date.ts

@@ -4,16 +4,35 @@ export function toLocalISODate(date: Date | null): string | null {
 	return date ? toLocalISODateTime(date).substring(0, 10) : null;
 }
 
-function pad(num: number) {
-	return String(num).padStart(2, "0");
+function pad(num: number, digits: number = 2) {
+	return String(num).padStart(digits, "0");
 }
 
+/**
+ * Returns an ISO string (yyyy-MM-ddTHH:mm:ss.SSS) representing the local time
+ * of the date object.
+ *
+ * @param date
+ */
 export function toLocalISODateTime(date: Date): string;
 export function toLocalISODateTime(date: Date | null): string | null;
 export function toLocalISODateTime(date: Date | null): string | null {
 	return date
 		? `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(
 				date.getMinutes(),
-		  )}:${pad(date.getSeconds())}.${pad(date.getMilliseconds())}`
+			)}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`
 		: null;
 }
+
+/**
+ * Converts a date object to a string compatible with input type datetime-local.
+ * Will handle the UTC value of the date as if it was local, to be compatible with
+ * data objects.
+ *
+ * If null or undefined is passed, returns an empty string.
+ *
+ * @param date
+ */
+export function toLocalDateTime(date?: Date | null): string {
+	return date ? date.toISOString().substring(0, 16) : "";
+}

package/src/downloadRequest.ts

@@ -14,15 +14,9 @@ export type DownloadParameters = {
 };
 
 export async function downloadRequest(request: Request, { fileName, signal, onProgress }: DownloadParameters) {
-	function reportProgress(progress: DownloadItem) {
-		if (typeof onProgress === "function") {
-			onProgress({ ...progress });
-		}
-	}
-
 	let bytesReceived = 0;
 
-	reportProgress({ status: "requested" });
+	onProgress?.({ status: "requested" });
 
 	try {
 		let response = await fetch(request);
@@ -47,7 +41,7 @@ export async function downloadRequest(request: Request, { fileName, signal, onPr
 							}
 
 							bytesReceived += read.value.length;
-							reportProgress({ bytesReceived, status: "downloading" });
+							onProgress?.({ bytesReceived, status: "downloading" });
 							controller.enqueue(read.value);
 
 							return pump();
@@ -63,16 +57,16 @@ export async function downloadRequest(request: Request, { fileName, signal, onPr
 
 		const blob = await response.blob();
 
-		reportProgress({ bytesReceived, status: "downloaded" });
+		onProgress?.({ bytesReceived, status: "downloaded" });
 
 		await downloadBlob(blob, fileName);
 
-		reportProgress({ bytesReceived, status: "completed" });
+		onProgress?.({ bytesReceived, status: "completed" });
 	} catch (err) {
 		if (signal?.aborted) {
-			reportProgress({ status: "cancelled" });
+			onProgress?.({ status: "cancelled" });
 		} else {
-			reportProgress({ error: (err as Error).message, status: "error" });
+			onProgress?.({ error: (err as Error).message, status: "error" });
 		}
 	}
 }

package/src/errorHandler.ts

@@ -1,26 +1,11 @@
+import { logError } from "./log.js";
+
 if (process.env.NODE_ENV === "production") {
 	globalThis.window?.addEventListener("error", (event) => {
-		try {
-			// Try to avoid error-logging-loop
-			const data = {
-				error: event.error?.message ?? event.message ?? null,
-				file: event.filename,
-				line: event.lineno ?? 0,
-				column: event.colno ?? 0,
-				stack: event.error?.stack ?? null,
-			};
-
-			fetch("/data/Logger/LogError", {
-				body: JSON.stringify(data),
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json; charset=utf-8",
-					"X-Requested-With": "XMLHttpRequest",
-				},
-				method: "POST",
-			});
-		} catch (ex) {
-			// ignore
+		if (typeof event === "object" && "error" in event) {
+			logError(event.error);
+		} else if (typeof event === "object" && "message" in event) {
+			logError(event);
 		}
 	});
 }

package/src/expose.test.ts

@@ -0,0 +1,59 @@
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+
+import { describe, expect, test } from "bun:test";
+
+import { expose } from "./expose.js";
+
+GlobalRegistrator.register();
+
+declare global {
+	var test: {
+		value?: string;
+		func: () => string;
+		nested: {
+			func: () => string;
+		};
+	};
+}
+
+describe("expose", () => {
+	test("should expose function to global scope", () => {
+		function func() {
+			return "test";
+		}
+		expose("test", func);
+
+		expect(globalThis.test.func).toBe(func);
+	});
+
+	test("should expose function to global scope with nested name", () => {
+		function func() {
+			return "test";
+		}
+		expose("test.nested", func);
+
+		expect(globalThis.test.nested.func).toBe(func);
+	});
+
+	test("should not overwrite existing without overwrite set to true", () => {
+		let value1 = "test1";
+		let value2 = "test2";
+
+		expose("test.value", value1);
+		expect(globalThis.test.value).toBe(value1);
+
+		expose("test.value", value2);
+		expect(globalThis.test.value).not.toBe(value2);
+	});
+
+	test("should overwrite existing with overwrite set to true", () => {
+		let value1 = "test1";
+		let value2 = "test2";
+
+		expose("test.value", value1);
+		expect(globalThis.test.value).toBe(value1);
+
+		expose("test.value", value2, { overwrite: true });
+		expect(globalThis.test.value).toBe(value2);
+	});
+});

package/src/expose.ts

@@ -17,7 +17,7 @@ export type ExposeOptions = {
  */
 export function expose(
 	name: object | string,
-	value: object | Function | Function[],
+	value: object | Function | Function[] | string | number,
 	options: ExposeOptions = {},
 ): void {
 	if (Array.isArray(value)) {

package/src/getUserImage.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test";
+
+import { getUserImage } from "./getUserImage";
+
+describe("getUserImage", () => {
+	test("should return empty string when primKey is null", () => {
+		expect(getUserImage(null, "login", "hash")).toEqual("");
+	});
+
+	test("should return empty string when hash is null", () => {
+		expect(getUserImage("primKey", "login", null)).toEqual("");
+	});
+
+	test("should return empty string when primKey and hash are null", () => {
+		expect(getUserImage(null, "login", null)).toEqual("");
+	});
+
+	test("should return empty string when primKey and hash are not provided", () => {
+		expect(getUserImage(null, "login", null)).toEqual("");
+	});
+
+	test("should return empty string when primKey and hash are not provided", () => {
+		expect(getUserImage(null, "login", null)).toEqual("");
+	});
+
+	test("should return empty string when primKey and hash are not provided", () => {
+		expect(getUserImage(null, "login", null)).toEqual("");
+	});
+
+	test("should return valid image path when all values are provided", () => {
+		expect(getUserImage("primKey", "login", "hash")).toEqual(
+			"/api/data/blob/EmployeesLookup/primKey/Image/login.hash.jpg?width=64",
+		);
+		expect(getUserImage("primKey", "login", "hash", "xs")).toEqual(
+			"/api/data/blob/EmployeesLookup/primKey/Image/login.hash.jpg?width=64",
+		);
+		expect(getUserImage("primKey", "login", "hash", "sm")).toEqual(
+			"/api/data/blob/EmployeesLookup/primKey/Image/login.hash.jpg?width=128",
+		);
+		expect(getUserImage("primKey", "login", "hash", "md")).toEqual(
+			"/api/data/blob/EmployeesLookup/primKey/Image/login.hash.jpg?width=256",
+		);
+		expect(getUserImage("primKey", "login", "hash", "lg")).toEqual(
+			"/api/data/blob/EmployeesLookup/primKey/Image/login.hash.jpg?width=512",
+		);
+		expect(getUserImage("primKey", "login", "hash", "xl")).toEqual(
+			"/api/data/blob/EmployeesLookup/primKey/Image/login.hash.jpg",
+		);
+	});
+});

package/src/index.ts

@@ -8,7 +8,7 @@ import { localize } from "./localize.js";
 import { getSessionData, logActivity, logError, startActivity, time } from "./log.js";
 
 export { default as mitt } from "mitt";
-export { toLocalISODate, toLocalISODateTime } from "./date.js";
+export { toLocalISODate, toLocalISODateTime, toLocalDateTime } from "./date.js";
 export { downloadBlob } from "./downloadBlob.js";
 export { downloadRequest } from "./downloadRequest.js";
 export type { DownloadParameters, DownloadItem } from "./downloadRequest.js";

package/src/invariant.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+
+import { invariant } from "./invariant";
+
+describe("invariant", () => {
+	test("should throw error when condition is false", () => {
+		expect(() => {
+			invariant(false, "Test message");
+		}).toThrowError("Test message");
+	});
+
+	test("should throw error when condition is false and message is a function", () => {
+		expect(() => {
+			invariant(false, () => "Test message");
+		}).toThrowError("Test message");
+	});
+
+	test("should not throw error when condition is true", () => {
+		expect(() => {
+			invariant(true, "Test message");
+		}).not.toThrowError();
+	});
+});

package/src/parseFunc.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "bun:test";
+
+import { parseFunc } from "./parseFunc";
+
+function testFunction(arg1: string, arg2: string) {
+	console.log(arg1, arg2);
+}
+
+describe("parseFunc", () => {
+	test("should parse function", () => {
+		expect(parseFunc(testFunction)).toEqual({
+			name: "testFunction",
+			args: ["arg1", "arg2"],
+			body: "\n  console.log(arg1, arg2);\n",
+		});
+	});
+});

package/src/parseFunc.ts

@@ -6,5 +6,5 @@ const funcRegex =
 export function parseFunc(func: Function) {
 	var match = func.toString().match(funcRegex);
 	invariant(match, "Unable to parse function!");
-	return { name: match[1], args: match[2].split(","), body: match[3] };
+	return { name: func.name ?? match[1], args: match[2].split(",").map((a) => a.trim()), body: match[3] };
 }