@olenbetong/appframe-core 2.11.0 → 2.11.2

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.11.0",
+	"version": "2.11.2",
 	"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": "a3bcfef01480d5761a4359316facf35f7e739ca0"
 }

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

@@ -1,4 +1,3 @@
-import { has } from "./has.js";
 import { invariant } from "./invariant.js";
 import { parseFunc } from "./parseFunc.js";
 import { requireNamespace } from "./requireNamespace.js";
@@ -17,7 +16,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)) {
@@ -53,7 +52,7 @@ export function expose(
 			invariant(false, "Invalid typeof parameter 'name', or unable to parse pValue!");
 		}
 
-		if (has(namespace, keyName) && options?.overwrite !== true) {
+		if (Object.hasOwn(namespace, keyName) && options?.overwrite !== true) {
 			// If class is already defined, warn or show an alert
 			console.warn([name, keyName].join(".") + " is already defined!");
 		} else {

package/src/getLocalizedString.ts

@@ -1,5 +1,3 @@
-import { has } from "./has.js";
-
 async function fetchLocalizedString(text: string) {
 	try {
 		let response = await fetch(`/api/user/localize/new/${af.article.id}`, {
@@ -45,7 +43,7 @@ export function getLocalizedString(
 	}
 
 	if (globalThis.af?.article?.i18n !== undefined) {
-		if (!has(af.article.i18n, string)) {
+		if (!Object.hasOwn(af.article.i18n, string)) {
 			af.article.i18n[string] = string;
 
 			let promise = fetchLocalizedString(string).then((text) => {

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

@@ -16,7 +16,6 @@ export { expose } from "./expose.js";
 export { getUserImage } from "./getUserImage.js";
 export type { getUserImageOptions } from "./getUserImage.js";
 export { getLocalizedString } from "./getLocalizedString.js";
-export { has } from "./has.js";
 export { invariant } from "./invariant.js";
 export { localize } from "./localize.js";
 export { afLocalStorage as localStorage };

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/invariant.ts

@@ -1,3 +1,11 @@
+/**
+ * Throws an error if the condition is falsy. The provided message is used as the error message.
+ * A function can be provided to lazily generate the message.
+ * 
+ * @param {any} condition 
+ * @param {string | (() => string)} [message] 
+ * @returns {void}
+ */
 export function invariant(condition: any, message?: string | (() => string)): asserts condition {
 	if (condition) {
 		return;

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

package/es/has.d.ts

@@ -1 +0,0 @@
-export declare function has(obj: any, key: string | number | symbol): boolean;

package/es/has.js

@@ -1,3 +0,0 @@
-export function has(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}

package/src/has.ts

@@ -1,3 +0,0 @@
-export function has(obj: any, key: string | number | symbol): boolean {
-	return Object.prototype.hasOwnProperty.call(obj, key);
-}