mybase 1.1.51 → 1.2.2

package/ts/funcs/isLANIp.ts

@@ -2,36 +2,33 @@ import ip6addr from '@7c/node-ip6addr'
 import net from 'net'
 
 export const private_network_cidrs = [
-    ip6addr.createCIDR('10.0.0.0/8'),
-    ip6addr.createCIDR('172.16.0.0/12'),
-    ip6addr.createCIDR('192.168.0.0/16'),
-    ip6addr.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
-    ip6addr.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
+  ip6addr.createCIDR('10.0.0.0/8'),
+  ip6addr.createCIDR('172.16.0.0/12'),
+  ip6addr.createCIDR('192.168.0.0/16'),
+  ip6addr.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
+  ip6addr.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
 ]
 
-export function isLANIp(ip:string) : boolean { 
-    ip=normalizeIp(ip)
-    if (net.isIP(ip)===0) return false
-    try {
-        // speed optimized
-        let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
-        for (let cidr of private_network_cidrs) {
-            if (!cidr) continue
-            
-            let first = cidr.first()
-            if (first.kind() !== ipVersion) continue
-            if (cidr.contains(ip))
-                return true
-        }
-    } catch (err) {
-        console.log(err)
-    }
-    return false
+function normalizeIp(ip: string): string | false {
+  if (net.isIP(ip) === 0) return false
+  if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
+  return ip
 }
 
-function normalizeIp(ip:string):string {
-    // also support ipv6
-    if (net.isIP(ip) === 0) return ''
-    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-    return ip
+export function isLANIp(ip: string): boolean | null {
+  const n = normalizeIp(ip)
+  if (n === false || net.isIP(n) === 0) return false
+  try {
+    const ipVersion = net.isIPv4(n) ? 'ipv4' : 'ipv6'
+    for (const cidr of private_network_cidrs) {
+      if (!cidr) continue
+      const first = cidr.first()
+      if (first.kind() !== ipVersion) continue
+      if (cidr.contains(n)) return true
+    }
+    return null
+  } catch (err) {
+    console.log(err)
+  }
+  return false
 }

package/ts/funcs/isLoopbackIP.d.ts

@@ -1,3 +1,2 @@
-import ip6addr from '@7c/node-ip6addr';
-export declare const local_network_cidrs: ip6addr.CIDR[];
-export declare function isLoopbackIP(ip: string): boolean;
+export declare const local_network_cidrs: import("@7c/node-ip6addr").CIDR[];
+export declare function isLoopbackIP(ip: string): boolean | null;

package/ts/funcs/isLoopbackIP.js

@@ -9,34 +9,33 @@ const node_ip6addr_1 = __importDefault(require("@7c/node-ip6addr"));
 const net_1 = __importDefault(require("net"));
 exports.local_network_cidrs = [
     node_ip6addr_1.default.createCIDR('127.0.0.0/8'),
-    node_ip6addr_1.default.createCIDR('::1/128')
+    node_ip6addr_1.default.createCIDR('::1/128'),
 ];
-function isLoopbackIP(ip) {
-    ip = normalizeIp(ip);
+function normalizeIp(ip) {
     if (net_1.default.isIP(ip) === 0)
         return false;
+    if (net_1.default.isIPv6(ip))
+        return ip.toLowerCase().replace(/^::ffff:/, '');
+    return ip;
+}
+function isLoopbackIP(ip) {
+    const n = normalizeIp(ip);
+    if (n === false || net_1.default.isIP(n) === 0)
+        return false;
     try {
-        // speed optimized
-        let ipVersion = net_1.default.isIPv4(ip) ? 'ipv4' : 'ipv6';
-        for (let cidr of exports.local_network_cidrs) {
-            let first = cidr.first();
+        const ipVersion = net_1.default.isIPv4(n) ? 'ipv4' : 'ipv6';
+        for (const cidr of exports.local_network_cidrs) {
+            const first = cidr.first();
             if (first.kind() !== ipVersion)
                 continue;
-            if (cidr.contains(ip))
+            if (cidr.contains(n))
                 return true;
         }
+        return null;
     }
     catch (err) {
         console.log(err);
     }
     return false;
 }
-function normalizeIp(ip) {
-    // also support ipv6
-    if (net_1.default.isIP(ip) === 0)
-        return '';
-    if (net_1.default.isIPv6(ip))
-        return ip.toLowerCase().replace(/^::ffff:/, '');
-    return ip;
-}
 //# sourceMappingURL=isLoopbackIP.js.map

package/ts/funcs/isLoopbackIP.test.ts

@@ -10,12 +10,12 @@ describe('isLoopbackIP', () => {
         expect(isLoopbackIP('::1')).toBe(true);
     });
 
-    test('should return false for non-loopback IPv4 address', () => {
-        expect(isLoopbackIP('192.168.0.1')).toBe(false);
+    test('should return null for non-loopback IPv4 address', () => {
+        expect(isLoopbackIP('192.168.0.1')).toBeNull();
     });
 
-    test('should return false for non-loopback IPv6 address', () => {
-        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(false);
+    test('should return null for non-loopback IPv6 address', () => {
+        expect(isLoopbackIP('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBeNull();
     });
 
     test('should return false for invalid IP address', () => {
@@ -49,12 +49,12 @@ describe('isLoopbackIP', () => {
 
     test('should return null for non-local IPv4', () => {
         const ip = '8.8.8.8'
-        expect(isLoopbackIP(ip)).toBe(false)
+        expect(isLoopbackIP(ip)).toBeNull()
     })
 
     test('should return null for non-local IPv6', () => {
         const ip = '2001:4860:4860::8888'
-        expect(isLoopbackIP(ip)).toBe(false)
+        expect(isLoopbackIP(ip)).toBeNull()
     })
 
     test('should return false for invalid IP', () => {
@@ -65,7 +65,7 @@ describe('isLoopbackIP', () => {
     test('random ips should not be Loopback', () => {
         for(let i=0;i<10;i++){
             let ip = randomIP()
-            expect(isLoopbackIP(ip)).toBe(false)
+            expect(isLoopbackIP(ip)).toBeNull()
         }
             
     })

package/ts/funcs/isLoopbackIP.ts

@@ -2,31 +2,29 @@ import ip6addr from '@7c/node-ip6addr'
 import net from 'net'
 
 export const local_network_cidrs = [
-    ip6addr.createCIDR('127.0.0.0/8'),
-    ip6addr.createCIDR('::1/128')
+  ip6addr.createCIDR('127.0.0.0/8'),
+  ip6addr.createCIDR('::1/128'),
 ]
 
-export function isLoopbackIP(ip:string) : boolean {
-    ip=normalizeIp(ip)
-    if (net.isIP(ip)===0) return false
-    try {
-        // speed optimized
-        let ipVersion = net.isIPv4(ip) ? 'ipv4' : 'ipv6'
-        for (let cidr of local_network_cidrs) {
-            let first = cidr.first()
-            if (first.kind() !== ipVersion) continue
-            if (cidr.contains(ip))
-                return true
-        }
-    } catch (err) {
-        console.log(err)
-    }
-    return false
+function normalizeIp(ip: string): string | false {
+  if (net.isIP(ip) === 0) return false
+  if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
+  return ip
 }
 
-function normalizeIp(ip:string):string {
-    // also support ipv6
-    if (net.isIP(ip) === 0) return ''
-    if (net.isIPv6(ip)) return ip.toLowerCase().replace(/^::ffff:/, '')
-    return ip
+export function isLoopbackIP(ip: string): boolean | null {
+  const n = normalizeIp(ip)
+  if (n === false || net.isIP(n) === 0) return false
+  try {
+    const ipVersion = net.isIPv4(n) ? 'ipv4' : 'ipv6'
+    for (const cidr of local_network_cidrs) {
+      const first = cidr.first()
+      if (first.kind() !== ipVersion) continue
+      if (cidr.contains(n)) return true
+    }
+    return null
+  } catch (err) {
+    console.log(err)
+  }
+  return false
 }

package/ts/funcs/validEmail.d.ts

@@ -1 +1 @@
-export declare function validEmail(email: string): boolean;
+export declare function validEmail(email: unknown): boolean;

package/ts/funcs/validEmail.js

@@ -13,8 +13,5 @@ function validEmail(email) {
     // taken from https://www.w3resource.com/javascript/form/email-validation.php
     // strange looking emails might be indeed valid
     // check https://www.w3resource.com/javascript/form/example-javascript-form-validation-email-REC-2822.html
-    if (typeof email === 'string')
-        email = email.toLowerCase().trim();
-    return (/(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/).test(email);
 }
 //# sourceMappingURL=validEmail.js.map

package/ts/funcs/validEmail.ts

@@ -1,6 +1,6 @@
 import validator from 'validator'
 
-export function validEmail(email:string) { 
+export function validEmail(email: unknown): boolean {
     if (typeof email==='string')
         return validator.isEmail(email) // validator needs a string
     return false
@@ -8,6 +8,4 @@ export function validEmail(email:string) {
     // taken from https://www.w3resource.com/javascript/form/email-validation.php
     // strange looking emails might be indeed valid
     // check https://www.w3resource.com/javascript/form/example-javascript-form-validation-email-REC-2822.html
-    if (typeof email==='string') email=email.toLowerCase().trim()
-    return (/(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/).test(email)
 }

package/ts/funcs/vaultFill.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.vaultFill = vaultFill;
 const debug_1 = require("debug");
 const vaultRead_1 = require("./vaultRead");
-const dbg = (0, debug_1.debug)('vaultFill');
+const dbg = (0, debug_1.debug)('mybase');
 function vaultFill(vaultInstance, inputObject, ignoreError = false, keepCache = true) {
     // v2.1
     // fills all strings with ^vault@/secret/... with proper vault values

package/ts/funcs/vaultFill.ts

@@ -1,7 +1,7 @@
 import { debug } from "debug"
 import nodeVault from "node-vault";
 import { vaultRead } from "./vaultRead";
-const dbg = debug('vaultFill')
+const dbg = debug('mybase')
 
 export function vaultFill(vaultInstance: nodeVault.client, inputObject: any, ignoreError = false, keepCache = true) {
     // v2.1

package/ts/funcs/vaultRead.js

@@ -5,18 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vaultRead = vaultRead;
 const debug_1 = require("debug");
+const chalk_1 = __importDefault(require("chalk"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
 const fileCacheIsValid_1 = require("./fileCacheIsValid");
 const global_1 = require("../global");
 const hash_sha512_1 = require("./hash_sha512");
-const dbg = (0, debug_1.debug)('vaultRead');
+const dbg = (0, debug_1.debug)('mybase');
 // need to implement it better
 function vaultRead(vaultInstance, vaultKey, cache_in_minutes = 10) {
     // v2 - supports caching
     return new Promise((resolve, reject) => {
-        let cache_file = path_1.default.join(global_1.vault_cache_folder, (0, hash_sha512_1.hash_sha512)(`${vaultInstance.endpoint}/${vaultKey}`));
+        const cacheKeyMaterial = `${vaultInstance.endpoint}/${vaultKey}`;
+        const cacheHash = (0, hash_sha512_1.hash_sha512)(cacheKeyMaterial);
+        if (cacheHash === false)
+            return reject(new Error('vault cache key hash failed'));
+        let cache_file = path_1.default.join(global_1.vault_cache_folder, cacheHash);
         if (cache_in_minutes > 0 && (0, fileCacheIsValid_1.fileCacheIsValid)(cache_file, cache_in_minutes))
             return resolve(JSON.parse((0, fs_2.readFileSync)(cache_file).toString()));
         vaultInstance.read(vaultKey).then((r) => {
@@ -33,10 +38,11 @@ function vaultRead(vaultInstance, vaultKey, cache_in_minutes = 10) {
             dbg(`vault ${vaultKey} - failed`);
             reject(r);
         }).catch(e => {
+            console.log(e);
             dbg(`exception inside vaultRead`, e);
             // we will still return latest information from cache
             try {
-                dbg(`returning vault@${vaultKey} from cache due to error`);
+                console.log(chalk_1.default.bgRed(`returning vault@${vaultKey} from cache due to error`));
                 if (fs_1.default.existsSync(cache_file))
                     return resolve(JSON.parse(fs_1.default.readFileSync(cache_file).toString()));
             }

package/ts/funcs/vaultRead.ts

@@ -1,4 +1,5 @@
 import { debug } from "debug"
+import chalk from "chalk"
 import nodeVault from "node-vault";
 import path from "path";
 import fs from "fs";
@@ -6,14 +7,17 @@ import { readFileSync } from 'fs';
 import { fileCacheIsValid } from "./fileCacheIsValid";
 import { vault_cache_folder } from "../global";
 import { hash_sha512 } from "./hash_sha512";
-const dbg = debug('vaultRead')
+const dbg = debug('mybase')
 
 // need to implement it better
 
 export function vaultRead(vaultInstance: nodeVault.client, vaultKey: string, cache_in_minutes = 10) : Promise<any> {
     // v2 - supports caching
     return new Promise((resolve, reject) => {
-        let cache_file = path.join(vault_cache_folder, hash_sha512(`${vaultInstance.endpoint}/${vaultKey}`))
+        const cacheKeyMaterial = `${vaultInstance.endpoint}/${vaultKey}`
+        const cacheHash = hash_sha512(cacheKeyMaterial)
+        if (cacheHash === false) return reject(new Error('vault cache key hash failed'))
+        let cache_file = path.join(vault_cache_folder, cacheHash)
 
         if (cache_in_minutes > 0 && fileCacheIsValid(cache_file, cache_in_minutes))
             return resolve(JSON.parse(readFileSync(cache_file as string).toString()))
@@ -28,10 +32,11 @@ export function vaultRead(vaultInstance: nodeVault.client, vaultKey: string, cac
             dbg(`vault ${vaultKey} - failed`)
             reject(r);
         }).catch(e => {
+            console.log(e)
             dbg(`exception inside vaultRead`, e)
             // we will still return latest information from cache
             try {
-                dbg(`returning vault@${vaultKey} from cache due to error`)
+                console.log(chalk.bgRed(`returning vault@${vaultKey} from cache due to error`))
                 if (fs.existsSync(cache_file))
                     return resolve(JSON.parse(fs.readFileSync(cache_file as string).toString()))
             } catch (e2) {

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');
+  });
+});