@praxisjs/decorators 0.4.2 → 0.4.3

package/src/__tests__/events.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi } from "vitest";
+
+import { StatefulComponent } from "@praxisjs/core";
+
+import { createCommand } from "../events/command";
+import { Emit } from "../events/emit";
+import { readProp } from "../events/helper";
+import { OnCommand } from "../events/on-command";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+class TestComponent extends StatefulComponent {
+  render() { return null; }
+}
+
+function methodCtx(name: string) {
+  const initializers: Array<(this: unknown) => void> = [];
+  return {
+    ctx: {
+      name,
+      kind: "method" as const,
+      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
+    } as ClassMethodDecoratorContext,
+    run(instance: unknown) { initializers.forEach((fn) => { fn.call(instance); }); },
+  };
+}
+
+// ── createCommand ─────────────────────────────────────────────────────────────
+
+describe("createCommand", () => {
+  it("trigger calls all subscribed handlers with the argument", () => {
+    const cmd = createCommand<number>();
+    const h1 = vi.fn();
+    const h2 = vi.fn();
+    cmd.subscribe(h1);
+    cmd.subscribe(h2);
+    cmd.trigger(42);
+    expect(h1).toHaveBeenCalledWith(42);
+    expect(h2).toHaveBeenCalledWith(42);
+  });
+
+  it("trigger does nothing when no handlers are subscribed", () => {
+    const cmd = createCommand<string>();
+    expect(() => cmd.trigger("hello")).not.toThrow();
+  });
+
+  it("subscribe returns an unsubscribe function", () => {
+    const cmd = createCommand<void>();
+    const handler = vi.fn();
+    const unsub = cmd.subscribe(handler);
+    unsub();
+    cmd.trigger();
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("void command can be triggered without args", () => {
+    const cmd = createCommand();
+    const handler = vi.fn();
+    cmd.subscribe(handler);
+    cmd.trigger(undefined as unknown as void);
+    expect(handler).toHaveBeenCalledOnce();
+  });
+});
+
+// ── readProp ──────────────────────────────────────────────────────────────────
+
+describe("readProp", () => {
+  it("returns value from _rawProps when defined", () => {
+    const instance = new TestComponent({ myProp: "fromParent" });
+    expect(readProp(instance, "myProp")).toBe("fromParent");
+  });
+
+  it("falls back to _defaults when _rawProps does not define the prop", () => {
+    const instance = new TestComponent();
+    instance._defaults.myProp = "default";
+    expect(readProp(instance, "myProp")).toBe("default");
+  });
+
+  it("returns undefined when prop is not in either", () => {
+    const instance = new TestComponent();
+    expect(readProp(instance, "missing")).toBeUndefined();
+  });
+});
+
+// ── Emit ─────────────────────────────────────────────────────────────────────
+
+describe("Emit decorator", () => {
+  it("calls the prop callback with the return value of the method", () => {
+    const { ctx, run } = methodCtx("handleInput");
+    const original = function (this: object, value: string) { return value.toUpperCase(); };
+    Emit("onChange")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onChange: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, (v: string) => void>).handleInput;
+    method.call(instance, "hello");
+    expect(callback).toHaveBeenCalledWith("HELLO");
+  });
+
+  it("calls the prop callback with the method args when return value is undefined", () => {
+    const { ctx, run } = methodCtx("doSomething");
+    const original = function (this: object, a: number, b: number) { return undefined; };
+    Emit("onDo")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onDo: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, (a: number, b: number) => void>).doSomething;
+    method.call(instance, 1, 2);
+    expect(callback).toHaveBeenCalledWith(1, 2);
+  });
+
+  it("calls the prop callback with no args when return is undefined and no args", () => {
+    const { ctx, run } = methodCtx("fire");
+    const original = function (this: object) { return undefined; };
+    Emit("onFire")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onFire: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, () => void>).fire;
+    method.call(instance);
+    expect(callback).toHaveBeenCalledOnce();
+    expect(callback).toHaveBeenCalledWith();
+  });
+
+  it("does not throw when the prop callback is not a function", () => {
+    const { ctx, run } = methodCtx("submit");
+    const original = function (this: object) { return "result"; };
+    Emit("onSubmit")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const instance = new TestComponent(); // no onSubmit prop
+    run(instance);
+
+    const method = (instance as unknown as Record<string, () => void>).submit;
+    expect(() => method.call(instance)).not.toThrow();
+  });
+
+  it("still returns the original method's return value", () => {
+    const { ctx, run } = methodCtx("compute");
+    const original = function (this: object) { return 99; };
+    Emit("onResult")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onResult: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, () => number>).compute;
+    const result = method.call(instance);
+    expect(result).toBe(99);
+  });
+});
+
+// ── OnCommand ─────────────────────────────────────────────────────────────────
+
+describe("OnCommand decorator", () => {
+  it("subscribes to the command on mount and calls the method when triggered", () => {
+    const { ctx, run } = methodCtx("handleCmd");
+    const handler = vi.fn();
+    OnCommand("myCommand")(handler as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const cmd = createCommand<string>();
+    const instance = new TestComponent({ myCommand: cmd });
+    run(instance);
+
+    instance.onMount?.();
+    cmd.trigger("payload");
+    expect(handler).toHaveBeenCalledWith("payload");
+  });
+
+  it("unsubscribes from the command on unmount", () => {
+    const { ctx, run } = methodCtx("onMsg");
+    const handler = vi.fn();
+    OnCommand("msg")(handler as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const cmd = createCommand<string>();
+    const instance = new TestComponent({ msg: cmd });
+    run(instance);
+
+    instance.onMount?.();
+    instance.onUnmount?.();
+    cmd.trigger("after-unmount");
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("warns when the command prop is not provided", () => {
+    const { ctx, run } = methodCtx("onMissing");
+    OnCommand("missingProp")(vi.fn() as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const instance = new TestComponent(); // no missingProp
+    run(instance);
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    instance.onMount?.();
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("[OnCommand]"));
+    warn.mockRestore();
+  });
+
+  it("warns when the command prop is not a valid Command", () => {
+    const { ctx, run } = methodCtx("onBadCmd");
+    OnCommand("badProp")(vi.fn() as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const instance = new TestComponent({ badProp: "not-a-command" });
+    run(instance);
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    instance.onMount?.();
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("[OnCommand]"));
+    warn.mockRestore();
+  });
+
+  it("preserves the original onMount and onUnmount implementations", () => {
+    const { ctx, run } = methodCtx("onEvt");
+    OnCommand("evt")(vi.fn() as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const cmd = createCommand<void>();
+    const instance = new TestComponent({ evt: cmd });
+    run(instance);
+
+    const mountSpy = vi.fn();
+    const unmountSpy = vi.fn();
+    const prevMount = instance.onMount?.bind(instance);
+    const prevUnmount = instance.onUnmount?.bind(instance);
+    instance.onMount = function () { mountSpy(); prevMount?.(); };
+    instance.onUnmount = function () { unmountSpy(); prevUnmount?.(); };
+
+    instance.onMount();
+    instance.onUnmount();
+    expect(mountSpy).toHaveBeenCalled();
+    expect(unmountSpy).toHaveBeenCalled();
+  });
+});

package/src/__tests__/functions.test.ts

@@ -129,6 +129,73 @@ describe("Retry", () => {
     await expect(wrapped.call({})).rejects.toThrow();
     expect(onRetry).toHaveBeenCalledTimes(2); // attempts 1 and 2, not the last
   });
+
+  it("maxAttempts=1 fails immediately without retrying", async () => {
+    const original = vi.fn(async () => { throw new Error("instant fail"); });
+    const ctx = mockMethodContext("once");
+    const wrapped = Retry(1)(original, ctx as unknown as ClassMethodDecoratorContext);
+
+    await expect(wrapped.call({})).rejects.toThrow("instant fail");
+    expect(original).toHaveBeenCalledTimes(1);
+  });
+
+  it("non-Error throw is wrapped in an Error", async () => {
+    const original = vi.fn(async () => {
+      // eslint-disable-next-line @typescript-eslint/only-throw-error
+      throw "string error";
+    });
+    const ctx = mockMethodContext("strThrow");
+    const wrapped = Retry(1)(original, ctx as unknown as ClassMethodDecoratorContext);
+
+    await expect(wrapped.call({})).rejects.toThrow("string error");
+  });
+
+  it("maxAttempts=0 throws immediately without calling the function", async () => {
+    const original = vi.fn(async () => "ok");
+    const ctx = mockMethodContext("never");
+    const wrapped = Retry(0)(original, ctx as unknown as ClassMethodDecoratorContext);
+
+    await expect(wrapped.call({})).rejects.toThrow("Unknown error");
+    expect(original).not.toHaveBeenCalled();
+  });
+
+  it("onRetry receives the correct attempt number", async () => {
+    const attempts: number[] = [];
+    const original = vi.fn(async () => { throw new Error("fail"); });
+    const ctx = mockMethodContext("numbered");
+    const wrapped = Retry(3, {
+      onRetry: (_err, attempt) => { attempts.push(attempt); },
+    })(original, ctx as unknown as ClassMethodDecoratorContext);
+
+    await expect(wrapped.call({})).rejects.toThrow();
+    expect(attempts).toEqual([1, 2]); // attempt 1 failed → onRetry(1), attempt 2 failed → onRetry(2)
+  });
+
+  it("backoff multiplies delay correctly", async () => {
+    vi.useFakeTimers();
+    const callTimes: number[] = [];
+    const original = vi.fn(async () => {
+      callTimes.push(Date.now());
+      throw new Error("fail");
+    });
+    const ctx = mockMethodContext("backoffTest");
+    const wrapped = Retry(3, { delay: 100, backoff: 2 })(
+      original,
+      ctx as unknown as ClassMethodDecoratorContext,
+    );
+
+    const p = wrapped.call({});
+    const rejection = expect(p).rejects.toThrow("fail");
+    await vi.runAllTimersAsync();
+    await rejection;
+
+    expect(callTimes.length).toBe(3);
+    // Attempt 2 runs 100ms after attempt 1
+    expect(callTimes[1] - callTimes[0]).toBeGreaterThanOrEqual(100);
+    // Attempt 3 runs 200ms after attempt 2 (backoff × 2)
+    expect(callTimes[2] - callTimes[1]).toBeGreaterThanOrEqual(200);
+    vi.useRealTimers();
+  });
 });
 
 // ── Log ──────────────────────────────────────────────────────────────────────
@@ -221,6 +288,66 @@ describe("Log", () => {
   });
 });
 
+// ── Log (additional branches) ─────────────────────────────────────────────────
+
+describe("Log — time option", () => {
+  it("includes elapsed time in sync result log when time=true", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const original = vi.fn(() => "value");
+    const ctx = mockMethodContext("timed");
+    const wrapped = Log({ args: false, result: true, time: true })(
+      original,
+      ctx as unknown as ClassMethodDecoratorContext,
+    );
+
+    class Svc {}
+    wrapped.call(new Svc());
+    // Third argument should be a string containing "ms"
+    expect(spy).toHaveBeenCalledWith(
+      expect.stringContaining("returned:"),
+      "value",
+      expect.stringContaining("ms"),
+    );
+    spy.mockRestore();
+  });
+
+  it("includes elapsed time in async result log when time=true", async () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const original = vi.fn(async () => "async-val");
+    const ctx = mockMethodContext("asyncTimed");
+    const wrapped = Log({ args: false, result: true, time: true })(
+      original,
+      ctx as unknown as ClassMethodDecoratorContext,
+    );
+
+    class Svc {}
+    await wrapped.call(new Svc());
+    expect(spy).toHaveBeenCalledWith(
+      expect.stringContaining("resolved:"),
+      "async-val",
+      expect.stringContaining("ms"),
+    );
+    spy.mockRestore();
+  });
+
+  it("skips result log when result=false", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const original = vi.fn(() => 42);
+    const ctx = mockMethodContext("noResult");
+    const wrapped = Log({ args: false, result: false })(
+      original,
+      ctx as unknown as ClassMethodDecoratorContext,
+    );
+
+    class Svc {}
+    wrapped.call(new Svc());
+    // Should not log a "returned:" line
+    const calls = spy.mock.calls.flat().join(" ");
+    expect(calls).not.toContain("returned:");
+    spy.mockRestore();
+  });
+});
+
 // ── Bind ─────────────────────────────────────────────────────────────────────
 
 describe("Bind", () => {
@@ -286,6 +413,49 @@ describe("Debounce", () => {
     expect(fn).toHaveBeenCalledOnce();
     vi.useRealTimers();
   });
+
+  it("multiple instances have independent timers", () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const ctx = mockMethodContext("act");
+    Debounce(100)(fn, ctx as unknown as ClassMethodDecoratorContext);
+
+    const obj1 = {};
+    const obj2 = {};
+    ctx.runInitializers(obj1);
+    ctx.runInitializers(obj2);
+
+    const m1 = (obj1 as Record<string, (...a: unknown[]) => void>).act;
+    const m2 = (obj2 as Record<string, (...a: unknown[]) => void>).act;
+
+    m1("from-1");
+    m2("from-2");
+
+    vi.advanceTimersByTime(100);
+    // Both timers fire independently
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(fn).toHaveBeenCalledWith("from-1");
+    expect(fn).toHaveBeenCalledWith("from-2");
+    vi.useRealTimers();
+  });
+
+  it("delay=0 fires after the next macrotask", () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const ctx = mockMethodContext("instant");
+    Debounce(0)(fn, ctx as unknown as ClassMethodDecoratorContext);
+
+    const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => void>).instant;
+
+    method("a");
+    expect(fn).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(0);
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith("a");
+    vi.useRealTimers();
+  });
 });
 
 // ── Throttle ─────────────────────────────────────────────────────────────────
