mybase 1.1.50 → 1.1.53

package/jest.config.js

@@ -3,4 +3,5 @@ module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   testTimeout: 15000,
+  testMatch: ['**/?(*.)+(spec|test).ts'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.50",
+  "version": "1.1.53",
   "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,8 +26,10 @@ 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";
 export * from "./models/OTPGenerator";
 export * from "./models/Interfaces";
+export * from "./models/DateIterator";

package/ts/index.js

@@ -42,10 +42,12 @@ __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);
 __exportStar(require("./models/IPAddress"), exports);
 __exportStar(require("./models/OTPGenerator"), exports);
 __exportStar(require("./models/Interfaces"), exports);
+__exportStar(require("./models/DateIterator"), exports);
 //# sourceMappingURL=index.js.map

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"
 
 
 
@@ -35,4 +36,4 @@ export * from "./models/Timespan"
 export * from "./models/IPAddress"
 export * from "./models/OTPGenerator"
 export * from "./models/Interfaces"
-
+export * from "./models/DateIterator"

package/ts/models/DateIterator.d.ts

@@ -0,0 +1,33 @@
+import { Unixtime } from "./Unixtime";
+/**
+ * Iterates day-by-day backwards from `start` toward `end` (end-exclusive),
+ * emitting each date as a `yyyy{sep}mm{sep}dd` string.
+ *
+ * @example
+ *   const it = new DateIterator(Unixtime.now(), Unixtime.now().addDays(-5))
+ *   it.next()  // "20260417"
+ *   it.next()  // "20260416"
+ *   // ...
+ *   it.next()  // null
+ *
+ * @example separator
+ *   new DateIterator(start, end, "-").toArray()
+ *   // ["2026-04-17", "2026-04-16", ...]
+ *
+ * @example for..of
+ *   for (const d of new DateIterator(start, end, "/")) console.log(d)
+ */
+export declare class DateIterator implements Iterable<string> {
+    private readonly start;
+    private readonly end;
+    private readonly separator;
+    private cursor;
+    constructor(start: Unixtime, end: Unixtime, separator?: string);
+    /** Returns the next formatted date going backwards, or `null` when exhausted. */
+    next(): string | null;
+    /** Reset the iterator so it can be consumed again from `start`. */
+    reset(): this;
+    /** Collect all remaining dates into an array. */
+    toArray(): string[];
+    [Symbol.iterator](): Iterator<string>;
+}

package/ts/models/DateIterator.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateIterator = void 0;
+/**
+ * Iterates day-by-day backwards from `start` toward `end` (end-exclusive),
+ * emitting each date as a `yyyy{sep}mm{sep}dd` string.
+ *
+ * @example
+ *   const it = new DateIterator(Unixtime.now(), Unixtime.now().addDays(-5))
+ *   it.next()  // "20260417"
+ *   it.next()  // "20260416"
+ *   // ...
+ *   it.next()  // null
+ *
+ * @example separator
+ *   new DateIterator(start, end, "-").toArray()
+ *   // ["2026-04-17", "2026-04-16", ...]
+ *
+ * @example for..of
+ *   for (const d of new DateIterator(start, end, "/")) console.log(d)
+ */
+class DateIterator {
+    constructor(start, end, separator = "") {
+        if (start.lessThan(end)) {
+            throw new Error('DateIterator: `start` must be newer than or equal to `end`');
+        }
+        // Defensive clones: callers' instances must not be mutated, and
+        // Unixtime.addDays() mutates the underlying Date.
+        this.start = start.clone();
+        this.end = end.clone();
+        this.separator = separator;
+        this.cursor = this.start.clone();
+    }
+    /** Returns the next formatted date going backwards, or `null` when exhausted. */
+    next() {
+        if (this.cursor === null)
+            return null;
+        if (!this.cursor.greaterThan(this.end)) {
+            this.cursor = null;
+            return null;
+        }
+        const value = this.cursor.yyyymmdd(this.separator);
+        this.cursor.addDays(-1);
+        return value;
+    }
+    /** Reset the iterator so it can be consumed again from `start`. */
+    reset() {
+        this.cursor = this.start.clone();
+        return this;
+    }
+    /** Collect all remaining dates into an array. */
+    toArray() {
+        const out = [];
+        let d;
+        while ((d = this.next()) !== null)
+            out.push(d);
+        return out;
+    }
+    [Symbol.iterator]() {
+        let cursor = this.start.clone();
+        const end = this.end;
+        const sep = this.separator;
+        return {
+            next() {
+                if (cursor === null || !cursor.greaterThan(end)) {
+                    return { value: undefined, done: true };
+                }
+                const value = cursor.yyyymmdd(sep);
+                cursor.addDays(-1);
+                return { value, done: false };
+            }
+        };
+    }
+}
+exports.DateIterator = DateIterator;
+//# sourceMappingURL=DateIterator.js.map

