Skip to content

The open alternative to Salesforce, designed for AI.

7.5 KB
Raw Blame
import { isDefined } from 'twenty-shared/utils';

import { type GeometryWakeSources } from '@/host/geometry/types/GeometryWakeSources';
import { createDevicePixelRatioChangeObserver } from '@/host/geometry/utils/createDevicePixelRatioChangeObserver';
import { createInputMediaFeatureChangeObserver } from '@/host/geometry/utils/createInputMediaFeatureChangeObserver';

const ANIMATION_EVENT_TYPES = [
  'transitionrun',
  'transitionend',
  'transitioncancel',
  'animationstart',
  'animationend',
  'animationcancel',
];

const MUTATION_OBSERVER_OPTIONS: MutationObserverInit = {
  subtree: true,
  childList: true,
  attributes: true,
  characterData: true,
};

const ROOT_ANCESTOR_MUTATION_OBSERVER_OPTIONS: MutationObserverInit = {
  attributes: true,
  attributeFilter: ['class', 'style', 'hidden'],
};

export const createGeometryWakeSources = (
  onWake: () => void,
): GeometryWakeSources => {
  const resizeObservedNodes = new Set<Element>();
  const devicePixelRatioChangeObserver =
    createDevicePixelRatioChangeObserver(onWake);
  const inputMediaFeatureChangeObserver =
    createInputMediaFeatureChangeObserver(onWake);

  let rootContainer: Element | null = null;
  let portalLayer: Element | null = null;
  let resizeObserver: ResizeObserver | null = null;
  let mutationObserver: MutationObserver | null = null;
  let rootAncestorMutationObserver: MutationObserver | null = null;
  let documentStyleObserver: MutationObserver | null = null;
  let areViewportSourcesAttached = false;
  let areElementSourcesAttached = false;

  const isEventTargetRelevantToRoot = (target: EventTarget | null): boolean => {
    if (!isDefined(rootContainer)) {
      return false;
    }

    if (!(target instanceof Node)) {
      return false;
    }

    return (
      rootContainer.contains(target) ||
      target.contains(rootContainer) ||
      (isDefined(portalLayer) && portalLayer.contains(target))
    );
  };

  const handleAnimationEvent = (event: Event): void => {
    if (!isEventTargetRelevantToRoot(event.target)) {
      return;
    }

    onWake();
  };

  const handleScroll = (event: Event): void => {
    if (
      event.target !== document &&
      !isEventTargetRelevantToRoot(event.target)
    ) {
      return;
    }

    onWake();
  };

  const syncScrollListener = (): void => {
    if (areElementSourcesAttached || isDefined(portalLayer)) {
      document.addEventListener('scroll', handleScroll, true);
      return;
    }

    document.removeEventListener('scroll', handleScroll, true);
  };

  const resolveResizeObserver = (): ResizeObserver | null => {
    if (isDefined(resizeObserver) || typeof ResizeObserver !== 'function') {
      return resizeObserver;
    }

    resizeObserver = new ResizeObserver(onWake);

    return resizeObserver;
  };

  const observeRootMutations = (node: Element): void => {
    if (typeof MutationObserver !== 'function') {
      return;
    }

    mutationObserver = new MutationObserver(onWake);
    mutationObserver.observe(node, MUTATION_OBSERVER_OPTIONS);
  };

  const observeRootAncestorMutations = (node: Element): void => {
    if (typeof MutationObserver !== 'function') {
      return;
    }

    rootAncestorMutationObserver = new MutationObserver(onWake);

    for (
      let ancestor = node.parentElement;
      isDefined(ancestor);
      ancestor = ancestor.parentElement
    ) {
      rootAncestorMutationObserver.observe(
        ancestor,
        ROOT_ANCESTOR_MUTATION_OBSERVER_OPTIONS,
      );
    }
  };

  const disconnectRootAncestorMutations = (): void => {
    rootAncestorMutationObserver?.disconnect();
    rootAncestorMutationObserver = null;
  };

  const startObservingNode = (node: Element): void => {
    if (!areElementSourcesAttached || resizeObservedNodes.has(node)) {
      return;
    }

    const observer = resolveResizeObserver();

    if (!isDefined(observer)) {
      return;
    }

    observer.observe(node);
    resizeObservedNodes.add(node);
  };

  const stopObservingNode = (node: Element): void => {
    if (!resizeObservedNodes.delete(node)) {
      return;
    }

    resizeObserver?.unobserve(node);
  };

  const observeDocumentStyleMutations = (): void => {
    if (typeof MutationObserver !== 'function') {
      return;
    }

    documentStyleObserver = new MutationObserver(onWake);
    documentStyleObserver.observe(document.documentElement, {
      attributes: true,
      attributeFilter: ['class', 'style'],
    });
    documentStyleObserver.observe(document.body, {
      attributes: true,
      attributeFilter: ['class', 'style'],
    });
  };

  const attachViewportSources = (): void => {
    if (areViewportSourcesAttached) {
      return;
    }

    areViewportSourcesAttached = true;

    window.addEventListener('resize', onWake);
    observeDocumentStyleMutations();
    devicePixelRatioChangeObserver.observe();
    inputMediaFeatureChangeObserver.observe();

    if (isDefined(rootContainer)) {
      resolveResizeObserver()?.observe(rootContainer);
    }
  };

  const attachElementSources = (): void => {
    if (areElementSourcesAttached) {
      return;
    }

    areElementSourcesAttached = true;
    syncScrollListener();

    for (const eventType of ANIMATION_EVENT_TYPES) {
      document.addEventListener(eventType, handleAnimationEvent, true);
    }

    if (isDefined(rootContainer)) {
      observeRootMutations(rootContainer);
    }
  };

  const detachElementSources = (): void => {
    if (!areElementSourcesAttached) {
      return;
    }

    areElementSourcesAttached = false;
    syncScrollListener();

    for (const eventType of ANIMATION_EVENT_TYPES) {
      document.removeEventListener(eventType, handleAnimationEvent, true);
    }

    mutationObserver?.disconnect();
    mutationObserver = null;

    for (const node of resizeObservedNodes) {
      resizeObserver?.unobserve(node);
    }
    resizeObservedNodes.clear();
  };

  const attachPortalLayerSources = (nextPortalLayer: Element): void => {
    const wasPortalLayerAttached = isDefined(portalLayer);

    portalLayer = nextPortalLayer;

    if (wasPortalLayerAttached) {
      return;
    }

    syncScrollListener();

    if (isDefined(rootContainer)) {
      observeRootAncestorMutations(rootContainer);
    }
  };

  const detachPortalLayerSources = (): void => {
    if (!isDefined(portalLayer)) {
      return;
    }

    portalLayer = null;
    syncScrollListener();
    disconnectRootAncestorMutations();
  };

  const detachAllSources = (): void => {
    detachElementSources();

    if (areViewportSourcesAttached) {
      areViewportSourcesAttached = false;
      window.removeEventListener('resize', onWake);
      documentStyleObserver?.disconnect();
      documentStyleObserver = null;
      devicePixelRatioChangeObserver.disconnect();
      inputMediaFeatureChangeObserver.disconnect();
    }

    resizeObserver?.disconnect();
    resizeObserver = null;
  };

  const setRoot = (node: Element | null): void => {
    if (isDefined(rootContainer)) {
      resizeObserver?.unobserve(rootContainer);
    }

    mutationObserver?.disconnect();
    mutationObserver = null;
    disconnectRootAncestorMutations();

    rootContainer = node;

    if (!isDefined(node)) {
      return;
    }

    if (areViewportSourcesAttached) {
      resolveResizeObserver()?.observe(node);
    }

    if (areElementSourcesAttached) {
      observeRootMutations(node);
    }

    if (isDefined(portalLayer)) {
      observeRootAncestorMutations(node);
    }
  };

  return {
    attachViewportSources,
    attachElementSources,
    detachElementSources,
    attachPortalLayerSources,
    detachPortalLayerSources,
    detachAllSources,
    setRoot,
    startObservingNode,
    stopObservingNode,
  };
};