More implementation of the new type

import paginatedPatches, {type PatchPage} from './src/paginatedPatches.ts'

    async ({ directories }) => {

          await exec(`mkdir ${tempDir}`)

  eleventyConfig.addFilter("getDirectoryContents", (repo: string, branch: string, dirPath: string) => {
    return reposData.find(current => current.name === repo).branches.find(current => current.name === branch).fileList.filter(file => file.startsWith(dirPath) && file !== dirPath)
  eleventyConfig.addFilter("getRelativePath", (currentDir: string, fullFilePath: string) => {
  eleventyConfig.addFilter("lineNumbers", (code: string) => {

  eleventyConfig.addAsyncFilter("renderContentIfAvailable", async (contentString: string, contentType: string) => {

  eleventyConfig.addFilter("languageExtension", (filename: string, repoName: string) => {
    let filenameParts = filename.split(".")
    let extension = filenameParts[filenameParts.length - 1]
  eleventyConfig.addFilter("topLevelFilesOnly", (files: Array<string>, currentLevel: string) => {

  eleventyConfig.addAsyncFilter("getFileLastTouchInfo", async (repo: string, branch: string, filename: string) => {
    const location = getLocation(reposConfiguration, repo)
    return repoOperations[config._type].getFileLastTouchInfo(branch, filename, location)

    const location = getLocation(reposConfiguration, repo)
  eleventyConfig.addFilter("pagesJustForBranch", (pages: Array<PatchPage>, repoName: string, branchName: string) => {
  eleventyConfig.addFilter("date", (dateString: string) => {
  eleventyConfig.addFilter("toDateObj", (dateString: string) => {
  eleventyConfig.addAsyncFilter("getReadMe", async (repoName: string, branchName: string) => {
    const location = getLocation(reposConfiguration, repoName)

          path: "list"
        },
        currentRepo: (data) => reposData.find(repo => {
          return repo.name === data.branchInfo.repoName
        }),
        currentBranch: (data) => reposData.find(repo => {
          return repo.name === data.branchInfo.repoName
        }).branches.find(branch => {
          return branch.name === data.branchInfo.branchName
        }),

          path: "files",
        },
        currentRepo: (data) => reposData.find(repo => {
          return repo.name === data.fileInfo.repoName
        }),
        currentBranch: (data) => reposData.find(repo => {
          return repo.name === data.fileInfo.repoName
        }).branches.find(branch => {
          return branch.name === data.fileInfo.branchName
        }),

          path: "files",

          path: "",

          path: "patches/page1",
        },
        currentRepo: (data) => reposData.find(repo => {
          return repo.name === data.patchPage.repoName
        }),
        currentBranch: (data) => reposData.find(repo => {
          return repo.name === data.patchPage.repoName
        }).branches.find(branch => {
          return branch.name === data.patchPage.branchName
        }),

        return `${reposPath}/${eleventyConfig.getFilter("slugify")(repoName)}/branches/${eleventyConfig.getFilter("slugify")(branchName)}/patches/${data.patchInfo.commit.hash}/`
          path: "patches/page1",
        },
        currentRepo: (data) => reposData.find(repo => {
          return repo.name === data.patchInfo.repoName
        }),
        currentBranch: (data) => reposData.find(repo => {
          return repo.name === data.patchInfo.repoName
        }).branches.find(branch => {
          return branch.name === data.patchInfo.branchName
        }),

    {% set url = currentRepo.cloneUrl %}

                        {% for branch in currentRepo.branches %}
                        <option value="{{currentRepo.name | slugify}},{{branch.name | slugify}},{{nav.path}}" {% if branch.name == nav.branchName %}selected{% endif %}>{{branch.name}}</option>

let cachedBranches: Array<{
  branchName: string,
  repoName: string,
}> | null = null

    parent: string | null,

type FlatPatchRecord = {
  commit: ReturnType<Repository['commits']['get']>,
  repoName: string,
  branchName: string,
}

let cachedFlatPatches: Array<FlatPatchRecord> | null = null
export default async (repos: Array<Repository>)
  : Promise<Array<FlatPatchRecord>> => {
      const flatPatches: Array<FlatPatchRecord> = []
      let currentCommit: ReturnType<Repository['commits']['get']> | undefined = repo.commits.get(branch.head)

      while (currentCommit !== undefined) {
        flatPatches.push({
          commit: currentCommit,
          repoName: repo.name,
          branchName: branch.name
        })

        currentCommit = repo.commits.get(currentCommit.parent)
      }

      return flatPatches

import { type ReposConfiguration } from './configTypes.ts'

const getLocation = (reposConfig: ReposConfiguration, repoName: string): string => {

import { type Repository } from './dataTypes.ts'
export type PatchPage = {
  repoName: string,
  branchName: string,
  commits: Array<ReturnType<Repository['commits']['get']>>,
  pageNumber: number,
}
let paginatedPatches: Array<PatchPage> | null = null
export default async (repos: Array<Repository>) => {

        && page.commits.length <= patchesPerPage

        commits: [patch.commit],
      paginatedPatches[index].commits.push(patch.commit)

import util from 'util'
import childProcess from 'child_process'
import cloneUrl from './vcses/git/helpers.ts'
import { getFileList } from './vcses/git/operations.ts'

const exec = util.promisify(childProcess.exec)

      const repoLocation = getLocation(reposConfig, repoName)
    const branches = await Promise.all(branchNames.map(async (branchName) => {
      const repoLocation = getLocation(reposConfig, repoName)
      const branchHeadRes = await exec(`(cd ${repoLocation} && git show-ref --branch ${branchName})`)
      const branchHead = branchHeadRes.stdout.split(" ")[0]
      return {
        name: branchName,
        head: branchHead,
        fileList: await getFileList(branchName, repoLocation)
      }
    }))

      branches,
      cloneUrl: cloneUrl.cloneUrl(reposConfig.baseUrl, repoName),
      tags: [], // todo

export const getFileList = async (branchName: string, repoLocation: string) => {

  let previousHash: null | string = null

      // set the parent hash of the previous commit, unless we're on the first commit
      if (previousHash !== null) {
        commits.get(previousHash)['parent'] = hash
      }
      previousHash = hash

        return

        diffs,
        parent: null,
export const getFileLastTouchInfo = async (branch: string, filename: string, repoLocation: string) => {

    getFileLastTouchInfo: (branchName: string, filename: string, repoLocation: string) => Promise<Array<{sha: string, author: string}>>,

  <li><a href="{{reposPath}}/{{branch.repoName | slugify}}/branches/{{branch.branchName | slugify}}">{{branch.branchName}}</a>{% if branch.branchName == branchInfo.branchName %} (current){% endif %}</li>

      <h1>commit first line goes here</h2>
      <p>{{patchInfo.commit.date | date }}</p>
      <p>{{patchInfo.commit.author }}</p>
      <pre>{{patchInfo.commit.message}}</pre>
      <p class="font-monospace fw-bold text-secondary">{{patchInfo.commit.hash}}</p>

  {% set patchHunks = patchInfo.commit.diffs %}

  {% for commit in patchPage.commits %}
        <span class="patch-name"><a href="{{reposPath}}/{{patchPage.repoName | slugify}}/branches/{{patchPage.branchName | slugify}}/patches/{{commit.hash}}">{{commit.message}}</a></span>
        <span>{{commit.date | date}}</span>
        <span>{{commit.author}}</span>
        <pre class="patch-hash">{{commit.hash}}</pre>