Skip to content

The open alternative to Salesforce, designed for AI.

3.1 KB
Raw Blame
import { type RemoteConnection } from '@remote-dom/core/elements';
import { CustomError, isDefined } from 'twenty-shared/utils';

import { workerGeometryStore } from '@/polyfills/geometry/states/workerGeometryStore';
import { workerMediaBridge } from '@/polyfills/media/states/workerMediaBridge';
import { frontComponentStorageBridges } from '@/polyfills/storage/states/frontComponentStorageBridges';
import { attachRemoteRenderRootToWorkerDocument } from '@/remote/worker/rendering/utils/attachRemoteRenderRootToWorkerDocument';
import { installHostFetchProxy } from '@/remote/worker/fetch-proxy/utils/installHostFetchProxy';
import { loadFrontComponentModule } from '@/remote/worker/module-loading/utils/loadFrontComponentModule';
import { seedFrontComponentExecutionContext } from '@/remote/worker/environment/utils/seedFrontComponentExecutionContext';
import { setWorkerEnvironmentVariablesFromRenderContext } from '@/remote/worker/environment/utils/setWorkerEnvironmentVariablesFromRenderContext';
import { waitForScheduledReactCommit } from '@/remote/worker/rendering/utils/waitForScheduledReactCommit';
import { type HostFetchFunction } from '@/types/HostFetchFunction';
import { type HostToWorkerRenderContext } from '@/types/HostToWorkerRenderContext';

type RenderFrontComponentInput = {
  connection: RemoteConnection;
  renderContext: HostToWorkerRenderContext;
  hostFetch: HostFetchFunction | null;
};

export const renderFrontComponent = async ({
  connection,
  renderContext,
  hostFetch,
}: RenderFrontComponentInput): Promise<void> => {
  if (!isDefined(hostFetch)) {
    throw new CustomError(
      'The front component fetch bridge is unavailable',
      'FRONT_COMPONENT_HOST_FETCH_UNAVAILABLE',
    );
  }

  installHostFetchProxy(hostFetch, renderContext.hostFetchOrigins ?? []);

  const { renderContainer, flushPendingMutations } =
    attachRemoteRenderRootToWorkerDocument(connection);

  setWorkerEnvironmentVariablesFromRenderContext(renderContext);

  if (isDefined(renderContext.initialViewportGeometry)) {
    workerGeometryStore.applyGeometryBatch({
      viewport: renderContext.initialViewportGeometry,
    });
  }

  if (isDefined(renderContext.initialExecutionContext)) {
    seedFrontComponentExecutionContext(renderContext.initialExecutionContext);
  }

  if (isDefined(renderContext.mediaRecorderCapabilities)) {
    workerMediaBridge.seedRecorderCapabilities(
      renderContext.mediaRecorderCapabilities,
    );
  }

  const storageSnapshots = renderContext.storageSnapshots;

  if (isDefined(storageSnapshots)) {
    frontComponentStorageBridges.localStorage.seed(
      storageSnapshots.localStorage,
    );
    frontComponentStorageBridges.sessionStorage.seed(
      storageSnapshots.sessionStorage,
    );
  }

  const componentModule = await loadFrontComponentModule({
    componentSource: renderContext.componentSource,
    sdkClientSources: renderContext.sdkClientSources,
    sharedDependenciesSource: renderContext.sharedDependenciesSource,
  });

  await componentModule.default(renderContainer, renderContext.componentProps);

  await waitForScheduledReactCommit();
  flushPendingMutations();
};