.eleventy.js

const definitionPermalink = require('./11ty/helpers/definitionPermalink')
const renderDefinitionContentNextEntries = require('./11ty/shortcodes/renderDefinitionContentNextEntries')
const findExistingDefinition = require('./11ty/filters/helpers/findExistingDefinition')

module.exports = function(config) {
	// Add a filter using the Config API
	config.addFilter('linkTarget', definitionPermalink)

	config.addFilter('linkIfExistsInCollection', (word, collection) => {
		const existingDefinition = findExistingDefinition(word, collection)

		if (existingDefinition) {
			return `<a href="${definitionPermalink(existingDefinition.data.slug)}">${word}</a>`
		}

		return `<span>${word}</span>`
	})

	config.addFilter('linkSubTermIfDefined', (subTermData, collection) => {
		const existingDefinition = findExistingDefinition(subTermData.full_title, collection)

		if (existingDefinition) {
			return `<a href="${definitionPermalink(existingDefinition.data.slug)}">${subTermData.text}</a>`
		}

		return `<span>${subTermData.text}</span>`
	})

	// just a debug filter to lazily inspect the content of anything in a template
	config.addFilter('postInspect', function(post) {
		console.log(post)
	})

	config.addShortcode('definitionFlag', (flag) => {
		const cleanText = new Map([
			[
				'avoid',
				{
					class: 'avoid',
					text: 'Avoid'
				}
			],
			[
				'better-alternative',
				{
					class: 'better',
					text: 'Better alternate'
				}
			],
			[
				'tool',
				{
					class: 'tool',
					text: ''
				}
			],
			[
				'warning',
				{
					class: 'warning',
					text: ''
				}
			]
		])

		if (flag) {
			const info = cleanText.get(flag.level.toLowerCase())

			const sep = flag.text && info.text ? '—' : ''
			const text = flag.text ? [ info.text, flag.text ].join(sep) : info.text

			return `<p class="definition-content__signal definition-content__signal--${info.class}">${text}</p>`
		}

		return '<p class="definition-content__signal"></p>'
	})

	config.addShortcode('renderDefinitionContentNextEntries', renderDefinitionContentNextEntries)

	// NOTE (ovlb): this will not be remembered as the best code i’ve written. if anyone seeing this has a better solution then the following to achieve sub groups of the definitions: i am happy to get rid of it
	config.addCollection('tableOfContent', (collection) => {
		const allItems = collection
			.getFilteredByGlob('./11ty/definitions/*.md')
			.filter((word) => !word.data.skip_in_table_of_content)
			.sort((a, b) => {
				const { title: firstTitle } = a.data
				const { title: secondTitle } = b.data
				const sortA = firstTitle.toLowerCase().replace(/^-/, '')
				const sortB = secondTitle.toLowerCase().replace(/^-/, '')

				// `localeCompare()` is super cool: http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare
				return sortA.localeCompare(sortB)
			})

		const split = {
			notLetters: {
				title: '#',
				definitions: []
			},
			aToE: {
				title: 'A–E',
				definitions: []
			},
			fToL: {
				title: 'F–L',
				definitions: []
			},
			mToS: {
				title: 'M–S',
				definitions: []
			},
			tToZ: {
				title: 'T–Z',
				definitions: []
			}
		}

		allItems.forEach((word) => {
			const { title } = word.data
			const { notLetters, aToE, fToL, mToS, tToZ } = split
			const sortableTitle = title.replace(/^-/, '')

			if (/^[a-e]/gim.test(sortableTitle)) {
				return aToE.definitions.push(word)
			}

			if (/^[f-l]/i.test(sortableTitle)) {
				return fToL.definitions.push(word)
			}

			if (/^[m-s]/i.test(sortableTitle)) {
				return mToS.definitions.push(word)
			}

			if (/^[t-z]/i.test(sortableTitle)) {
				return tToZ.definitions.push(word)
			}

			// no reg ex as the fallback to avoid testing for emojis and numbers
			notLetters.definitions.push(word)
		})

		return Object.keys(split).map((key) => {
			const { title, definitions } = split[key]

			return { title, definitions }
		})
	})

	config.addCollection('definedWords', (collection) => {
		return collection
			.getFilteredByGlob('./11ty/definitions/*.md')
			.filter((word) => word.data.defined)
			.sort((a, b) => {
				// `localeCompare()` is super cool: http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare
				return a.data.title.toLowerCase().localeCompare(b.data.title.toLowerCase())
			})
	})

	const mdIt = require('markdown-it')({
		html: true
	})
	const prism = require('markdown-it-prism')
	const anchor = require('markdown-it-anchor')

	mdIt.use(prism)
	mdIt.use(anchor)

	config.setLibrary('md', mdIt)

	// You can return your Config object (optional).
	return {
		dir: {
			input: '11ty',
			output: 'dist'
		},
		templateFormats: [ 'njk', 'md' ],
		htmlTemplateEngine: 'njk',
		markdownTemplateEngine: 'njk'
	}
}