@bash-app/bash-common 30.246.0 → 30.253.0

package/src/utils/__tests__/arrayUtils.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "@jest/globals";
+import { asyncFilter } from "../arrayUtils.js";
+
+describe("asyncFilter", () => {
+  test("keeps items where async predicate resolves true", async () => {
+    const nums = [1, 2, 3, 4];
+    const result = await asyncFilter(nums, async (n) => n % 2 === 0);
+    expect(result).toEqual([2, 4]);
+  });
+
+  test("returns empty array when no items match", async () => {
+    const result = await asyncFilter([1, 3, 5], async () => false);
+    expect(result).toEqual([]);
+  });
+
+  test("returns empty array for empty input", async () => {
+    const result = await asyncFilter([], async () => true);
+    expect(result).toEqual([]);
+  });
+
+  test("preserves order of matching items", async () => {
+    const items = ["a", "b", "c", "d"];
+    const result = await asyncFilter(items, async (v) => v !== "b");
+    expect(result).toEqual(["a", "c", "d"]);
+  });
+});

package/src/utils/__tests__/blogUtils.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "@jest/globals";
+import { DEFAULT_BLOG_IMAGE } from "../../definitions.js";
+import {
+  calculateReadingTime,
+  formatPublishDate,
+  generateBlogDetailUrl,
+  generateExcerpt,
+  generateMetaDescription,
+  generateMetaTitle,
+  getBlogDetailUrl,
+  getBlogImageUrl,
+  highlightSearchTerms,
+  parseBlogUrlParams,
+  processTags,
+  validateBlogContent,
+} from "../blogUtils.js";
+
+describe("blogUtils", () => {
+  describe("URL helpers", () => {
+    test("generateBlogDetailUrl with slug", () => {
+      expect(generateBlogDetailUrl("abc123", "my-post")).toBe("/blog/abc123-my-post");
+    });
+
+    test("generateBlogDetailUrl without slug", () => {
+      expect(generateBlogDetailUrl("abc123")).toBe("/blog/abc123");
+    });
+
+    test("getBlogDetailUrl prefers explicit slug", () => {
+      expect(getBlogDetailUrl("id1", "saved-slug", "Ignored Title")).toBe(
+        "/blog/id1-saved-slug"
+      );
+    });
+
+    test("getBlogDetailUrl generates slug from title when slug missing", () => {
+      expect(getBlogDetailUrl("id1", undefined, "Hello World Party")).toBe(
+        "/blog/id1-hello-world-party"
+      );
+    });
+
+    test("getBlogDetailUrl falls back to id-only URL", () => {
+      expect(getBlogDetailUrl("id1")).toBe("/blog/id1");
+    });
+
+    test("parseBlogUrlParams handles id-only param", () => {
+      expect(parseBlogUrlParams("abc123")).toEqual({ id: "abc123" });
+    });
+
+    test("parseBlogUrlParams splits id-slug at first hyphen", () => {
+      expect(parseBlogUrlParams("abc123-my-cool-post")).toEqual({
+        id: "abc123",
+        slug: "my-cool-post",
+      });
+    });
+
+    test("parseBlogUrlParams returns null for empty input", () => {
+      expect(parseBlogUrlParams("")).toBeNull();
+    });
+  });
+
+  describe("content processing", () => {
+    test("generateExcerpt strips HTML tags", () => {
+      expect(generateExcerpt("<p>Hello <strong>world</strong></p>")).toBe("Hello world");
+    });
+
+    test("generateExcerpt truncates at word boundary with ellipsis", () => {
+      const long = "word ".repeat(50);
+      const excerpt = generateExcerpt(long, 20);
+      expect(excerpt.endsWith("...")).toBe(true);
+      expect(excerpt.length).toBeLessThanOrEqual(23);
+    });
+
+    test("calculateReadingTime rounds up by word count", () => {
+      const words = Array.from({ length: 401 }, (_, i) => `w${i}`).join(" ");
+      expect(calculateReadingTime(words)).toBe(3);
+    });
+
+    test("getBlogImageUrl uses default when missing", () => {
+      expect(getBlogImageUrl(null)).toBe(DEFAULT_BLOG_IMAGE);
+      expect(getBlogImageUrl("https://cdn.example/img.jpg")).toBe(
+        "https://cdn.example/img.jpg"
+      );
+    });
+  });
+
+  describe("SEO helpers", () => {
+    test("generateMetaTitle appends site name", () => {
+      expect(generateMetaTitle("My Post")).toBe("My Post | Bash");
+      expect(generateMetaTitle("My Post", "Custom")).toBe("My Post | Custom");
+    });
+
+    test("generateMetaDescription uses excerpt or fallback", () => {
+      const content = "x".repeat(200);
+      expect(generateMetaDescription(content, "Title")).toContain("...");
+      expect(generateMetaDescription("", "Title")).toContain("Title");
+    });
+  });
+
+  describe("validateBlogContent", () => {
+    test("accepts valid title and content", () => {
+      expect(
+        validateBlogContent("Good title", "x".repeat(100))
+      ).toEqual({ isValid: true, errors: [] });
+    });
+
+    test("collects validation errors", () => {
+      const result = validateBlogContent("", "short");
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toContain("Title is required");
+      expect(result.errors).toContain("Content must be at least 100 characters");
+    });
+  });
+
+  describe("processTags", () => {
+    test("splits, trims, lowercases, and caps at 10 tags", () => {
+      const tags = processTags(" Jazz, ROCK , ,Blues, " + "tag,".repeat(15));
+      expect(tags[0]).toBe("jazz");
+      expect(tags[1]).toBe("rock");
+      expect(tags.length).toBeLessThanOrEqual(10);
+    });
+
+    test("returns empty array for blank input", () => {
+      expect(processTags("")).toEqual([]);
+    });
+  });
+
+  describe("highlightSearchTerms", () => {
+    test("wraps matches in mark tags case-insensitively", () => {
+      expect(highlightSearchTerms("Hello Bash world", "bash")).toBe(
+        "Hello <mark>Bash</mark> world"
+      );
+    });
+
+    test("returns text unchanged when search term empty", () => {
+      expect(highlightSearchTerms("Hello", "")).toBe("Hello");
+    });
+  });
+
+  describe("formatPublishDate", () => {
+    test("formats Date and ISO string consistently", () => {
+      const date = new Date("2024-06-15T12:00:00Z");
+      expect(formatPublishDate(date)).toMatch(/June/);
+      expect(formatPublishDate("2024-06-15T12:00:00Z")).toMatch(/2024/);
+    });
+  });
+});

