@fictjs/testing-library 0.2.2 → 0.3.0

package/dist/index.cjs

@@ -1 +1,503 @@
 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  act: () => act,
+  cleanup: () => cleanup,
+  createTestSuspenseToken: () => createTestSuspenseToken,
+  flush: () => flush,
+  prettyDOM: () => import_dom.prettyDOM,
+  queries: () => import_dom.queries,
+  render: () => render,
+  renderHook: () => renderHook,
+  renderWithErrorBoundary: () => renderWithErrorBoundary,
+  renderWithSuspense: () => renderWithSuspense,
+  testEffect: () => testEffect,
+  waitForCondition: () => waitForCondition
+});
+module.exports = __toCommonJS(index_exports);
+var import_runtime = require("@fictjs/runtime");
+var import_advanced = require("@fictjs/runtime/advanced");
+var import_internal = require("@fictjs/runtime/internal");
+var import_dom = require("@testing-library/dom");
+__reExport(index_exports, require("@testing-library/dom"), module.exports);
+var mountedContainers = /* @__PURE__ */ new Set();
+var mountedHookRoots = /* @__PURE__ */ new Set();
+if (typeof process === "undefined" || !process.env?.FICT_TL_SKIP_AUTO_CLEANUP) {
+  const globalAfterEach = globalThis.afterEach;
+  if (typeof globalAfterEach === "function") {
+    globalAfterEach(() => {
+      cleanup();
+    });
+  }
+}
+function render(view, options = {}) {
+  const {
+    container: providedContainer,
+    baseElement: providedBaseElement,
+    queries: customQueries,
+    wrapper
+  } = options;
+  let container = providedContainer;
+  let baseElement = providedBaseElement;
+  let ownedContainer = false;
+  if (!baseElement) {
+    baseElement = container ?? document.body;
+  }
+  if (!container) {
+    container = baseElement.appendChild(document.createElement("div"));
+    ownedContainer = true;
+  }
+  let wrappedView = view;
+  if (wrapper) {
+    const Wrapper = wrapper;
+    wrappedView = () => {
+      const children = view();
+      return (0, import_runtime.createElement)({ type: Wrapper, props: { children } });
+    };
+  }
+  let currentTeardown = null;
+  const teardown = (0, import_runtime.render)(wrappedView, container);
+  currentTeardown = teardown;
+  const ref = { container, baseElement, ownedContainer, teardown };
+  mountedContainers.add(ref);
+  const queryHelpers = (0, import_dom.getQueriesForElement)(container, customQueries);
+  const debug = (el = baseElement, maxLength, debugOptions) => {
+    if (Array.isArray(el)) {
+      el.forEach((e) => console.log((0, import_dom.prettyDOM)(e, maxLength, debugOptions)));
+    } else {
+      console.log((0, import_dom.prettyDOM)(el, maxLength, debugOptions));
+    }
+  };
+  const unmount = () => {
+    if (currentTeardown) {
+      currentTeardown();
+      currentTeardown = null;
+    }
+    if (ownedContainer && container?.parentNode) {
+      container.parentNode.removeChild(container);
+    }
+    mountedContainers.delete(ref);
+  };
+  const rerender = (newView) => {
+    if (currentTeardown) {
+      currentTeardown();
+    }
+    let wrappedNewView = newView;
+    if (wrapper) {
+      const Wrapper = wrapper;
+      wrappedNewView = () => {
+        const children = newView();
+        return (0, import_runtime.createElement)({ type: Wrapper, props: { children } });
+      };
+    }
+    currentTeardown = (0, import_runtime.render)(wrappedNewView, container);
+    ref.teardown = currentTeardown;
+  };
+  return {
+    asFragment: () => container?.innerHTML ?? "",
+    container,
+    baseElement,
+    debug,
+    unmount,
+    rerender,
+    ...queryHelpers
+  };
+}
+function cleanupAtContainer(ref) {
+  const { container, teardown, ownedContainer } = ref;
+  if (typeof teardown === "function") {
+    teardown();
+  } else if (typeof teardown !== "undefined") {
+    console.warn(
+      "[@fictjs/testing-library] Expected teardown to be a function. This might indicate a version mismatch between @fictjs/runtime and @fictjs/testing-library."
+    );
+  }
+  if (ownedContainer && container?.parentNode) {
+    container.parentNode.removeChild(container);
+  }
+  mountedContainers.delete(ref);
+}
+function cleanup() {
+  mountedContainers.forEach(cleanupAtContainer);
+  mountedHookRoots.forEach((dispose) => {
+    try {
+      dispose();
+    } catch (err) {
+      console.error("[fict/testing-library] Error during hook cleanup:", err);
+    }
+  });
+  mountedHookRoots.clear();
+}
+function renderHook(hookFn, options = {}) {
+  let initialProps;
+  let wrapper;
+  if (Array.isArray(options)) {
+    initialProps = options;
+  } else {
+    initialProps = options.initialProps;
+    wrapper = options.wrapper;
+  }
+  const resultContainer = { current: void 0 };
+  let currentProps = initialProps ?? [];
+  let disposeRoot = null;
+  let registeredDispose = null;
+  const registerDispose = (dispose) => {
+    if (registeredDispose) {
+      mountedHookRoots.delete(registeredDispose);
+    }
+    registeredDispose = dispose;
+    mountedHookRoots.add(dispose);
+  };
+  const executeHook = () => {
+    const { dispose, value } = (0, import_runtime.createRoot)(() => {
+      let hookResult;
+      if (wrapper) {
+        const Wrapper = wrapper;
+        (0, import_runtime.createElement)({
+          type: Wrapper,
+          props: {
+            children: (() => {
+              (0, import_internal.__fictPushContext)();
+              try {
+                hookResult = hookFn(...currentProps);
+              } finally {
+                (0, import_internal.__fictPopContext)();
+              }
+              return null;
+            })()
+          }
+        });
+      } else {
+        (0, import_internal.__fictPushContext)();
+        try {
+          hookResult = hookFn(...currentProps);
+        } finally {
+          (0, import_internal.__fictPopContext)();
+        }
+      }
+      return hookResult;
+    });
+    disposeRoot = dispose;
+    registerDispose(dispose);
+    resultContainer.current = value;
+    return value;
+  };
+  executeHook();
+  const rerender = (newProps) => {
+    if (disposeRoot) {
+      disposeRoot();
+    }
+    if (newProps !== void 0) {
+      currentProps = newProps;
+    }
+    executeHook();
+  };
+  const cleanupHook = () => {
+    if (disposeRoot) {
+      disposeRoot();
+      disposeRoot = null;
+    }
+    if (registeredDispose) {
+      mountedHookRoots.delete(registeredDispose);
+      registeredDispose = null;
+    }
+  };
+  return {
+    result: resultContainer,
+    rerender,
+    cleanup: cleanupHook,
+    unmount: cleanupHook
+  };
+}
+function testEffect(fn) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let resolveScheduled = false;
+    let disposed = false;
+    const disposeRef = { current: null };
+    const scheduleDispose = () => {
+      if (disposed) return;
+      queueMicrotask(() => {
+        if (disposed) return;
+        disposed = true;
+        disposeRef.current?.();
+      });
+    };
+    const reportError = (err) => {
+      if (settled) {
+        queueMicrotask(() => {
+          throw err;
+        });
+        return;
+      }
+      settled = true;
+      reject(err);
+      scheduleDispose();
+    };
+    const scheduleResolve = (result) => {
+      if (settled || resolveScheduled) return;
+      resolveScheduled = true;
+      queueMicrotask(() => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+        scheduleDispose();
+      });
+    };
+    const root = (0, import_runtime.createRoot)(() => {
+      (0, import_advanced.registerErrorHandler)((err) => {
+        reportError(err);
+        return true;
+      });
+      try {
+        fn((result) => {
+          scheduleResolve(result);
+        });
+      } catch (err) {
+        reportError(err);
+      }
+    });
+    disposeRef.current = root.dispose;
+  });
+}
+function waitForCondition(condition, options = {}) {
+  const { timeout = 1e3, interval = 50 } = options;
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const check = () => {
+      if (condition()) {
+        resolve();
+        return;
+      }
+      if (Date.now() - startTime >= timeout) {
+        reject(new Error(`waitForCondition timed out after ${timeout}ms`));
+        return;
+      }
+      setTimeout(check, interval);
+    };
+    check();
+  });
+}
+function flush() {
+  return new Promise((resolve) => queueMicrotask(resolve));
+}
+async function act(fn) {
+  try {
+    const result = await fn();
+    await flush();
+    await flush();
+    return result;
+  } catch (err) {
+    await flush();
+    await flush();
+    throw err;
+  }
+}
+function renderWithErrorBoundary(view, options = {}) {
+  const {
+    fallback = (0, import_runtime.createElement)({
+      type: "div",
+      props: { "data-testid": "error-fallback", children: "Error occurred" }
+    }),
+    onError,
+    resetKeys,
+    ...renderOptions
+  } = options;
+  let hasError = false;
+  let resetFn;
+  let _currentError = null;
+  const wrappedFallback = (err, reset) => {
+    hasError = true;
+    _currentError = err;
+    resetFn = reset;
+    if (typeof fallback === "function") {
+      return fallback(err, reset);
+    }
+    return fallback;
+  };
+  const ErrorBoundaryComponent = import_runtime.ErrorBoundary;
+  const wrapView = (nextView) => {
+    return () => {
+      const ViewComponent = () => nextView();
+      return (0, import_runtime.createElement)({
+        type: ErrorBoundaryComponent,
+        props: {
+          fallback: wrappedFallback,
+          onError: (err) => {
+            hasError = true;
+            _currentError = err;
+            onError?.(err);
+          },
+          resetKeys,
+          children: {
+            type: ViewComponent,
+            props: {},
+            key: void 0
+          }
+        }
+      });
+    };
+  };
+  const result = render(wrapView(view), renderOptions);
+  return {
+    ...result,
+    triggerError: (error) => {
+      hasError = true;
+      _currentError = error;
+      const Thrower = () => {
+        throw error;
+      };
+      result.rerender(
+        wrapView(() => ({
+          type: Thrower,
+          props: {},
+          key: void 0
+        }))
+      );
+    },
+    resetErrorBoundary: () => {
+      hasError = false;
+      _currentError = null;
+      if (resetFn) {
+        try {
+          resetFn();
+        } catch (err) {
+          onError?.(err);
+        }
+      }
+    },
+    isShowingFallback: () => hasError,
+    rerender: (nextView) => {
+      hasError = false;
+      _currentError = null;
+      resetFn = void 0;
+      result.rerender(wrapView(nextView));
+    }
+  };
+}
+function createTestSuspenseToken() {
+  const handle = (0, import_runtime.createSuspenseToken)();
+  return {
+    // Cast to match the TestSuspenseHandle type
+    token: handle.token,
+    resolve: handle.resolve,
+    reject: handle.reject
+  };
+}
+function renderWithSuspense(view, options = {}) {
+  const {
+    fallback = (0, import_runtime.createElement)({
+      type: "div",
+      props: { "data-testid": "suspense-fallback", children: "Loading..." }
+    }),
+    onResolve,
+    onReject,
+    resetKeys,
+    ...renderOptions
+  } = options;
+  let isSuspended = false;
+  let isResolved = true;
+  let resolveWaiters = [];
+  const wrappedFallback = (err) => {
+    isSuspended = true;
+    isResolved = false;
+    if (typeof fallback === "function") {
+      return fallback(err);
+    }
+    return fallback;
+  };
+  const SuspenseComponent = import_runtime.Suspense;
+  const wrapView = (nextView) => {
+    return () => {
+      if (onReject) {
+        (0, import_advanced.registerErrorHandler)(() => true);
+      }
+      const ViewComponent = () => nextView();
+      return (0, import_runtime.createElement)({
+        type: SuspenseComponent,
+        props: {
+          fallback: wrappedFallback,
+          onResolve: () => {
+            isSuspended = false;
+            isResolved = true;
+            onResolve?.();
+            resolveWaiters.forEach((waiter) => waiter());
+            resolveWaiters = [];
+          },
+          onReject: (err) => {
+            isSuspended = false;
+            onReject?.(err);
+          },
+          resetKeys,
+          children: {
+            type: ViewComponent,
+            props: {},
+            key: void 0
+          }
+        }
+      });
+    };
+  };
+  const result = render(wrapView(view), renderOptions);
+  return {
+    ...result,
+    isShowingFallback: () => {
+      const fallbackEl = result.container.querySelector('[data-testid="suspense-fallback"]');
+      return !!fallbackEl || isSuspended;
+    },
+    waitForResolution: (waitOptions) => {
+      const { timeout = 5e3 } = waitOptions ?? {};
+      if (isResolved && !isSuspended) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(new Error(`Suspense did not resolve within ${timeout}ms`));
+        }, timeout);
+        resolveWaiters.push(() => {
+          clearTimeout(timeoutId);
+          resolve();
+        });
+      });
+    },
+    rerender: (nextView) => {
+      result.rerender(wrapView(nextView));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  act,
+  cleanup,
+  createTestSuspenseToken,
+  flush,
+  prettyDOM,
+  queries,
+  render,
+  renderHook,
+  renderWithErrorBoundary,
+  renderWithSuspense,
+  testEffect,
+  waitForCondition,
+  ...require("@testing-library/dom")
+});