mybase 1.1.49 → 1.1.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.49",
+  "version": "1.1.51",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/funcs/deepCopy.d.ts

@@ -0,0 +1 @@
+export declare function deepCopy<T>(obj: T, visited?: WeakMap<object, any>): T;

package/ts/funcs/deepCopy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepCopy = deepCopy;
+function deepCopy(obj, visited = new WeakMap()) {
+    // Handle null and non-objects
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    // Handle circular references
+    if (visited.has(obj)) {
+        return visited.get(obj);
+    }
+    // Handle Date
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    // Handle Array
+    if (Array.isArray(obj)) {
+        const copy = [];
+        visited.set(obj, copy);
+        obj.forEach((item, i) => {
+            copy[i] = deepCopy(item, visited);
+        });
+        return copy;
+    }
+    // Handle Object
+    const copy = Object.create(Object.getPrototypeOf(obj));
+    visited.set(obj, copy);
+    for (const key of Object.keys(obj)) {
+        copy[key] = deepCopy(obj[key], visited);
+    }
+    return copy;
+}
+//# sourceMappingURL=deepCopy.js.map

package/ts/funcs/deepCopy.test.ts

@@ -0,0 +1,108 @@
+import { Unixtime } from "../models/Unixtime";
+import { deepCopy } from "./deepCopy"
+
+describe('deepCopy', () => {
+  it('deep-copies plain objects', () => {
+    const src = { a: 1, b: { c: 2 } };
+    const copy = deepCopy(src) as typeof src;
+
+    expect(copy).toEqual(src);
+    expect(copy).not.toBe(src);
+
+    copy.b.c = 3;
+    expect(src.b.c).toBe(2);   // original stays intact
+  });
+
+
+  it('Date objects are copied as Date objects', () => {
+    const src = { date: new Date() }
+    const copy = deepCopy(src) as typeof src
+    expect(copy.date).toBeInstanceOf(Date)
+    expect(copy.date).not.toBe(src.date)
+  })
+
+  it('deep-copies arrays', () => {
+    const src = [1, [2, 3]];
+    const copy = deepCopy(src) as typeof src;
+
+    expect(copy).toEqual(src);
+    //@ts-ignore
+    copy[1][0] = 99;
+    //@ts-ignore
+    expect(src[1][0]).toBe(2);
+  });
+
+  it('returns primitives unchanged', () => {
+    expect(deepCopy(42 as any)).toBe(42);
+    expect(deepCopy('hello' as any)).toBe('hello');
+    expect(deepCopy(null as any)).toBeNull();
+  });
+
+  it('should handle circular references', () => {
+    const obj: any = { a: 1 };
+    obj.self = obj;
+    const copy = deepCopy(obj);
+    expect(copy).toEqual({ a: 1, self: copy });
+    expect(copy.self).toBe(copy);
+  });
+
+  it('should preserve prototype chain', () => {
+    class MyClass { x = 1; }
+    const obj = new MyClass();
+    const copy = deepCopy(obj);
+    expect(copy).toBeInstanceOf(MyClass);
+    expect(copy.x).toBe(1);
+  });
+
+  it('changing Date at src should not change copy', () => {
+    const src = { a: new Date("2024-05-05"), b: { c: 2 } };
+    const copy = deepCopy(src) as typeof src;
+    expect(copy).toEqual(src);
+    expect(copy).not.toBe(src);
+    src.a.setFullYear(2025)
+    expect(src.a.getFullYear()).toBe(2025)
+    expect(copy.a.getFullYear()).toBe(2024)
+  })
+
+  it('changing src integer should not change copy', () => {
+    const src = { a: 1, b: { c: 2 } };
+    const copy = deepCopy(src) as typeof src;
+    expect(copy).toEqual(src);
+    expect(copy).not.toBe(src);
+    src.a = 2
+    expect(src.a).toBe(2)
+    expect(copy.a).toBe(1)
+  })
+
+  it('changing src string should not change copy', () => {
+    const src = { a: "hello", b: { c: 2 } };
+    const copy = deepCopy(src) as typeof src;
+    expect(copy).toEqual(src);
+    expect(copy).not.toBe(src);
+    src.a = "world"
+    expect(src.a).toBe("world")
+    expect(copy.a).toBe("hello")
+  })
+
+  it('changing src boolean should not change copy', () => {
+    const src = { a: true, b: { c: 2 } };
+    const copy = deepCopy(src) as typeof src;
+    expect(copy).toEqual(src);
+    expect(copy).not.toBe(src);
+    src.a = false
+    expect(src.a).toBe(false)
+    expect(copy.a).toBe(true)
+
+  })
+
+  it('changing src Unixtime should not change copy', () => {
+    const src = { a: new Unixtime("2024-05-02"), b: { c: 2 } };
+    const copy = deepCopy(src) as typeof src;
+    expect(copy).toEqual(src);
+    expect(copy).not.toBe(src);
+    src.a.addYears(-1)
+    expect(src.a.toDate().getFullYear()).toBe(2023)
+    expect(copy.a.toDate().getFullYear()).toBe(2024)
+  })
+
+});

package/ts/funcs/deepCopy.ts

@@ -0,0 +1,34 @@
+export function deepCopy<T>(obj: T, visited = new WeakMap()): T {
+    // Handle null and non-objects
+    if (obj === null || typeof obj !== 'object') {
+      return obj;
+    }
+  
+    // Handle circular references
+    if (visited.has(obj)) {
+      return visited.get(obj);
+    }
+  
+    // Handle Date
+    if (obj instanceof Date) {
+      return new Date(obj.getTime()) as any;
+    }
+  
+    // Handle Array
+    if (Array.isArray(obj)) {
+      const copy: any[] = [];
+      visited.set(obj, copy);
+      obj.forEach((item, i) => {
+        copy[i] = deepCopy(item, visited);
+      });
+      return copy as T;
+    }
+  
+    // Handle Object
+    const copy = Object.create(Object.getPrototypeOf(obj));
+    visited.set(obj, copy);
+    for (const key of Object.keys(obj)) {
+      copy[key] = deepCopy((obj as any)[key], visited);
+    }
+    return copy;
+  }

package/ts/index.d.ts

@@ -26,6 +26,7 @@ export * from "./funcs/randomUTFString";
 export * from "./funcs/MaxRuntimeHours";
 export * from "./funcs/ensureFolder";
 export * from "./funcs/knexConnection";
+export * from "./funcs/deepCopy";
 export * from "./models/Unixtime";
 export * from "./models/Timespan";
 export * from "./models/IPAddress";

package/ts/index.js

@@ -42,6 +42,7 @@ __exportStar(require("./funcs/randomUTFString"), exports);
 __exportStar(require("./funcs/MaxRuntimeHours"), exports);
 __exportStar(require("./funcs/ensureFolder"), exports);
 __exportStar(require("./funcs/knexConnection"), exports);
+__exportStar(require("./funcs/deepCopy"), exports);
 // models
 __exportStar(require("./models/Unixtime"), exports);
 __exportStar(require("./models/Timespan"), exports);

package/ts/index.ts

@@ -26,6 +26,7 @@ export * from "./funcs/randomUTFString"
 export * from "./funcs/MaxRuntimeHours"
 export * from "./funcs/ensureFolder"
 export * from "./funcs/knexConnection"
+export * from "./funcs/deepCopy"