@anyblades/buildawesome-kit 1.3.0-alpha

package/plugin/features/mdAutoNl2br.js

@@ -0,0 +1,22 @@
+/*<!--section:docs-->
+
+`mdAutoNl2br` feature 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.
+
+> **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.
+
+<!--section:code-->```js */
+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>");
+}
+
+export default function mdAutoNl2br(eleventyConfig) {
+  eleventyConfig.amendLibrary("md", (mdLib) => {
+    mdLib.renderer.rules.text = (tokens, idx) => {
+      return transformNl2br(tokens[idx].content);
+    };
+  });
+}
+//```

package/plugin/features/mdAutoNl2br.test.js

@@ -0,0 +1,68 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { transformNl2br } from "./mdAutoNl2br.js";
+
+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/plugin/features/mdAutoRawTags.js

@@ -0,0 +1,17 @@
+/*<!--section:docs-->
+
+`mdAutoRawTags` feature wraps template syntax `{{, }}, {%, %}` with `{% raw %}` tags
+to prevent them from being processed by the template engine in Markdown files.
+
+<!--section:code-->```js */
+export function transformAutoRaw(content) {
+  // This regex looks for {{, }}, {%, or %} individually and wraps them
+  return content.replace(/({{|}}|{%|%})/g, "{% raw %}$1{% endraw %}");
+}
+
+export default function mdAutoRawTags(eleventyConfig) {
+  eleventyConfig.addPreprocessor("mdAutoRawTags", "md", (data, content) => {
+    return transformAutoRaw(content);
+  });
+}
+//```

package/plugin/features/mdAutoRawTags.test.js

