Make sure directories are included in the pagination date for files.ts

      m('div', {class: "col"},
        m('h3', [
          m('span', {class: "bezel-gray p-1 my-1 d-inline-block"},
            m('a', {href: `${data.reposPath}/${slugify(fileInfo.repoName)}/${fileInfo.type}/${slugify(fileInfo.refName)}/files`}, './')
          ),
          fileInfo.file.split('/').map((dir, index, arr) => {
            if (index === arr.length - 1) {

            else {
              return m('span', {class: "bezel-gray p-1 my-1 d-inline-block"}, [
                m('a', {
                  href: `${data.reposPath}/${slugify(fileInfo.repoName)}/${fileInfo.type}/${slugify(fileInfo.refName)}/files/${arr.slice(0, index + 1).map((part) => slugify(part)).join('/')}`}, `${dir}/`)
              ])
            }
          })
        ])
      )
    ),
    (fileInfo.isDirectory ?
      m('div', {class: "row"},
        m('div', {class: "col"},
          m('ul', {class: "list-group"},

                    return pathPart.split('.').map((subPart) => {
                      return slugify(subPart)
                    }).join('.')
                  }).join('/')}`},
                  getRelativePath(fileInfo.file, dir.name)
                )
              ])

    m('div', {class: "row d-flex flex-wrap"},
      data.repos.map((repo) => {
        return (
          m('div', {class: "col", style: "flex-basis: 30rem;"},
            m('div', {class: "my-2 card bezel-gray flex-grow-1"},
              m('div', {class: "card-header"},
                m('a', {class: "card-title fs-5", href: `${data.reposPath}/${slugify(repo.name)}`}, repo.name)

import childProcess from 'child_process'
import {repos, getBranchesAndTags} from './src/repos.ts'
import getFlatRefs from './src/flatRefs.ts'
import { flatFiles, flatDirectories } from './src/flatFiles.ts'
import flatPatches from './src/flatPatches.ts'
import paginatedPatches, {type PatchPage} from './src/paginatedPatches.ts'
import {getLocation} from './src/helpers.ts'

    return sortedByDirectory
  })

⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
  eleventyConfig.addFilter("pagesJustForRef", (pages: Array<PatchPage>, repoName: string, refName: string, refType: "branch" | "tag") => {
    return pages.filter(page => page.repoName === repoName && page.refName === refName && page.type === refType)
  })

  // FILE.TS
  const flatFilesData = flatFiles(reposData)
  const flatDirectoriesData = flatDirectories(reposData)

  eleventyConfig.addTemplate(
    'repos/file.11ty.js',
    commonPage(fileJsTemplate, reposConfiguration, eleventyConfig),

        size: 1,
        alias: "fileInfo",
      },
      flatFiles: flatFilesData.concat(flatDirectoriesData),
      permalink: (data) => {
        const repoName = data.fileInfo.repoName
        const refName = data.fileInfo.refName

        const repoName = data.fileInfo.repoName
        const refName = data.fileInfo.refName
        const refType = data.fileInfo.type
        return `${reposPath}/${eleventyConfig.getFilter("slugify")(repoName)}/${refType}/${eleventyConfig.getFilter("slugify")(refName)}/raw/${data.fileInfo.file.split('/').map((filePart) => filePart.split('.').map((subPart) => eleventyConfig.getFilter("slugify")(subPart)).join('.')).join('/')}`
      },
      eleventyComputed: {
        currentRepo: (data) => reposData.find(repo => {

import { type Repository } from "./dataTypes.ts"

let cachedFlatFiles: Array<FlatFileEntry> | null = null

export type FlatFileEntry = {
  file: string,
  refName: string,
  repoName: string,
  type: 'branch' | 'tag',
  isDirectory: boolean,
}

const dirsFromRefFileList: (
  ref: Repository['tags'][0],
  repoName: string,
  refType: 'branch' | 'tag'
) => Array<FlatFileEntry> = (ref, repoName, refType) => {
  const filesAndDirs = new Set<string>()

  for (const file of ref.fileList) {
    const fileParts = file.split('/')

    // Iterate through fileParts except for the last part, which will be
    // the file name. Since we just want dirs here, we can ignore that.
    const filePartsWithoutEnd = fileParts.slice(0, fileParts.length - 1)
    for (const [index, _val] of filePartsWithoutEnd.entries()) {
      const path = fileParts.slice(0, filePartsWithoutEnd.length - index).join('/')
      if (filesAndDirs.has(path)) {
        break
      } else {
        filesAndDirs.add(path)
      }
    }
  }

  return Array.from(filesAndDirs).map((file) => {
    return {
      file,
      refName: ref.name,
      repoName: repoName,
      type: refType,
      isDirectory: true,
    }
  })
}

const filesFromRefFileList: (
  ref: Repository['tags'][0],
  repoName: string,
  refType: 'branch' | 'tag'
) => Array<FlatFileEntry> = (ref, repoName, refType) => {
  return Array.from(ref.fileList).map((file) => {
    return {
      file,
      refName: ref.name,
      repoName: repoName,
      type: refType,
      isDirectory: false,
    }
  })
}

const flatFiles = (repos: Array<Repository>) : Array<FlatFileEntry> => {
  if (cachedFlatFiles !== null) { return cachedFlatFiles }

  const branches: FlatFileEntry[] = repos.flatMap((repo) => {
    return repo.branches.flatMap(branch => filesFromRefFileList(branch, repo.name, 'branch'))
  })

  const tags: FlatFileEntry[] = repos.flatMap((repo) => {
    return repo.tags.flatMap(tag => filesFromRefFileList(tag, repo.name, 'tag'))
  })

  cachedFlatFiles = [...branches, ...tags]

  return cachedFlatFiles
}

const flatDirectories = (repos: Array<Repository>) : Array<FlatFileEntry> => {
  const branches: FlatFileEntry[] = repos.flatMap((repo) => {
    return repo.branches.flatMap(branch => dirsFromRefFileList(branch, repo.name, 'branch'))
  })

  const tags: FlatFileEntry[] = repos.flatMap((repo) => {
    return repo.tags.flatMap(tag => dirsFromRefFileList(tag, repo.name, 'tag'))
  })

  return [...branches, ...tags]
}

export {
  flatFiles,
  flatDirectories,
}

  if (cachedFlatPatches !== null) { return cachedFlatPatches }

  const itemsForRef: (
    ref: Repository['tags'][0],
    refType: 'branch' | 'tag',
    repo: Repository
  ) => Array<FlatPatchRecord> = (ref, refType, repo) => {
    const flatPatches: Array<FlatPatchRecord> = []
    let currentCommit: ReturnType<Repository['commits']['get']> | undefined = repo.commits.get(ref.sha)