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')

import { type Repository } from '../../src/dataTypes.ts'
import branchesListItems from './branchesListItems.ts'

⁣
⁣
export default (refName: string, refType: "branch" | "tag" | "commit", repo: Repository, branchesWithHrefs) => {
  return m('div', {class: "branch-selector dropdown-center d-inline-block"}, [
    m('button', {
      class: `branches nav-link d-inline-block btn btn-bg dropdown-toggle ${refType === 'commit' ? 'current-ref-commit' : ''}`,
      'data-bs-toggle': "dropdown",
      'data-bs-auto-close': "outside",
      'aria-expanded': "false"
    }, refName),
    m('div', {class: "dropdown-menu"}, [
      (refType === 'commit'
        ? [
          m('div', {class: 'container'}, m.trust(`ℹ️ You are currently on a specific commit. Navigation links from this page will take you back to the default branch.`)),
          m('div', {class: 'dropdown-divider'}),
        ]
        : null
      ),
      m('form', {class: "mx-3 my-1"}, [
        m('input', {type: "text", class: "form-control", id: "dropdownBranchSearch", placeholder: "Search branches..."}),
        m('div', [

      ]),
      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,

      const refName = newRef?.refName || args.currentRefName
      const refType = newRef?.refType || args.currentRefType

⁣
⁣
      return refPath(refName, refType)
    },
    file: (filePath: string, newRef: RefArgument = null) => {
      const refName = newRef?.refName || args.currentRefName
      const refType = newRef?.refType || args.currentRefType

      return `${refPath(refName, refType)}/files/${filePath.split('/')
        .map((pathPart) => {
          return pathPart.split('.').map((subPart) => {
            return args.slugify(subPart)
          }).join('.')
        }).join('/')}.html`
    },
    raw: (filePath: string, newRef: RefArgument = null) => {
      const refName = newRef?.refName || args.currentRefName
      const refType = newRef?.refType || args.currentRefType

      return `${refPath(refName, refType)}/raw/${filePath.split('/')
        .map((filePart) => {
          return filePart.split('.').map((subPart) => {
            return args.slugify(subPart)
          }).join('.')
        }).join('/')}`
    },
    files: (newRef: RefArgument = null) => {
      const refName = newRef?.refName || args.currentRefName
      const refType = newRef?.refType || args.currentRefType

      return `${refPath(refName, refType)}/files`
    },
    commit: (hash: string) => {
      return `${repoBasePath}/commits/${hash}`
    },
    commits: (pageNum: number, newRef: RefArgument = null) => {
      const refName = newRef?.refName || args.currentRefName
      const refType = newRef?.refType || args.currentRefType

      return `${refPath(refName, refType)}/commits/page${pageNum.toString()}`
    },
    branches: (newRef: RefArgument = null) => {
      const refName = newRef?.refName || args.currentRefName

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: {

  )

  // COMMIT.TS
  const flatPatchesData = flatPatches(reposData)
  const commitsInRepos = commitsInRepo(reposData)

  eleventyConfig.addTemplate(
    `repos/commit.11ty.js`,
    commonPage(commitJsTemplate, reposConfiguration, eleventyConfig),
    {
      pagination: {
        data: "commitsInRepos",
        size: 1,
        alias: "patchInfo",
      },
      commitsInRepos,
      permalink: (data) => {
        const repoName = data.patchInfo.repoName
⁣
⁣
        return `${reposPath}/${eleventyConfig.getFilter("slugify")(repoName)}/commits/${data.patchInfo.commit.hash}/`
      },
      eleventyComputed: {
        nav: {
          repoName: (data) => data.patchInfo.repoName,
          refName: (data) => data.patchInfo.commit.hash,
          path: 'commits/page1',
        },
        currentRepo: (data) => reposData.find(repo => {
          return repo.name === data.patchInfo.repoName
        }),
        currentRef: (data) => {
⁣
⁣
⁣
          // TODO: fix this hack (it's becuse other places expect a ref.name to be available)
⁣
          return {name: data.patchInfo.commit.hash.substring(0, 6)}
        },
        currentRefType: (data) => "commit",
      },
      navTab: "commits",
    }

  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

# One Page Per Commit

Currently, it generates one page per commit per branch and tag. Like, each commit
that exists on a branch has its own url of /branch/branch-name/commits/123abc, and
if that same commit is on `other-branch`, then it will also have
/branch/other-branch/commits/123abc, even though the content of the commit is the same
between the two.

The only thing different on these pages is which branch is set as the "current" branch
in the ref dropdown menu at the top of the page.

This will be pretty wasteful for large repositories with a lot of branches and tags.

I think it would be a better idea to only generate one HTML page for the commit.

## What to change

- Get rid of flatPatches, as it is right now
- Should just be flatMap of commits per repo
- Pagination data for the commits page is this new list, URL should not include
  the branch or tag name
- The currentRef for the commits pages should be the commit itself. The menu in the
  nav should show this -- have a special case for the commits page.
- Clicking any new links should just go to the default branch (kinda sucks, but that's
  also what github and codeberg do)
- Links to files on the commits page should instead give you a dropdown menu with a
  list of branches/tags that have that file in them.

## Some notes:
- The commit page will not have a currentRef or currentRefType that is set to a
  branch or tag
- Is this now the right time to think about having per-commit snapshots? This can
  be part of that.