npm - @anydigital/eleventy-bricks - Versions diffs - 0.22.0 - Mend

@anydigital/eleventy-bricks 0.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/.prettierrc.json +3 -0
package/LICENSE +21 -0
package/README.md +1064 -0
package/package.json +49 -0
package/src/admin/index.html +12 -0
package/src/cli/download-files.js +136 -0
package/src/do/package.json +15 -0
package/src/eleventy.config.js +72 -0
package/src/filters/attr.js +16 -0
package/src/filters/attr_concat.js +65 -0
package/src/filters/attr_concat.test.js +205 -0
package/src/filters/if.js +39 -0
package/src/filters/if.test.js +63 -0
package/src/filters/merge.js +47 -0
package/src/filters/merge.test.js +51 -0
package/src/filters/remove_tag.js +42 -0
package/src/filters/remove_tag.test.js +60 -0
package/src/filters/where_in.js +49 -0
package/src/filters/where_in.test.js +148 -0
package/src/index.cjs +26 -0
package/src/index.js +94 -0
package/src/markdown.js +163 -0
package/src/markdown.test.js +589 -0
package/src/siteData.js +12 -0

package/package.json ADDED Viewed

@@ -0,0 +1,49 @@
+{
+  "name": "@anydigital/eleventy-bricks",
+  "version": "0.22.0",
+  "description": "A collection of helpful utilities and filters for Eleventy (11ty)",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    }
+  },
+  "bin": {
+    "download-files": "src/cli/download-files.js"
+  },
+  "scripts": {
+    "build": "npx download-files",
+    "test": "node --test src/**/*.test.js"
+  },
+  "keywords": [
+    "11ty",
+    "eleventy",
+    "plugin",
+    "helpers",
+    "filters",
+    "markdown",
+    "nunjucks"
+  ],
+  "author": "Anton Staroverov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anydigital/eleventy-bricks.git"
+  },
+  "bugs": {
+    "url": "https://github.com/anydigital/eleventy-bricks/issues"
+  },
+  "homepage": "https://github.com/anydigital/eleventy-bricks#readme",
+  "peerDependencies": {
+    "@11ty/eleventy": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "_downloadFiles": {
+    "https://raw.githubusercontent.com/anydigital/bricks/refs/heads/main/.prettierrc.json": ".prettierrc.json",
+    "https://raw.githubusercontent.com/danurbanowicz/eleventy-sveltia-cms-starter/refs/heads/master/admin/index.html": "src/admin/index.html"
+  }
+}

package/src/admin/index.html ADDED Viewed

@@ -0,0 +1,12 @@
+<!-- https://sveltiacms.app/en/docs/start#manual-installation -->
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="robots" content="noindex" />
+    <title>Sveltia CMS</title>
+  </head>
+  <body>
+    <script src="https://cdn.jsdelivr.net/npm/@sveltia/cms@0.128/dist/sveltia-cms.min.js"></script>
+  </body>
+</html>

