@multiplatform.one/frappe 6.0.0

package/dist/cjs/frappeReact.spec.cjs

@@ -0,0 +1,531 @@
+var import_vitest = require("vitest");
+var import_react = require("@testing-library/react");
+var import_frappeReact = require("./frappeReact.cjs");
+const {
+  mockSubscribe,
+  mockUnsubscribe,
+  mockGetDocsForSubscription,
+  mockGetPageInfo,
+  mockGetNextBatch,
+  mockSubscribeStore
+} = import_vitest.vi.hoisted(() => ({
+  mockSubscribe: import_vitest.vi.fn(),
+  mockUnsubscribe: import_vitest.vi.fn(),
+  mockGetDocsForSubscription: import_vitest.vi.fn(),
+  mockGetPageInfo: import_vitest.vi.fn(),
+  mockGetNextBatch: import_vitest.vi.fn(),
+  mockSubscribeStore: import_vitest.vi.fn()
+}));
+import_vitest.vi.mock("./sync", () => ({
+  SyncModule: class {
+    subscribe = mockSubscribe;
+    unsubscribe = mockUnsubscribe;
+    getDocsForSubscription = mockGetDocsForSubscription;
+    getPageInfo = mockGetPageInfo;
+    getNextBatch = mockGetNextBatch;
+    subscribeStore = mockSubscribeStore;
+  }
+}));
+import_vitest.vi.mock("./realtime", () => ({
+  RealtimeModule: class {}
+}));
+import_vitest.vi.mock("./core/http", () => ({
+  HttpClient: class {}
+}));
+import_vitest.vi.mock("./db", () => ({
+  DbModule: class {}
+}));
+const {
+  mockCreateFrappeCollection,
+  mockIsBrowser
+} = import_vitest.vi.hoisted(() => ({
+  mockCreateFrappeCollection: import_vitest.vi.fn(),
+  mockIsBrowser: import_vitest.vi.fn(() => true)
+}));
+import_vitest.vi.mock("./collection", () => ({
+  createFrappeCollection: mockCreateFrappeCollection
+}));
+import_vitest.vi.mock("./util", () => ({
+  isBrowser: mockIsBrowser
+}));
+import_vitest.vi.mock("./fixtureDb", () => ({
+  FixtureDbModule: class {}
+}));
+const testDocs = [{
+  name: "doc-1",
+  doctype: "Task",
+  title: "Task 1"
+}, {
+  name: "doc-2",
+  doctype: "Task",
+  title: "Task 2"
+}, {
+  name: "doc-3",
+  doctype: "Task",
+  title: "Task 3"
+}];
+(0, import_vitest.describe)("useFrappeInfiniteList", () => {
+  let storeListener;
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.clearAllMocks();
+    storeListener = void 0;
+    mockSubscribe.mockResolvedValue({
+      subscriptionId: "sub-1",
+      rows: testDocs,
+      checkpoint: "2024-01-01T12:00:00"
+    });
+    mockGetDocsForSubscription.mockReturnValue(testDocs);
+    mockGetPageInfo.mockReturnValue({
+      hasMore: true,
+      currentPage: 1
+    });
+    mockGetNextBatch.mockResolvedValue(testDocs);
+    mockSubscribeStore.mockImplementation(listener => {
+      storeListener = listener;
+      return import_vitest.vi.fn();
+    });
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.restoreAllMocks();
+  });
+  const defaultConfig = {
+    config: {
+      baseURL: "http://test.local"
+    },
+    doctype: "Task",
+    fields: ["name", "title"],
+    pageSize: 20
+  };
+  (0, import_vitest.it)("should subscribe with progressive: true on mount", async () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(mockSubscribe).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+      doctype: "Task",
+      progressive: true,
+      limit: 20
+    }));
+  });
+  (0, import_vitest.it)("should populate items after subscription resolves", async () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(result.current.items).toHaveLength(3);
+    (0, import_vitest.expect)(result.current.items[0].name).toBe("doc-1");
+    (0, import_vitest.expect)(result.current.hasMore).toBe(true);
+  });
+  (0, import_vitest.it)("should set error state on subscribe failure", async () => {
+    mockSubscribe.mockRejectedValueOnce(new Error("Network error"));
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(result.current.error).toBeInstanceOf(Error);
+    (0, import_vitest.expect)(result.current.error.message).toBe("Network error");
+    (0, import_vitest.expect)(result.current.items).toHaveLength(0);
+  });
+  (0, import_vitest.it)("should call getNextBatch on loadMore", async () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    await (0, import_react.act)(async () => {
+      await result.current.loadMore();
+    });
+    (0, import_vitest.expect)(mockGetNextBatch).toHaveBeenCalledWith("sub-1", "doc-3", 20);
+  });
+  (0, import_vitest.it)("should not loadMore when hasMore is false", async () => {
+    mockGetPageInfo.mockReturnValue({
+      hasMore: false,
+      currentPage: 1
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    await (0, import_react.act)(async () => {
+      await result.current.loadMore();
+    });
+    (0, import_vitest.expect)(mockGetNextBatch).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("should unsubscribe on unmount", async () => {
+    const {
+      result,
+      unmount
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    unmount();
+    (0, import_vitest.expect)(mockUnsubscribe).toHaveBeenCalledWith("sub-1");
+  });
+  (0, import_vitest.it)("should update items when store listener fires", async () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    const updatedDocs = [...testDocs, {
+      name: "doc-4",
+      doctype: "Task",
+      title: "Task 4"
+    }];
+    mockGetDocsForSubscription.mockReturnValue(updatedDocs);
+    mockGetPageInfo.mockReturnValue({
+      hasMore: false,
+      currentPage: 1
+    });
+    (0, import_react.act)(() => {
+      storeListener?.();
+    });
+    (0, import_vitest.expect)(result.current.items).toHaveLength(4);
+    (0, import_vitest.expect)(result.current.hasMore).toBe(false);
+  });
+  (0, import_vitest.it)("should apply transform to items", async () => {
+    const config = {
+      ...defaultConfig,
+      transform: doc => ({
+        ...doc,
+        title: doc.title.toUpperCase()
+      })
+    };
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(config));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(result.current.items[0].title).toBe("TASK 1");
+  });
+  (0, import_vitest.it)("should refresh by re-subscribing", async () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    mockSubscribe.mockResolvedValueOnce({
+      subscriptionId: "sub-2",
+      rows: [testDocs[0]],
+      checkpoint: "2024-01-02T12:00:00"
+    });
+    mockGetDocsForSubscription.mockReturnValue([testDocs[0]]);
+    await (0, import_react.act)(async () => {
+      await result.current.refresh();
+    });
+    (0, import_vitest.expect)(mockUnsubscribe).toHaveBeenCalledWith("sub-1");
+    (0, import_vitest.expect)(mockSubscribe).toHaveBeenCalledTimes(2);
+  });
+  (0, import_vitest.it)("should return loading state while subscribing", () => {
+    mockSubscribe.mockReturnValue(new Promise(() => {}));
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(defaultConfig));
+    (0, import_vitest.expect)(result.current.isLoading).toBe(true);
+    (0, import_vitest.expect)(result.current.items).toHaveLength(0);
+  });
+  (0, import_vitest.it)("should not subscribe when config is undefined", () => {
+    const config = {
+      ...defaultConfig,
+      config: void 0
+    };
+    (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeInfiniteList)(config));
+    (0, import_vitest.expect)(mockSubscribe).not.toHaveBeenCalled();
+  });
+});
+(0, import_vitest.describe)("useFrappeCollection", () => {
+  let testNum = 0;
+  const mockCollection = {
+    id: "mock-collection"
+  };
+  (0, import_vitest.beforeEach)(() => {
+    testNum++;
+    import_vitest.vi.clearAllMocks();
+    mockIsBrowser.mockReturnValue(true);
+    mockCreateFrappeCollection.mockReturnValue(mockCollection);
+  });
+  (0, import_vitest.afterEach)(() => {
+    mockIsBrowser.mockReturnValue(true);
+  });
+  (0, import_vitest.it)("returns undefined when config is undefined", () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeCollection)(void 0, "Task"));
+    (0, import_vitest.expect)(result.current).toBeUndefined();
+  });
+  (0, import_vitest.it)("returns undefined during SSR (isBrowser returns false)", () => {
+    mockIsBrowser.mockReturnValue(false);
+    const config = {
+      baseURL: `https://ssr-${testNum}.example.com`
+    };
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeCollection)(config, "Task"));
+    (0, import_vitest.expect)(result.current).toBeUndefined();
+    (0, import_vitest.expect)(mockCreateFrappeCollection).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("creates a collection in a browser environment", () => {
+    const config = {
+      baseURL: `https://browser-${testNum}.example.com`
+    };
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeCollection)(config, "Pokemon"));
+    (0, import_vitest.expect)(mockCreateFrappeCollection).toHaveBeenCalledWith("Pokemon", import_vitest.expect.objectContaining({
+      sync: import_vitest.expect.any(Object)
+    }));
+    (0, import_vitest.expect)(result.current).toBe(mockCollection);
+  });
+  (0, import_vitest.it)("returns the same collection instance on re-render (stable ref)", () => {
+    const config = {
+      baseURL: `https://stable-${testNum}.example.com`
+    };
+    const {
+      result,
+      rerender
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeCollection)(config, "Task"));
+    const first = result.current;
+    rerender();
+    rerender();
+    (0, import_vitest.expect)(result.current).toBe(first);
+    (0, import_vitest.expect)(mockCreateFrappeCollection).toHaveBeenCalledTimes(1);
+  });
+  (0, import_vitest.it)("creates a new collection when baseURL changes", () => {
+    const mockCollection2 = {
+      id: "mock-collection-2"
+    };
+    mockCreateFrappeCollection.mockReturnValueOnce(mockCollection).mockReturnValueOnce(mockCollection2);
+    const {
+      result,
+      rerender
+    } = (0, import_react.renderHook)(({
+      baseURL
+    }) => (0, import_frappeReact.useFrappeCollection)({
+      baseURL
+    }, "Task"), {
+      initialProps: {
+        baseURL: `https://change-a-${testNum}.example.com`
+      }
+    });
+    const first = result.current;
+    rerender({
+      baseURL: `https://change-b-${testNum}.example.com`
+    });
+    (0, import_vitest.expect)(result.current).not.toBe(first);
+    (0, import_vitest.expect)(mockCreateFrappeCollection).toHaveBeenCalledTimes(2);
+  });
+  (0, import_vitest.it)("clears the collection when config becomes undefined", () => {
+    const config = {
+      baseURL: `https://clear-${testNum}.example.com`
+    };
+    const {
+      result,
+      rerender
+    } = (0, import_react.renderHook)(({
+      cfg
+    }) => (0, import_frappeReact.useFrappeCollection)(cfg, "Task"), {
+      initialProps: {
+        cfg: config
+      }
+    });
+    (0, import_vitest.expect)(result.current).toBeDefined();
+    rerender({
+      cfg: void 0
+    });
+    (0, import_vitest.expect)(result.current).toBeUndefined();
+  });
+  (0, import_vitest.it)("__getActiveSyncModule returns a SyncModule after a collection is created", () => {
+    const config = {
+      baseURL: `https://active-${testNum}.example.com`
+    };
+    (0, import_react.renderHook)(() => (0, import_frappeReact.useFrappeCollection)(config, "Task"));
+    const active = (0, import_frappeReact.__getActiveSyncModule)();
+    (0, import_vitest.expect)(active).toBeDefined();
+  });
+});
+(0, import_vitest.describe)("useInfiniteScroll", () => {
+  let ioInstances;
+  function installMockIO() {
+    ioInstances = [];
+    const MockIO = function (cb) {
+      const instance = {
+        observe: import_vitest.vi.fn(),
+        disconnect: import_vitest.vi.fn(),
+        cb
+      };
+      ioInstances.push(instance);
+      this.observe = instance.observe;
+      this.disconnect = instance.disconnect;
+    };
+    import_vitest.vi.stubGlobal("IntersectionObserver", MockIO);
+  }
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.useRealTimers();
+    import_vitest.vi.unstubAllGlobals();
+  });
+  (0, import_vitest.it)("returns correct initial state", () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useInfiniteScroll)({
+      hasMore: true,
+      isLoading: false,
+      onLoadMore: import_vitest.vi.fn()
+    }));
+    (0, import_vitest.expect)(result.current.isVisible).toBe(false);
+    (0, import_vitest.expect)(result.current.isLoadingMore).toBe(false);
+    (0, import_vitest.expect)(typeof result.current.sentinelRef).toBe("function");
+  });
+  (0, import_vitest.it)("does not create IntersectionObserver when enabled=false", async () => {
+    installMockIO();
+    const el = document.createElement("div");
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_frappeReact.useInfiniteScroll)({
+      hasMore: true,
+      isLoading: false,
+      onLoadMore: import_vitest.vi.fn(),
+      enabled: false
+    }));
+    await (0, import_react.act)(async () => {
+      result.current.sentinelRef(el);
+    });
+    (0, import_vitest.expect)(ioInstances).toHaveLength(0);
+  });
+  (0, import_vitest.it)("creates IntersectionObserver and observes element when enabled and sentinel is set", async () => {
+    installMockIO();
+    const el = document.createElement("div");
+    const {
+      result,
+      rerender
+    } = (0, import_react.renderHook)(({
+      enabled
+    }) => (0, import_frappeReact.useInfiniteScroll)({
+      hasMore: true,
+      isLoading: false,
+      onLoadMore: import_vitest.vi.fn(),
+      enabled
+    }), {
+      initialProps: {
+        enabled: false
+      }
+    });
+    await (0, import_react.act)(async () => {
+      result.current.sentinelRef(el);
+    });
+    await (0, import_react.act)(async () => {
+      rerender({
+        enabled: true
+      });
+    });
+    (0, import_vitest.expect)(ioInstances).toHaveLength(1);
+    (0, import_vitest.expect)(ioInstances[0].observe).toHaveBeenCalledWith(el);
+  });
+  (0, import_vitest.it)("calls onLoadMore when intersection fires with hasMore=true", async () => {
+    installMockIO();
+    const onLoadMore = import_vitest.vi.fn().mockResolvedValue(void 0);
+    const el = document.createElement("div");
+    const {
+      result,
+      rerender
+    } = (0, import_react.renderHook)(({
+      enabled
+    }) => (0, import_frappeReact.useInfiniteScroll)({
+      hasMore: true,
+      isLoading: false,
+      onLoadMore,
+      debounceMs: 0,
+      enabled
+    }), {
+      initialProps: {
+        enabled: false
+      }
+    });
+    await (0, import_react.act)(async () => {
+      result.current.sentinelRef(el);
+    });
+    await (0, import_react.act)(async () => {
+      rerender({
+        enabled: true
+      });
+    });
+    (0, import_vitest.expect)(ioInstances).toHaveLength(1);
+    await (0, import_react.act)(async () => {
+      ioInstances[0].cb([{
+        isIntersecting: true
+      }], {});
+    });
+    await (0, import_react.act)(async () => {
+      import_vitest.vi.runAllTimers();
+    });
+    (0, import_vitest.expect)(onLoadMore).toHaveBeenCalledTimes(1);
+  });
+  (0, import_vitest.it)("does not call onLoadMore when hasMore=false", async () => {
+    installMockIO();
+    const onLoadMore = import_vitest.vi.fn();
+    const el = document.createElement("div");
+    const {
+      result,
+      rerender
+    } = (0, import_react.renderHook)(({
+      enabled
+    }) => (0, import_frappeReact.useInfiniteScroll)({
+      hasMore: false,
+      isLoading: false,
+      onLoadMore,
+      debounceMs: 0,
+      enabled
+    }), {
+      initialProps: {
+        enabled: false
+      }
+    });
+    await (0, import_react.act)(async () => {
+      result.current.sentinelRef(el);
+    });
+    await (0, import_react.act)(async () => {
+      rerender({
+        enabled: true
+      });
+    });
+    if (ioInstances.length > 0) {
+      await (0, import_react.act)(async () => {
+        ioInstances[0].cb([{
+          isIntersecting: true
+        }], {});
+      });
+    }
+    await (0, import_react.act)(async () => {
+      import_vitest.vi.runAllTimers();
+    });
+    (0, import_vitest.expect)(onLoadMore).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("disconnects IntersectionObserver on unmount", async () => {
+    installMockIO();
+    const el = document.createElement("div");
+    const {
+      result,
+      rerender,
+      unmount
+    } = (0, import_react.renderHook)(({
+      enabled
+    }) => (0, import_frappeReact.useInfiniteScroll)({
+      hasMore: true,
+      isLoading: false,
+      onLoadMore: import_vitest.vi.fn(),
+      enabled
+    }), {
+      initialProps: {
+        enabled: false
+      }
+    });
+    await (0, import_react.act)(async () => {
+      result.current.sentinelRef(el);
+    });
+    await (0, import_react.act)(async () => {
+      rerender({
+        enabled: true
+      });
+    });
+    unmount();
+    (0, import_vitest.expect)(ioInstances[0].disconnect).toHaveBeenCalled();
+  });
+});