@nativerent/js-utils 1.2.2 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativerent/js-utils",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/index.ts

@@ -791,7 +791,10 @@ export function flattenObject(
     const val = obj[k];
     const key = `${pre}${k}`;
 
-    if (isObject(val) || Array.isArray(val)) {
+    if (
+      (isObject(val) || Array.isArray(val)) &&
+      getObjectKeys(obj[k]).length > 0
+    ) {
       Object.assign(acc, flattenObject(val, key));
     } else {
       acc[key] = val;
@@ -906,3 +909,17 @@ export function autoSizeText(
 
   resizeText();
 }
+
+export async function monitor(
+  fn: Function,
+  interval: number = 10,
+  attempts: number = 100,
+): Promise<boolean> {
+  for (let i = 0; i < attempts; i++) {
+    if (await fn()) return true;
+    if (i < attempts - 1) {
+      await new Promise<void>((r) => setTimeout(r, interval));
+    }
+  }
+  return false;
+}

package/tests/tests.ts

@@ -72,6 +72,7 @@ import {
   toCamelCase,
   toPercent,
   toSnakeCase,
+  monitor,
 } from "../src";
 
 test.each([
@@ -2233,6 +2234,134 @@ describe("autoSizeText (using real getNumericStyleProp)", () => {
   });
 });
 
+describe("monitor", () => {
+  beforeEach(() => jest.useFakeTimers());
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  test("returns true immediately when fn resolves true on first attempt (no sleep)", async () => {
+    const fn = jest.fn().mockResolvedValue(true);
+
+    const promise = monitor(fn, 10, 100);
+
+    // fn resolves immediately; no timers needed
+    await expect(promise).resolves.toBe(true);
+    expect(fn).toHaveBeenCalledTimes(1);
+    // no sleeps scheduled
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test("retries until fn resolves true, sleeping between attempts", async () => {
+    const fn = jest
+      .fn()
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    const promise = monitor(fn, 25, 10);
+
+    // attempt 1 happens immediately
+    await Promise.resolve();
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    // sleep 25ms -> attempt 2
+    await jest.advanceTimersByTimeAsync(25);
+    expect(fn).toHaveBeenCalledTimes(2);
+
+    // sleep 25ms -> attempt 3 succeeds
+    await jest.advanceTimersByTimeAsync(25);
+    await expect(promise).resolves.toBe(true);
+
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  test("returns false after exhausting attempts", async () => {
+    const fn = jest.fn().mockResolvedValue(false);
+
+    const promise = monitor(fn, 10, 3);
+
+    // attempt 1
+    await Promise.resolve();
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    // attempt 2
+    await jest.advanceTimersByTimeAsync(10);
+    expect(fn).toHaveBeenCalledTimes(2);
+
+    // attempt 3 (last) - no further sleep
+    await jest.advanceTimersByTimeAsync(10);
+    await expect(promise).resolves.toBe(false);
+
+    expect(fn).toHaveBeenCalledTimes(3);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test("does not sleep after the last attempt (even if fn returns false)", async () => {
+    const fn = jest.fn().mockResolvedValue(false);
+
+    const promise = monitor(fn, 50, 2);
+
+    // attempt 1 then one sleep scheduled
+    await Promise.resolve();
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(1);
+
+    // advance once -> attempt 2 (last)
+    await jest.advanceTimersByTimeAsync(50);
+    await expect(promise).resolves.toBe(false);
+
+    // should not schedule another sleep
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test("uses default interval=10 and attempts=100 when omitted", async () => {
+    const fn = jest.fn().mockResolvedValue(false);
+
+    const promise = monitor(fn); // defaults
+
+    // attempt 1
+    await Promise.resolve();
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    // drive 99 more attempts with 99 sleeps of 10ms each
+    for (let i = 0; i < 99; i++) {
+      await jest.advanceTimersByTimeAsync(10);
+    }
+
+    await expect(promise).resolves.toBe(false);
+    expect(fn).toHaveBeenCalledTimes(100);
+  });
+
+  test("awaits fn each time (supports async fn that resolves later)", async () => {
+    const fn = jest
+      .fn()
+      .mockImplementationOnce(
+        () => new Promise<boolean>((res) => setTimeout(() => res(false), 5)),
+      )
+      .mockImplementationOnce(
+        () => new Promise<boolean>((res) => setTimeout(() => res(true), 5)),
+      );
+
+    const promise = monitor(fn, 20, 5);
+
+    // attempt 1's internal 5ms
+    await jest.advanceTimersByTimeAsync(5);
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    // then monitor sleeps 20ms before attempt 2
+    await jest.advanceTimersByTimeAsync(20);
+    // attempt 2's internal 5ms
+    await jest.advanceTimersByTimeAsync(5);
+
+    await expect(promise).resolves.toBe(true);
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+});
+
 function mockRect(el: HTMLElement, rect: Partial<DOMRect>): void {
   jest.spyOn(el, "getBoundingClientRect").mockReturnValue({
     x: 0,