@@ -339,4 +509,41 @@ describe("Throttle", () => {
     expect(fn).toHaveBeenCalledTimes(2);
     vi.useRealTimers();
   });
+
+  it("passes the first call's arguments to the underlying function", () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const ctx = mockMethodContext("click");
+    Throttle(100)(fn, ctx as unknown as ClassMethodDecoratorContext);
+
+    const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => void>).click;
+
+    method("first-arg");
+    method("second-arg");
+    expect(fn).toHaveBeenCalledWith("first-arg");
+    vi.useRealTimers();
+  });
+
+  it("multiple instances throttle independently", () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const ctx = mockMethodContext("ping");
+    Throttle(100)(fn, ctx as unknown as ClassMethodDecoratorContext);
+
+    const obj1 = {};
+    const obj2 = {};
+    ctx.runInitializers(obj1);
+    ctx.runInitializers(obj2);
+
+    const m1 = (obj1 as Record<string, (...a: unknown[]) => void>).ping;
+    const m2 = (obj2 as Record<string, (...a: unknown[]) => void>).ping;
+
+    m1("a");
+    m2("b");
+    // Both first calls go through
+    expect(fn).toHaveBeenCalledTimes(2);
+    vi.useRealTimers();
+  });
 });

package/src/__tests__/lazy.test.ts

