@anydigital/eleventy-bricks 1.0.0-alpha.17 → 1.0.0-alpha.19

package/src/filters/where_in.js

@@ -0,0 +1,49 @@
+import lodash from "@11ty/lodash-custom";
+const { get } = lodash;
+
+/**
+ * Core logic for filtering collection items by attribute value
+ *
+ * This function 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.
+ *
+ * Supports nested attribute names using dot notation (e.g., "data.tags").
+ *
+ * @param {Array} collection - The collection to filter
+ * @param {string} attrName - The attribute name to check (supports dot notation for nested properties)
+ * @param {*} targetValue - The value to match against
+ * @returns {Array} Filtered collection
+ */
+export function whereIn(collection, attrName, targetValue) {
+  if (!collection || !Array.isArray(collection)) {
+    return [];
+  }
+
+  return collection.filter((item) => {
+    // Get the attribute value from the item (supports nested paths like "data.tags")
+    const attrValue = get(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;
+  });
+}
+
+/**
+ * Registers the where_in filter with Eleventy
+ *
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ */
+export function whereInFilter(eleventyConfig) {
+  eleventyConfig.addFilter("where_in", whereIn);
+}

package/src/filters/where_in.test.js

@@ -0,0 +1,148 @@
+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);
+  });
+});

package/src/index.cjs

@@ -10,7 +10,7 @@ module.exports = async function eleventyBricksPlugin(eleventyConfig, options) {
 };
 
 // Export individual helpers for granular usage