package/src/utils/__tests__/dateTimeUtils.test.ts

@@ -0,0 +1,233 @@
+/**
+ * dateTimeUtils — parsing, comparison, and normalization helpers.
+ * Pin UTC normalization and comparison semantics with fixed instants.
+ */
+import { DateTime } from "luxon";
+import { describe, expect, test, beforeEach, afterEach, jest } from "@jest/globals";
+import {
+  getLocalTimezoneName,
+  ensureIsDateTime,
+  normalizeDate,
+  normalizeDates,
+  dateWithinDateRange,
+  findLatestDateTime,
+  isDateTimeLaterThanNow,
+  areDateTimesEqual,
+  compareDateTime,
+  parseTimeString,
+  timestampMinutesFromNow,
+} from "../dateTimeUtils.js";
+
+describe("getLocalTimezoneName", () => {
+  test("returns a non-empty timezone string", () => {
+    const tz = getLocalTimezoneName();
+    expect(typeof tz).toBe("string");
+    expect(tz.length).toBeGreaterThan(0);
+  });
+});
+
+describe("ensureIsDateTime", () => {
+  test("returns undefined for null/undefined", () => {
+    expect(ensureIsDateTime(null)).toBeUndefined();
+    expect(ensureIsDateTime(undefined)).toBeUndefined();
+  });
+
+  test("returns Date for Date input", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(ensureIsDateTime(d)).toBe(d);
+  });
+
+  test("parses ISO string to Date", () => {
+    const result = ensureIsDateTime("2026-03-07T12:00:00Z");
+    expect(result).toBeInstanceOf(Date);
+    expect(result?.toISOString()).toBe("2026-03-07T12:00:00.000Z");
+  });
+});
+
+describe("normalizeDate", () => {
+  test("returns undefined for null/undefined", () => {
+    expect(normalizeDate(null)).toBeUndefined();
+    expect(normalizeDate(undefined)).toBeUndefined();
+  });
+
+  test("returns undefined for invalid date", () => {
+    const spy = jest.spyOn(console, "error").mockImplementation(() => {});
+    expect(normalizeDate("not-a-date")).toBeUndefined();
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+  });
+
+  test("normalizes to UTC start of minute", () => {
+    const input = new Date("2026-03-07T12:34:56.789Z");
+    const result = normalizeDate(input);
+    expect(result).toEqual(
+      DateTime.fromJSDate(input).toUTC().startOf("minute").toJSDate()
+    );
+  });
+
+  test("accepts ISO string input", () => {
+    const result = normalizeDate("2026-03-07T12:34:56.789Z");
+    expect(result?.getUTCSeconds()).toBe(0);
+    expect(result?.getUTCMilliseconds()).toBe(0);
+  });
+});
+
+describe("normalizeDates", () => {
+  test("filters out invalid dates", () => {
+    const spy = jest.spyOn(console, "error").mockImplementation(() => {});
+    const results = normalizeDates([
+      "2026-03-07T12:00:00Z",
+      null,
+      "bad",
+      "2026-03-08T12:00:00Z",
+    ]);
+    expect(results).toHaveLength(2);
+    spy.mockRestore();
+  });
+});
+
+describe("compareDateTime", () => {
+  test("returns 0 when both dates are null/undefined", () => {
+    expect(compareDateTime(null, null)).toBe(0);
+    expect(compareDateTime(undefined, undefined)).toBe(0);
+  });
+
+  test("null date1 is treated as earlier", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(compareDateTime(null, d)).toBe(-1);
+  });
+
+  test("null date2 is treated as earlier than date1", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(compareDateTime(d, null)).toBe(1);
+  });
+
+  test("compares Date objects", () => {
+    const earlier = new Date("2026-03-07T10:00:00Z");
+    const later = new Date("2026-03-07T12:00:00Z");
+    expect(compareDateTime(later, earlier)).toBe(1);
+    expect(compareDateTime(earlier, later)).toBe(-1);
+    expect(compareDateTime(earlier, earlier)).toBe(0);
+  });
+
+  test("compares ISO strings", () => {
+    expect(compareDateTime("2026-03-07T12:00:00Z", "2026-03-07T10:00:00Z")).toBe(1);
+    expect(compareDateTime("2026-03-07T10:00:00Z", "2026-03-07T12:00:00Z")).toBe(-1);
+  });
+});
+
+describe("areDateTimesEqual", () => {
+  test("returns true for equal instants", () => {
+    const d = new Date("2026-03-07T12:00:00Z");
+    expect(areDateTimesEqual(d, d)).toBe(true);
+    expect(areDateTimesEqual("2026-03-07T12:00:00Z", d)).toBe(true);
+  });
+
+  test("returns false for different instants", () => {
+    expect(
+      areDateTimesEqual("2026-03-07T12:00:00Z", "2026-03-07T10:00:00Z")
+    ).toBe(false);
+  });
+});
+
+describe("findLatestDateTime", () => {
+  test("returns the later date", () => {
+    const earlier = "2026-03-07T10:00:00Z";
+    const later = "2026-03-07T12:00:00Z";
+    expect(findLatestDateTime(earlier, later)?.toISOString()).toBe(
+      new Date(later).toISOString()
+    );
+    expect(findLatestDateTime(later, earlier)?.toISOString()).toBe(
+      new Date(later).toISOString()
+    );
+  });
+});
+
+describe("isDateTimeLaterThanNow", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-03-07T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("returns true for future dates", () => {
+    expect(isDateTimeLaterThanNow("2026-03-07T13:00:00Z")).toBe(true);
+  });
+
+  test("returns false for past dates", () => {
+    expect(isDateTimeLaterThanNow("2026-03-07T11:00:00Z")).toBe(false);
+  });
+});
+
+describe("dateWithinDateRange", () => {
+  test("returns true when date is within inclusive start, exclusive end", () => {
+    const inRange = dateWithinDateRange("2026-03-07T15:00:00Z", {
+      startDate: new Date("2026-03-07T00:00:00Z"),
+      endDate: new Date("2026-03-08T00:00:00Z"),
+    });
+    expect(inRange).toBe(true);
+  });
+
+  test("returns false when date is on or after end day", () => {
+    const onEndDay = dateWithinDateRange("2026-03-08T12:00:00Z", {
+      startDate: new Date("2026-03-07T00:00:00Z"),
+      endDate: new Date("2026-03-08T00:00:00Z"),
+    });
+    expect(onEndDay).toBe(false);
+  });
+
+  test("defaults to today when range is undefined", () => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-03-07T15:00:00Z"));
+    expect(dateWithinDateRange("2026-03-07T16:00:00Z", undefined)).toBe(true);
+    expect(dateWithinDateRange("2026-03-09T12:00:00Z", undefined)).toBe(false);
+    jest.useRealTimers();
+  });
+});
+
+describe("parseTimeString", () => {
+  test("parses 10:30 AM", () => {
+    expect(parseTimeString("10:30 AM")).toEqual({ hours: 10, minutes: 30, ampm: "AM" });
+  });
+
+  test("parses 10:30 PM as 24h hours", () => {
+    expect(parseTimeString("10:30 PM")).toEqual({ hours: 22, minutes: 30, ampm: "PM" });
+  });
+
+  test("parses 12:00 PM", () => {
+    expect(parseTimeString("12:00 PM")).toEqual({ hours: 12, minutes: 0, ampm: "PM" });
+  });
+
+  test("parses 1:05 AM", () => {
+    expect(parseTimeString("1:05 AM")).toEqual({ hours: 1, minutes: 5, ampm: "AM" });
+  });
+
+  test("returns null for invalid formats", () => {
+    expect(parseTimeString("")).toBeNull();
+    expect(parseTimeString("25:00 AM")).toBeNull();
+    expect(parseTimeString("10:60 AM")).toBeNull();
+    expect(parseTimeString("10:30")).toBeNull();
+    expect(parseTimeString("noon")).toBeNull();
+  });
+});
+
+describe("timestampMinutesFromNow", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-03-07T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("returns unix seconds floored for N minutes ahead", () => {
+    const expected = Math.floor(
+      DateTime.fromJSDate(new Date("2026-03-07T12:00:00Z")).plus({ minutes: 30 }).toSeconds()
+    );
+    expect(timestampMinutesFromNow(30)).toBe(expected);
+  });
+});