Put commit pages as a single permalink, not per-branch or per-tag

import m from 'mithril'
import htmlPage from './common/htmlPage.ts'
import { NavHelper } from './helpers/nav.ts'

export default async (
  reposConfig: any,

  const slugify = eleventyConfig.getFilter("slugify")
  const lineNumbers = eleventyConfig.getFilter("lineNumbers")
  const languageExtension = eleventyConfig.getFilter("languageExtension")
  const nav = NavHelper({
    reposConfig,
    slugify,
    currentRepoName: data.currentRepo.name,
    currentRefName: data.currentRef.name,
    currentRefType: data.currentRefType,
  })

  return await htmlPage(reposConfig, eleventyConfig, data, [
    m('div', {class: "row"},

      return m('div', {class: 'hunk'}, [
        m('span', {class: "font-monospace fw-bold"},
          m('a', {
            href: nav.file(hunk.fileName)
          }, `${hunk.fileName}:${hunk.lineNumber}`)
        ),
        m('div', {class: "diff d-flex"}, [

          return m('li', {class: "page-item"},
            m('a', {
              class: `page-link ${pageObj.pageNumber === data.patchPage.pageNumber ? 'active' : ''}`,
              href: `${nav.commits(pageObj.pageNumber)}`,
            }, pageObj.pageNumber)
          )
        })

          return m('li', {class: "page-item"},
            m('a', {
              class: `page-link ${pageObj.pageNumber === data.patchPage.pageNumber ? 'active' : ''}`,
              href: `${nav.commits(pageObj.pageNumber)}`,
            }, pageObj.pageNumber)
          )
        })

type Ref = { name: string, href: string, date: string }
type RefType = 'branch' | 'tag' | 'commit'

// These are the menu items that show up in the ref: dropdown menu.
const htmlForRef = (ref: Ref, refType: RefType, currentPageRef: string, currentPageRefType: RefType, defaultBranch: string) => {

        ),
        m('li', {class: "nav-item me-4 mb-1"}, [
          m('span', {class: "nav-link d-inline-block"}, 'ref:'),
          relDropDown(ref.name, data.currentRefType, repo, branchesWithHrefs),
        ]),
        m('ul', {class: "main-nav navbar-nav flex-wrap"}, [
          m('li', {class: "nav-item"},

            m('a', {class: `nav-link ${data.navTab === 'files' ? 'active' : ''}`, href: nav.files()}, 'Files')
          ),
          m('li', {class: "nav-item"},
            m('a', {class: `nav-link ${data.navTab === 'commits' ? 'active' : ''}`, href: nav.commits(1)}, 'Commits')
          ),
          m('li', {class: "nav-item"},
            m('a', {class: `nav-link ${data.navTab === 'branches' ? 'active' : ''}`, href: nav.branches()}, 'Branches')

      ]),
      m('div', {class: "dropdown-divider"}),
      m('div', {id: "dropdown-branches-results", class: "dropdown-branches"},
        m.trust(branchesListItems(branchesWithHrefs, repo.defaultBranch, refName, refType, 'date'))
      )
    ])
  ])

import { type Repository } from '../src/dataTypes.ts'
import getFlatRefs from '../src/flatRefs.ts'
import { dateToRfc3339 } from '@11ty/eleventy-plugin-rss'
import { flatPatches } from '../src/flatPatches.ts'

export default async (
  eleventyConfig: any,

import htmlPage from './common/htmlPage.ts'
import { type Repository } from '../src/dataTypes.ts'
import { type FlatFileEntry } from '../src/flatFiles.ts'
import { NavHelper } from './helpers/nav.ts'
type Branch = Repository['branches'][0]

export default async (reposConfig: any, eleventyConfig: any, data: any) => {

  const highlightCode = eleventyConfig.getFilter("highlightCode")
  const languageExtension = eleventyConfig.getFilter("languageExtension")
  const renderContentIfAvailable = eleventyConfig.getFilter("renderContentIfAvailable")
⁣
  const currentRef: Branch = data.currentRef
  const currentRepo: Repository = data.currentRepo
  const fileInfo: FlatFileEntry = data.fileInfo

  const nav = NavHelper({
    reposConfig,
    slugify,
    currentRepoName: currentRepo.name,
    currentRefName: currentRef.name,
    currentRefType: data.currentRefType,
  })

  const pageContent = [  
    m('div', {class: "row mt-3 mb-1"},
      m('div', {class: "col"},

              return m('li', {class: 'list-group-item'}, [
                dir.isDirectory ? m('span', m.trust('📁 ')) : null,
                m('a', {
⁣
⁣
⁣
⁣
                  href: nav.file(dir.fullPath)},
                  getRelativePath(fileInfo.file, dir.name)
                )
              ])

        m('div', {class: "row my-3"},
          m('div', {class: "col"},
            m('span', m('a', {
              href: nav.raw(fileInfo.file)}, 'View raw file'))
          )
        ),
        (fileInfo.file.endsWith(".md") ?

                m('code', {style: "white-space: pre;"}, [
                  m('pre', {class: "language-text"}, m.trust(
                    (await currentRepo.files(fileInfo.file, currentRef.sha)).blameLines.map((annotation) => {
                      return `<a href="${nav.commit(annotation.sha)}">${annotation.sha.substr(0, 6)}</a> ${annotation.author}`
                    }).join('\n')))
                ])
              ),

      return m('li', {class: 'list-group-item'}, [
        file.isDirectory ? m.trust('<span>&#x1F4C1;&nbsp;</span>') : null,
        m('a', {
          href: nav.file(file.fullPath)
        }, file.name)
      ])
    }))

i⁣
mport { type ReposConfiguration } from "../../src/configTypes.ts"

/**

  slugify: Function,
  currentRepoName: string,
  currentRefName: string,
  currentRefType: 'branch' | 'tag' | 'commit'
}
export const NavHelper = (args: CurrentRefArgs) => {
  const reposPath = args.reposConfig.path || ""

  // or 'repos/my-repo-name/branches.'
  const repoBasePath = `${reposPath}/${args.slugify(args.currentRepoName)}`

  const refPath = (refName, refType) => {
    if (refType === 'commit'
        || (refType === 'branch' && refName === args.reposConfig.repos[args.currentRepoName].defaultBranch)) {
      return repoBasePath
    }
    return `${repoBasePath}/${refType}/${args.slugify(refName)}`
  }

  type RefArgument = {
    refName: string,

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

import tagsJsTemplate from './js_templates/tags.ts'
import rawJsTemplate from './js_templates/raw.ts'
import feedJsTemplate from './js_templates/feed.ts'
import { NavHelper } from './js_templates/helpers/nav.ts'

const ajv = new Ajv()
const exec = util.promisify(childProcess.exec)

        alias: "flatRef",
      },
      permalink: (data) => {
        const nav = NavHelper({
          reposConfig: reposConfiguration,
          slugify,
          currentRepoName: data.flatRef.repoName,
          currentRefName: data.flatRef.refName,
          currentRefType: data.flatRef.type,
        })

        return nav.branches() + '/'
      },
      eleventyComputed: {
        nav: {

        alias: "flatRef",
      },
      permalink: (data) => {
        const nav = NavHelper({
          reposConfig: reposConfiguration,
          slugify,
          currentRepoName: data.flatRef.repoName,
          currentRefName: data.flatRef.refName,
          currentRefType: data.flatRef.type,
        })

        return nav.tags() + '/'
      },
      eleventyComputed: {
        nav: {

      },
      flatFiles: flatFilesData.concat(flatDirectoriesData),
      permalink: (data) => {
        const nav = NavHelper({
          reposConfig: reposConfiguration,
          slugify,
          currentRepoName: data.fileInfo.repoName,
          currentRefName: data.fileInfo.refName,
          currentRefType: data.fileInfo.type,
        })

        return nav.file(data.fileInfo.file)
      },
      eleventyComputed: {
        nav: {

      eleventyAllowMissingExtension: true,
      flatFiles: flatFilesData,
      permalink: (data) => {
        const nav = NavHelper({
          reposConfig: reposConfiguration,
          slugify,
          currentRepoName: data.fileInfo.repoName,
          currentRefName: data.fileInfo.refName,
          currentRefType: data.fileInfo.type,
        })

        return nav.raw(data.fileInfo.file)
      },
      eleventyComputed: {
        currentRepo: (data) => reposData.find(repo => {

        alias: "flatRef",
      },
      permalink: (data) => {
        const nav = NavHelper({
          reposConfig: reposConfiguration,
          slugify,
          currentRepoName: data.flatRef.repoName,
          currentRefName: data.flatRef.refName,
          currentRefType: data.flatRef.type,
        })

        return nav.files() + '/'
      },
      eleventyComputed: {
        nav: {

        alias: "flatRef",
      },
      permalink: (data) => {
        const nav = NavHelper({
          reposConfig: reposConfiguration,
          slugify,
          currentRepoName: data.flatRef.repoName,
          currentRefName: data.flatRef.refName,
          currentRefType: data.flatRef.type,
⁣
        })

⁣
        return nav.refHome() + '/'
⁣
      },
      eleventyComputed: {
        nav: {

      },
      paginatedPatches: paginatedPatchesData,
      permalink: (data) => {
        const nav = NavHelper({
          reposConfig: reposConfiguration,
          slugify,
          currentRepoName: data.patchPage.repoName,
          currentRefName: data.patchPage.refName,
          currentRefType: data.patchPage.type,
        })

        return nav.commits(data.patchPage.pageNumber) + '/'
      },
      eleventyComputed: {
        nav: {

  max-width: 100%;
}

.branch-selector {
  /* Special purple box to draw user's attention to the fact that
   * commit pages are a special case. */
  .current-ref-commit {
    background: $purple;
    color: white;
  }

  .dropdown-menu {
    min-width: 220px;
    max-height: 80vh;
    overflow-y: scroll;
  }
}

.badge {

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

⁣
type Commit = ReturnType<Repository['commits']['get']>
type FlatPatchRecord = {
  commit: Commit,
  repoName: string,
  refName: string,
  type: "branch" | "tag",
}

let cachedFlatPatches: Array<FlatPatchRecord> | null = null
let cachedRepoCommits: Array<{
  repoName: string,
  commit: Commit,
}> | null = null

const flatPatches = (repos: Array<Repository>)
  : Array<FlatPatchRecord> => {
  if (cachedFlatPatches !== null) { return cachedFlatPatches }

  const itemsForRef: (

  return cachedFlatPatches
}

const commitsInRepo = (repos: Array<Repository>) : Array<{repoName: string, commit: Commit}> => {
  if (cachedRepoCommits !== null) { return cachedRepoCommits }

  cachedRepoCommits = repos.flatMap((repo) => {
    return Array.from(repo.commits.values()).map((commit) => {
      return {
        repoName: repo.name,
        commit,
      }
    })
  })

  return cachedRepoCommits
}

export {
  flatPatches,
  commitsInRepo,
}

import { type Repository } from './dataTypes.ts'
import { flatPatches as flatPatchesFunc } from './flatPatches.js'

export type PatchPage = {
  repoName: string,

## Works in Progress

- [ ] Clean up the template views, create mithril components for rows and columns
- [ ] [Make it only generate one page per commit](./projects/one-page-per-commit.md.html)

## Ideas and Todos