Add configuration defaults that are merged with user's config

import m from 'mithril'
import { type ReposConfigurationWithDefaultsApplied } from '../../src/configTypes.ts'
import { type Repository } from '../../src/dataTypes.ts'
import { NavHelper } from '../helpers/nav.ts'
import relDropDown from './relDropDown.ts'

export default async (
  reposConfig: ReposConfigurationWithDefaultsApplied,
  eleventyConfig: any,
  data: any,
  pageContent: any
) => {
  // this still necessary?
  if (data.currentRepo === '') {
    return

import { type ReposConfigurationWithDefaultsApplied } from "../../src/configTypes.ts"

/**
 * Returns links to various pages used by the default template. Will return a link

 * it'll give you /branch/main/commits.
 */
type CurrentRefArgs = {
  reposConfig: ReposConfigurationWithDefaultsApplied,
  slugify: Function,
  currentRepoName: string,
  currentRefName: string,
  currentRefType: 'branch' | 'tag' | 'commit'
}
export const NavHelper = (args: CurrentRefArgs) => {
  const reposPath = args.reposConfig.path

  // These two aren't actually used by any pages, but they're in almost
  // every page URL. E.g. all of them start with 'repos/my-repo-name'

      return `${refPath(refName, refType)}/commits.xml`
    },
    homepageButtons: args.reposConfig.repos[args.currentRepoName].defaultTemplate.homepageButtons
  }
}

  const pageContent = m('div', {class: "container"}, [
    m('div', {class: "row my-3"},
      m('div', {class: "col"},
        m('h1', data.reposConfig.defaultTemplate.allRepositoriesPageTitle)
      )
    ),
    m('div', {class: "row d-flex flex-wrap"},

                  class: "mx-1 my-2 btn btn-outline-secondary shadow-none dropdown-toggle clone-popover-btn",
                  'data-copy-text': repo.cloneUrl
                }, 'Clone'),
                (data.reposConfig.repos[repo.name].defaultTemplate.homepageButtons).map((button) => {
                  return m('a', {
                    class: "mx-1 my-2 btn btn-outline-secondary shadow-none",
                    href: button.url,

  const largestPercent = Math.max(...topLanguagePercentages.map(tuple => tuple[1]), otherLanguagePercent)

  const readmeContent = await renderContentIfAvailable(await getReadMe(repo.name, ref.name), ref.name)
  // TODO: make dark mode work here
  const colors = reposConfig.defaultTemplate.colors.languageGraph

  const pageContent = [
    m('div', {class: "row"}, [

                  ]),
                  m('div', {class: "flex-grow-1 d-flex flex-column"}, [
                    topLanguagePercentages.map((percentTuple, index) => {
                      const color = colors[index % (colors.length - 1)].light
                      return m('div', {
                        class: 'language-col flex-grow-1',
                        style: `width: ${percentTuple[1] / largestPercent * 100}%; background-color: ${color};`

                    otherLanguagePercent > 0
                      ? m('div', {
                        class: 'language-col flex-grow-1',
                        style: `width: ${otherLanguagePercent / largestPercent * 100}%; background-color: ${colors[colors.length - 1].light};`
                      })
                      : null
                  ])

import { flatPatches, commitsInRepo } from './src/flatPatches.ts'
import paginatedPatches, {type PatchPage} from './src/paginatedPatches.ts'
import {getLocation} from './src/helpers.ts'
import {
  ReposConfiguration,
  ReposConfigurationWithDefaultsApplied
} from './src/configTypes.ts'
import { type SortedFileList } from './src/dataTypes.ts'
⁣
⁣
import commonPage from './js_templates/common/commonPage.ts'
import repoJsTemplate from './js_templates/repo.ts'
import filesJsTemplate from './js_templates/files.ts'

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

const exec = util.promisify(childProcess.exec)

// TODO document how people need to do this and why. And maybe file 11ty bug?
export function beforeHook(eleventyConfig: any, userConfiguration: ReposConfiguration) {
⁣
⁣
⁣
  const reposConfiguration: ReposConfigurationWithDefaultsApplied = getConfig(userConfiguration)

⁣
  return async ({directories}) => {
    const cwd = process.cwd()
    const reposPath = reposConfiguration.path
    const slugify = eleventyConfig.getFilter("slugify")
    // Check to see if there is already a repo in all of the locations
    // that should have one.

  }
}

export default async function repoViewer(eleventyConfig: any, userConfiguration: ReposConfiguration) {
⁣
⁣
⁣
  const reposConfiguration: ReposConfigurationWithDefaultsApplied = getConfig(userConfiguration)

⁣
  const slugify = eleventyConfig.getFilter("slugify")
  const reposData = await repos(reposConfiguration, eleventyConfig.dir.output, slugify)
  // TODO: make a better way of making this default to "" so that it doesn't have to
  // be done again in src/repos.ts.
  const reposPath = reposConfiguration.path

  eleventyConfig.addGlobalData("repos", reposData)
  eleventyConfig.addGlobalData("reposConfig", reposConfiguration)

    let filenameParts = filename.split(".")
    let extension = filenameParts[filenameParts.length - 1]
    const extensionsConfig = reposConfiguration.repos[repoName].languageExtensions
    return extensionsConfig[extension] ? extensionsConfig[extension] : extension
  })

  eleventyConfig.addFilter("topLevelFilesOnly", (files: Array<string>, currentLevel: string): SortedFileList => {

              "properties": {
                "languageGraph": {
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "dark": {
                        "type": "string"
                      },
                      "light": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "light"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }

/** @ignore **/
export type ReposConfigurationWithDefaultsApplied = ReposConfiguration & {
  path: string,
  repos: {
    [repoName: string]: GitConfigWithDefaultsApplied
  },
  defaultTemplate: {
    enabled: boolean,
    allRepositoriesPageTitle: string,
    colors: {
      languageGraph: Array<any>,
    }
  }
}

/** @ignore **/
export type GitConfigWithDefaultsApplied = GitConfig & {
  defaultBranch: string,
  branches: Array<any>,
  tags: Array<any>,
  languageExtensions: Object,
  defaultTemplate: {
    homepageButtons: Array<any>
  }
}

/**
 The ReposConfiguration object contains information about your local repositories,
 like their name and location on your local filesystem. Add repositories to this

    enabled?: boolean,
    allRepositoriesPageTitle?: string,
    colors?: {
      languageGraph?: Array<{light: string, dark?: string}>,
    },
  },
}

import escape from 'escape-html'
import * as Diff from 'diff'
import {type Repository} from './dataTypes.ts'
import { type ReposConfigurationWithDefaultsApplied } from './configTypes.ts'

type Diffs = ReturnType<Repository['commits']['get']>['diffs']

  return hunks
}

const getLocation = (reposConfig: ReposConfigurationWithDefaultsApplied, outputDir: string, repoName: string, slugify: Function): string => {
  return outputDir + (reposConfig.path) + "/" + slugify(repoName) + ".git"
}

const readChunkedCommandOutput = async (executable, args): Promise<string> => {

import {
  type ReposConfigurationWithDefaultsApplied,
  type GitConfig,
} from './configTypes.ts'
import util from 'util'

const tagsForReposMap: Map<string, Array<{name: string}>> = new Map()

const getBranchesAndTags = async (
  reposConfig: ReposConfigurationWithDefaultsApplied,
  repoName: string,
  outputDir: string,
  slugify: Function,

// The key for this map is a string like "filename-sha".
const fileMap: Map<string, FileInfo> = new Map()

const repos: (
  reposConfig: ReposConfigurationWithDefaultsApplied,
  outputDir: string,
  slugify: Function
) => Promise<Array<Repository>> = async (reposConfig, outputDir, slugify) => {
  if (cachedRepos !== null) { return cachedRepos }

  const repoNames = Object.keys(reposConfig.repos)