package/src/cli/download-files.js ADDED Viewed

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { dirname, resolve, join } from 'path';
+/**
+ * Parse command line arguments
+ *
+ * @returns {Object} Parsed arguments
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const parsed = {
+    outputDir: null
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--output' || arg === '-o') {
+      if (i + 1 < args.length) {
+        parsed.outputDir = args[i + 1];
+        i++; // Skip next argument
+      } else {
+        throw new Error(`${arg} requires a directory path`);
+      }
+    }
+  }
+  return parsed;
+}
+/**
+ * Downloads files specified in package.json's _downloadFiles field
+ *
+ * @param {string|null} outputDir - Optional output directory to prepend to all paths
+ * @returns {Promise<boolean>} True if all downloads succeeded, false if any failed
+ */
+async function download(outputDir = null) {
+  try {
+    // Find and read package.json from the current working directory
+    const packageJsonPath = resolve(process.cwd(), 'package.json');
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    const downloadFiles = packageJson._downloadFiles;
+    if (!downloadFiles || typeof downloadFiles !== 'object') {
+      console.log('No _downloadFiles field found in package.json');
+      return true;
+    }
+    const entries = Object.entries(downloadFiles);
+    if (entries.length === 0) {
+      console.log('No files to download (_downloadFiles is empty)');
+      return true;
+    }
+    console.log(`Starting download of ${entries.length} file(s)...\n`);
+    let hasErrors = false;
+    // Process all downloads
+    for (const entry of entries) {
+      const url = entry[0];
+      let localPath = entry[1];
+      try {
+        console.log(`Downloading: ${url}`);
+        console.log(`        To: ${localPath}`);
+        // Download the file
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Get the file content
+        const content = await response.arrayBuffer();
+        const buffer = Buffer.from(content);
+        // Prepend output directory to local path if specified
+        if (outputDir) {
+          localPath = join(outputDir, localPath);
+        }
+        // Resolve the full path
+        const fullPath = resolve(process.cwd(), localPath);
+        // Create directory if it doesn't exist
+        const dir = dirname(fullPath);
+        await mkdir(dir, { recursive: true });
+        // Write the file
+        await writeFile(fullPath, buffer);
+        console.log(`   Success: ${localPath}\n`);
+      } catch (error) {
+        hasErrors = true;
+        console.error(`     Error: ${error.message}`);
+        console.error(`       URL: ${url}\n`);
+      }
+    }
+    // Summary
+    if (hasErrors) {
+      console.log('Download completed with errors');
+      return false;
+    } else {
+      console.log('All downloads completed successfully');
+      return true;
+    }
+  } catch (error) {
+    console.error(`Fatal error: ${error.message}`);
+    return false;
+  }
+}
+/**
+ * CLI entry point
+ */
+async function main() {
+  try {
+    const args = parseArgs();
+    const success = await download(args.outputDir);
+    process.exit(success ? 0 : 1);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+main();

package/src/do/package.json ADDED Viewed

@@ -0,0 +1,15 @@
+{
+  "name": "@anydigital/eleventy-bricks-do",
+  "private": true,
+  "scripts": {
+    "build": "npm run 11ty -- $ELTY_OPTIONS        && npm run tw -- --minify",
+    "start": "npm run 11ty -- $ELTY_OPTIONS --serve & npm run tw -- --watch",
+    "prerestart": "npm run 11ty:clean",
+    "stage": "npm run 11ty:clean; npm run build && serve ../_site",
+    "11ty": "cd ../ && NODE_OPTIONS='--preserve-symlinks' eleventy",
+    "11ty:clean": "rm -r ../_site",
+    "11ty:debug": "DEBUG=* npm run 11ty --",
+    "tw": "tailwindcss -i ../src/_theme/styles.css -o ../_site/styles.css",
+    "tw:debug": "DEBUG=* npm run tw --"
+  }
+}

package/src/eleventy.config.js ADDED Viewed

@@ -0,0 +1,72 @@
+/* CLI */
+import minimist from "minimist";
+/* Plugins */
+import { RenderPlugin } from "@11ty/eleventy";
+import eleventyNavigationPlugin from "@11ty/eleventy-navigation";
+import eleventyBricksPlugin from "@anydigital/eleventy-bricks";
+/* Libraries */
+import markdownIt from "markdown-it";
+import markdownItAnchor from "markdown-it-anchor";
+import markdownItAttrs from "markdown-it-attrs";
+/* Data */
+import yaml from "js-yaml";
+/**
+ * Eleventy Configuration
+ * @param {Object} eleventyConfig - The Eleventy configuration object
+ * @returns {Object} The Eleventy configuration object
+ */
+export default function (eleventyConfig) {
+  /* CLI support */
+  const argv = minimist(process.argv.slice(2));
+  const inputDir = argv.input || "src";
+  /* Plugins */
+  eleventyConfig.addPlugin(RenderPlugin);
+  eleventyConfig.addPlugin(eleventyNavigationPlugin);
+  eleventyConfig.addPlugin(eleventyBricksPlugin, {
+    mdAutoNl2br: true,
+    mdAutoRawTags: true,
+    mdAutoLinkFavicons: true,
+    siteData: true,
+    filters: ["attr", "where_in", "merge", "remove_tag", "if", "attr_concat"],
+  });
+  /* Libraries */
+  eleventyConfig.setLibrary(
+    "md",
+    markdownIt({
+      html: true,
+      breaks: true,
+      linkify: true,
+    })
+      .use(markdownItAnchor, {
+        permalink: markdownItAnchor.permalink.headerLink(),
+      })
+      .use(markdownItAttrs),
+  );
+  /* Data */
+  eleventyConfig.addDataExtension("yml", (contents) => yaml.load(contents));
+  /* Build */
+  eleventyConfig.addPassthroughCopy(
+    {
+      "src/_public": ".",
+      ...(inputDir !== "src" && { [`${inputDir}/_public`]: "." }),
+    },
+    { expand: true }, // This follows/resolves symbolic links
+  );
+  /* Dev tools */
+  // Follow symlinks in Chokidar used by 11ty to watch files
+  eleventyConfig.setChokidarConfig({ followSymlinks: true });
+  /* Config */
+  return {
+    dir: {
+      input: inputDir,
+      includes: "_theme",
+    },
+  };
+}

package/src/filters/attr.js ADDED Viewed

@@ -0,0 +1,16 @@
+/**
+ * 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/attr_concat.js ADDED Viewed

@@ -0,0 +1,65 @@
+/**
+ * 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") {
+    // 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);
+}

package/src/filters/attr_concat.test.js ADDED Viewed

@@ -0,0 +1,205 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { attrConcat } from "./attr_concat.js";
+describe("attrConcat", () => {
+  it("should concatenate array values to existing array attribute", () => {
+    const obj = { classes: ["foo", "bar"] };
+    const result = attrConcat(obj, "classes", ["baz", "qux"]);
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar", "baz", "qux"],
+    });
+  });
+  it("should parse JSON array string", () => {
+    const obj = { classes: ["foo", "bar"] };
+    const result = attrConcat(obj, "classes", '["baz", "qux", "quux"]');
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar", "baz", "qux", "quux"],
+    });
+  });
+  it("should handle single string value (not JSON)", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", "bar baz");
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar baz"],
+    });
+  });
+  it("should create new array if attribute doesn't exist", () => {
+    const obj = { name: "test" };
+    const result = attrConcat(obj, "classes", ["foo", "bar"]);
+    assert.deepStrictEqual(result, {
+      name: "test",
+      classes: ["foo", "bar"],
+    });
+  });
+  it("should handle empty object", () => {
+    const obj = {};
+    const result = attrConcat(obj, "classes", ["foo", "bar"]);
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar"],
+    });
+  });
+  it("should handle null object", () => {
+    const result = attrConcat(null, "classes", ["foo", "bar"]);
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar"],
+    });
+  });
+  it("should handle single value (non-array, non-string)", () => {
+    const obj = { ids: [1, 2] };
+    const result = attrConcat(obj, "ids", 3);
+    assert.deepStrictEqual(result, {
+      ids: [1, 2, 3],
+    });
+  });
+  it("should not mutate original object", () => {
+    const obj = { classes: ["foo", "bar"] };
+    const result = attrConcat(obj, "classes", ["baz"]);
+    assert.deepStrictEqual(obj, { classes: ["foo", "bar"] });
+    assert.deepStrictEqual(result, { classes: ["foo", "bar", "baz"] });
+    assert.notStrictEqual(obj, result);
+  });
+  it("should preserve other attributes", () => {
+    const obj = { classes: ["foo"], id: "test", data: { value: 42 } };
+    const result = attrConcat(obj, "classes", ["bar"]);
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar"],
+      id: "test",
+      data: { value: 42 },
+    });
+  });
+  it("should handle empty array values", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", []);
+    assert.deepStrictEqual(result, {
+      classes: ["foo"],
+    });
+  });
+  it("should handle empty string values", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", "");
+    assert.deepStrictEqual(result, {
+      classes: ["foo", ""],
+    });
+  });
+  it("should handle multiline strings as single value (not JSON)", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", "bar\n\nbaz\n\n\nqux");
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar\n\nbaz\n\n\nqux"],
+    });
+  });
+  it("should remove duplicate values from existing array", () => {
+    const obj = { classes: ["foo", "bar"] };
+    const result = attrConcat(obj, "classes", ["bar", "baz"]);
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar", "baz"],
+    });
+  });
+  it("should remove duplicate values from new array", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", ["bar", "bar", "baz", "baz"]);
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar", "baz"],
+    });
+  });
+  it("should handle duplicates in JSON array strings", () => {
+    const obj = { classes: ["foo", "bar"] };
+    const result = attrConcat(obj, "classes", '["bar", "baz", "bar", "qux"]');
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar", "baz", "qux"],
+    });
+  });
+  it("should preserve order and remove only duplicates", () => {
+    const obj = { classes: ["a", "b", "c"] };
+    const result = attrConcat(obj, "classes", ["b", "d", "e", "a"]);
+    assert.deepStrictEqual(result, {
+      classes: ["a", "b", "c", "d", "e"],
+    });
+  });
+  it("should parse valid JSON array string", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", '["bar", "baz", "qux"]');
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar", "baz", "qux"],
+    });
+  });
+  it("should treat non-JSON string as single value", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", "bar\nbaz\nqux");
+    assert.deepStrictEqual(result, {
+      classes: ["foo", "bar\nbaz\nqux"],
+    });
+  });
+  it("should keep plain string as single value", () => {
+    const obj = { tags: ["existing"] };
+    const result = attrConcat(obj, "tags", "single value");
+    assert.deepStrictEqual(result, {
+      tags: ["existing", "single value"],
+    });
+  });
+  it("should parse JSON with numbers", () => {
+    const obj = { ids: [1, 2] };
+    const result = attrConcat(obj, "ids", "[3, 4, 5]");
+    assert.deepStrictEqual(result, {
+      ids: [1, 2, 3, 4, 5],
+    });
+  });
+  it("should treat invalid JSON as single string value", () => {
+    const obj = { classes: ["foo"] };
+    const result = attrConcat(obj, "classes", '["bar", "baz"'); // Invalid JSON
+    assert.deepStrictEqual(result, {
+      classes: ["foo", '["bar", "baz"'],
+    });
+  });
+  it("should treat JSON non-array as single value", () => {
+    const obj = { tags: ["foo"] };
+    const result = attrConcat(obj, "tags", '{"key": "value"}');
+    assert.deepStrictEqual(result, {
+      tags: ["foo", '{"key": "value"}'],
+    });
+  });
+});

package/src/filters/if.js ADDED Viewed

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

package/src/filters/if.test.js ADDED Viewed

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert";
+import { iff } from "./if.js";
+test("iff returns trueValue when condition is truthy", () => {
+  assert.strictEqual(iff("yes", true, "no"), "yes");
+  assert.strictEqual(iff("yes", 1, "no"), "yes");
+  assert.strictEqual(iff("yes", "truthy", "no"), "yes");
+  assert.strictEqual(iff("yes", { a: 1 }, "no"), "yes"); // non-empty object is truthy
+  assert.strictEqual(iff("yes", [], "no"), "yes");
+});
+test("iff returns falseValue when condition is falsy", () => {
+  assert.strictEqual(iff("yes", false, "no"), "no");
+  assert.strictEqual(iff("yes", 0, "no"), "no");
+  assert.strictEqual(iff("yes", "", "no"), "no");
+  assert.strictEqual(iff("yes", null, "no"), "no");
+  assert.strictEqual(iff("yes", undefined, "no"), "no");
+});
+test("iff treats empty objects as falsy", () => {
+  assert.strictEqual(iff("yes", {}, "no"), "no");
+  assert.strictEqual(iff("yes", {}, ""), "");
+  assert.strictEqual(iff(100, {}, 200), 200);
+  // Non-empty objects should still be truthy
+  assert.strictEqual(iff("yes", { a: 1 }, "no"), "yes");
+  assert.strictEqual(iff("yes", { nested: {} }, "no"), "yes");
+});
+test("iff returns falseValue when condition is undefined", () => {
+  assert.strictEqual(iff("yes", undefined, "no"), "no");
+  assert.strictEqual(iff("yes", undefined), "");
+  assert.strictEqual(iff(100, undefined, 200), 200);
+});
+test("iff returns empty string as default falseValue", () => {
+  assert.strictEqual(iff("yes", false), "");
+  assert.strictEqual(iff("yes", 0), "");
+  assert.strictEqual(iff("yes", null), "");
+});
+test("iff works with various value types", () => {
+  assert.strictEqual(iff(100, true, 200), 100);
+  assert.strictEqual(iff(100, false, 200), 200);
+  const obj1 = { a: 1 };
+  const obj2 = { b: 2 };
+  assert.strictEqual(iff(obj1, true, obj2), obj1);
+  assert.strictEqual(iff(obj1, false, obj2), obj2);
+  const arr1 = [1, 2];
+  const arr2 = [3, 4];
+  assert.strictEqual(iff(arr1, true, arr2), arr1);
+  assert.strictEqual(iff(arr1, false, arr2), arr2);
+});
+test("iff evaluates condition correctly without type coercion confusion", () => {
+  // Common edge cases
+  assert.strictEqual(iff("yes", "false", "no"), "yes"); // string 'false' is truthy
+  assert.strictEqual(iff("yes", "0", "no"), "yes"); // string '0' is truthy
+  assert.strictEqual(iff("yes", NaN, "no"), "no"); // NaN is falsy
+});