@olenbetong/appframe-core 2.11.0 → 2.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@olenbetong/appframe-core",
-	"version": "2.11.0",
+	"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": "8b9f374849381e92b3cde78cbba9a96fde0816ca"
+	"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,8 +4,8 @@ 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");
 }
 
 /**
@@ -20,7 +20,7 @@ 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;
 }
 

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/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] };
 }