@windstream/react-shared-components 0.1.93 → 0.1.95

package/src/hooks/use-carousel-swipe.test.ts

@@ -0,0 +1,393 @@
+import React from "react";
+import { CarouselSwipeConfig, useCarouselSwipe } from "./use-carousel-swipe";
+
+import { act, renderHook } from "@testing-library/react";
+
+// Helper to create a mock TouchEvent
+function makeTouchEvent(clientX: number): React.TouchEvent {
+  return {
+    touches: [{ clientX }],
+  } as unknown as React.TouchEvent;
+}
+
+describe("useCarouselSwipe", () => {
+  const defaultConfig: CarouselSwipeConfig = {
+    itemCount: 5,
+    enableAutoScroll: false,
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe("Initial state", () => {
+    it("returns currentIndex 0", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("returns swipeOffset 0", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.swipeOffset).toBe(0);
+    });
+
+    it("returns isSwiping false", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.isSwiping).toBe(false);
+    });
+
+    it("returns containerRef", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.containerRef).toBeDefined();
+      expect(result.current.containerRef.current).toBeNull();
+    });
+
+    it("returns default constants", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.constants).toEqual({
+        CARD_OFFSET_PERCENTAGE: 105,
+        SWIPE_THRESHOLD: 0.15,
+        MOBILE_BREAKPOINT: 768,
+        AUTO_SCROLL_INTERVAL: 8000,
+      });
+    });
+
+    it("uses custom constants from config", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 3,
+          cardOffsetPercentage: 110,
+          swipeThreshold: 0.2,
+          mobileBreakpoint: 1024,
+          autoScrollInterval: 5000,
+        })
+      );
+      expect(result.current.constants).toEqual({
+        CARD_OFFSET_PERCENTAGE: 110,
+        SWIPE_THRESHOLD: 0.2,
+        MOBILE_BREAKPOINT: 1024,
+        AUTO_SCROLL_INTERVAL: 5000,
+      });
+    });
+  });
+
+  describe("nextSlide", () => {
+    it("advances to next slide", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.nextSlide());
+      expect(result.current.currentIndex).toBe(1);
+    });
+
+    it("wraps around to 0 from last slide", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      // Go to last slide (index 4)
+      act(() => result.current.goToSlide(4));
+      act(() => result.current.nextSlide());
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("does nothing when itemCount is 0", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({ itemCount: 0, enableAutoScroll: false })
+      );
+      act(() => result.current.nextSlide());
+      expect(result.current.currentIndex).toBe(0);
+    });
+  });
+
+  describe("prevSlide", () => {
+    it("goes to previous slide", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.goToSlide(2));
+      act(() => result.current.prevSlide());
+      expect(result.current.currentIndex).toBe(1);
+    });
+
+    it("wraps to last slide from first slide", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.prevSlide());
+      expect(result.current.currentIndex).toBe(4);
+    });
+
+    it("does nothing when itemCount is 0", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({ itemCount: 0, enableAutoScroll: false })
+      );
+      act(() => result.current.prevSlide());
+      expect(result.current.currentIndex).toBe(0);
+    });
+  });
+
+  describe("goToSlide", () => {
+    it("navigates to specific slide index", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.goToSlide(3));
+      expect(result.current.currentIndex).toBe(3);
+    });
+
+    it("ignores negative index", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.goToSlide(-1));
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("ignores index >= itemCount", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.goToSlide(5));
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("navigates to first slide (index 0)", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.goToSlide(3));
+      act(() => result.current.goToSlide(0));
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("navigates to last valid slide", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.goToSlide(4));
+      expect(result.current.currentIndex).toBe(4);
+    });
+  });
+
+  describe("Touch gesture handling", () => {
+    it("sets isSwiping to true on touch start", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.handleTouchStart(makeTouchEvent(200)));
+      expect(result.current.isSwiping).toBe(true);
+    });
+
+    it("tracks swipe offset during touch move", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.handleTouchStart(makeTouchEvent(200)));
+      act(() => result.current.handleTouchMove(makeTouchEvent(150)));
+      expect(result.current.swipeOffset).toBe(-50);
+    });
+
+    it("does not track move when not swiping", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      // Don't call handleTouchStart, so isSwiping is false
+      act(() => result.current.handleTouchMove(makeTouchEvent(150)));
+      expect(result.current.swipeOffset).toBe(0);
+    });
+
+    it("resets swipeOffset and isSwiping on touch end", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      act(() => result.current.handleTouchStart(makeTouchEvent(200)));
+      act(() => result.current.handleTouchMove(makeTouchEvent(210)));
+      act(() => result.current.handleTouchEnd());
+      expect(result.current.swipeOffset).toBe(0);
+      expect(result.current.isSwiping).toBe(false);
+    });
+
+    it("triggers prevSlide on right swipe exceeding threshold", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({ ...defaultConfig, swipeThreshold: 0.01 })
+      );
+      // Start at slide 2 so prevSlide can go back
+      act(() => result.current.goToSlide(2));
+      act(() => result.current.handleTouchStart(makeTouchEvent(100)));
+      act(() => result.current.handleTouchMove(makeTouchEvent(300)));
+      act(() => result.current.handleTouchEnd());
+      expect(result.current.currentIndex).toBe(1);
+    });
+
+    it("triggers nextSlide on left swipe exceeding threshold", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({ ...defaultConfig, swipeThreshold: 0.01 })
+      );
+      act(() => result.current.handleTouchStart(makeTouchEvent(300)));
+      act(() => result.current.handleTouchMove(makeTouchEvent(100)));
+      act(() => result.current.handleTouchEnd());
+      expect(result.current.currentIndex).toBe(1);
+    });
+
+    it("does not change slide when swipe is below threshold", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({ ...defaultConfig, swipeThreshold: 0.99 })
+      );
+      act(() => result.current.handleTouchStart(makeTouchEvent(200)));
+      act(() => result.current.handleTouchMove(makeTouchEvent(195)));
+      act(() => result.current.handleTouchEnd());
+      expect(result.current.currentIndex).toBe(0);
+    });
+  });
+
+  describe("Auto-scroll", () => {
+    it("auto-scrolls to next slide at configured interval", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 5,
+          enableAutoScroll: true,
+          autoScrollInterval: 3000,
+        })
+      );
+      expect(result.current.currentIndex).toBe(0);
+      act(() => jest.advanceTimersByTime(3000));
+      expect(result.current.currentIndex).toBe(1);
+      act(() => jest.advanceTimersByTime(3000));
+      expect(result.current.currentIndex).toBe(2);
+    });
+
+    it("does not auto-scroll when enableAutoScroll is false", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 5,
+          enableAutoScroll: false,
+          autoScrollInterval: 3000,
+        })
+      );
+      act(() => jest.advanceTimersByTime(10000));
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("does not auto-scroll when autoScrollInterval is 0", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 5,
+          enableAutoScroll: true,
+          autoScrollInterval: 0,
+        })
+      );
+      act(() => jest.advanceTimersByTime(10000));
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("does not auto-scroll when itemCount is 0", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 0,
+          enableAutoScroll: true,
+          autoScrollInterval: 3000,
+        })
+      );
+      act(() => jest.advanceTimersByTime(10000));
+      expect(result.current.currentIndex).toBe(0);
+    });
+
+    it("pauses auto-scroll on touch start", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 5,
+          enableAutoScroll: true,
+          autoScrollInterval: 3000,
+        })
+      );
+      act(() => result.current.handleTouchStart(makeTouchEvent(200)));
+      act(() => jest.advanceTimersByTime(10000));
+      // Should still be at 0 because auto-scroll was paused
+      // (though the initial interval may have already ticked)
+      expect(result.current.isSwiping).toBe(true);
+    });
+
+    it("restarts auto-scroll after touch end when enabled", () => {
+      const { result } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 5,
+          enableAutoScroll: true,
+          autoScrollInterval: 3000,
+        })
+      );
+      // Touch interaction
+      act(() => result.current.handleTouchStart(makeTouchEvent(200)));
+      act(() => result.current.handleTouchEnd());
+      // After touch end, auto-scroll should restart
+      act(() => jest.advanceTimersByTime(3000));
+      expect(result.current.currentIndex).toBeGreaterThan(0);
+    });
+
+    it("cleans up interval on unmount", () => {
+      const clearIntervalSpy = jest.spyOn(global, "clearInterval");
+      const { unmount } = renderHook(() =>
+        useCarouselSwipe({
+          itemCount: 5,
+          enableAutoScroll: true,
+          autoScrollInterval: 3000,
+        })
+      );
+      unmount();
+      expect(clearIntervalSpy).toHaveBeenCalled();
+      clearIntervalSpy.mockRestore();
+    });
+  });
+
+  describe("Responsive behavior", () => {
+    it("detects mobile viewport", () => {
+      Object.defineProperty(window, "innerWidth", {
+        writable: true,
+        value: 500,
+      });
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.isMobile).toBe(true);
+    });
+
+    it("detects desktop viewport", () => {
+      Object.defineProperty(window, "innerWidth", {
+        writable: true,
+        value: 1024,
+      });
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.isMobile).toBe(false);
+    });
+
+    it("updates isMobile on resize", () => {
+      Object.defineProperty(window, "innerWidth", {
+        writable: true,
+        value: 1024,
+      });
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      expect(result.current.isMobile).toBe(false);
+
+      act(() => {
+        Object.defineProperty(window, "innerWidth", {
+          writable: true,
+          value: 500,
+        });
+        window.dispatchEvent(new Event("resize"));
+      });
+      expect(result.current.isMobile).toBe(true);
+    });
+
+    it("updates containerWidth on resize", () => {
+      const { result } = renderHook(() => useCarouselSwipe(defaultConfig));
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const initialWidth = result.current.containerWidth;
+      act(() => {
+        Object.defineProperty(window, "innerWidth", {
+          writable: true,
+          value: 800,
+        });
+        window.dispatchEvent(new Event("resize"));
+      });
+      // containerRef is null so falls back to window.innerWidth
+      expect(result.current.containerWidth).toBe(800);
+    });
+
+    it("uses custom mobileBreakpoint", () => {
+      Object.defineProperty(window, "innerWidth", {
+        writable: true,
+        value: 900,
+      });
+      const { result } = renderHook(() =>
+        useCarouselSwipe({ ...defaultConfig, mobileBreakpoint: 1024 })
+      );
+      expect(result.current.isMobile).toBe(true);
+    });
+
+    it("removes resize listeners on unmount", () => {
+      const removeEventListenerSpy = jest.spyOn(window, "removeEventListener");
+      const { unmount } = renderHook(() => useCarouselSwipe(defaultConfig));
+      unmount();
+      const resizeCalls = removeEventListenerSpy.mock.calls.filter(
+        call => call[0] === "resize"
+      );
+      expect(resizeCalls.length).toBeGreaterThanOrEqual(2); // containerWidth + isMobile
+      removeEventListenerSpy.mockRestore();
+    });
+  });
+});

