Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

5.0 KB
Raw Blame
import { act } from "react-dom/test-utils";
import { createRoot, type Root } from "react-dom/client";
import { EditorSelection } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, expect, test, vi } from "vitest";
import { userEvent } from "@vitest/browser/context";
import { cssVar } from "@webstudio-is/design-system";
import "@webstudio-is/design-system/global.css";
import {
  EditorContent,
  EditorDialogButton,
  EditorDialogControl,
} from "./code-editor-base";

(
  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;

let container: HTMLDivElement;
let root: Root;
const rangeGetClientRects = Object.getOwnPropertyDescriptor(
  Range.prototype,
  "getClientRects"
);

beforeEach(() => {
  vi.stubGlobal(
    "ResizeObserver",
    class {
      observe() {}
      unobserve() {}
      disconnect() {}
    }
  );
  Object.defineProperty(Range.prototype, "getClientRects", {
    configurable: true,
    value: () => [new DOMRect(0, 0, 20, 16)],
  });
  container = document.createElement("div");
  document.body.appendChild(container);
  root = createRoot(container);
});

afterEach(() => {
  act(() => root.unmount());
  container.remove();
  document.documentElement.removeAttribute("data-color-scheme");
  vi.unstubAllGlobals();
  if (rangeGetClientRects === undefined) {
    delete (Range.prototype as { getClientRects?: unknown }).getClientRects;
  } else {
    Object.defineProperty(
      Range.prototype,
      "getClientRects",
      rangeGetClientRects
    );
  }
});

test.each(["light", "dark"] as const)(
  "uses the shared selection color in %s mode",
  async (mode) => {
    document.documentElement.dataset.colorScheme = mode;
    act(() => {
      root.render(
        <EditorContent
          value="selected text"
          onChange={() => {}}
          onChangeComplete={() => {}}
        />
      );
    });

    const editor = container.querySelector<HTMLElement>('[role="textbox"]');
    if (editor === null) {
      throw new Error("Expected the code editor");
    }
    const view = EditorView.findFromDOM(editor);
    if (view === null) {
      throw new Error("Expected the CodeMirror view");
    }
    act(() => {
      view.dispatch({
        selection: EditorSelection.range(0, view.state.doc.length),
      });
      view.focus();
    });
    await act(
      () =>
        new Promise<void>((resolve) =>
          requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
        )
    );

    const selection = container.querySelector<HTMLElement>(
      ".cm-selectionBackground"
    );
    if (selection === null) {
      throw new Error("Expected a rendered selection");
    }
    const reference = document.createElement("span");
    reference.style.background = cssVar("--background-text-selection");
    reference.style.color = "var(--foreground-on-text-selection)";
    document.body.appendChild(reference);

    const selectionColor = getComputedStyle(selection).backgroundColor;
    const referenceColor = getComputedStyle(reference).backgroundColor;
    const content = container.querySelector<HTMLElement>(".cm-content");
    if (content === null) {
      throw new Error("Expected editor content");
    }
    const selectedTextColor = getComputedStyle(content, "::selection").color;
    const referenceTextColor = getComputedStyle(reference).color;
    reference.remove();
    expect(selectionColor).toBe(referenceColor);
    expect(selectedTextColor).toBe(referenceTextColor);
  }
);

test("scopes disabled styles to the Webstudio code editor", () => {
  act(() => {
    root.render(
      <fieldset disabled>
        <EditorContent
          value="disabled editor"
          onChange={() => {}}
          onChangeComplete={() => {}}
        />
        <div className="cm-editor" data-foreign-editor />
      </fieldset>
    );
  });

  const editors = container.querySelectorAll<HTMLElement>(".cm-editor");
  const foreignEditor = container.querySelector<HTMLElement>(
    "[data-foreign-editor]"
  );
  if (editors[0] === undefined || foreignEditor === null) {
    throw new Error("Expected both code editors");
  }

  expect(getComputedStyle(editors[0]).opacity).toBe("0.3");
  expect(getComputedStyle(foreignEditor).opacity).toBe("1");
});

test("keeps the editor maximize button background transparent when hovered", async () => {
  act(() => {
    root.render(
      <div style={{ width: 320, height: 160 }}>
        <EditorDialogControl>
          <EditorContent
            value="editor content"
            onChange={() => {}}
            onChangeComplete={() => {}}
          />
          <EditorDialogButton aria-label="Expand" />
        </EditorDialogControl>
      </div>
    );
  });

  const maximizeButton = container.querySelector<HTMLButtonElement>(
    '[aria-label="Expand"]'
  );
  if (maximizeButton === null) {
    throw new Error("Expected the maximize button");
  }
  await userEvent.hover(maximizeButton.parentElement!);
  await userEvent.hover(maximizeButton);
  expect(getComputedStyle(maximizeButton).backgroundColor).toBe(
    "rgba(0, 0, 0, 0)"
  );
});