@@ -0,0 +1,80 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { transformAutoRaw } from "./mdAutoRawTags.js";
+
+describe("transformAutoRaw", () => {
+  it("should wrap opening double curly braces with raw tags", () => {
+    const input = "Use {{ variable }} to output.";
+    const expected = "Use {% raw %}{{{% endraw %} variable {% raw %}}}{% endraw %} to output.";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap closing double curly braces with raw tags", () => {
+    const input = "{{ name }}";
+    const expected = "{% raw %}{{{% endraw %} name {% raw %}}}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap opening template tags with raw tags", () => {
+    const input = "{% if condition %}";
+    const expected = "{% raw %}{%{% endraw %} if condition {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap closing template tags with raw tags", () => {
+    const input = "{% endif %}";
+    const expected = "{% raw %}{%{% endraw %} endif {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should handle multiple Nunjucks patterns in one string", () => {
+    const input = "{{ var1 }} and {% if test %} something {% endif %}";
+    const expected =
+      "{% raw %}{{{% endraw %} var1 {% raw %}}}{% endraw %} and {% raw %}{%{% endraw %} if test {% raw %}%}{% endraw %} something {% raw %}{%{% endraw %} endif {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should handle multiline content with Nunjucks syntax", () => {
+    const input = `# Title
+{{ variable }}
+Some text
+{% for item in items %}
+  {{ item }}
+{% endfor %}`;
+    const expected = `# Title
+{% raw %}{{{% endraw %} variable {% raw %}}}{% endraw %}
+Some text
+{% raw %}{%{% endraw %} for item in items {% raw %}%}{% endraw %}
+  {% raw %}{{{% endraw %} item {% raw %}}}{% endraw %}
+{% raw %}{%{% endraw %} endfor {% raw %}%}{% endraw %}`;
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should return unchanged content when no Nunjucks syntax is present", () => {
+    const input = "This is just plain text with no templates.";
+    assert.equal(transformAutoRaw(input), input);
+  });
+
+  it("should handle empty string", () => {
+    assert.equal(transformAutoRaw(""), "");
+  });
+
+  it("should handle content with only Nunjucks syntax", () => {
+    const input = "{{}}";
+    const expected = "{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should handle consecutive Nunjucks patterns", () => {
+    const input = "{{{{}}}}";
+    const expected = "{% raw %}{{{% endraw %}{% raw %}{{{% endraw %}{% raw %}}}{% endraw %}{% raw %}}}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+
+  it("should wrap each delimiter individually", () => {
+    const input = "Show {{ and }} and {% and %}";
+    const expected =
+      "Show {% raw %}{{{% endraw %} and {% raw %}}}{% endraw %} and {% raw %}{%{% endraw %} and {% raw %}%}{% endraw %}";
+    assert.equal(transformAutoRaw(input), expected);
+  });
+});

package/plugin/features/mdAutoUncommentAttrs.js

@@ -0,0 +1,26 @@
+/*<!--section:docs-->
+
+`mdAutoUncommentAttrs` feature amends the markdown library to automatically expand
+HTML-comment-wrapped attribute blocks `<!—-{...}-->` to their raw form
+`{...}`, which is useful when attribute syntax needs to be hidden from
+HTML parsers but expanded before markdown-it processes them.
+
+Implemented as a core rule so the transformation runs on the raw source
+before markdown-it-attrs (or any other plugin) parses the content.
+
+<!--section:code-->```js */
+export function transformUncommentAttrs(content) {
+  if (content.includes("<!--{")) {
+    content = content.replace(/<!--(\{[^}]*\})-->/g, "$1");
+  }
+  return content;
+}
+
+export default function mdAutoUncommentAttrs(eleventyConfig) {
+  eleventyConfig.amendLibrary("md", (mdLib) => {
+    mdLib.core.ruler.before("normalize", "uncomment_attrs", (state) => {
+      state.src = transformUncommentAttrs(state.src);
+    });
+  });
+}
+//```

package/plugin/features/mdAutoUncommentAttrs.test.js

@@ -0,0 +1,65 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { transformUncommentAttrs } from "./mdAutoUncommentAttrs.js";
+
+describe("transformUncommentAttrs", () => {
+  it("should expand a single <!--{...}--> to {...}", () => {
+    const input = "Some text <!--{.class}-->";
+    const expected = "Some text {.class}";
+    assert.equal(transformUncommentAttrs(input), expected);
+  });
+
+  it("should expand multiple <!--{...}--> occurrences", () => {
+    const input = "<!--{.foo}--> text <!--{.bar}-->";
+    const expected = "{.foo} text {.bar}";
+    assert.equal(transformUncommentAttrs(input), expected);
+  });
+
+  it("should handle attributes with spaces inside braces", () => {
+    const input = "Heading <!--{ .class #id }-->";
+    const expected = "Heading { .class #id }";
+    assert.equal(transformUncommentAttrs(input), expected);
+  });
+
+  it("should handle multiline content", () => {
+    const input = `# Title <!--{.heading}-->
+Some paragraph.
+> Blockquote <!--{.note}-->`;
+    const expected = `# Title {.heading}
+Some paragraph.
+> Blockquote {.note}`;
+    assert.equal(transformUncommentAttrs(input), expected);
+  });
+
+  it("should leave regular HTML comments untouched", () => {
+    const input = "<!-- this is a comment -->";
+    assert.equal(transformUncommentAttrs(input), input);
+  });
+
+  it("should leave <!--{...}--> intact when the content contains a closing brace inside", () => {
+    // The regex [^}]* stops at the first }, so nested } prevents a full match
+    const input = "<!--{{nested}}-->";
+    assert.equal(transformUncommentAttrs(input), input);
+  });
+
+  it("should not touch plain text with no comments", () => {
+    const input = "Just plain text with {.class} already exposed.";
+    assert.equal(transformUncommentAttrs(input), input);
+  });
+
+  it("should handle empty string", () => {
+    assert.equal(transformUncommentAttrs(""), "");
+  });
+
+  it("should handle back-to-back patterns without separator", () => {
+    const input = "<!--{.a}--><!--{.b}-->";
+    const expected = "{.a}{.b}";
+    assert.equal(transformUncommentAttrs(input), expected);
+  });
+
+  it("should preserve surrounding markdown content", () => {
+    const input = "| Cell 1 <!--{.highlight}--> | Cell 2 |";
+    const expected = "| Cell 1 {.highlight} | Cell 2 |";
+    assert.equal(transformUncommentAttrs(input), expected);
+  });
+});

package/plugin/features/siteData.js

@@ -0,0 +1,43 @@
+/*<!--section:docs-->
+
+`siteData` adds global `site` data via `eleventyComputed`. All scalar fields from `pkg.site` (`package.json`) and `data.site` (`_data/site.*`) are spread onto `site`; page-level wins over pkg. The asset keys below are **merged** (pkg → site) rather than overridden.
+
+| Variable             | Value / Description                                                          |
+| -------------------- | ---------------------------------------------------------------------------- |
+| `{{ site.year }}`     | Current year (e.g. `2026`)                                                   |
+| `{{ site.prod }}`     | `true` for `eleventy build`, `false` for `eleventy serve`                    |
+| `{{ site.styles }}`   | Merged array of stylesheet URLs                                              |
+| `{{ site.scripts }}`  | Merged array of script URLs                                                  |
+| `{{ site.head_extras }}` | Merged array of custom head HTML/strings                                   |
+| `{{ site.body_extras }}` | Merged array of custom body HTML/strings                                   |
+
+The named export `siteData(data)` is also usable directly (e.g. as RSS feed metadata).
+
+<!--section:code-->```js */
+const MERGED_KEYS = ["styles", "scripts", "head_extras", "body_extras"];
+
+// Lodash style
+export const castArray = (val) => (val == null ? [] : Array.isArray(val) ? val : [val]);
+
+export const concatUnique = (a, b) => [...new Set([...castArray(a), ...castArray(b)])];
+
+export const siteData = (data) => {
+  const pkgSite = data.pkg?.site ?? {};
+  const dataSite = data.site ?? {};
+  return {
+    ...pkgSite,
+    ...dataSite,
+    ...Object.fromEntries(MERGED_KEYS.map((key) => [key, concatUnique(pkgSite[key], dataSite[key])])),
+  };
+};
+
+export default function (eleventyConfig) {
+  eleventyConfig.addGlobalData("eleventyComputed", {
+    site: (data) => ({
+      ...siteData(data),
+      prod: process.env.ELEVENTY_RUN_MODE === "build",
+      year: new Date().getFullYear(),
+    }),
+  });
+}
+//```

package/plugin/features/siteData.test.js

@@ -0,0 +1,120 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { siteData, castArray, concatUnique } from "./siteData.js";
+
+describe("siteData", () => {
+  it("should merge keys from pkg.site and site, ignoring page-level data[key]", () => {
+    const data = {
+      pkg: {
+        site: {
+          title: "My Site",
+          head_extras: ["<meta name='pkg-meta' />"],
+          body_extras: ["<script src='pkg-script.js'></script>"],
+          styles: ["pkg.css"],
+          scripts: ["pkg.js"],
+        }
+      },
+      site: {
+        title: "Override Site",
+        head_extras: ["<meta name='site-meta' />"],
+        body_extras: ["<script src='site-script.js'></script>"],
+        styles: ["site.css"],
+        scripts: ["site.js"],
+      },
+      head_extras: ["<meta name='page-meta' />"],
+      body_extras: ["<script src='page-script.js'></script>"],
+      styles: ["page.css"],
+      scripts: ["page.js"],
+    };
+
+    const result = siteData(data);
+
+    assert.equal(result.title, "Override Site");
+    assert.deepEqual(result.head_extras, ["<meta name='pkg-meta' />", "<meta name='site-meta' />"]);
+    assert.deepEqual(result.body_extras, ["<script src='pkg-script.js'></script>", "<script src='site-script.js'></script>"]);
+    assert.deepEqual(result.styles, ["pkg.css", "site.css"]);
+    assert.deepEqual(result.scripts, ["pkg.js", "site.js"]);
+  });
+
+  it("should handle missing keys gracefully", () => {
+    const data = {
+      pkg: {},
+      site: {},
+    };
+    const result = siteData(data);
+    assert.deepEqual(result.head_extras, []);
+    assert.deepEqual(result.body_extras, []);
+    assert.deepEqual(result.styles, []);
+    assert.deepEqual(result.scripts, []);
+  });
+
+  it("should deduplicate merged keys using Set", () => {
+    const data = {
+      pkg: {
+        site: {
+          styles: ["pkg.css", "duplicate.css"],
+        }
+      },
+      site: {
+        styles: ["duplicate.css", "site.css"],
+      }
+    };
+    const result = siteData(data);
+    assert.deepEqual(result.styles, ["pkg.css", "duplicate.css", "site.css"]);
+  });
+
+  it("should support string values instead of arrays for merged keys", () => {
+    const data = {
+      pkg: {
+        site: {
+          styles: "pkg.css",
+          scripts: ["pkg.js"],
+        }
+      },
+      site: {
+        styles: ["site.css"],
+        scripts: "site.js",
+      }
+    };
+    const result = siteData(data);
+    assert.deepEqual(result.styles, ["pkg.css", "site.css"]);
+    assert.deepEqual(result.scripts, ["pkg.js", "site.js"]);
+  });
+});
+
+describe("castArray", () => {
+  it("should return an empty array for null or undefined", () => {
+    assert.deepEqual(castArray(null), []);
+    assert.deepEqual(castArray(undefined), []);
+  });
+
+  it("should return the same array reference if given an array", () => {
+    const arr = [1, 2, 3];
+    assert.equal(castArray(arr), arr);
+  });
+
+  it("should wrap non-array, non-null values in an array", () => {
+    assert.deepEqual(castArray("hello"), ["hello"]);
+    assert.deepEqual(castArray(123), [123]);
+    assert.deepEqual(castArray({ a: 1 }), [{ a: 1 }]);
+  });
+});
+
+describe("concatUnique", () => {
+  it("should concatenate and deduplicate arrays", () => {
+    assert.deepEqual(concatUnique([1, 2], [2, 3]), [1, 2, 3]);
+  });
+
+  it("should handle null or undefined arguments gracefully", () => {
+    assert.deepEqual(concatUnique(null, [1, 2]), [1, 2]);
+    assert.deepEqual(concatUnique([1, 2], undefined), [1, 2]);
+    assert.deepEqual(concatUnique(null, undefined), []);
+  });
+
+  it("should handle single values or mixed types", () => {
+    assert.deepEqual(concatUnique("a", "b"), ["a", "b"]);
+    assert.deepEqual(concatUnique("a", ["a", "b"]), ["a", "b"]);
+  });
+});
+
+

package/plugin/features/virtualPages.js

@@ -0,0 +1,18 @@
+/*<!--section:docs-->
+
+`virtualPages` generates Eleventy pages from a `pages.yaml` file in the input directory. Each entry's front-matter data is passed directly to `addTemplate`; if the entry has a `permalink` field it is used to derive the virtual slug (e.g. `permalink: /about/` → `.about/index.md`), otherwise the array index is used.
+
+<!--section:code-->```js */
+import { readFileSync } from "fs";
+import YAML from "js-yaml";
+
+export default function (eleventyConfig) {
+  // Virtual pages
+  const pages = YAML.load(readFileSync(eleventyConfig.directories.input + "/pages.yaml", "utf8"));
+  for (const [index, data] of pages.entries()) {
+    const virtualSlug = data.permalink ? data.permalink + "index" : index;
+    // console.log(data, virtualSlug);
+    eleventyConfig.addTemplate("." + virtualSlug + ".md", "", data);
+  }
+}
+//```

package/plugin/filters/attr_concat.js

@@ -0,0 +1,55 @@
+/*<!--section:docs-->
+
+A filter that concatenates values to an attribute array, returning a new object with the combined array. Useful for adding items to arrays like tags, classes, or other list-based attributes.
+
+<!--section:code-->```js */
+export default function (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,
+  };
+}
+/*```<!--section:docs-->
+
+### Examples
+
+Add tags to a post object in `.njk`:
+
+```jinja2
+{% set enhancedPost = post | attr_concat('tags', ['featured', 'popular']) %}
+```
+*/