package/src/hooks/use-outside-click.test.ts

@@ -0,0 +1,142 @@
+import React from "react";
+import { useOutsideClick } from "./use-outside-click";
+
+import { renderHook } from "@testing-library/react";
+
+describe("useOutsideClick", () => {
+  let callback: jest.Mock;
+
+  beforeEach(() => {
+    callback = jest.fn();
+  });
+
+  describe("Event listener lifecycle", () => {
+    it("adds click event listener on mount", () => {
+      const addSpy = jest.spyOn(document, "addEventListener");
+      const ref = { current: document.createElement("div") };
+      renderHook(() => useOutsideClick(ref, callback));
+      const clickCalls = addSpy.mock.calls.filter(c => c[0] === "click");
+      expect(clickCalls.length).toBeGreaterThanOrEqual(1);
+      addSpy.mockRestore();
+    });
+
+    it("removes click event listener on unmount", () => {
+      const removeSpy = jest.spyOn(document, "removeEventListener");
+      const ref = { current: document.createElement("div") };
+      const { unmount } = renderHook(() => useOutsideClick(ref, callback));
+      unmount();
+      const clickCalls = removeSpy.mock.calls.filter(c => c[0] === "click");
+      expect(clickCalls.length).toBeGreaterThanOrEqual(1);
+      removeSpy.mockRestore();
+    });
+  });
+
+  describe("Click detection", () => {
+    it("calls callback when clicking outside the ref element", () => {
+      const inside = document.createElement("div");
+      const outside = document.createElement("button");
+      document.body.appendChild(inside);
+      document.body.appendChild(outside);
+
+      const ref = { current: inside };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      outside.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      document.body.removeChild(inside);
+      document.body.removeChild(outside);
+    });
+
+    it("does not call callback when clicking inside the ref element", () => {
+      const container = document.createElement("div");
+      const child = document.createElement("span");
+      container.appendChild(child);
+      document.body.appendChild(container);
+
+      const ref = { current: container };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      child.click();
+      expect(callback).not.toHaveBeenCalled();
+
+      document.body.removeChild(container);
+    });
+
+    it("does not call callback when clicking on the ref element itself", () => {
+      const el = document.createElement("div");
+      document.body.appendChild(el);
+
+      const ref = { current: el };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      el.click();
+      expect(callback).not.toHaveBeenCalled();
+
+      document.body.removeChild(el);
+    });
+
+    it("calls callback when ref.current is null", () => {
+      const ref = { current: null } as React.RefObject<any>;
+      renderHook(() => useOutsideClick(ref, callback));
+
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("calls callback when ref is undefined-like", () => {
+      const ref = {} as React.RefObject<any>;
+      renderHook(() => useOutsideClick(ref, callback));
+
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("calls callback when ref is null", () => {
+      renderHook(() => useOutsideClick(null as any, callback));
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("Multiple clicks", () => {
+    it("calls callback for each outside click", () => {
+      const inside = document.createElement("div");
+      document.body.appendChild(inside);
+
+      const ref = { current: inside };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      document.body.click();
+      document.body.click();
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(3);
+
+      document.body.removeChild(inside);
+    });
+  });
+
+  describe("Re-render behavior", () => {
+    it("updates listener on re-render with new callback", () => {
+      const el = document.createElement("div");
+      document.body.appendChild(el);
+
+      const callback1 = jest.fn();
+      const callback2 = jest.fn();
+      const ref = { current: el };
+
+      const { rerender } = renderHook(({ cb }) => useOutsideClick(ref, cb), {
+        initialProps: { cb: callback1 },
+      });
+
+      document.body.click();
+      expect(callback1).toHaveBeenCalledTimes(1);
+
+      rerender({ cb: callback2 });
+      document.body.click();
+      expect(callback2).toHaveBeenCalledTimes(1);
+
+      document.body.removeChild(el);
+    });
+  });
+});

package/src/index.ts

@@ -60,7 +60,7 @@ export type {
 } from "./components/brand-button";
 
 export { Checklist } from "./components/checklist";
-export type { ChecklistProps } from "./components/checklist";
+export type { ChecklistItem, ChecklistProps } from "./components/checklist";
 
 export { Collapse } from "./components/collapse";
 export type { CollapsibleProps } from "./components/collapse";

package/src/next/index.test.ts

@@ -0,0 +1,7 @@
+import * as NextExports from "./index";
+
+describe("next barrel exports", () => {
+  it("exports NextImage component", () => {
+    expect(NextExports.NextImage).toBeDefined();
+  });
+});

package/src/setupTests.ts

@@ -3,43 +3,49 @@ import "@testing-library/jest-dom";
 // Mock window.matchMedia
 Object.defineProperty(window, "matchMedia", {
   writable: true,
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
   value: (query: string) => ({
     matches: false,
     media: query,
     onchange: null,
-    addListener: () => {}, // deprecated
-    removeListener: () => {}, // deprecated
-    addEventListener: () => {},
-    removeEventListener: () => {},
+    addListener: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+    removeListener: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+    addEventListener: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+    removeEventListener: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
     dispatchEvent: () => true,
   }),
 });
 
 // Mock ResizeObserver
+// eslint-disable-next-line no-undef, @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
 global.ResizeObserver = class ResizeObserver {
-  observe = () => {};
-  unobserve = () => {};
-  disconnect = () => {};
+  observe = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function
+  unobserve = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function
+  disconnect = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function
+  // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars, no-undef
   constructor(_callback: ResizeObserverCallback) {}
 } as unknown as typeof ResizeObserver;
 
 // Mock IntersectionObserver
+// eslint-disable-next-line no-undef, @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
 global.IntersectionObserver = class IntersectionObserver {
-  observe = () => {};
-  unobserve = () => {};
-  disconnect = () => {};
+  observe = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function
+  unobserve = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function
+  disconnect = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function
+  // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars, no-undef
   constructor(_callback: IntersectionObserverCallback) {}
 } as unknown as typeof IntersectionObserver;
 
 // Mock scrollTo
 Object.defineProperty(window, "scrollTo", {
   writable: true,
-  value: () => {},
+  value: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
 });
 
 // Mock getComputedStyle
 Object.defineProperty(window, "getComputedStyle", {
   writable: true,
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
   value: () => ({
     getPropertyValue: () => "",
   }),

package/src/utils/contentful/to-document.test.ts

@@ -0,0 +1,85 @@
+import { toDocument } from "./to-document";
+
+import { BLOCKS, type Document } from "@contentful/rich-text-types";
+
+const makeDocument = (text = "Hello"): Document => ({
+  nodeType: BLOCKS.DOCUMENT,
+  data: {},
+  content: [
+    {
+      nodeType: BLOCKS.PARAGRAPH,
+      data: {},
+      content: [{ nodeType: "text", value: text, marks: [], data: {} }],
+    },
+  ],
+});
+
+describe("toDocument", () => {
+  // ── Falsy inputs ─────────────────────────────────────
+  it("returns null for null", () => {
+    expect(toDocument(null)).toBeNull();
+  });
+
+  it("returns null for undefined", () => {
+    expect(toDocument(undefined)).toBeNull();
+  });
+
+  it("returns null for empty string", () => {
+    expect(toDocument("")).toBeNull();
+  });
+
+  it("returns null for 0", () => {
+    expect(toDocument(0)).toBeNull();
+  });
+
+  it("returns null for false", () => {
+    expect(toDocument(false)).toBeNull();
+  });
+
+  // ── REST/CDA Document ────────────────────────────────
+  it("returns Document directly when given a valid REST Document", () => {
+    const doc = makeDocument();
+    expect(toDocument(doc)).toBe(doc);
+  });
+
+  // ── GraphQL RichText { json: Document } ──────────────
+  it("extracts Document from GraphQL format { json, links }", () => {
+    const doc = makeDocument("GraphQL");
+    const graphql = { json: doc, links: { assets: [] } };
+    expect(toDocument(graphql)).toBe(doc);
+  });
+
+  it("extracts Document from GraphQL format without links", () => {
+    const doc = makeDocument("NoLinks");
+    expect(toDocument({ json: doc })).toBe(doc);
+  });
+
+  it("returns null when json property is not a valid Document", () => {
+    expect(toDocument({ json: "not-a-document" })).toBeNull();
+  });
+
+  it("returns null when json property is null", () => {
+    expect(toDocument({ json: null })).toBeNull();
+  });
+
+  // ── Non-matching objects ─────────────────────────────
+  it("returns null for an object without nodeType or json", () => {
+    expect(toDocument({ foo: "bar" })).toBeNull();
+  });
+
+  it("returns null for an object with nodeType but no content", () => {
+    expect(toDocument({ nodeType: BLOCKS.DOCUMENT })).toBeNull();
+  });
+
+  it("returns null for an array", () => {
+    expect(toDocument([1, 2, 3])).toBeNull();
+  });
+
+  it("returns null for a number", () => {
+    expect(toDocument(42)).toBeNull();
+  });
+
+  it("returns null for a non-empty string", () => {
+    expect(toDocument("hello")).toBeNull();
+  });
+});