WIP: placeholder for file content and blame lines

  const renderContentIfAvailable = eleventyConfig.getFilter("renderContentIfAvailable")

  const currentRef: Branch = data.currentRef
⁣
  const fileInfo: FlatFileEntry = data.fileInfo

  const pageContent = [  

            m('div', {class: "row rendered-content"},
              m('div', {class: "col"},
                m.trust(await renderContentIfAvailable(
                  currentRef.fileList.get(fileInfo.file).fileInfo.contents
                ))
              )
            )

              m('div', {class: "col-auto p-0"},
                m('code', {style: "white-space: pre;"},
                  m('pre', {class: "language-text"},
                    lineNumbers(currentRef.fileList.get(fileInfo.file).fileInfo.contents).map((lineNumber) => {
                      return lineNumber
                    }).join('\n')
                  )

              m('div', {id: "annotations", class: "col-auto d-none p-0"},
                m('code', {style: "white-space: pre;"}, [
                  m('pre', {class: "language-text"}, m.trust(
                    currentRef.fileList.get(fileInfo.file).fileInfo.blameLines.map((annotation) => {
                      return `<a href="${data.reposPath}/${slugify(fileInfo.repoName)}/${fileInfo.type}/${slugify(fileInfo.refName)}/commits/${annotation.sha}">${annotation.sha.substr(0, 6)}</a> ${annotation.author}`
                    }).join('\n')))
                ])
              ),
              m('div', {class: "col overflow-scroll p-0"},
                m('code', m.trust(highlightCode(
                  currentRef.fileList.get(fileInfo.file).fileInfo.contents,
                  languageExtension(
                    fileInfo.file,
                    fileInfo.repoName

import { type Repository } from "../src/dataTypes.ts"
type Branch = Repository['branches'][0]

⁣
export default async (eleventyConfig: any) => {
  return async (data) => {
    const branch: Branch = data.currentRef

    return branch.fileList.get(data.fileInfo.file).fileInfo.contents
  }
}

        return `${reposPath}/${eleventyConfig.getFilter("slugify")(repoName)}/${refType}/${eleventyConfig.getFilter("slugify")(refName)}/raw/${data.fileInfo.file.split('.').map(filePart => eleventyConfig.getFilter("slugify")(filePart)).join('.')}`
      },
      eleventyComputed: {
⁣
⁣
⁣
        currentRef: (data) => {
          const refKey = data.fileInfo.type === 'branch' ? 'branches' : 'tags'

export type Commit = {
  hash: string,
  // TODO: put cached files map in here. Save file as an object
  // so that it gets saved by reference.
  cachedFiles: Map<string, FileInfo>,
  message: string,
  isMerge: boolean,
  author: string,

    behind: number,
    compareTo: string,
    sha: string,
    // instead of strings, make it point to a function that returns
    // the file contents. The first time, search in both directions for a commit
    // that has already cached this file before a diff in that commit mentions
    // this filename. If one is found, return the *object* in the cached file
    // map (so that it returns a reference). Also set that in a const inside
    // the function so that we don't have to compute it again.
    // If one is not found, then `cat` the file and save it in the commit
    // cache.
    // The FileInfo needs to know which commit it is looking at, then, in order
    // to query for the file contents or to search around the existing file list
    // to see if a copy is already available.
    fileList: Map<string, {fileInfo: FileInfo}>,
  }>,
  tags?: Array<{
    name: string,
    sha: string,
    fileList: Map<string, {fileInfo: FileInfo}>,
  }>,
  commits?: Map<string, Commit>,
}

      cloneUrl: cloneUrl.cloneUrl(reposConfig.baseUrl, repoName),
      defaultBranch: reposConfig.repos[repoName].defaultBranch,
      tags: tags,
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
      commits,
    })
  }

import childProcess from 'child_process'
const exec = util.promisify(childProcess.exec)
import { getGitDiffsFromPatchText} from '../../helpers.ts'
import { type Repository, type FileInfo } from '../../dataTypes.ts'

export const getFileList = async (
  branchName: string, repoLocation: string
) : Promise<Map<string, {fileInfo: FileInfo}>> => {
  const command = `git -C ${repoLocation} ls-tree -r --name-only ${branchName}`

  const result = await exec(command)
  let files = result.stdout.split("\n").filter(item => item.length > 0 && item != ".")
  // TODO: this could be better. This is adding each sub-path of a file to a set, so that
  // we don't wind up with repeats, and then converting that back into an array. E.g. if
  // we have two files:
  // - posts/blog/one.md
  // - posts/blog/two.md
  // this will add the following to the set:
  // posts, posts/blog, posts/blog/one.md, posts, posts/blog, posts/blog/two.md
  // The repeats will be omitted because it's a Set, and the resulting array will
  // be [posts, posts/blog, posts/blog/one.md, posts/blog/two.md].
  // This is because it's convenient to have the directories show up as their own "file"
  // in the file list, even though git doesn't treat them that way.
  const filesMap: Map<string, {fileInfo: FileInfo}> = new Map()
  files.forEach((file) => {
    const fileParts = file.split("/")
    const allPathsInFile = fileParts.reduce((accumulator, currentValue, index) => {
      // Skip the first iteration, we have already added it as the initialValue
      if (index === 0) { return accumulator }

      accumulator.push(accumulator[accumulator.length - 1] + '/' + currentValue)
      return accumulator
    }, [fileParts[0]])

    allPathsInFile.forEach((path) => {
      filesMap.set(path, {
        get fileInfo() {
          return {
            contents: "", // TODO: implement this part
            lastModified: new Date(),
            blameLines: []
          }
        }
      })
    })
  })
  return filesMap
}

export const addBranchToCommitsMap = async(branchName: string, repoLocation: string, commits: Repository['commits']): Promise<void> => {

                                             // js Date() exects milliseconds
      diffs,
      parent,
      cachedFiles: new Map(),
    })
  } while (gitLogSubset.length > 1)
}