@@ -0,0 +1,220 @@
+// @vitest-environment jsdom
+import { beforeEach, afterEach, describe, it, expect, vi } from "vitest";
+
+import { StatefulComponent } from "@praxisjs/core";
+import { Lazy } from "../component/lazy";
+
+type AnyConstructor = new (...args: unknown[]) => StatefulComponent;
+
+function applyLazy<T extends AnyConstructor>(cls: T, placeholder?: number): T {
+  return placeholder !== undefined
+    ? Lazy(placeholder)(cls, {} as ClassDecoratorContext)
+    : Lazy()(cls, {} as ClassDecoratorContext);
+}
+
+class BaseComp extends StatefulComponent {
+  render() {
+    return document.createTextNode("content");
+  }
+}
+
+describe("Lazy decorator", () => {
+  let intersectionCallback: IntersectionObserverCallback = () => {};
+  let mockObserve: ReturnType<typeof vi.fn>;
+  let mockDisconnect: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    intersectionCallback = () => {};
+    mockObserve = vi.fn();
+    mockDisconnect = vi.fn();
+
+    globalThis.IntersectionObserver = class {
+      constructor(cb: IntersectionObserverCallback) {
+        intersectionCallback = cb;
+      }
+      observe = mockObserve;
+      disconnect = mockDisconnect;
+    } as unknown as typeof IntersectionObserver;
+  });
+
+  afterEach(() => {
+    // @ts-expect-error – removing test stub
+    delete globalThis.IntersectionObserver;
+  });
+
+  it("returns null from render before visibility", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor);
+    const instance = new Wrapped();
+    expect(instance.render()).toBeNull();
+  });
+
+  it("sets _lazyVisible to true when IntersectionObserver is not supported", () => {
+    // Remove IntersectionObserver to simulate unsupported environment
+    // @ts-expect-error – removing test stub
+    delete globalThis.IntersectionObserver;
+
+    const Wrapped = applyLazy(BaseComp as AnyConstructor);
+    const instance = new Wrapped();
+
+    // Simulate anchor with parent element
+    const parent = document.createElement("div");
+    document.body.appendChild(parent);
+    const anchor = document.createComment("end");
+    parent.appendChild(anchor);
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    instance.onMount?.();
+    // Without IntersectionObserver, _lazyVisible should be set to true
+    const lazyVisible = (instance as unknown as { _lazyVisible: () => boolean })._lazyVisible;
+    expect(lazyVisible()).toBe(true);
+    document.body.removeChild(parent);
+  });
+
+  it("sets minHeight placeholder on mount", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor, 300);
+    const instance = new Wrapped();
+
+    const parent = document.createElement("div");
+    document.body.appendChild(parent);
+    const anchor = document.createComment("end");
+    parent.appendChild(anchor);
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    instance.onMount?.();
+    expect(parent.style.minHeight).toBe("300px");
+    document.body.removeChild(parent);
+  });
+
+  it("sets _lazyVisible and clears minHeight when intersecting", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor, 200);
+    const instance = new Wrapped();
+
+    const parent = document.createElement("div");
+    document.body.appendChild(parent);
+    const anchor = document.createComment("end");
+    parent.appendChild(anchor);
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    instance.onMount?.();
+    expect(instance.render()).toBeNull();
+
+    intersectionCallback(
+      [{ isIntersecting: true } as IntersectionObserverEntry],
+      null as unknown as IntersectionObserver,
+    );
+
+    expect(parent.style.minHeight).toBe("");
+    const lazyVisible = (instance as unknown as { _lazyVisible: () => boolean })._lazyVisible;
+    expect(lazyVisible()).toBe(true);
+    expect(mockDisconnect).toHaveBeenCalled();
+    document.body.removeChild(parent);
+  });
+
+  it("does nothing when _anchor has no parent", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor);
+    const instance = new Wrapped();
+
+    const anchor = document.createComment("end");
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    // Should not throw even though anchor has no parent
+    expect(() => instance.onMount?.()).not.toThrow();
+  });
+
+  it("disconnects observer on unmount", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor);
+    const instance = new Wrapped();
+
+    const parent = document.createElement("div");
+    document.body.appendChild(parent);
+    const anchor = document.createComment("end");
+    parent.appendChild(anchor);
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    instance.onMount?.();
+    instance.onUnmount?.();
+    expect(mockDisconnect).toHaveBeenCalled();
+    document.body.removeChild(parent);
+  });
+
+  it("onMount does nothing when _anchor is undefined", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor);
+    const instance = new Wrapped();
+    // _anchor is undefined by default
+    expect(() => instance.onMount?.()).not.toThrow();
+  });
+
+  it("render() returns original content after becoming visible", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor, 200);
+    const instance = new Wrapped();
+
+    const parent = document.createElement("div");
+    document.body.appendChild(parent);
+    const anchor = document.createComment("end");
+    parent.appendChild(anchor);
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    instance.onMount?.();
+    expect(instance.render()).toBeNull(); // not yet visible
+
+    intersectionCallback(
+      [{ isIntersecting: true } as IntersectionObserverEntry],
+      null as unknown as IntersectionObserver,
+    );
+
+    // Now visible: render() must delegate to the original render()
+    const result = instance.render();
+    expect(result).not.toBeNull();
+    document.body.removeChild(parent);
+  });
+
+  it("observer stays active and minHeight is preserved when entry is not intersecting", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor, 200);
+    const instance = new Wrapped();
+
+    const parent = document.createElement("div");
+    document.body.appendChild(parent);
+    const anchor = document.createComment("end");
+    parent.appendChild(anchor);
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    instance.onMount?.();
+
+    // Fire callback with isIntersecting=false — should be a no-op
+    intersectionCallback(
+      [{ isIntersecting: false } as IntersectionObserverEntry],
+      null as unknown as IntersectionObserver,
+    );
+
+    expect(instance.render()).toBeNull();
+    expect(mockDisconnect).not.toHaveBeenCalled();
+    expect(parent.style.minHeight).toBe("200px");
+    document.body.removeChild(parent);
+  });
+
+  it("does not re-apply minHeight on remount when already visible", () => {
+    const Wrapped = applyLazy(BaseComp as AnyConstructor, 300);
+    const instance = new Wrapped();
+
+    const parent = document.createElement("div");
+    document.body.appendChild(parent);
+    const anchor = document.createComment("end");
+    parent.appendChild(anchor);
+    (instance as unknown as { _anchor: Comment })._anchor = anchor;
+
+    // First mount — become visible
+    instance.onMount?.();
+    intersectionCallback(
+      [{ isIntersecting: true } as IntersectionObserverEntry],
+      null as unknown as IntersectionObserver,
+    );
+    instance.onUnmount?.();
+
+    // Second mount — _lazyVisible is already true
+    instance.onMount?.();
+
+    // minHeight must NOT be re-applied because _lazyVisible() is true
+    expect(parent.style.minHeight).toBe("");
+    document.body.removeChild(parent);
+  });
+});