@anydigital/11ty-bricks 1.0.0-alpha.6 → 1.0.0-alpha.8

package/README.md

@@ -22,7 +22,7 @@ import eleventyBricks from "@anydigital/11ty-bricks";
 
 export default function(eleventyConfig) {
   eleventyConfig.addPlugin(eleventyBricks, {
-    autoRaw: true  // Enable autoRaw preprocessor (default: false)
+    mdAutoRawTags: true  // Enable mdAutoRawTags preprocessor (default: false)
   });
   
   // Your other configuration...
@@ -35,7 +35,7 @@ const eleventyBricks = require("@anydigital/11ty-bricks");
 
 module.exports = function(eleventyConfig) {
   eleventyConfig.addPlugin(eleventyBricks, {
-    autoRaw: true  // Enable autoRaw preprocessor (default: false)
+    mdAutoRawTags: true  // Enable mdAutoRawTags preprocessor (default: false)
   });
   
   // Your other configuration...
@@ -48,11 +48,11 @@ Import only the specific helpers you need without using the plugin:
 
 **ES Modules:**
 ```javascript
-import { bricksRegistry, autoRaw } from "@anydigital/11ty-bricks";
+import { bricks, mdAutoRawTags } from "@anydigital/11ty-bricks";
 
 export default function(eleventyConfig) {
-  bricksRegistry(eleventyConfig);
-  autoRaw(eleventyConfig);
+  bricks(eleventyConfig);
+  mdAutoRawTags(eleventyConfig);
   
   // Your other configuration...
 }
@@ -60,11 +60,11 @@ export default function(eleventyConfig) {
 
 **CommonJS:**
 ```javascript
-const { bricksRegistry, autoRaw } = require("@anydigital/11ty-bricks");
+const { bricks, mdAutoRawTags } = require("@anydigital/11ty-bricks");
 
 module.exports = function(eleventyConfig) {
-  bricksRegistry(eleventyConfig);
-  autoRaw(eleventyConfig);
+  bricks(eleventyConfig);
+  mdAutoRawTags(eleventyConfig);
   
   // Your other configuration...
 };
@@ -76,57 +76,64 @@ When using the plugin (Option 1), you can configure which helpers to enable:
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `bricksRegistry` | boolean | `false` | Enable the bricksRegistry system for dependency management |
-| `autoRaw` | boolean | `false` | Enable the autoRaw preprocessor for Markdown files |
+| `bricks` | boolean | `false` | Enable the bricks system for dependency management |
+| `mdAutoRawTags` | boolean | `false` | Enable the mdAutoRawTags preprocessor for Markdown files |
+| `mdAutoNl2br` | boolean | `false` | Enable the mdAutoNl2br preprocessor to convert \n to `<br>` tags |
+| `fragments` | boolean | `false` | Enable the fragment shortcode for including content from fragments |
+| `setAttrFilter` | boolean | `false` | Enable the setAttr filter for overriding object attributes |
+| `byAttrFilter` | boolean | `false` | Enable the byAttr filter for filtering collections by attribute values |
 
 **Example:**
 ```javascript
 eleventyConfig.addPlugin(eleventyBricks, {
-  bricksRegistry: true,
-  autoRaw: true
+  bricks: true,
+  mdAutoRawTags: true,
+  byAttrFilter: true
 });
 ```
 
 ## Available 11ty Helpers
 
-### bricksRegistry
+### bricks
 
 A dependency management system for Eleventy that automatically collects and injects CSS and JavaScript dependencies (both external and inline) per page. This allows brick components to declare their dependencies, and the system will inject them in the correct location in your HTML.
 
 **Why use this?**
 
-When building reusable components (bricks) in Eleventy, you often need to include CSS and JavaScript dependencies. Instead of manually adding these to every page, `bricksRegistry` automatically:
+When building reusable components (bricks) in Eleventy, you often need to include CSS and JavaScript dependencies. Instead of manually adding these to every page, `bricks` automatically:
 - Collects dependencies from all bricks used on a page
 - Categorizes them (external CSS, external JS, inline styles, inline scripts)
 - Injects them in the correct location in your HTML output
 
 **How it works:**
 
-1. Use the `bricksRegistry` shortcode in your base template to mark where dependencies should be injected
+1. Use the `bricksDependencies` shortcode in your base template to mark where dependencies should be injected
 2. Use the `brick` shortcode to register and render brick components that declare their dependencies
 3. The system automatically collects all dependencies and injects them when the page is built
 
 **Usage:**
 
-1. Enable `bricksRegistry` in your Eleventy config:
+1. Enable `bricks` in your Eleventy config:
 
 ```javascript
-import { bricksRegistry } from "@anydigital/11ty-bricks";
+import { bricks } from "@anydigital/11ty-bricks";
 
 export default function(eleventyConfig) {
-  bricksRegistry(eleventyConfig);
+  bricks(eleventyConfig);
   // Or use as plugin:
-  // eleventyConfig.addPlugin(eleventyBricks, { bricksRegistry: true });
+  // eleventyConfig.addPlugin(eleventyBricks, { bricks: true });
 }
 ```
 
-2. Add the `bricksRegistry` shortcode in your base template (typically in the `<head>` section):
+2. Add the `bricksDependencies` shortcode in your base template (typically in the `<head>` section):
 
 ```njk
 <head>
   <meta charset="UTF-8">
   <title>My Site</title>
-  {% bricksRegistry %}
+  {% bricksDependencies [
+    ... (global dependencies can be set here) ...
+  ] %}
   <!-- Other head content -->
 </head>
 ```
@@ -192,101 +199,309 @@ The system will automatically inject all dependencies in the order they were reg
 - Works with both external URLs and inline code
 - Clears registry before each build to prevent stale data
 
-### autoRaw
+### mdAutoRawTags
 
 Prevents Nunjucks syntax from being processed in Markdown files by automatically wrapping `{{`, `}}`, `{%`, and `%}` with `{% raw %}` tags.
 
 **Why use this?**
 
-When writing documentation or tutorials about templating in Markdown files, you often want to show Nunjucks/Liquid syntax as literal text. This helper automatically escapes these special characters so they display as-is instead of being processed by the template engine.
+When writing documentation or tutorials about templating in Markdown files, you often want to show Nunjucks/Liquid syntax as literal text. This preprocessor automatically escapes these special characters so they display as-is instead of being processed by the template engine.
+
+**Usage:**
+
+1. Enable `mdAutoRawTags` in your Eleventy config:
+
+```javascript
+import { mdAutoRawTags } from "@anydigital/11ty-bricks";
+
+export default function(eleventyConfig) {
+  mdAutoRawTags(eleventyConfig);
+  // Or use as plugin:
+  // eleventyConfig.addPlugin(eleventyBricks, { mdAutoRawTags: true });
+}
+```
 
 **Example:**
 
-Before `autoRaw`, writing this in Markdown:
+Before `mdAutoRawTags`, writing this in Markdown:
 ```markdown
 Use {{ variable }} to output variables.
 ```
 
-Would try to process `{{ variable }}` as a template variable. With `autoRaw`, it displays exactly as written.
+Would try to process `{{ variable }}` as a template variable. With `mdAutoRawTags`, it displays exactly as written.
 
-## Available Bricks (Components)
+### mdAutoNl2br
 
-### Navigation Macro (`_nav.njk`)
+Automatically converts `\n` sequences to `<br>` tags in Markdown content. This is particularly useful for adding line breaks inside Markdown tables where standard newlines don't work.
 
-A reusable Nunjucks macro for rendering navigation menus with proper accessibility attributes. This macro works seamlessly with the [11ty Navigation Plugin](https://www.11ty.dev/docs/plugins/navigation/).
+**Why use this?**
+
+Markdown tables don't support multi-line content in cells. By using `\n` in your content, this preprocessor will convert it to `<br>` tags, allowing you to display line breaks within table cells and other content.
 
 **Usage:**
 
-1. Import the macro in your template:
+1. Enable `mdAutoNl2br` in your Eleventy config:
 
-```njk
-{% from "bricks/_nav.njk" import render as renderNav %}
+```javascript
+import { mdAutoNl2br } from "@anydigital/11ty-bricks";
+
+export default function(eleventyConfig) {
+  mdAutoNl2br(eleventyConfig);
+  // Or use as plugin:
+  // eleventyConfig.addPlugin(eleventyBricks, { mdAutoNl2br: true });
+}
+```
+
+**Example:**
+
+In your Markdown file:
+```markdown
+| Column 1 | Column 2 |
+|----------|----------|
+| Line 1\nLine 2\nLine 3 | Another cell\nWith multiple lines |
+```
+
+Will render as:
+```html
+<td>Line 1<br>Line 2<br>Line 3</td>
+<td>Another cell<br>With multiple lines</td>
+```
+
+**Note:** This processes literal `\n` sequences (backslash followed by 'n'), not actual newline characters. Type `\n` in your source files where you want line breaks.
+
+### fragment
+
+A shortcode that includes content from fragment files stored in the `_fragments` directory. The content will be processed by the template engine.
+
+**Why use this?**
+
+Fragments allow you to organize reusable content snippets in a dedicated directory and include them in your templates. This is useful for:
+- Reusable content blocks
+- Shared template sections
+- Component-like content organization
+
+**Usage:**
+
+1. Enable `fragment` in your Eleventy config:
+
+```javascript
+import { fragment } from "@anydigital/11ty-bricks";
+
+export default function(eleventyConfig) {
+  fragment(eleventyConfig);
+  // Or use as plugin:
+  // eleventyConfig.addPlugin(eleventyBricks, { fragments: true });
+}
 ```
 
-2. Call the macro with your navigation data:
+2. Create fragment files in the `_fragments` directory (relative to your input directory):
+
+```
+your-project/
+  _fragments/
+    header.njk
+    footer.njk
+    callout.md
+```
+
+3. Use the `fragment` shortcode in your templates:
 
 ```njk
-{{ renderNav(collections.all | eleventyNavigation, page) }}
+{% fragment "header.njk" %}
+
+<main>
+  <!-- Your content -->
+</main>
+
+{% fragment "footer.njk" %}
 ```
 
 **Parameters:**
 
-- `navPages`: Array of navigation entries (typically from `eleventyNavigation` filter)
-- `curPage`: Current page object (use Eleventy's `page` variable)
+- `path`: The path to the fragment file relative to the `_fragments` directory
 
 **Features:**
 
-- Renders a semantic `<nav>` element
-- Automatically adds `aria-current="page"` to the current page link for accessibility
-- Clean, minimal markup ready for styling
-- Works with nested navigation structures from the 11ty Navigation Plugin
+- Reads files from `_fragments` directory in your input directory
+- Content is processed by the template engine
+- Supports any template language that Eleventy supports
+- Shows helpful error comment if fragment is not found
+
+**Example:**
 
-**Example Output:**
+Create `_fragments/callout.njk`:
+```njk
+<div class="callout callout-{{ type | default('info') }}">
+  {{ content }}
+</div>
+```
 
-```html
-<nav>
-  <a href="/">Home</a>
-  <a href="/about/">About</a>
-  <a href="/contact/" aria-current="page">Contact</a>
-</nav>
+Use it in your template:
+```njk
+{% set type = "warning" %}
+{% set content = "This is important!" %}
+{% fragment "callout.njk" %}
 ```
 
-### Google Tag Manager Macro (`_gtm.njk`)
+### setAttr
+
+A filter that creates a new object with an overridden attribute value. This is useful for modifying data objects in templates without mutating the original.
 
-A reusable Nunjucks macro for integrating Google Tag Manager (GTM) into your site. Provides separate macros for the head and body GTM snippets.
+**Why use this?**
+
+When working with Eleventy data, you sometimes need to modify an object's properties for a specific use case. The `setAttr` filter provides a clean way to create a modified copy of an object without affecting the original.
 
 **Usage:**
 
-1. Import the macros in your base template:
+1. Enable `setAttr` in your Eleventy config:
+
+```javascript
+import { setAttr } from "@anydigital/11ty-bricks";
+
+export default function(eleventyConfig) {
+  setAttr(eleventyConfig);
+  // Or use as plugin:
+  // eleventyConfig.addPlugin(eleventyBricks, { setAttrFilter: true });
+}
+```
+
+2. Use the filter in your templates:
 
 ```njk
-{% import 'bricks/_gtm.njk' as gtm %}
+{# Create a modified version of a page object #}
+{% set modifiedPage = page | setAttr('title', 'New Title') %}
+
+<h1>{{ modifiedPage.title }}</h1>
+<p>Original title: {{ page.title }}</p>
 ```
 
-2. Call the macros in the appropriate locations:
+**Parameters:**
+
+- `obj`: The object to modify
+- `key`: The attribute name to set (string)
+- `value`: The value to set for the attribute (any type)
+
+**Returns:**
+
+A new object with the specified attribute set to the given value. The original object is not modified.
+
+**Features:**
+
+- Non-mutating: Creates a new object, leaving the original unchanged
+- Works with any object type
+- Supports any attribute name and value type
+- Can be chained with other filters
+
+**Examples:**
 
 ```njk
-<head>
-  <!-- Other head content -->
-  {{ gtm.renderHead('GTM-XXXXXXX') }}
-</head>
-<body>
-  {{ gtm.renderBody('GTM-XXXXXXX') }}
-  <!-- Rest of body content -->
-</body>
+{# Override a single attribute #}
+{% set updatedPost = post | setAttr('featured', true) %}
+
+{# Chain multiple setAttr filters #}
+{% set modifiedPost = post 
+  | setAttr('category', 'blog') 
+  | setAttr('priority', 1) 
+%}
+
+{# Use in loops #}
+{% for item in collection %}
+  {% set enhancedItem = item | setAttr('processed', true) %}
+  {# ... use enhancedItem ... #}
+{% endfor %}
+```
+
+### byAttr
+
+A filter that filters collection items by attribute value. It checks if an item's attribute matches a target value. If the attribute is an array, it checks if the array includes the target value.
+
+**Why use this?**
+
+When working with Eleventy collections, you often need to filter items based on front matter data. The `byAttr` filter provides a flexible way to filter by any attribute, with special handling for array attributes (like tags).
+
+**Usage:**
+
+1. Enable `byAttr` in your Eleventy config:
+
+```javascript
+import { byAttr } from "@anydigital/11ty-bricks";
+
+export default function(eleventyConfig) {
+  byAttr(eleventyConfig);
+  // Or use as plugin:
+  // eleventyConfig.addPlugin(eleventyBricks, { byAttrFilter: true });
+}
+```
+
+2. Use the filter in your templates:
+
+**Filter by exact attribute match:**
+```njk
+{# Get all posts with category 'blog' #}
+{% set blogPosts = collections.all | byAttr('category', 'blog') %}
+
+{% for post in blogPosts %}
+  <h2>{{ post.data.title }}</h2>
+{% endfor %}
+```
+
+**Filter by array attribute (tags):**
+```njk
+{# Get all posts that include 'javascript' tag #}
+{% set jsPosts = collections.all | byAttr('tags', 'javascript') %}
+
+{% for post in jsPosts %}
+  <h2>{{ post.data.title }}</h2>
+{% endfor %}
 ```
 
 **Parameters:**
 
-Both macros accept the same parameter:
-- `gtmId`: Your Google Tag Manager container ID (e.g., `'GTM-XXXXXXX'`)
+- `collection`: The collection to filter (array of items)
+- `attrName`: The attribute name to check (string)
+- `targetValue`: The value to match against (any type)
 
 **Features:**
 
-- Separate macros for head and body placement as recommended by Google
-- Clean, standard GTM implementation
-- Easy to maintain and update across your site
-- Works with all GTM features including noscript fallback
+- Works with any attribute in front matter
+- Handles both `item.data.attrName` and `item.attrName` patterns
+- Special handling for array attributes (uses `includes()` check)
+- Returns empty array if collection is invalid
+- Filters out items without the specified attribute
+
+**Examples:**
+
+Front matter:
+```yaml
+---
+title: My Post
+category: blog
+tags: [javascript, tutorial, beginner]
+priority: 1
+---
+```
+
+Template usage:
+```njk
+{# Filter by category #}
+{% set blogPosts = collections.all | byAttr('category', 'blog') %}
+
+{# Filter by tag (array) #}
+{% set jsTutorials = collections.all | byAttr('tags', 'javascript') %}
+
+{# Filter by numeric value #}
+{% set highPriority = collections.all | byAttr('priority', 1) %}
+
+{# Chain filters #}
+{% set recentBlogPosts = collections.all | byAttr('category', 'blog') | reverse | limit(5) %}
+```
+
+### Additional Exports
+
+The plugin also exports the following for advanced usage:
+
+- `transformAutoRaw(content)`: The transform function used by `mdAutoRawTags` preprocessor. Can be used programmatically to wrap Nunjucks syntax with raw tags.
+- `transformNl2br(content)`: The transform function used by `mdAutoNl2br` preprocessor. Can be used programmatically to convert `\n` sequences to `<br>` tags.
 
 ## CLI Helper Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anydigital/11ty-bricks",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.8",
   "description": "A collection of helpful utilities and filters for Eleventy (11ty)",
   "type": "module",
   "main": "./src/index.js",

package/src/{bricksRegistry.js → bricks.js}

@@ -1,4 +1,4 @@
-export function bricksRegistry(eleventyConfig) {
+export function bricks(eleventyConfig) {
 
   // Brick Registry System
   // Global registry to track dependencies per page
@@ -23,7 +23,7 @@ export function bricksRegistry(eleventyConfig) {
   });
 
   // brick shortcode: registers and renders a brick component
-  eleventyConfig.addShortcode("brick", function(brickModule) {
+  eleventyConfig.addShortcode("brick", function(brickModule, ...args) {
     const registry = getPageRegistry(this.page);
     
     if (!brickModule) return '';
@@ -47,14 +47,14 @@ export function bricksRegistry(eleventyConfig) {
     
     // Render the brick using render() macro
     if (brickModule.render && typeof brickModule.render === 'function') {
-      return brickModule.render();
+      return brickModule.render(...args);
     }
     
     return '';
   });
 
   // bricksRegistry shortcode: outputs placeholder and base dependencies
-  eleventyConfig.addShortcode("bricksRegistry", function(dependencies = []) {
+  eleventyConfig.addShortcode("bricksDependencies", function(dependencies = []) {
     const registry = getPageRegistry(this.page);
     
     // Register root dependencies if provided (categorized later in transform)

package/src/byAttrFilter.js

@@ -0,0 +1,35 @@
+/**
+ * byAttr filter - Filter collection items by attribute value
+ * 
+ * This filter takes a collection, an attribute name, and a target value,
+ * and returns items where the attribute matches the target value.
+ * If the attribute is an array, it checks if the array includes the target value.
+ * 
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ */
+export function byAttrFilter(eleventyConfig) {
+  eleventyConfig.addFilter("byAttr", function(collection, attrName, targetValue) {
+    if (!collection || !Array.isArray(collection)) {
+      return [];
+    }
+
+    return collection.filter(item => {
+      // Get the attribute value from the item's data
+      const attrValue = item?.data?.[attrName] ?? item?.[attrName];
+
+      // If attribute doesn't exist, skip this item
+      if (attrValue === undefined || attrValue === null) {
+        return false;
+      }
+
+      // If the attribute is an array, check if it includes the target value
+      if (Array.isArray(attrValue)) {
+        return attrValue.includes(targetValue);
+      }
+
+      // Otherwise, do a direct comparison
+      return attrValue === targetValue;
+    });
+  });
+}
+

package/src/byAttrFilter.test.js

@@ -0,0 +1,105 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { byAttrFilter } from './byAttrFilter.js';
+
+describe('byAttr filter', () => {
+  let filterFn;
+
+  // Mock eleventyConfig to capture the filter function
+  const mockEleventyConfig = {
+    addFilter(name, fn) {
+      if (name === 'byAttr') {
+        filterFn = fn;
+      }
+    }
+  };
+
+  // Register the filter
+  byAttrFilter(mockEleventyConfig);
+
+  it('should filter items by exact attribute match', () => {
+    const collection = [
+      { data: { category: 'blog' }, title: 'Post 1' },
+      { data: { category: 'news' }, title: 'Post 2' },
+      { data: { category: 'blog' }, title: 'Post 3' }
+    ];
+
+    const result = filterFn(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 = [
+      { data: { tags: ['javascript', 'tutorial'] }, title: 'Post 1' },
+      { data: { tags: ['python', 'tutorial'] }, title: 'Post 2' },
+      { data: { tags: ['javascript', 'advanced'] }, title: 'Post 3' }
+    ];
+
+    const result = filterFn(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 = filterFn(null, 'category', 'blog');
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('should filter out items without the specified attribute', () => {
+    const collection = [
+      { data: { category: 'blog' }, title: 'Post 1' },
+      { data: {}, title: 'Post 2' },
+      { data: { category: 'blog' }, title: 'Post 3' }
+    ];
+
+    const result = filterFn(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 = filterFn(collection, 'category', 'blog');
+    assert.strictEqual(result.length, 2);
+  });
+
+  it('should handle mixed data structures', () => {
+    const collection = [
+      { data: { category: 'blog' }, title: 'Post 1' },
+      { category: 'blog', title: 'Post 2' },
+      { data: { category: 'news' }, title: 'Post 3' }
+    ];
+
+    const result = filterFn(collection, 'category', 'blog');
+    assert.strictEqual(result.length, 2);
+  });
+
+  it('should handle array that does not include target value', () => {
+    const collection = [
+      { data: { tags: ['python', 'tutorial'] }, title: 'Post 1' },
+      { data: { tags: ['ruby', 'guide'] }, title: 'Post 2' }
+    ];
+
+    const result = filterFn(collection, 'tags', 'javascript');
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('should handle different value types', () => {
+    const collection = [
+      { data: { priority: 1 }, title: 'Post 1' },
+      { data: { priority: 2 }, title: 'Post 2' },
+      { data: { priority: 1 }, title: 'Post 3' }
+    ];
+
+    const result = filterFn(collection, 'priority', 1);
+    assert.strictEqual(result.length, 2);
+  });
+});
+

package/src/fragments.js

@@ -0,0 +1,34 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+
+/**
+ * fragment shortcode - Include content from fragments
+ * 
+ * This shortcode reads a file from the _fragments directory and includes
+ * its content. The content will be processed by the template engine.
+ * 
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ */
+export function fragments(eleventyConfig) {
+  eleventyConfig.addShortcode("fragment", function(path) {
+    // Get the input directory from Eleventy's context
+    const inputDir = this.page?.inputPath 
+      ? join(process.cwd(), eleventyConfig.dir?.input || ".") 
+      : process.cwd();
+    
+    // Construct the full path to the fragment file
+    const fragmentPath = join(inputDir, "_fragments", path);
+    
+    try {
+      // Read the fragment file
+      const content = readFileSync(fragmentPath, "utf8");
+      
+      // Return content to be processed by the template engine
+      return content;
+    } catch (error) {
+      console.error(`Error reading fragment at ${fragmentPath}:`, error.message);
+      return `<!-- Fragment not found: ${path} -->`;
+    }
+  });
+}
+

package/src/index.cjs

@@ -9,12 +9,18 @@ module.exports = async function eleventyBricksPlugin(eleventyConfig, options) {
   return plugin(eleventyConfig, options);
 };
 
-// Export individual helpers
-module.exports.bricksRegistry = async function(eleventyConfig) {
-  const { bricksRegistry } = await import('./index.js');
-  return bricksRegistry(eleventyConfig);
-};
-module.exports.autoRaw = async function(eleventyConfig) {
-  const { autoRaw } = await import('./index.js');
-  return autoRaw(eleventyConfig);
-};
+// Export individual helpers for granular usage
+['bricks', 'mdAutoRawTags', 'mdAutoNl2br', 'fragments', 'setAttrFilter', 'byAttrFilter'].forEach(name => {
+  module.exports[name] = async (eleventyConfig) => {
+    const module = await import('./index.js');
+    return module[name](eleventyConfig);
+  };
+});
+
+// Export transform functions for advanced usage
+['transformAutoRaw', 'transformNl2br'].forEach(name => {
+  module.exports[name] = async (content) => {
+    const module = await import('./index.js');
+    return module[name](content);
+  };
+});

package/src/index.js

@@ -1,5 +1,8 @@
-import { bricksRegistry } from "./bricksRegistry.js";
-import { autoRaw } from "./autoRaw.js";
+import { bricks } from "./bricks.js";
+import { mdAutoRawTags, mdAutoNl2br, transformAutoRaw, transformNl2br } from "./markdown.js";
+import { fragments } from "./fragments.js";
+import { setAttrFilter } from "./setAttrFilter.js";
+import { byAttrFilter } from "./byAttrFilter.js";
 
 /**
  * 11ty Bricks Plugin
@@ -9,18 +12,20 @@ import { autoRaw } from "./autoRaw.js";
  * 
  * @param {Object} eleventyConfig - The Eleventy configuration object
  * @param {Object} options - Plugin options
- * @param {boolean} options.bricksRegistry - Enable bricksRegistry (default: false)
- * @param {boolean} options.autoRaw - Enable autoRaw preprocessor (default: false)
+ * @param {boolean} options.bricks - Enable bricks system with dependencies injection (default: false)
+ * @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.fragments - Enable fragment shortcode (default: false)
+ * @param {boolean} options.setAttrFilter - Enable setAttr filter (default: false)
+ * @param {boolean} options.byAttrFilter - Enable byAttr filter (default: false)
  */
 export default function eleventyBricksPlugin(eleventyConfig, options = {}) {
-  if (options.bricksRegistry) {
-    bricksRegistry(eleventyConfig);
-  }
-  if (options.autoRaw) {
-    autoRaw(eleventyConfig);
-  }
+  const plugins = { bricks, mdAutoRawTags, mdAutoNl2br, fragments, setAttrFilter, byAttrFilter };
+  Object.entries(options).forEach(([key, enabled]) => enabled && plugins[key]?.(eleventyConfig));
 }
 
 // Export individual helpers for granular usage
-export { bricksRegistry };
-export { autoRaw };
+export { bricks, mdAutoRawTags, mdAutoNl2br, fragments, setAttrFilter, byAttrFilter };
+
+// Export transform functions for advanced usage
+export { transformAutoRaw, transformNl2br };

package/src/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/{autoRaw.test.js → markdown.test.js}

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { transformAutoRaw } from "./autoRaw.js";
+import { transformAutoRaw, transformNl2br } from "./markdown.js";
 
 describe("transformAutoRaw", () => {
   it("should wrap opening double curly braces with raw tags", () => {
@@ -85,3 +85,68 @@ Some text
   });
 });
 
+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/setAttrFilter.js

@@ -0,0 +1,17 @@
+/**
+ * setAttr 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("setAttr", function(obj, key, value) {
+    return {
+      ...obj,
+      [key]: value
+    };
+  });
+}
+

package/src/autoRaw.js

@@ -1,28 +0,0 @@
-/**
- * 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 %}");
-}
-
-/**
- * autoRaw - 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 autoRaw(eleventyConfig) {
-  eleventyConfig.addPreprocessor("autoRaw", "md", (data, content) => {
-    return transformAutoRaw(content);
-  });
-}
-

package/src/bricks/_gtm.njk

@@ -1,16 +0,0 @@
-{% macro renderHead(gtmId) %}
-<!-- Google Tag Manager -->
-<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
-new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
-j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
-'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
-})(window,document,'script','dataLayer','{{ gtmId }}');</script>
-<!-- End Google Tag Manager -->
-{% endmacro %}
-
-{% macro renderBody(gtmId) %}
-<!-- Google Tag Manager (noscript) -->
-<noscript><iframe src="https://www.googletagmanager.com/ns.html?id={{ gtmId }}"
-height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
-<!-- End Google Tag Manager (noscript) -->
-{% endmacro %}

package/src/bricks/_nav.njk

@@ -1,10 +0,0 @@
-{% macro render(navPages, curPage) %}
-{# https://www.11ty.dev/docs/plugins/navigation/#bring-your-own-html-render-the-menu-items-manually #}
-<nav>
-  {%- for entry in navPages %}
-  <a href="{{ entry.url }}" {{ 'aria-current="page"' | safe if entry.url == curPage.url }}>
-    {{- entry.title -}}
-  </a>
-  {%- endfor %}
-</nav>
-{% endmacro %}