@anydigital/eleventy-bricks 0.24.0 → 0.26.0

package/src/{markdown.test.js → transforms/autoLinkFavicons.test.js}

@@ -1,156 +1,12 @@
 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);
-  });
-});
+} from "./autoLinkFavicons.js";
 
 describe("isPlainUrlText", () => {
   it("should return true when linkText contains domain", () => {
@@ -202,10 +58,11 @@ describe("cleanLinkText", () => {
     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 return cleaned domain for root domain (no long path)", () => {
+    // When path is too short (<=2 chars), returns cleanedText instead of withoutDomain
+    assert.equal(cleanLinkText("example.com/", "example.com"), "example.com");
+    assert.equal(cleanLinkText("example.com", "example.com"), "example.com");
+    assert.equal(cleanLinkText("https://example.com", "example.com"), "example.com");
   });
 
   it("should handle whitespace", () => {
@@ -283,15 +140,16 @@ describe("transformLink", () => {
     );
   });
 
-  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>';
+  it("should transform links with short paths (shows domain)", () => {
+    // When path is short (<=2 chars), cleanLinkText returns cleanedText (with domain)
+    // The link still gets transformed and shows the domain
     const result = transformLink(
-      match,
+      '<a href="https://example.com/a">https://example.com/a</a>',
       'href="https://example.com/a"',
       "https://example.com/a",
       "https://example.com/a",
     );
-    assert.equal(result, match);
+    assert.match(result, /<i><img[^>]*><\/i><span>example\.com\/a<\/span>/);
   });
 
   it("should not transform custom link text without URL", () => {
@@ -300,16 +158,26 @@ describe("transformLink", () => {
     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 transform root domain links (shows domain)", () => {
+    // Root domains are transformed and display the domain name
+    const result = transformLink(
+      '<a href="https://example.com">example.com</a>',
+      'href="https://example.com"',
+      "https://example.com",
+      "example.com",
+    );
+    assert.match(result, /<i><img[^>]*><\/i><span>example\.com<\/span>/);
   });
 
-  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 transform links ending with slash only (shows domain)", () => {
+    // Links with trailing slash are transformed and display the domain name
+    const result = transformLink(
+      '<a href="https://example.com/">https://example.com/</a>',
+      'href="https://example.com/"',
+      "https://example.com/",
+      "https://example.com/",
+    );
+    assert.match(result, /<i><img[^>]*><\/i><span>example\.com<\/span>/);
   });
 
   it("should handle invalid URLs gracefully", () => {

package/src/transforms/markdown.js

@@ -0,0 +1,58 @@
+/**
+ * Transform Nunjucks syntax in content by wrapping it with raw tags
+ *
+ * This function wraps Nunjucks syntax ({{, }}, {%, %}) with {% raw %} tags
+ * to prevent them from being processed by the template engine.
+ *
+ * @param {string} content - The content to transform
+ * @returns {string} The transformed content with Nunjucks syntax wrapped
+ */
+export function transformAutoRaw(content) {
+  // This regex looks for {{, }}, {%, or %} individually and wraps them
+  return content.replace(/({{|}}|{%|%})/g, "{% raw %}$1{% endraw %}");
+}
+
+/**
+ * mdAutoRawTags - Forbid Nunjucks processing in Markdown files
+ *
+ * This preprocessor wraps Nunjucks syntax ({{, }}, {%, %}) with {% raw %} tags
+ * to prevent them from being processed by the template engine in Markdown files.
+ *
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ */
+export function mdAutoRawTags(eleventyConfig) {
+  eleventyConfig.addPreprocessor("mdAutoRawTags", "md", (data, content) => {
+    return transformAutoRaw(content);
+  });
+}
+
+/**
+ * Transform \n sequences to <br> tags
+ *
+ * This function converts literal \n sequences (double backslash + n) to HTML <br> tags.
+ * It handles both double \n\n and single \n sequences, processing double ones first.
+ *
+ * @param {string} content - The content to transform
+ * @returns {string} The transformed content with \n converted to <br>
+ */
+export function transformNl2br(content) {
+  // Replace double \n\n first, then single \n to avoid double conversion
+  return content.replace(/\\n\\n/g, "<br>").replace(/\\n/g, "<br>");
+}
+
+/**
+ * mdAutoNl2br - Auto convert \\n to <br> in markdown (especially tables)
+ *
+ * This function amends the markdown library to automatically convert \\n
+ * to <br> tags in text content, which is particularly useful for line breaks
+ * inside markdown tables where standard newlines don't work.
+ *
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ */
+export function mdAutoNl2br(eleventyConfig) {
+  eleventyConfig.amendLibrary("md", (mdLib) => {
+    mdLib.renderer.rules.text = (tokens, idx) => {
+      return transformNl2br(tokens[idx].content);
+    };
+  });
+}

package/src/transforms/markdown.test.js

@@ -0,0 +1,145 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { transformAutoRaw, transformNl2br } 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);
+  });
+});

package/src/filters/attr.js

@@ -1,16 +0,0 @@
-/**
- * attr filter - Override an attribute and return the object
- *
- * This filter takes an object, a key, and a value, and returns a new object
- * with the specified attribute set to the given value.
- *
- * @param {Object} eleventyConfig - The Eleventy configuration object
- */
-export function setAttrFilter(eleventyConfig) {
-  eleventyConfig.addFilter("attr", function (obj, key, value) {
-    return {
-      ...obj,
-      [key]: value,
-    };
-  });
-}

package/src/filters/where_in.test.js

@@ -1,148 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { whereIn, whereInFilter } from "./where_in.js";
-
-describe("whereIn (core logic)", () => {
-  it("should filter items by exact attribute match", () => {
-    const collection = [
-      { category: "blog", title: "Post 1" },
-      { category: "news", title: "Post 2" },
-      { category: "blog", title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "category", "blog");
-    assert.strictEqual(result.length, 2);
-    assert.strictEqual(result[0].title, "Post 1");
-    assert.strictEqual(result[1].title, "Post 3");
-  });
-
-  it("should filter items when attribute is an array (includes check)", () => {
-    const collection = [
-      { tags: ["javascript", "tutorial"], title: "Post 1" },
-      { tags: ["python", "tutorial"], title: "Post 2" },
-      { tags: ["javascript", "advanced"], title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "tags", "javascript");
-    assert.strictEqual(result.length, 2);
-    assert.strictEqual(result[0].title, "Post 1");
-    assert.strictEqual(result[1].title, "Post 3");
-  });
-
-  it("should return empty array when collection is not an array", () => {
-    const result = whereIn(null, "category", "blog");
-    assert.strictEqual(result.length, 0);
-  });
-
-  it("should filter out items without the specified attribute", () => {
-    const collection = [
-      { category: "blog", title: "Post 1" },
-      { title: "Post 2" },
-      { category: "blog", title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "category", "blog");
-    assert.strictEqual(result.length, 2);
-  });
-
-  it("should work with attribute directly on item (not in data)", () => {
-    const collection = [
-      { category: "blog", title: "Post 1" },
-      { category: "news", title: "Post 2" },
-      { category: "blog", title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "category", "blog");
-    assert.strictEqual(result.length, 2);
-  });
-
-  it("should handle array that does not include target value", () => {
-    const collection = [
-      { tags: ["python", "tutorial"], title: "Post 1" },
-      { tags: ["ruby", "guide"], title: "Post 2" },
-    ];
-
-    const result = whereIn(collection, "tags", "javascript");
-    assert.strictEqual(result.length, 0);
-  });
-
-  it("should handle different value types", () => {
-    const collection = [
-      { priority: 1, title: "Post 1" },
-      { priority: 2, title: "Post 2" },
-      { priority: 1, title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "priority", 1);
-    assert.strictEqual(result.length, 2);
-  });
-
-  it("should support nested attribute names with dot notation", () => {
-    const collection = [
-      { data: { category: "blog" }, title: "Post 1" },
-      { data: { category: "news" }, title: "Post 2" },
-      { data: { category: "blog" }, title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "data.category", "blog");
-    assert.strictEqual(result.length, 2);
-    assert.strictEqual(result[0].title, "Post 1");
-    assert.strictEqual(result[1].title, "Post 3");
-  });
-
-  it("should support nested arrays with dot notation", () => {
-    const collection = [
-      { data: { tags: ["javascript", "tutorial"] }, title: "Post 1" },
-      { data: { tags: ["python", "tutorial"] }, title: "Post 2" },
-      { data: { tags: ["javascript", "advanced"] }, title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "data.tags", "javascript");
-    assert.strictEqual(result.length, 2);
-    assert.strictEqual(result[0].title, "Post 1");
-    assert.strictEqual(result[1].title, "Post 3");
-  });
-
-  it("should handle deeply nested paths", () => {
-    const collection = [
-      { data: { meta: { status: "published" } }, title: "Post 1" },
-      { data: { meta: { status: "draft" } }, title: "Post 2" },
-      { data: { meta: { status: "published" } }, title: "Post 3" },
-    ];
-
-    const result = whereIn(collection, "data.meta.status", "published");
-    assert.strictEqual(result.length, 2);
-    assert.strictEqual(result[0].title, "Post 1");
-    assert.strictEqual(result[1].title, "Post 3");
-  });
-
-  it("should return empty array when nested path does not exist", () => {
-    const collection = [
-      { data: { category: "blog" }, title: "Post 1" },
-      { title: "Post 2" },
-    ];
-
-    const result = whereIn(collection, "data.nonexistent.path", "value");
-    assert.strictEqual(result.length, 0);
-  });
-});
-
-describe("whereInFilter (Eleventy integration)", () => {
-  it("should register the filter with eleventyConfig", () => {
-    let registeredName;
-    let registeredFn;
-
-    const mockEleventyConfig = {
-      addFilter(name, fn) {
-        registeredName = name;
-        registeredFn = fn;
-      },
-    };
-
-    whereInFilter(mockEleventyConfig);
-
-    assert.strictEqual(registeredName, "where_in");
-    assert.strictEqual(typeof registeredFn, "function");
-    assert.strictEqual(registeredFn, whereIn);
-  });
-});