Function createGitClient

packages/computer/src/git/index.ts:361–703

({
  adapter = workspaceIsomorphicGitClient,
}: CreateGitClientOptions = {})

 * or CLI) reuses the resolved modules.
 */
export function createGitClient({
  adapter = workspaceIsomorphicGitClient,
}: CreateGitClientOptions = {}): GitClientFactory {
  return function createWorkspaceGitClient({
    ws,
    defaultIdentity,
  }: WorkspaceGitClientOptions): GitClient {
    let fsPromise: Promise<IsomorphicGitFSClient> | undefined;
    const fs = () => {
      if (!fsPromise) fsPromise = adapter(ws.provider());
      return fsPromise;
    };
    const cache: Record<string, unknown> = {};

    // Memoised module loaders. Each holds the promise returned by
    // the dynamic import so concurrent first-use callers share one
    // import pass, and subsequent callers reuse the resolved module
    // synchronously through the cached promise.
    let gitPromise: Promise<unknown> | undefined;
    let httpPromise: Promise<object> | undefined;
    let createPatchPromise: Promise<CreatePatchFn> | undefined;
    const loadGit = <T>(): Promise<T> => {
      if (!gitPromise) gitPromise = loadIsomorphicGit();
      return gitPromise as Promise<T>;
    };
    const loadHttp = (): Promise<object> => {
      if (!httpPromise) httpPromise = loadDefaultHTTP();
      return httpPromise;
    };
    const loadDiffPatch = (): Promise<CreatePatchFn> => {
      if (!createPatchPromise) createPatchPromise = loadCreatePatch();
      return createPatchPromise;
    };

    const client: GitClient = {
      async clone(options) {
        await cloneWith({
          ...options,
          fs: await fs(),
          git: await loadGit<IsomorphicGitClient>(),
          http: await loadHttp(),
          cache,
        });
      },
      async diff(options = {}) {
        const f = await fs();
        return diffWith({
          ...options,
          fs: f,
          git: await loadGit<IsomorphicGitDiffClient>(),
          createPatch: await loadDiffPatch(),
          readFile: readFileFrom(f),
          cache,
        });
      },
      async diffSummary(options = {}) {
        const f = await fs();
        return diffSummaryWith({