@anydigital/eleventy-bricks 0.22.0

package/src/markdown.test.js

@@ -0,0 +1,589 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  transformAutoRaw,
+  transformNl2br,
+  isPlainUrlText,
+  cleanLinkText,
+  buildFaviconLink,
+  transformLink,
+  replaceLinksInHtml,
+} from "./markdown.js";
+
+describe("transformAutoRaw", () => {
+  it("should wrap opening double curly braces with raw tags", () => {
+    const input = "Use {{ variable }} to output.";
+    const expected = "Use {% raw %}{{{% endraw %} variable {% raw %}}}{% endraw %} to output.";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap closing double curly braces with raw tags", () => {
+    const input = "{{ name }}";
+    const expected = "{% raw %}{{{% endraw %} name {% raw %}}}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap opening template tags with raw tags", () => {
+    const input = "{% if condition %}";
+    const expected = "{% raw %}{%{% endraw %} if condition {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap closing template tags with raw tags", () => {
+    const input = "{% endif %}";
+    const expected = "{% raw %}{%{% endraw %} endif {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should handle multiple Nunjucks patterns in one string", () => {
+    const input = "{{ var1 }} and {% if test %} something {% endif %}";
+    const expected =
+      "{% raw %}{{{% endraw %} var1 {% raw %}}}{% endraw %} and {% raw %}{%{% endraw %} if test {% raw %}%}{% endraw %} something {% raw %}{%{% endraw %} endif {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should handle multiline content with Nunjucks syntax", () => {
+    const input = `# Title
+{{ variable }}
+Some text
+{% for item in items %}
+  {{ item }}
+{% endfor %}`;
+    const expected = `# Title
+{% raw %}{{{% endraw %} variable {% raw %}}}{% endraw %}
+Some text
+{% raw %}{%{% endraw %} for item in items {% raw %}%}{% endraw %}
+  {% raw %}{{{% endraw %} item {% raw %}}}{% endraw %}
+{% raw %}{%{% endraw %} endfor {% raw %}%}{% endraw %}`;
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should return unchanged content when no Nunjucks syntax is present", () => {
+    const input = "This is just plain text with no templates.";
+    assert.equal(transformAutoRaw(input), input);
+  });
+
+  it("should handle empty string", () => {
+    assert.equal(transformAutoRaw(""), "");
+  });
+
+  it("should handle content with only Nunjucks syntax", () => {
+    const input = "{{}}";
+    const expected = "{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should handle consecutive Nunjucks patterns", () => {
+    const input = "{{{{}}}}";
+    const expected = "{% raw %}{{{% endraw %}{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}{% raw %}}}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap each delimiter individually", () => {
+    const input = "Show {{ and }} and {% and %}";
+    const expected =
+      "Show {% raw %}{{{% endraw %} and {% raw %}}}{% endraw %} and {% raw %}{%{% endraw %} and {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+});
+
+describe("transformNl2br", () => {
+  it("should convert single \\n to <br>", () => {
+    const input = "Line 1\\nLine 2";
+    const expected = "Line 1<br>Line 2";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should convert double \\n\\n to <br>", () => {
+    const input = "Line 1\\n\\nLine 2";
+    const expected = "Line 1<br>Line 2";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should convert multiple \\n sequences", () => {
+    const input = "Line 1\\nLine 2\\nLine 3";
+    const expected = "Line 1<br>Line 2<br>Line 3";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should handle mixed single and double \\n", () => {
+    const input = "Line 1\\n\\nLine 2\\nLine 3";
+    const expected = "Line 1<br>Line 2<br>Line 3";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should handle text without \\n", () => {
+    const input = "Just plain text";
+    assert.equal(transformNl2br(input), input);
+  });
+
+  it("should handle empty content", () => {
+    assert.equal(transformNl2br(""), "");
+  });
+
+  it("should handle content with only \\n", () => {
+    const input = "\\n\\n\\n";
+    const expected = "<br><br>";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should handle markdown table cell content with \\n", () => {
+    const input = "Cell 1\\nCell 1 Line 2\\n\\nCell 1 Line 3";
+    const expected = "Cell 1<br>Cell 1 Line 2<br>Cell 1 Line 3";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should handle multiple consecutive double \\n\\n", () => {
+    const input = "Line 1\\n\\n\\n\\nLine 2";
+    const expected = "Line 1<br><br>Line 2";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should preserve actual newlines (not literal \\n)", () => {
+    const input = "Line 1\nLine 2";
+    const expected = "Line 1\nLine 2";
+    assert.equal(transformNl2br(input), expected);
+  });
+
+  it("should only convert literal backslash-n sequences", () => {
+    const input = "Text with\\nbackslash-n and\nreal newline";
+    const expected = "Text with<br>backslash-n and\nreal newline";
+    assert.equal(transformNl2br(input), expected);
+  });
+});
+
+describe("isPlainUrlText", () => {
+  it("should return true when linkText contains domain", () => {
+    assert.equal(isPlainUrlText("example.com", "example.com"), true);
+    assert.equal(isPlainUrlText("https://example.com/path", "example.com"), true);
+    assert.equal(isPlainUrlText("Visit example.com for more", "example.com"), true);
+  });
+
+  it("should return true when linkText starts with http://", () => {
+    assert.equal(isPlainUrlText("http://example.com", "example.com"), true);
+    assert.equal(isPlainUrlText("http://other.com/path", "other.com"), true);
+  });
+
+  it("should return true when linkText starts with https://", () => {
+    assert.equal(isPlainUrlText("https://example.com", "example.com"), true);
+    assert.equal(isPlainUrlText("https://other.com/path", "other.com"), true);
+  });
+
+  it("should return false for custom link text without domain", () => {
+    assert.equal(isPlainUrlText("Click here", "example.com"), false);
+    assert.equal(isPlainUrlText("Read more", "example.com"), false);
+    assert.equal(isPlainUrlText("Documentation", "example.com"), false);
+  });
+
+  it("should handle whitespace in linkText", () => {
+    assert.equal(isPlainUrlText("  example.com  ", "example.com"), true);
+    assert.equal(isPlainUrlText("  https://example.com  ", "example.com"), true);
+  });
+
+  it("should return false for empty linkText", () => {
+    assert.equal(isPlainUrlText("", "example.com"), false);
+  });
+});
+
+describe("cleanLinkText", () => {
+  it("should remove protocol and domain", () => {
+    assert.equal(cleanLinkText("https://example.com/docs", "example.com"), "/docs");
+    assert.equal(cleanLinkText("http://example.com/docs", "example.com"), "/docs");
+    assert.equal(cleanLinkText("https://example.com/docs/guide", "example.com"), "/docs/guide");
+  });
+
+  it("should handle links without protocol", () => {
+    assert.equal(cleanLinkText("example.com/docs", "example.com"), "/docs");
+    assert.equal(cleanLinkText("example.com/path/to/page", "example.com"), "/path/to/page");
+  });
+
+  it("should preserve leading slash after domain removal", () => {
+    assert.equal(cleanLinkText("https://example.com/docs", "example.com"), "/docs");
+    assert.equal(cleanLinkText("example.com/docs", "example.com"), "/docs");
+  });
+
+  it("should return empty string for root domain", () => {
+    assert.equal(cleanLinkText("example.com/", "example.com"), "");
+    assert.equal(cleanLinkText("example.com", "example.com"), "");
+    assert.equal(cleanLinkText("https://example.com", "example.com"), "");
+  });
+
+  it("should handle whitespace", () => {
+    assert.equal(cleanLinkText("  https://example.com/docs  ", "example.com"), "/docs");
+    assert.equal(cleanLinkText("\nhttps://example.com/docs\n", "example.com"), "/docs");
+  });
+
+  it("should preserve path after domain", () => {
+    assert.equal(cleanLinkText("https://example.com/api/v1/docs", "example.com"), "/api/v1/docs");
+  });
+
+  it("should handle query parameters", () => {
+    const result = cleanLinkText("https://example.com/search?q=test", "example.com");
+    assert.equal(result, "/search?q=test");
+  });
+
+  it("should handle hash fragments", () => {
+    const result = cleanLinkText("https://example.com/page#section", "example.com");
+    assert.equal(result, "/page#section");
+  });
+});
+
+describe("buildFaviconLink", () => {
+  it("should create correct HTML with favicon", () => {
+    const result = buildFaviconLink('href="https://example.com/docs"', "example.com", "/docs");
+    assert.equal(
+      result,
+      '<a href="https://example.com/docs" target="_blank"><i><img src="https://www.google.com/s2/favicons?domain=example.com&sz=32"></i>/docs</a>',
+    );
+  });
+
+  it("should handle complex attributes", () => {
+    const result = buildFaviconLink('href="https://example.com" class="link"', "example.com", "text");
+    assert.equal(
+      result,
+      '<a href="https://example.com" class="link" target="_blank"><i><img src="https://www.google.com/s2/favicons?domain=example.com&sz=32"></i>text</a>',
+    );
+  });
+
+  it("should use sz=32 parameter for favicon size", () => {
+    const result = buildFaviconLink('href="https://example.com"', "example.com", "text");
+    assert.match(result, /sz=32/);
+  });
+
+  it("should wrap img in <i> tag", () => {
+    const result = buildFaviconLink('href="https://example.com"', "example.com", "text");
+    assert.match(result, /<i><img[^>]*><\/i>/);
+  });
+
+  it("should handle different domains", () => {
+    const result = buildFaviconLink('href="https://github.com/repo"', "github.com", "/repo");
+    assert.equal(
+      result,
+      '<a href="https://github.com/repo" target="_blank"><i><img src="https://www.google.com/s2/favicons?domain=github.com&sz=32"></i>/repo</a>',
+    );
+  });
+
+  it("should preserve link text as provided", () => {
+    const result = buildFaviconLink('href="https://example.com"', "example.com", "custom text");
+    assert.match(result, />custom text<\/a>$/);
+  });
+});
+
+describe("transformLink", () => {
+  it("should transform plain URL links with sufficient length", () => {
+    const result = transformLink(
+      '<a href="https://example.com/docs">https://example.com/docs</a>',
+      'href="https://example.com/docs"',
+      "https://example.com/docs",
+      "https://example.com/docs",
+    );
+    assert.match(
+      result,
+      /<i><img src="https:\/\/www\.google\.com\/s2\/favicons\?domain=example\.com&sz=32"><\/i>\/docs/,
+    );
+  });
+
+  it("should not transform if cleaned text is too short (2 chars or less)", () => {
+    const match = '<a href="https://example.com/a">https://example.com/a</a>';
+    const result = transformLink(
+      match,
+      'href="https://example.com/a"',
+      "https://example.com/a",
+      "https://example.com/a",
+    );
+    assert.equal(result, match);
+  });
+
+  it("should not transform custom link text without URL", () => {
+    const match = '<a href="https://example.com/docs">Click here</a>';
+    const result = transformLink(match, 'href="https://example.com/docs"', "https://example.com/docs", "Click here");
+    assert.equal(result, match);
+  });
+
+  it("should not transform root domain links", () => {
+    const match = '<a href="https://example.com">example.com</a>';
+    const result = transformLink(match, 'href="https://example.com"', "https://example.com", "example.com");
+    assert.equal(result, match);
+  });
+
+  it("should not transform links ending with slash only", () => {
+    const match = '<a href="https://example.com/">https://example.com/</a>';
+    const result = transformLink(match, 'href="https://example.com/"', "https://example.com/", "https://example.com/");
+    assert.equal(result, match);
+  });
+
+  it("should handle invalid URLs gracefully", () => {
+    const match = '<a href="not-a-url">not-a-url</a>';
+    const result = transformLink(match, 'href="not-a-url"', "not-a-url", "not-a-url");
+    assert.equal(result, match);
+  });
+
+  it("should work with http:// protocol", () => {
+    const result = transformLink(
+      '<a href="http://example.com/docs">http://example.com/docs</a>',
+      'href="http://example.com/docs"',
+      "http://example.com/docs",
+      "http://example.com/docs",
+    );
+    assert.match(result, /<i><img[^>]*><\/i>\/docs/);
+  });
+
+  it("should work with https:// protocol", () => {
+    const result = transformLink(
+      '<a href="https://example.com/docs">https://example.com/docs</a>',
+      'href="https://example.com/docs"',
+      "https://example.com/docs",
+      "https://example.com/docs",
+    );
+    assert.match(result, /<i><img[^>]*><\/i>\/docs/);
+  });
+
+  it("should handle longer paths correctly", () => {
+    const result = transformLink(
+      '<a href="https://example.com/path/to/document">https://example.com/path/to/document</a>',
+      'href="https://example.com/path/to/document"',
+      "https://example.com/path/to/document",
+      "https://example.com/path/to/document",
+    );
+    assert.match(result, /<i><img[^>]*><\/i>\/path\/to\/document/);
+  });
+
+  it("should not transform when linkText doesn't look like URL", () => {
+    const match = '<a href="https://example.com/page">Read the documentation</a>';
+    const result = transformLink(
+      match,
+      'href="https://example.com/page"',
+      "https://example.com/page",
+      "Read the documentation",
+    );
+    assert.equal(result, match);
+  });
+
+  it("should transform when linkText contains domain even without protocol", () => {
+    const result = transformLink(
+      '<a href="https://example.com/docs">example.com/docs</a>',
+      'href="https://example.com/docs"',
+      "https://example.com/docs",
+      "example.com/docs",
+    );
+    assert.match(result, /<i><img[^>]*><\/i>\/docs/);
+  });
+
+  it("should handle malformed URLs by returning original match", () => {
+    const match = '<a href="ht!tp://bad-url">ht!tp://bad-url</a>';
+    const result = transformLink(match, 'href="ht!tp://bad-url"', "ht!tp://bad-url", "ht!tp://bad-url");
+    assert.equal(result, match);
+  });
+});
+
+describe("replaceLinksInHtml", () => {
+  it("should replace a single anchor link with transformer function", () => {
+    const html = '<a href="https://example.com">Click here</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Click here](https://example.com)");
+  });
+
+  it("should replace multiple anchor links in HTML", () => {
+    const html = '<a href="https://example.com">Link 1</a> and <a href="https://other.com">Link 2</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link 1](https://example.com) and [Link 2](https://other.com)");
+  });
+
+  it("should handle links with single quotes in href", () => {
+    const html = "<a href='https://example.com'>Link</a>";
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link](https://example.com)");
+  });
+
+  it("should handle links with double quotes in href", () => {
+    const html = '<a href="https://example.com">Link</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link](https://example.com)");
+  });
+
+  it("should capture all attributes in first group", () => {
+    const html = '<a href="https://example.com" class="link" target="_blank">Link</a>';
+    let capturedAttrs = "";
+    const transformer = (match, attrs, url, linkText) => {
+      capturedAttrs = attrs;
+      return match;
+    };
+    replaceLinksInHtml(html, transformer);
+    assert.equal(capturedAttrs, 'href="https://example.com" class="link" target="_blank"');
+  });
+
+  it("should capture URL in second group", () => {
+    const html = '<a href="https://example.com/path">Link</a>';
+    let capturedUrl = "";
+    const transformer = (match, attrs, url, linkText) => {
+      capturedUrl = url;
+      return match;
+    };
+    replaceLinksInHtml(html, transformer);
+    assert.equal(capturedUrl, "https://example.com/path");
+  });
+
+  it("should capture link text in third group", () => {
+    const html = '<a href="https://example.com">Click here</a>';
+    let capturedText = "";
+    const transformer = (match, attrs, url, linkText) => {
+      capturedText = linkText;
+      return match;
+    };
+    replaceLinksInHtml(html, transformer);
+    assert.equal(capturedText, "Click here");
+  });
+
+  it("should preserve content that is not an anchor link", () => {
+    const html = '<p>Some text</p><a href="https://example.com">Link</a><div>More text</div>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "<p>Some text</p>[Link](https://example.com)<div>More text</div>");
+  });
+
+  it("should handle empty HTML content", () => {
+    const html = "";
+    const transformer = (match) => match;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "");
+  });
+
+  it("should handle HTML with no anchor links", () => {
+    const html = "<p>No links here</p><div>Just text</div>";
+    const transformer = (match) => "REPLACED";
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, html);
+  });
+
+  it("should handle links with query parameters", () => {
+    const html = '<a href="https://example.com/search?q=test&lang=en">Search</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Search](https://example.com/search?q=test&lang=en)");
+  });
+
+  it("should handle links with hash fragments", () => {
+    const html = '<a href="https://example.com/page#section">Section</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Section](https://example.com/page#section)");
+  });
+
+  it("should be case-insensitive for anchor tag", () => {
+    const html = '<A HREF="https://example.com">Link</A>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link](https://example.com)");
+  });
+
+  it("should handle links with additional attributes before href", () => {
+    const html = '<a class="link" href="https://example.com" id="mylink">Link</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link](https://example.com)");
+  });
+
+  it("should handle links with additional attributes after href", () => {
+    const html = '<a href="https://example.com" class="link" id="mylink">Link</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link](https://example.com)");
+  });
+
+  it("should handle relative URLs", () => {
+    const html = '<a href="/docs/guide">Guide</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Guide](/docs/guide)");
+  });
+
+  it("should handle root-relative URLs", () => {
+    const html = '<a href="/">Home</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Home](/)");
+  });
+
+  it("should not match anchor tags with nested HTML in link text", () => {
+    const html = '<a href="https://example.com"><span>Link</span></a>';
+    const transformer = (match) => "REPLACED";
+    const result = replaceLinksInHtml(html, transformer);
+    // Should not match because regex expects [^<]+ for link text (no nested tags)
+    assert.equal(result, html);
+  });
+
+  it("should handle transformer that returns original match unchanged", () => {
+    const html = '<a href="https://example.com">Link</a>';
+    const transformer = (match) => match;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, html);
+  });
+
+  it("should work with transformLink function for real-world usage", () => {
+    const html = '<a href="https://example.com/docs">https://example.com/docs</a>';
+    const result = replaceLinksInHtml(html, transformLink);
+    // transformLink should add favicon for plain URL links
+    assert.match(result, /<img src="https:\/\/www\.google\.com\/s2\/favicons\?domain=example\.com&sz=32">/);
+    assert.match(result, /\/docs<\/a>/);
+  });
+
+  it("should not transform custom link text when using transformLink", () => {
+    const html = '<a href="https://example.com/docs">Click here</a>';
+    const result = replaceLinksInHtml(html, transformLink);
+    // transformLink should not add favicon for custom text
+    assert.equal(result, html);
+  });
+
+  it("should handle multiple links with mixed transformation results", () => {
+    const html =
+      '<a href="https://example.com/docs">https://example.com/docs</a> and <a href="https://other.com">Click</a>';
+    const result = replaceLinksInHtml(html, transformLink);
+    // First link should be transformed (plain URL), second should not (custom text)
+    assert.match(result, /img src=/);
+    assert.match(result, /Click<\/a>/);
+  });
+
+  it("should handle link text with special characters", () => {
+    const html = '<a href="https://example.com">Link & More!</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link & More!](https://example.com)");
+  });
+
+  it("should handle URLs with ports", () => {
+    const html = '<a href="https://example.com:8080/page">Link</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link](https://example.com:8080/page)");
+  });
+
+  it("should handle http protocol links", () => {
+    const html = '<a href="http://example.com">Link</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link](http://example.com)");
+  });
+
+  it("should handle links in multiline HTML", () => {
+    const html = `<div>
+  <a href="https://example.com">Link 1</a>
+  <p>Some text</p>
+  <a href="https://other.com">Link 2</a>
+</div>`;
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.match(result, /\[Link 1\]\(https:\/\/example\.com\)/);
+    assert.match(result, /\[Link 2\]\(https:\/\/other\.com\)/);
+  });
+
+  it("should handle adjacent anchor links", () => {
+    const html = '<a href="https://example.com">Link1</a><a href="https://other.com">Link2</a>';
+    const transformer = (match, attrs, url, linkText) => `[${linkText}](${url})`;
+    const result = replaceLinksInHtml(html, transformer);
+    assert.equal(result, "[Link1](https://example.com)[Link2](https://other.com)");
+  });
+});

package/src/siteData.js

@@ -0,0 +1,12 @@
+/**
+ * Add site.year and site.prod global data
+ * - site.prod: Boolean indicating if running in production mode (build) vs development (serve)
+ * - site.year: Sets the current year to be available in all templates as {{ site.year }}
+ * 
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ */
+export function siteData(eleventyConfig) {
+  eleventyConfig.addGlobalData("site.prod", () => process.env.ELEVENTY_RUN_MODE === "build");
+  eleventyConfig.addGlobalData("site.year", () => new Date().getFullYear());
+}
+