@lifeart/gxt/dist/gxt.utils.es.js

<img align="right" width="95" height="95" alt="Philosopher’s stone, logo of PostCSS" src="./public/logo.png">

import { r as renderComponent, F as getRoot, j as $args, am as $context, ae as RENDERED_NODES_PROPERTY, h as $template, ax as getDocument, b as runDestructors, I as resetNodeCounter, D as resetRoot, ay as withRehydration, B as createRoot, E as setRoot } from './reactive-CVZF9xBs.js';

async function renderInBrowser(componentRenderFn) {
  const doc = getDocument();
  const rootNode = doc.createElement("div");
  renderComponent({
    // @ts-expect-error typings error
    [$args]: {
      [$context]: getRoot()
    },
    [RENDERED_NODES_PROPERTY]: [],
    [$template]: function() {
      return new componentRenderFn(...arguments);
    }
  }, rootNode, getRoot());
  const html = rootNode.innerHTML;
  rootNode.remove();
  return html;
}

async function cleanupRender() {
  const root = getRoot();
  if (root) {
    await Promise.all(runDestructors(root));
  }
  resetNodeCounter();
  resetRoot();
}
function rehydrate(component) {
  withRehydration(component, renderTarget());
}
async function ssr(component) {
  if (getRoot()) {
    throw new Error("Root already exists");
  }
  resetNodeCounter();
  let root = createRoot();
  setRoot(root);
  const content = await renderInBrowser(component);
  renderTarget().innerHTML = content;
  await Promise.all(runDestructors(root));
  resetNodeCounter();
  resetRoot();
}
function renderTarget() {
  return getDocument().getElementById("ember-testing");
}
async function render(component) {
  const targetElement = getDocument().getElementById("ember-testing");
  if (getRoot()) {
    await cleanupRender();
  }
  if (targetElement.childNodes.length) {
    console.warn("testing container not empty, force cleanup");
    console.info(targetElement.innerHTML);
    targetElement.innerHTML = "";
  }
  const owner = createRoot();
  setRoot(owner);
  let renderResult = renderComponent({
    // @ts-expect-error typings mismatch
    [$args]: {
      [$context]: owner
    },
    template: component
  }, targetElement, owner, false);
  await rerender();
  if (!getRoot()) {
    throw new Error("Root does not exist");
  }
  return renderResult;
}
async function rerender(timeout = 16) {
  return new Promise((resolve) => {
    setTimeout(resolve, timeout);
  });
}
function find(selector) {
  const element = getDocument().getElementById("ember-testing").querySelector(selector);
  return element;
}
async function click(selector) {
  const element = find(selector);
  if (!element) {
    throw new Error(`Unable to find DOM element matching selector: ${selector}`);
  }
  const event = new MouseEvent("click", {
    view: window,
    bubbles: true,
    cancelable: true
  });
  element.dispatchEvent(event);
  await rerender();
}
function step(message) {
  QUnit.assert.pushResult({
    message: `[Step] ${message}`,
    result: true,
    expected: true,
    actual: true
  });
}

export { cleanupRender, click, find, rehydrate, render, renderTarget, rerender, ssr, step };