Eleventy-config-objects.md

Config objects

• Config classes.
  • UserConfig and TemplateConfig (with defaultConfig providing, um, defaults) appear to be the only classes dedicated to configuration (according to their names).
• eleventyConfig.
  • Many class constructors and methods accept an eleventyConfig argument.
  • In Eleventy.initializeConfig(), this is a TemplateConfig instance.
  • A TemplateConfig instance holds a reference to a UserConfig instance. If I understand correctly, this is so that a user’s configuration can be tweaked on a template-by-template basis. Is this correct?
• “Config” vs. “options”.
  • When a class handles both “config” and “options”, what distinguishes whether a setting falls into one category or another?
• Total configuration awareness®.
  • Are there any other types of config?
  • What makes their roles different?
  • Which ones override others (and in which circumstances)?

Eleventy-constructor-signatures.md

Eleventy constructor signatures

In Getting to know the Eleventy 3 codebase, I started to try and become familiar with the many moving parts of the awesome Eleventy project.

I’m trying to take a project-wide view and compare bits of code in order to learn how everything works.

Here, I’ve collected the signatures of every constructor in order to look at them side-by-side and see what I notice.

// src/Benchmark.js:
class Benchmark { constructor() {} }

// src/BenchmarkGroup.js:
class BenchmarkGroup { constructor() {} }

// src/BenchmarkManager.js:
class BenchmarkManager { constructor() {} }

// src/ComputedData.js:
class ComputedData {
	constructor(config) {}
}

// src/ComputedDataProxy.js:
class ComputedDataProxy {
	constructor(computedKeys) {}
}

// src/ComputedDataQueue.js:
class ComputedDataQueue { constructor() {} }

// src/ComputedDataTemplateString.js:
class ComputedDataTemplateString {
	constructor(computedKeys) {}
}

// src/Eleventy.js:
class Eleventy {
	constructor(input, output, options = {}, eleventyConfig = null) {}
}

// src/EleventyBaseError.js:
class EleventyBaseError {
	constructor(message, originalError) {}
}

// src/EleventyErrorHandler.js:
class EleventyErrorHandler { constructor() {} }

// src/EleventyExtensionMap.js:
class EleventyExtensionMap {
	constructor(formatKeys, config) {}
}

// src/EleventyFiles.js:
class EleventyFiles {
	constructor(input, outputDir, formats, eleventyConfig) {}
}

// src/EleventyServe.js:
class EleventyServe { constructor() {} }

// src/EleventyWatch.js:
class EleventyWatch { constructor() {} }

// src/EleventyWatchTargets.js:
class EleventyWatchTargets { constructor() {} }

// src/FileSystemSearch.js:
class FileSystemSearch { constructor() {} }

// src/Template.js:
class Template extends TemplateContent {
	constructor(templatePath, inputDir, outputDir, templateData, extensionMap, config) {}
}

// src/TemplateBehavior.js:
class TemplateBehavior {
	constructor(config) {}
}

// src/TemplateCache.js:
class TemplateCache { constructor() {} }

// src/TemplateCollection.js:
class TemplateCollection extends Sortable { constructor() {} }

// src/TemplateConfig.js:
class TemplateConfig {
	constructor(customRootConfig, projectConfigPath) {}
}

// src/TemplateContent.js:
class TemplateContent {
	constructor(inputPath, inputDir, config) {}
}

// src/TemplateData.js:
class TemplateData {
	constructor(inputDir, eleventyConfig) {}
}

// src/TemplateDataInitialGlobalData.js:
class TemplateDataInitialGlobalData {
	constructor(templateConfig) {}
}

// src/TemplateEngineManager.js:
class TemplateEngineManager {
	constructor(eleventyConfig) {}
}

// src/TemplateFileSlug.js:
class TemplateFileSlug {
	constructor(inputPath, inputDir, extensionMap) {}
}

// src/TemplateLayout.js:
class TemplateLayout extends TemplateContent {
	constructor(key, inputDir, extensionMap, eleventyConfig) {}
}

// src/TemplateLayoutPathResolver.js:
class TemplateLayoutPathResolver {
	constructor(path, inputDir, extensionMap, eleventyConfig) {}
}

// src/TemplateMap.js:
class TemplateMap {
	constructor(eleventyConfig) {}
}

// src/TemplatePassthrough.js:
class TemplatePassthrough {
	constructor(path, outputDir, inputDir, config) {}
}

// src/TemplatePassthroughManager.js:
class TemplatePassthroughManager {
	constructor(eleventyConfig) {}
}

// src/TemplatePermalink.js:
class TemplatePermalink {  
	constructor(link, extraSubdir) {}
}


// src/TemplateRender.js:
class TemplateRender {
	constructor(tmplPath, inputDir, config) {}
}

// src/TemplateWriter.js:
class TemplateWriter {
	constructor(
		inputPath,
		outputDir,
		templateFormats, // TODO remove this, see `get eleventyFiles` first
		templateData,
		eleventyConfig,
	) {}
}

// src/UserConfig.js:
class UserConfig { constructor() {} }

// src/Engines/Custom.js:
class CustomEngine extends TemplateEngine {
	constructor(name, dirs, config) {}
}

// src/Engines/Html.js:
class Html extends TemplateEngine {
	constructor(name, dirs, config) {}
}

// src/Engines/JavaScript.js:
class JavaScript extends TemplateEngine {
	constructor(name, dirs, config) {}
}

// src/Engines/Liquid.js:
class Liquid extends TemplateEngine {
	constructor(name, dirs, config) {}
}


// src/Engines/Markdown.js:
class Markdown extends TemplateEngine {
	constructor(name, dirs, config) {}
}

// src/Engines/Nunjucks.js:
class Nunjucks extends TemplateEngine {
	constructor(name, dirs, config) {}
}

// src/Engines/TemplateEngine.js:
class TemplateEngine {
	constructor(name, dirs, eleventyConfig) {}
}

// src/Plugins/Pagination.js:
class Pagination {
	constructor(tmpl, data, config) {}
}

// src/Plugins/RenderPlugin.js:
class RenderManager { constructor() {} }

// src/Util/Compatibility.js:
class Compatibility { 
	constructor(compatibleRange) {}
}

// src/Util/ConsoleLogger.js:
class ConsoleLogger { constructor() {} }

// src/Util/ExistsCache.js:
class ExistsCache { constructor() {} }

// src/Util/HtmlTransformer.js:
class HtmlTransformer { constructor() {} }

// src/Util/Sortable.js:
class Sortable { constructor() {} }

Eleventy-files-and-paths.md

Files & Paths

According to filenames, below is a list of all the files/classes that deal with files or paths (including “globs”). I’ll list path-related dependencies outside of the node: standard library under each one.

I’m trying to get a list of all path-related functionality here. I’m not trying to include I/O (read/write) operations. If a class does some of both, and its name implies more path-related purpose, then I’ll include it.

• 📂 Util/
  • DirContains
  • PathNormalizer
    • uses TemplatePath from @11ty/eleventy-utils
  • PathPrefixer
    • uses PathNormalizer
• EleventyFiles
  • uses TemplateGlob
  • uses TemplatePath from @11ty/eleventy-utils
• FileSystemSearch
  • uses TemplatePath from @11ty/eleventy-utils
  • uses fastglob and micromatch (3rd party deps)
• TemplateFileSlug
  • uses TemplatePath from @11ty/eleventy-utils
• TemplateGlob
  • uses TemplatePath from @11ty/eleventy-utils

Here’s where you come in!

Did I miss anything?

Any observations about the above?