feat: added a tag to allow for featured notes

test/build-integrity.test.js

@@ -45,7 +45,7 @@ test("Build & Link Integrity: Output inspection and link verification", () => {
     // 2. HTML Boilerplate Invariants
     assert.match(content, /<!DOCTYPE html>/i, `${relHtml} must contain <!DOCTYPE html>`);
     assert.match(content, /<meta\s+name="viewport"/i, `${relHtml} must have viewport meta tag`);
-    assert.match(content, /<link\s+rel="stylesheet"\s+href="\/assets\/css\/main\.css">/i, `${relHtml} must link to main.css`);
+    assert.match(content, /<link\s+rel="stylesheet"\s+href="\/assets\/css\/main\.css(?:\?[^"]*)?">/i, `${relHtml} must link to main.css`);
 
     // 3. Internal Link Integrity (No 404s!)
     const internalLinks = [...content.matchAll(/href="(\/[^"#?]*)"/g)].map((m) => m[1]);

test/post-sorting.test.js

@@ -0,0 +1,104 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { postComparator, isPostPinned, getPostTimestamp } from "../src/_utils/sort-posts.js";
+
+test("Post Sorting: isPostPinned detection", () => {
+  assert.equal(isPostPinned({ data: { pinned: true } }), true);
+  assert.equal(isPostPinned({ data: { featured: true } }), true);
+  assert.equal(isPostPinned({ data: { pinned: false } }), false);
+  assert.equal(isPostPinned({ data: { featured: false } }), false);
+  assert.equal(isPostPinned({ data: { pinned: null } }), false);
+  assert.equal(isPostPinned({ data: {} }), false);
+  assert.equal(isPostPinned({}), false);
+  assert.equal(isPostPinned(null), false);
+  assert.equal(isPostPinned(undefined), false);
+  assert.equal(isPostPinned("invalid"), false);
+});
+
+test("Post Sorting: getPostTimestamp extraction and fallback", () => {
+  const d = new Date("2026-09-01T00:00:00Z");
+  assert.equal(getPostTimestamp({ date: d }), d.getTime());
+  assert.equal(getPostTimestamp({ data: { date: "2026-09-01" } }), new Date("2026-09-01").getTime());
+  assert.equal(getPostTimestamp({ data: { created: "2026-09-01" } }), new Date("2026-09-01").getTime());
+  assert.equal(getPostTimestamp({ date: "not-a-date" }), 0);
+  assert.equal(getPostTimestamp({}), 0);
+  assert.equal(getPostTimestamp(null), 0);
+});
+
+test("Post Sorting: standard chronological sort (unpinned posts)", () => {
+  const postNew = {
+    data: { title: "Newer Post" },
+    date: new Date("2026-09-10")
+  };
+  const postOld = {
+    data: { title: "Older Post" },
+    date: new Date("2026-08-01")
+  };
+
+  const sorted = [postOld, postNew].sort(postComparator);
+  assert.deepEqual(sorted.map((p) => p.data.title), ["Newer Post", "Older Post"]);
+});
+
+test("Post Sorting: pinned post forces top position over newer unpinned post", () => {
+  const newerUnpinned = {
+    data: { title: "Newer Unpinned", pinned: false },
+    date: new Date("2026-09-20")
+  };
+  const olderPinned = {
+    data: { title: "Older Pinned", pinned: true },
+    date: new Date("2026-07-01")
+  };
+
+  const sorted = [newerUnpinned, olderPinned].sort(postComparator);
+  assert.equal(sorted[0].data.title, "Older Pinned");
+  assert.equal(sorted[1].data.title, "Newer Unpinned");
+});
+
+test("Post Sorting: featured post forces top position over newer unpinned post", () => {
+  const newerRegular = {
+    data: { title: "Fresh Article" },
+    date: new Date("2026-09-22")
+  };
+  const olderFeatured = {
+    data: { title: "Featured Pillar", featured: true },
+    date: new Date("2026-06-15")
+  };
+
+  const sorted = [newerRegular, olderFeatured].sort(postComparator);
+  assert.equal(sorted[0].data.title, "Featured Pillar");
+  assert.equal(sorted[1].data.title, "Fresh Article");
+});
+
+test("Post Sorting: multiple pinned posts sort among themselves chronologically", () => {
+  const olderPinned = {
+    data: { title: "Older Pinned", pinned: true },
+    date: new Date("2026-05-01")
+  };
+  const newerPinned = {
+    data: { title: "Newer Pinned", featured: true },
+    date: new Date("2026-08-15")
+  };
+  const freshUnpinned = {
+    data: { title: "Fresh Regular" },
+    date: new Date("2026-09-01")
+  };
+
+  const list = [olderPinned, freshUnpinned, newerPinned];
+  const sorted = list.sort(postComparator);
+
+  assert.deepEqual(
+    sorted.map((p) => p.data.title),
+    ["Newer Pinned", "Older Pinned", "Fresh Regular"]
+  );
+});
+
+test("Post Sorting: adversarial robustness against missing data or equal dates", () => {
+  const postNoData = { date: new Date("2026-09-01") };
+  const postMalformedDate = { data: { title: "Malformed", date: "invalid-date" } };
+  const postIdenticalDate1 = { data: { title: "Post A" }, date: new Date("2026-09-01") };
+  const postIdenticalDate2 = { data: { title: "Post B" }, date: new Date("2026-09-01") };
+
+  assert.doesNotThrow(() => {
+    [postNoData, postMalformedDate, postIdenticalDate1, postIdenticalDate2].sort(postComparator);
+  });
+});