mybase 1.1.51 → 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.51",
+  "version": "1.1.53",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/index.d.ts

@@ -32,3 +32,4 @@ export * from "./models/Timespan";
 export * from "./models/IPAddress";
 export * from "./models/OTPGenerator";
 export * from "./models/Interfaces";
+export * from "./models/DateIterator";

package/ts/index.js

@@ -49,4 +49,5 @@ __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

@@ -36,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);
     })