Build Awesome / 11ty Filters

/**
 * Concatenate values to an attribute array
 *
 * This function takes an object, an attribute name, and values to append.
 * It returns a new object with the attribute as a combined array of unique items.
 *
 * @param {Object} obj - The object to modify
 * @param {string} attr - The attribute name
 * @param {Array|string|*} values - Values to concatenate (array, JSON string array, or single value)
 * @returns {Object} A new object with the combined unique array
 */
export function attrConcat(obj, attr, values) {
  // Get the existing attribute value, default to empty array if not present
  const existingArray = obj?.[attr] || [];

  // Check if existing value is an array, convert if not
  if (!Array.isArray(existingArray)) {
    console.error(`attrConcat: Expected ${attr} to be an array, got ${typeof existingArray}`);
  }

  // Process the values argument
  let valuesToAdd = [];
  if (Array.isArray(values)) {
    valuesToAdd = values;
  } else if (typeof values === "string" && values.length >= 2 && values.at(0) == "[" && values.at(-1) == "]") {
    // Try to parse as JSON array
    try {
      const parsed = JSON.parse(values);
      if (Array.isArray(parsed)) {
        valuesToAdd = parsed;
      } else {
        valuesToAdd = [values];
      }
    } catch {
      // Not valid JSON, treat as single value
      valuesToAdd = [values];
    }
  } else {
    // If it's a single value, wrap it in an array
    valuesToAdd = [values];
  }

  // Combine arrays and remove duplicates using Set
  const combinedArray = [...new Set([...existingArray, ...valuesToAdd])];

  // Return a new object with the combined array
  return {
    ...obj,
    [attr]: combinedArray,
  };
}

/**
 * attr_concat filter - Concatenate values to an attribute array
 *
 * This filter takes an object, an attribute name, and values to append.
 * It returns a new object with the attribute as a combined array of unique items.
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function attrConcatFilter(eleventyConfig) {
  eleventyConfig.addFilter("attr_concat", attrConcat);
}

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 attrIncludes(collection, attrName, targetValue) {
  // If no targetValue, return original collection
  if (!targetValue) {
    return collection;
  }

  return collection.filter((item) => {
    // Get the attribute value from the item (supports nested paths like "data.tags")
    const attrValue = get(item, attrName);

    // If the attribute is an array, check if it includes the target value
    if (Array.isArray(attrValue)) {
      return attrValue.includes(targetValue);
    }

    // Otherwise skip this item
    return false;
  });
}

/**
 * Registers the attr_includes filter with Eleventy
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function attrIncludesFilter(eleventyConfig) {
  eleventyConfig.addFilter("attr_includes", attrIncludes);
}

/**
 * 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);
}

import EleventyFetch from "@11ty/eleventy-fetch";
import path from "path";
import fs from "fs/promises";

/**
 * fetch filter - Fetch a URL or local file and return its raw content
 *
 * This filter takes a URL or local file path. For URLs, it downloads them
 * using eleventy-fetch to the input directory's _downloads folder.
 * For local paths, it reads them relative to the input directory.
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function fetchFilter(eleventyConfig) {
  eleventyConfig.addFilter("fetch", async function (url) {
    if (!url) {
      throw new Error("fetch filter requires a URL or path");
    }

    // Get the input directory from Eleventy config
    const inputDir = this.eleventy.directories.input;

    // Check if it's a URL or local path
    const isUrl = url.startsWith("http://") || url.startsWith("https://");

    try {
      if (isUrl) {
        // Handle remote URLs with eleventy-fetch
        const cacheDirectory = path.join(inputDir, "_downloads");
        const content = await EleventyFetch(url, {
          duration: "1d", // Cache for 1 day by default
          type: "text", // Return as text
          directory: cacheDirectory,
        });
        return content.toString(); // toString() handles bytes cache (inside eleventyComputed)
      } else {
        // Handle local file paths relative to input directory
        const filePath = path.join(inputDir, url);
        const content = await fs.readFile(filePath, "utf-8");
        return content;
      }
    } catch (error) {
      throw new Error(`Failed to fetch ${url}: ${error.message}`);
    }
  });
}

/**
 * if utility function - Ternary/conditional helper
 *
 * Returns trueValue if condition is truthy, otherwise returns falseValue.
 * Similar to Nunjucks' inline if: `value if condition else other_value`
 *
 * @param {*} trueValue - The value to return if condition is truthy
 * @param {*} condition - The condition to evaluate
 * @param {*} falseValue - The value to return if condition is falsy (default: empty string)
 * @returns {*} Either trueValue or falseValue based on condition
 */
export function iff(trueValue, condition, falseValue = "") {
  // Treat empty objects {} as falsy
  if (condition && typeof condition === "object" && !Array.isArray(condition) && Object.keys(condition).length === 0) {
    return falseValue;
  }
  return !!condition ? trueValue : falseValue;
}

/**
 * if filter - Inline conditional/ternary operator for templates
 *
 * This filter provides a simple inline if/else similar to Nunjucks.
 *
 * Usage in Liquid templates:
 *   {{ "Active" | if: isActive, "Inactive" }}
 *   {{ "Yes" | if: condition }}
 *   {{ someValue | if: test, otherValue }}
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function ifFilter(eleventyConfig) {
  eleventyConfig.addFilter("if", iff);
}

/**
 * Merge objects together
 *
 * Shallow merges objects (later values override earlier ones)
 *
 * @param {Object} first - The first object
 * @param {...Object} rest - Additional objects to merge
 * @returns {Object} The merged result
 */
