@anydigital/eleventy-bricks 0.24.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anydigital/eleventy-bricks",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "A collection of helpful utilities and filters for Eleventy (11ty)",
   "type": "module",
   "main": "./src/index.js",
@@ -11,8 +11,8 @@
     }
   },
   "scripts": {
-    "build": "curl -O https://raw.githubusercontent.com/anydigital/bricks/refs/heads/main/.prettierrc.json",
-    "test": "node --test src/**/*.test.js"
+    "test": "node --test src/**/*.test.js",
+    "prepublishOnly": "npm run test"
   },
   "keywords": [
     "11ty",

package/src/eleventy.config.js

@@ -4,6 +4,13 @@ import minimist from "minimist";
 import { RenderPlugin } from "@11ty/eleventy";
 import eleventyNavigationPlugin from "@11ty/eleventy-navigation";
 import eleventyBricksPlugin from "@anydigital/eleventy-bricks";
+/* Conditional imports */
+let pluginTOC;
+try {
+  pluginTOC = (await import("@uncenter/eleventy-plugin-toc")).default;
+} catch (e) {
+  // @uncenter/eleventy-plugin-toc not installed
+}
 /* Libraries */
 import markdownIt from "markdown-it";
 import markdownItAnchor from "markdown-it-anchor";
@@ -27,10 +34,16 @@ export default function (eleventyConfig) {
   eleventyConfig.addPlugin(eleventyBricksPlugin, {
     mdAutoNl2br: true,
     mdAutoRawTags: true,
-    mdAutoLinkFavicons: true,
+    autoLinkFavicons: true,
     siteData: true,
-    filters: ["attr", "where_in", "merge", "remove_tag", "if", "attr_concat", "fetch"],
+    filters: ["attr_set", "attr_includes", "merge", "remove_tag", "if", "attr_concat", "fetch"],
   });
+  if (pluginTOC) {
+    eleventyConfig.addPlugin(pluginTOC, {
+      ignoredElements: ["sub", ".header-anchor"],
+      ul: true,
+    });
+  }
 
   /* Libraries */
   eleventyConfig.setLibrary(

package/src/filters/{where_in.js → attr_includes.js}

@@ -15,7 +15,7 @@ const { get } = lodash;
  * @param {*} targetValue - The value to match against
  * @returns {Array} Filtered collection
  */
-export function whereIn(collection, attrName, targetValue) {
+export function attrIncludes(collection, attrName, targetValue) {
   // If no targetValue, return original collection
   if (!targetValue) {
     return collection;
@@ -36,10 +36,10 @@ export function whereIn(collection, attrName, targetValue) {
 }
 
 /**
- * Registers the where_in filter with Eleventy
+ * Registers the attr_includes filter with Eleventy
  *
  * @param {Object} eleventyConfig - The Eleventy configuration object
  */
-export function whereInFilter(eleventyConfig) {
-  eleventyConfig.addFilter("where_in", whereIn);
+export function attrIncludesFilter(eleventyConfig) {
+  eleventyConfig.addFilter("attr_includes", attrIncludes);
 }

package/src/filters/attr_includes.test.js

@@ -0,0 +1,145 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { attrIncludes, attrIncludesFilter } from "./attr_includes.js";
+
+describe("attrIncludes (core logic)", () => {
+  it("should only work with array attributes, not exact matches", () => {
+    const collection = [
+      { category: "blog", title: "Post 1" },
+      { category: "news", title: "Post 2" },
+      { category: "blog", title: "Post 3" },
+    ];
+
+    // Non-array attributes are skipped
+    const result = attrIncludes(collection, "category", "blog");
+    assert.strictEqual(result.length, 0);
+  });
+
+  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 = attrIncludes(collection, "tags", "javascript");
+    assert.strictEqual(result.length, 2);
+    assert.strictEqual(result[0].title, "Post 1");
+    assert.strictEqual(result[1].title, "Post 3");
+  });
+
+  it("should throw error when collection is not an array", () => {
+    assert.throws(() => {
+      attrIncludes(null, "category", "blog");
+    }, TypeError);
+  });
+
+  it("should filter out items without array attributes", () => {
+    const collection = [
+      { tags: ["javascript"], title: "Post 1" },
+      { title: "Post 2" },
+      { tags: ["javascript"], title: "Post 3" },
+    ];
+
+    const result = attrIncludes(collection, "tags", "javascript");
+    assert.strictEqual(result.length, 2);
+  });
+
+  it("should work with array attribute directly on item (not in data)", () => {
+    const collection = [
+      { tags: ["blog"], title: "Post 1" },
+      { tags: ["news"], title: "Post 2" },
+      { tags: ["blog"], title: "Post 3" },
+    ];
+
+    const result = attrIncludes(collection, "tags", "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 = attrIncludes(collection, "tags", "javascript");
+    assert.strictEqual(result.length, 0);
+  });
+
+  it("should handle different value types in arrays", () => {
+    const collection = [
+      { priorities: [1, 3], title: "Post 1" },
+      { priorities: [2, 4], title: "Post 2" },
+      { priorities: [1, 5], title: "Post 3" },
+    ];
+
+    const result = attrIncludes(collection, "priorities", 1);
+    assert.strictEqual(result.length, 2);
+  });
+
+  it("should support nested array attributes with dot notation", () => {
+    const collection = [
+      { data: { categories: ["blog"] }, title: "Post 1" },
+      { data: { categories: ["news"] }, title: "Post 2" },
+      { data: { categories: ["blog"] }, title: "Post 3" },
+    ];
+
+    const result = attrIncludes(collection, "data.categories", "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 = attrIncludes(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 array paths", () => {
+    const collection = [
+      { data: { meta: { statuses: ["published"] } }, title: "Post 1" },
+      { data: { meta: { statuses: ["draft"] } }, title: "Post 2" },
+      { data: { meta: { statuses: ["published"] } }, title: "Post 3" },
+    ];
+
+    const result = attrIncludes(collection, "data.meta.statuses", "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 array path does not exist", () => {
+    const collection = [{ data: { tags: ["blog"] }, title: "Post 1" }, { title: "Post 2" }];
+
+    const result = attrIncludes(collection, "data.nonexistent.path", "value");
+    assert.strictEqual(result.length, 0);
+  });
+});
+
+describe("attrIncludesFilter (Eleventy integration)", () => {
+  it("should register the filter with eleventyConfig", () => {
+    let registeredName;
+    let registeredFn;
+
+    const mockEleventyConfig = {
+      addFilter(name, fn) {
+        registeredName = name;
+        registeredFn = fn;
+      },
+    };
+
+    attrIncludesFilter(mockEleventyConfig);
+
+    assert.strictEqual(registeredName, "attr_includes");
+    assert.strictEqual(typeof registeredFn, "function");
+    assert.strictEqual(registeredFn, attrIncludes);
+  });
+});

package/src/filters/attr_set.js

@@ -0,0 +1,27 @@
+/**
+ * attr_set 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
+ */
+
+/**
+ * Core attr_set function - Override an attribute and return a new object
+ *
+ * @param {Object} obj - The object to modify
+ * @param {string} key - The attribute name to set
+ * @param {*} value - The value to set for the attribute
+ * @returns {Object} A new object with the specified attribute set to the given value
+ */
+export function attrSet(obj, key, value) {
+  return {
+    ...obj,
+    [key]: value,
+  };
+}
+
+export function attrSetFilter(eleventyConfig) {
+  eleventyConfig.addFilter("attr_set", attrSet);
+}

package/src/filters/attr_set.test.js

@@ -0,0 +1,71 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import { attrSet } from "./attr_set.js";
+
+test("attrSet - sets a single attribute", () => {
+  const result = attrSet({ a: 1 }, "b", 2);
+  assert.deepStrictEqual(result, { a: 1, b: 2 });
+});
+
+test("attrSet - overrides an existing attribute", () => {
+  const result = attrSet({ a: 1, b: 2 }, "b", 3);
+  assert.deepStrictEqual(result, { a: 1, b: 3 });
+});
+
+test("attrSet - sets attribute on empty object", () => {
+  const result = attrSet({}, "key", "value");
+  assert.deepStrictEqual(result, { key: "value" });
+});
+
+test("attrSet - does not modify original object", () => {
+  const original = { a: 1, b: 2 };
+  const result = attrSet(original, "c", 3);
+
+  assert.deepStrictEqual(original, { a: 1, b: 2 });
+  assert.deepStrictEqual(result, { a: 1, b: 2, c: 3 });
+});
+
+test("attrSet - works with different value types", () => {
+  const obj = { name: "test" };
+
+  // String
+  assert.deepStrictEqual(attrSet(obj, "str", "value"), { name: "test", str: "value" });
+
+  // Number
+  assert.deepStrictEqual(attrSet(obj, "num", 42), { name: "test", num: 42 });
+
+  // Boolean
+  assert.deepStrictEqual(attrSet(obj, "bool", true), { name: "test", bool: true });
+
+  // Array
+  assert.deepStrictEqual(attrSet(obj, "arr", [1, 2, 3]), { name: "test", arr: [1, 2, 3] });
+
+  // Object
+  assert.deepStrictEqual(attrSet(obj, "nested", { x: 1 }), { name: "test", nested: { x: 1 } });
+
+  // Null
+  assert.deepStrictEqual(attrSet(obj, "nil", null), { name: "test", nil: null });
+
+  // Undefined
+  assert.deepStrictEqual(attrSet(obj, "undef", undefined), { name: "test", undef: undefined });
+});
+
+test("attrSet - can chain multiple calls", () => {
+  const original = { a: 1 };
+  const step1 = attrSet(original, "b", 2);
+  const step2 = attrSet(step1, "c", 3);
+  const step3 = attrSet(step2, "d", 4);
+
+  assert.deepStrictEqual(original, { a: 1 });
+  assert.deepStrictEqual(step3, { a: 1, b: 2, c: 3, d: 4 });
+});
+
+test("attrSet - handles special characters in keys", () => {
+  const result = attrSet({}, "data-id", 123);
+  assert.deepStrictEqual(result, { "data-id": 123 });
+});
+
+test("attrSet - works with numeric keys", () => {
+  const result = attrSet({ a: 1 }, "0", "zero");
+  assert.deepStrictEqual(result, { a: 1, 0: "zero" });
+});

package/src/index.cjs

@@ -5,22 +5,47 @@
 
 // Dynamic import for ES modules
 module.exports = async function eleventyBricksPlugin(eleventyConfig, options) {
-  const { default: plugin } = await import('./index.js');
+  const { default: plugin } = await import("./index.js");
   return plugin(eleventyConfig, options);
 };
 
 // Export individual helpers for granular usage
-['mdAutoRawTags', 'mdAutoNl2br', 'setAttrFilter', 'whereInFilter', 'mergeFilter', 'removeTagFilter', 'ifFilter', 'attrConcatFilter', 'siteData'].forEach(name => {
-  module.exports[name] = async (eleventyConfig) => {
-    const module = await import('./index.js');
-    return module[name](eleventyConfig);
+[
+  "mdAutoRawTags",
+  "mdAutoNl2br",
+  "autoLinkFavicons",
+  "attrSetFilter",
+  "attrIncludesFilter",
+  "mergeFilter",
+  "removeTagFilter",
+  "ifFilter",
+  "attrConcatFilter",
+  "fetchFilter",
+  "siteData",
+].forEach((name) => {
+  module.exports[name] = async (...args) => {
+    const module = await import("./index.js");
+    return module[name](...args);
   };
 });
 
 // Export transform/utility functions for advanced usage
-['transformAutoRaw', 'transformNl2br', 'merge', 'removeTag', 'iff', 'attrConcat'].forEach(name => {
+[
+  "transformAutoRaw",
+  "transformNl2br",
+  "isPlainUrlText",
+  "cleanLinkText",
+  "buildFaviconLink",
+  "transformLink",
+  "replaceLinksInHtml",
+  "merge",
+  "removeTag",
+  "iff",
+  "attrConcat",
+  "attrSet",
+].forEach((name) => {
   module.exports[name] = async (...args) => {
-    const module = await import('./index.js');
+    const module = await import("./index.js");
     return module[name](...args);
   };
 });

package/src/index.js

@@ -1,16 +1,14 @@
+import { mdAutoRawTags, mdAutoNl2br, transformAutoRaw, transformNl2br } from "./transforms/markdown.js";
 import {
-  mdAutoRawTags,
-  mdAutoNl2br,
-  mdAutoLinkFavicons,
-  transformAutoRaw,
-  transformNl2br,
+  autoLinkFavicons,
   isPlainUrlText,
   cleanLinkText,
   buildFaviconLink,
   transformLink,
-} from "./markdown.js";
-import { setAttrFilter } from "./filters/attr.js";
-import { whereInFilter } from "./filters/where_in.js";
+  replaceLinksInHtml,
+} from "./transforms/autoLinkFavicons.js";
+import { attrSetFilter, attrSet } from "./filters/attr_set.js";
+import { attrIncludesFilter } from "./filters/attr_includes.js";
 import { mergeFilter, merge } from "./filters/merge.js";
 import { removeTagFilter, removeTag } from "./filters/remove_tag.js";
 import { ifFilter, iff } from "./filters/if.js";
@@ -37,21 +35,21 @@ try {
  * @param {Object} options - Plugin options
  * @param {boolean} options.mdAutoRawTags - Enable mdAutoRawTags preprocessor (default: false)
  * @param {boolean} options.mdAutoNl2br - Enable mdAutoNl2br for \n to <br> conversion (default: false)
- * @param {boolean} options.mdAutoLinkFavicons - Enable mdAutoLinkFavicons to add favicons to plain text links (default: false)
- * @param {Array<string>} options.filters - Array of filter names to enable: 'attr', 'where_in', 'merge', 'remove_tag', 'if', 'attr_concat', 'fetch' (default: [])
+ * @param {boolean} options.autoLinkFavicons - Enable autoLinkFavicons to add favicons to plain text links (default: false)
+ * @param {Array<string>} options.filters - Array of filter names to enable: 'attr_set', 'attr_includes', 'merge', 'remove_tag', 'if', 'attr_concat', 'fetch' (default: [])
  * @param {boolean} options.siteData - Enable site.year and site.prod global data (default: false)
  */
 export default function eleventyBricksPlugin(eleventyConfig, options = {}) {
   const plugins = {
     mdAutoRawTags,
     mdAutoNl2br,
-    mdAutoLinkFavicons,
+    autoLinkFavicons,
     siteData,
   };
 
   const filters = {
-    attr: setAttrFilter,
-    where_in: whereInFilter,
+    attr_set: attrSetFilter,
+    attr_includes: attrIncludesFilter,
     merge: mergeFilter,
     remove_tag: removeTagFilter,
     if: ifFilter,
@@ -81,9 +79,9 @@ export default function eleventyBricksPlugin(eleventyConfig, options = {}) {
 export {
   mdAutoRawTags,
   mdAutoNl2br,
-  mdAutoLinkFavicons,
-  setAttrFilter,
-  whereInFilter,
+  autoLinkFavicons,
+  attrSetFilter,
+  attrIncludesFilter,
   mergeFilter,
   removeTagFilter,
   ifFilter,
@@ -100,8 +98,10 @@ export {
   cleanLinkText,
   buildFaviconLink,
   transformLink,
+  replaceLinksInHtml,
   merge,
   removeTag,
   iff,
   attrConcat,
+  attrSet,
 };

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

@@ -1,62 +1,3 @@
-/**
- * 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);
-    };
-  });
-}
-
 /**
  * Check if link text looks like a plain URL or domain
  *
@@ -157,7 +98,7 @@ export function replaceLinksInHtml(content, transformer) {
 }
 
 /**
- * mdAutoLinkFavicons - Add favicon images to plain text links
+ * autoLinkFavicons - Add favicon images to plain text links
  *
  * This transform automatically adds favicon images from Google's favicon service
  * to links that display plain URLs or domain names. It processes all HTML output
@@ -165,8 +106,8 @@ export function replaceLinksInHtml(content, transformer) {
  *
  * @param {Object} eleventyConfig - The Eleventy configuration object
  */
-export function mdAutoLinkFavicons(eleventyConfig) {
-  eleventyConfig.addTransform("mdAutoLinkFavicons", function (content) {
+export function autoLinkFavicons(eleventyConfig) {
+  eleventyConfig.addTransform("autoLinkFavicons", function (content) {
     if (this.page.outputPath && this.page.outputPath.endsWith(".html")) {
       return replaceLinksInHtml(content, transformLink);
     }