package/ts/models/DateIterator.test.ts

@@ -0,0 +1,149 @@
+import { DateIterator } from './DateIterator';
+import { Unixtime } from './Unixtime';
+
+describe('DateIterator', () => {
+  const start = () => Unixtime.fromYYYYMMDD('20240110');
+  const end = () => Unixtime.fromYYYYMMDD('20240105');
+
+  it('should iterate backwards day-by-day (end-exclusive) with default separator', () => {
+    const it = new DateIterator(start(), end());
+    expect(it.toArray()).toEqual([
+      '20240110',
+      '20240109',
+      '20240108',
+      '20240107',
+      '20240106',
+    ]);
+  });
+
+  it('should honor a custom separator', () => {
+    const it = new DateIterator(start(), end(), '-');
+    expect(it.toArray()).toEqual([
+      '2024-01-10',
+      '2024-01-09',
+      '2024-01-08',
+      '2024-01-07',
+      '2024-01-06',
+    ]);
+  });
+
+  it('should honor a slash separator', () => {
+    const it = new DateIterator(start(), end(), '/');
+    expect(it.toArray()).toEqual([
+      '2024/01/10',
+      '2024/01/09',
+      '2024/01/08',
+      '2024/01/07',
+      '2024/01/06',
+    ]);
+  });
+
+  it('next() should return null when exhausted', () => {
+    const s = Unixtime.fromYYYYMMDD('20240103');
+    const e = Unixtime.fromYYYYMMDD('20240101');
+    const it = new DateIterator(s, e);
+    expect(it.next()).toEqual('20240103');
+    expect(it.next()).toEqual('20240102');
+    expect(it.next()).toBeNull();
+    expect(it.next()).toBeNull();
+  });
+
+  it('should return empty array when start equals end (end-exclusive)', () => {
+    const s = Unixtime.fromYYYYMMDD('20240105');
+    const e = Unixtime.fromYYYYMMDD('20240105');
+    const it = new DateIterator(s, e);
+    expect(it.toArray()).toEqual([]);
+    expect(it.next()).toBeNull();
+  });
+
+  it('should throw when start is older than end', () => {
+    const s = Unixtime.fromYYYYMMDD('20240101');
+    const e = Unixtime.fromYYYYMMDD('20240110');
+    expect(() => new DateIterator(s, e)).toThrow(
+      'DateIterator: `start` must be newer than or equal to `end`'
+    );
+  });
+
+  it('should not mutate the caller-supplied Unixtime instances', () => {
+    const s = Unixtime.fromYYYYMMDD('20240110');
+    const e = Unixtime.fromYYYYMMDD('20240105');
+    const sBefore = s.toLongUnixtime();
+    const eBefore = e.toLongUnixtime();
+    const it = new DateIterator(s, e);
+    it.toArray();
+    expect(s.toLongUnixtime()).toEqual(sBefore);
+    expect(e.toLongUnixtime()).toEqual(eBefore);
+  });
+
+  it('reset() should allow the iterator to be consumed again', () => {
+    const it = new DateIterator(start(), end());
+    const first = it.toArray();
+    expect(it.next()).toBeNull();
+    it.reset();
+    const second = it.toArray();
+    expect(second).toEqual(first);
+  });
+
+  it('reset() should return the iterator for chaining', () => {
+    const it = new DateIterator(start(), end());
+    expect(it.reset()).toBe(it);
+  });
+
+  it('should be iterable via for..of', () => {
+    const it = new DateIterator(start(), end(), '-');
+    const out: string[] = [];
+    for (const d of it) out.push(d);
+    expect(out).toEqual([
+      '2024-01-10',
+      '2024-01-09',
+      '2024-01-08',
+      '2024-01-07',
+      '2024-01-06',
+    ]);
+  });
+
+  it('for..of should be independent of next()/toArray() cursor', () => {
+    const it = new DateIterator(start(), end());
+    expect(it.next()).toEqual('20240110');
+    const collected: string[] = [];
+    for (const d of it) collected.push(d);
+    expect(collected).toEqual([
+      '20240110',
+      '20240109',
+      '20240108',
+      '20240107',
+      '20240106',
+    ]);
+    expect(it.next()).toEqual('20240109');
+  });
+
+  it('should support spread syntax', () => {
+    const it = new DateIterator(
+      Unixtime.fromYYYYMMDD('20240103'),
+      Unixtime.fromYYYYMMDD('20240101')
+    );
+    expect([...it]).toEqual(['20240103', '20240102']);
+  });
+
+  it('should cross month boundaries correctly', () => {
+    const s = Unixtime.fromYYYYMMDD('20240302');
+    const e = Unixtime.fromYYYYMMDD('20240227');
+    const it = new DateIterator(s, e, '-');
+    expect(it.toArray()).toEqual([
+      '2024-03-02',
+      '2024-03-01',
+      '2024-02-29',
+      '2024-02-28',
+    ]);
+  });
+
+  it('should produce N entries for a span of N+1 days (end-exclusive)', () => {
+    const s = Unixtime.fromYYYYMMDD('20240620');
+    const e = Unixtime.fromYYYYMMDD('20240610');
+    const it = new DateIterator(s, e);
+    const arr = it.toArray();
+    expect(arr.length).toEqual(10);
+    expect(arr[0]).toEqual('20240620');
+    expect(arr[arr.length - 1]).toEqual('20240611');
+  });
+});