-['bricks', 'mdAutoRawTags', 'mdAutoNl2br', 'setAttrFilter', 'byAttrFilter', 'mergeFilter', 'removeTagFilter', 'siteData'].forEach(name => {
+['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);
@@ -18,7 +18,7 @@ module.exports = async function eleventyBricksPlugin(eleventyConfig, options) {
 });
 
 // Export transform/utility functions for advanced usage
-['transformAutoRaw', 'transformNl2br', 'merge', 'removeTag'].forEach(name => {
+['transformAutoRaw', 'transformNl2br', 'merge', 'removeTag', 'iff', 'attrConcat'].forEach(name => {
   module.exports[name] = async (...args) => {
     const module = await import('./index.js');
     return module[name](...args);

package/src/index.js

@@ -1,35 +1,75 @@
-import { bricks } from "./bricks.js";
-import { mdAutoRawTags, mdAutoNl2br, transformAutoRaw, transformNl2br } from "./markdown.js";
-import { setAttrFilter } from "./setAttrFilter.js";
-import { byAttrFilter } from "./byAttrFilter.js";
-import { mergeFilter, merge } from "./mergeFilter.js";
-import { removeTagFilter, removeTag } from "./removeTagFilter.js";
+import {
+  mdAutoRawTags,
+  mdAutoNl2br,
+  transformAutoRaw,
+  transformNl2br,
+} from "./markdown.js";
+import { setAttrFilter } from "./filters/attr.js";
+import { whereInFilter } from "./filters/where_in.js";
+import { mergeFilter, merge } from "./filters/merge.js";
+import { removeTagFilter, removeTag } from "./filters/remove_tag.js";
+import { ifFilter, iff } from "./filters/if.js";
+import { attrConcatFilter, attrConcat } from "./filters/attr_concat.js";
 import { siteData } from "./siteData.js";
 
 /**
  * 11ty Bricks Plugin
- * 
+ *
  * A collection of helpful utilities and filters for Eleventy (11ty).
  * Can be used as a plugin or by importing individual helpers.
- * 
+ *
  * @param {Object} eleventyConfig - The Eleventy configuration object
  * @param {Object} options - Plugin options
- * @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.setAttrFilter - Enable setAttr filter (default: false)
- * @param {boolean} options.byAttrFilter - Enable byAttr filter (default: false)
- * @param {boolean} options.mergeFilter - Enable merge filter (default: false)
- * @param {boolean} options.removeTagFilter - Enable removeTag filter (default: false)
- * @param {boolean} options.siteData - Enable site.year and site.isProd global data (default: false)
+ * @param {Array<string>} options.filters - Array of filter names to enable: 'attr', 'where_in', 'merge', 'remove_tag', 'if', 'attr_concat' (default: [])
+ * @param {boolean} options.siteData - Enable site.year and site.prod global data (default: false)
  */
 export default function eleventyBricksPlugin(eleventyConfig, options = {}) {
-  const plugins = { bricks, mdAutoRawTags, mdAutoNl2br, setAttrFilter, byAttrFilter, mergeFilter, removeTagFilter, siteData };
-  Object.entries(options).forEach(([key, enabled]) => enabled && plugins[key]?.(eleventyConfig));
+  const plugins = {
+    mdAutoRawTags,
+    mdAutoNl2br,
+    siteData,
+  };
+
+  const filters = {
+    attr: setAttrFilter,
+    where_in: whereInFilter,
+    merge: mergeFilter,
+    remove_tag: removeTagFilter,
+    if: ifFilter,
+    attr_concat: attrConcatFilter,
+  };
+
+  // Handle individual plugin options
+  Object.entries(options).forEach(([key, enabled]) => {
+    if (key !== "filters" && enabled && plugins[key]) {
+      plugins[key](eleventyConfig);
+    }
+  });
+
+  // Handle filters array
+  if (Array.isArray(options.filters)) {
+    options.filters.forEach((filterName) => {
+      if (filters[filterName]) {
+        filters[filterName](eleventyConfig);
+      }
+    });
+  }
 }
 
 // Export individual helpers for granular usage
-export { bricks, mdAutoRawTags, mdAutoNl2br, setAttrFilter, byAttrFilter, mergeFilter, removeTagFilter, siteData };
+export {
+  mdAutoRawTags,
+  mdAutoNl2br,
+  setAttrFilter,
+  whereInFilter,
+  mergeFilter,
+  removeTagFilter,
+  ifFilter,
+  attrConcatFilter,
+  siteData,
+};
 
 // Export transform/utility functions for advanced usage
-export { transformAutoRaw, transformNl2br, merge, removeTag };
+export { transformAutoRaw, transformNl2br, merge, removeTag, iff, attrConcat };

package/src/siteData.js

@@ -1,12 +1,12 @@
 /**
- * Add site.year and site.isProd global data
- * - site.isProd: Boolean indicating if running in production mode (build) vs development (serve)
+ * 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.isProd", () => process.env.ELEVENTY_RUN_MODE === "build");
+  eleventyConfig.addGlobalData("site.prod", () => process.env.ELEVENTY_RUN_MODE === "build");
   eleventyConfig.addGlobalData("site.year", () => new Date().getFullYear());
 }
 

package/src/bricks.js

@@ -1,125 +0,0 @@
-export function bricks(eleventyConfig) {
-
-  // Brick Registry System
-  // Global registry to track dependencies per page
-  const brickRegistry = new Map();
-
-  // Helper to get or create page registry
-  function getPageRegistry(page) {
-    const pageUrl = page.url || page.outputPath || 'default';
-    if (!brickRegistry.has(pageUrl)) {
-      brickRegistry.set(pageUrl, {
-        dependencies: new Set(),  // Raw dependencies (URLs) - categorized later
-        inlineStyles: new Set(),
-        inlineScripts: new Set()
-      });
-    }
-    return brickRegistry.get(pageUrl);
-  }
-
-  // Clear registry before each build
-  eleventyConfig.on("eleventy.before", async () => {
-    brickRegistry.clear();
-  });
-
-  // brick shortcode: registers and renders a brick component
-  eleventyConfig.addShortcode("brick", function(brickModule, ...args) {
-    const registry = getPageRegistry(this.page);
-    
-    if (!brickModule) return '';
-    
-    // Register external dependencies (categorized later in transform)
-    if (brickModule.dependencies) {
-      brickModule.dependencies.forEach(dep => {
-        registry.dependencies.add(dep);
-      });
-    }
-    
-    // Register inline styles directly from style variable
-    if (brickModule.style && brickModule.style.trim()) {
-      registry.inlineStyles.add(brickModule.style);
-    }
-    
-    // Register inline scripts directly from script variable
-    if (brickModule.script && brickModule.script.trim()) {
-      registry.inlineScripts.add(brickModule.script);
-    }
-    
-    // Render the brick using render() macro
-    if (brickModule.render && typeof brickModule.render === 'function') {
-      return brickModule.render(...args);
-    }
-    
-    return '';
-  });
-
-  // bricksRegistry shortcode: outputs placeholder and base dependencies
-  eleventyConfig.addShortcode("bricksDependencies", function(dependencies = []) {
-    const registry = getPageRegistry(this.page);
-    
-    // Register root dependencies if provided (categorized later in transform)
-    if (dependencies && Array.isArray(dependencies)) {
-      dependencies.forEach(dep => {
-        registry.dependencies.add(dep);
-      });
-    }
-    
-    // Return placeholder comment that will be replaced by transform
-    return '<!-- BRICK_DEPENDENCIES_PLACEHOLDER -->';
-  });
-
-  // Transform to inject collected dependencies
-  eleventyConfig.addTransform("injectBrickDependencies", function(content, outputPath) {
-    if (!outputPath || !outputPath.endsWith(".html")) {
-      return content;
-    }
-
-    const pageUrl = this.page?.url || this.page?.outputPath || outputPath;
-    const registry = brickRegistry.get(pageUrl);
-
-    if (!registry || !content.includes('<!-- BRICK_DEPENDENCIES_PLACEHOLDER -->')) {
-      return content;
-    }
-
-    // Categorize dependencies by type
-    const externalStyles = [];
-    const externalScripts = [];
-    
-    registry.dependencies.forEach(dep => {
-      // Categorize by type
-      if (dep.endsWith('.css') || dep.includes('.css?')) {
-        externalStyles.push(dep);
-      } else if (dep.endsWith('.js') || dep.includes('.js?')) {
-        externalScripts.push(dep);
-      }
-    });
-
-    // Build HTML for dependencies
-    let dependenciesHtml = '\n';
-    
-    // Add external CSS links
-    externalStyles.forEach(href => {
-      dependenciesHtml += `  <link rel="stylesheet" href="${href}">\n`;
-    });
-    
-    // Add inline styles
-    registry.inlineStyles.forEach(style => {
-      dependenciesHtml += `  <style>${style}</style>\n`;
-    });
-    
-    // Add external script links
-    externalScripts.forEach(src => {
-      dependenciesHtml += `  <script src="${src}"></script>\n`;
-    });
-    
-    // Add inline scripts
-    registry.inlineScripts.forEach(script => {
-      dependenciesHtml += `  <script>${script}</script>\n`;
-    });
-    
-    dependenciesHtml += '  ';
-
-    // Replace placeholder with actual dependencies
-    return content.replace('<!-- BRICK_DEPENDENCIES_PLACEHOLDER -->', dependenciesHtml);
-  });
-}

package/src/byAttrFilter.js

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,105 +0,0 @@
-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/mergeFilter.js

@@ -1,57 +0,0 @@
-/**
- * Merge arrays or objects together
- * 
- * For arrays: concatenates them together
- * For objects: shallow merges them (later values override earlier ones)
- * 
- * @param {Array|Object} first - The first array or object
- * @param {...Array|Object} rest - Additional arrays or objects to merge
- * @returns {Array|Object} The merged result
- */
-export function merge(first, ...rest) {
-  // If first argument is null or undefined, treat as empty
-  if (first === null || first === undefined) {
-    first = Array.isArray(rest[0]) ? [] : {};
-  }
-
-  // Determine if we're working with arrays or objects
-  const isArray = Array.isArray(first);
-
-  if (isArray) {
-    // Merge arrays by concatenating
-    return rest.reduce((acc, item) => {
-      if (Array.isArray(item)) {
-        return acc.concat(item);
-      }
-      // If item is not an array, add it as a single element
-      return acc.concat([item]);
-    }, [...first]);
-  } else if (typeof first === 'object') {
-    // Merge objects using spread operator (shallow merge)
-    return rest.reduce((acc, item) => {
-      if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
-        return { ...acc, ...item };
-      }
-      return acc;
-    }, { ...first });
-  }
-
-  // If first is a primitive, return it as-is
-  return first;
-}
-
-/**
- * merge filter - Merge arrays or objects together
- * 
- * This filter merges arrays or objects, similar to Twig's merge filter.
- * 
- * Usage in templates:
- *   {{ array1 | merge(array2) }}
- *   {{ array1 | merge(array2, array3) }}
- *   {{ obj1 | merge(obj2) }}
- * 
- * @param {Object} eleventyConfig - The Eleventy configuration object
- */
-export function mergeFilter(eleventyConfig) {
-  eleventyConfig.addFilter("merge", merge);
-}