export function merge(first, ...rest) {
  // If first argument is null or undefined, treat as empty object
  if (first === null || first === undefined) {
    first = {};
  }

  // Only support objects
  if (typeof first === "object" && !Array.isArray(first)) {
    // 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 not an object, return empty object
  return {};
}

/**
 * merge filter - Merge objects together
 *
 * This filter merges objects, similar to Twig's merge filter.
 *
 * Usage in templates:
 *   {{ obj1 | merge(obj2) }}
 *   {{ obj1 | merge(obj2, obj3) }}
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function mergeFilter(eleventyConfig) {
  eleventyConfig.addFilter("merge", merge);
}

/**
 * Remove specified HTML element from provided HTML
 *
 * @param {string} html - The HTML content to process
 * @param {string} tagName - The tag name to remove
 * @returns {string} The HTML with the specified tag removed
 */
export function removeTag(html, tagName) {
  if (!html || typeof html !== "string") {
    return html;
  }

  if (typeof tagName !== "string" || !tagName) {
    return html;
  }

  // Escape special regex characters in tag name
  const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

  // Remove opening and closing tags along with their content
  // This regex matches: <tag attributes>content</tag>
  const regex = new RegExp(`<${escapedTag}(?:\\s[^>]*)?>.*?<\\/${escapedTag}>`, "gis");
  let result = html.replace(regex, "");

  // Also remove self-closing tags: <tag />
  const selfClosingRegex = new RegExp(`<${escapedTag}(?:\\s[^>]*)?\\s*\\/?>`, "gi");
  result = result.replace(selfClosingRegex, "");

  return result;
}

/**
 * remove_tag filter - Remove specified HTML element from provided HTML
 *
 * Usage in templates:
 *   {{ htmlContent | remove_tag('script') }}
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function removeTagFilter(eleventyConfig) {
  eleventyConfig.addFilter("remove_tag", removeTag);
}

/**
 * Extract a named section from content marked with HTML comments
 *
 * @param {string} content - The content to process
 * @param {string} sectionName - The section name(s) to extract
 * @returns {string} The extracted section content
 */
export function section(content, sectionName) {
  if (!content || typeof content !== "string") {
    return content;
  }

  if (typeof sectionName !== "string" || !sectionName) {
    return "";
  }

  // Normalize section name for comparison (trim whitespace)
  const targetName = sectionName.trim().toLowerCase();

  // Regex to match section markers with content up to the next section or end of string
  // Captures: (1) section names, (2) content until next section marker or end
  const sectionRegex = /<[!]--section:([^>]+)-->([\s\S]*?)(?=<[!]--section|$)/g;

  let results = [];
  let match;

  // Find all sections
  while ((match = sectionRegex.exec(content)) !== null) {
    const namesStr = match[1];
    const sectionContent = match[2];
    const names = namesStr.split(",").map((n) => n.trim().toLowerCase());

    // Check if any of the names match the target
    if (names.includes(targetName)) {
      results.push(sectionContent);
    }
  }

  // Join all matching sections
  return results.join("");
}

/**
 * section filter - Extract a named section from content
 *
 * Usage in templates:
 *   {{ content | section('intro') }}
 *   {{ content | section('footer') }}
 *
 * Content format:
 *   <!--section:intro-->
 *   This is the intro content
 *   <!--section:main-->
 *   This is the main content
 *   <!--section:footer,sidebar-->
 *   This appears in both footer and sidebar sections
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function sectionFilter(eleventyConfig) {
  eleventyConfig.addFilter("section", section);
}

/**
 * Strip a specified HTML element from provided HTML, keeping its inner content
 *
 * @param {string} html - The HTML content to process
 * @param {string} tagName - The tag name to strip (opening/closing tags removed, inner content kept)
 * @returns {string} The HTML with the specified tag stripped but its inner content preserved
 */
export function stripTag(html, tagName) {
  if (!html || typeof html !== "string") {
    return html;
  }

  if (typeof tagName !== "string" || !tagName) {
    return html;
  }

  // Escape special regex characters in tag name
  const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

  // Remove opening tags (with optional attributes): <tag> or <tag attr="val">
  const openingRegex = new RegExp(`<${escapedTag}(?:\\s[^>]*)?>`, "gi");
  let result = html.replace(openingRegex, "");

  // Remove closing tags: </tag>
  const closingRegex = new RegExp(`<\\/${escapedTag}>`, "gi");
  result = result.replace(closingRegex, "");

  return result;
}

/**
 * strip_tag filter - Strip a specified HTML element, keeping its inner content
 *
 * Usage in templates:
 *   {{ htmlContent | strip_tag('div') }}
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function stripTagFilter(eleventyConfig) {
  eleventyConfig.addFilter("strip_tag", stripTag);
}

/**
 * Remove the minimal common indentation from a multi-line string
 *
 * Finds the smallest leading-whitespace count across all non-empty lines
 * and strips that many characters from the beginning of every line.
 *
 * @param {string} content - The input string
 * @returns {string} The unindented string
 */
export function unindent(content) {
  const lines = String(content ?? "").split("\n");
  const minIndent = Math.min(...lines.filter((l) => l.trim()).map((l) => l.match(/^(\s*)/)[1].length));
  return lines.map((l) => l.slice(minIndent)).join("\n");
}

/**
 * unindent filter - Remove minimal common indentation
 *
 * Strips the smallest leading-whitespace indent shared by all non-empty
 * lines, useful for dedenting captured or indented template blocks.
 *
 * Usage in templates:
 *   {{ content | unindent }}
 *
 * @param {Object} eleventyConfig - The Eleventy configuration object
 */
export function unindentFilter(eleventyConfig) {
  eleventyConfig.addFilter("unindent", unindent);
}