package/ts/models/DateIterator.ts

@@ -0,0 +1,80 @@
+import { Unixtime } from "./Unixtime"
+
+/**
+ * Iterates day-by-day backwards from `start` toward `end` (end-exclusive),
+ * emitting each date as a `yyyy{sep}mm{sep}dd` string.
+ *
+ * @example
+ *   const it = new DateIterator(Unixtime.now(), Unixtime.now().addDays(-5))
+ *   it.next()  // "20260417"
+ *   it.next()  // "20260416"
+ *   // ...
+ *   it.next()  // null
+ *
+ * @example separator
+ *   new DateIterator(start, end, "-").toArray()
+ *   // ["2026-04-17", "2026-04-16", ...]
+ *
+ * @example for..of
+ *   for (const d of new DateIterator(start, end, "/")) console.log(d)
+ */
+export class DateIterator implements Iterable<string> {
+    private readonly start: Unixtime
+    private readonly end: Unixtime
+    private readonly separator: string
+    private cursor: Unixtime | null
+
+    constructor(start: Unixtime, end: Unixtime, separator: string = "") {
+        if (start.lessThan(end)) {
+            throw new Error('DateIterator: `start` must be newer than or equal to `end`')
+        }
+        // Defensive clones: callers' instances must not be mutated, and
+        // Unixtime.addDays() mutates the underlying Date.
+        this.start = start.clone()
+        this.end = end.clone()
+        this.separator = separator
+        this.cursor = this.start.clone()
+    }
+
+    /** Returns the next formatted date going backwards, or `null` when exhausted. */
+    next(): string | null {
+        if (this.cursor === null) return null
+        if (!this.cursor.greaterThan(this.end)) {
+            this.cursor = null
+            return null
+        }
+        const value = this.cursor.yyyymmdd(this.separator)
+        this.cursor.addDays(-1)
+        return value
+    }
+
+    /** Reset the iterator so it can be consumed again from `start`. */
+    reset(): this {
+        this.cursor = this.start.clone()
+        return this
+    }
+
+    /** Collect all remaining dates into an array. */
+    toArray(): string[] {
+        const out: string[] = []
+        let d: string | null
+        while ((d = this.next()) !== null) out.push(d)
+        return out
+    }
+
+    [Symbol.iterator](): Iterator<string> {
+        let cursor: Unixtime | null = this.start.clone()
+        const end = this.end
+        const sep = this.separator
+        return {
+            next(): IteratorResult<string> {
+                if (cursor === null || !cursor.greaterThan(end)) {
+                    return { value: undefined as unknown as string, done: true }
+                }
+                const value = cursor.yyyymmdd(sep)
+                cursor.addDays(-1)
+                return { value, done: false }
+            }
+        }
+    }
+}

package/ts/models/OTPGenerator.test.ts

@@ -15,7 +15,7 @@ describe('OTPGenerator', () => {
     it('should generate different OTPs in milliseconds', async () => {
         const otpGenerator = new OTPGenerator(passkey, 5);
         const otp1 = otpGenerator.generateOTP()
-        await wait(1/1000);
+        await wait(3/1000);
         const otp2 = otpGenerator.generateOTP();
         expect(otp1).not.toBe(otp2);
     })