@jant/core 0.3.23 → 0.3.25

package/src/lib/__tests__/schemas.test.ts

@@ -1,45 +1,41 @@
 import { describe, it, expect } from "vitest";
 import {
-  PostTypeSchema,
-  VisibilitySchema,
+  FormatSchema,
+  StatusSchema,
   RedirectTypeSchema,
   CreatePostSchema,
   UpdatePostSchema,
   parseFormData,
   parseFormDataOptional,
-  validateMediaForPostType,
+  validateMediaCount,
 } from "../schemas.js";
 import { z } from "zod";
-import {
-  POST_TYPES,
-  VISIBILITY_LEVELS,
-  MAX_MEDIA_ATTACHMENTS,
-} from "../../types.js";
-
-describe("PostTypeSchema", () => {
-  it("accepts all valid post types", () => {
-    for (const type of POST_TYPES) {
-      expect(PostTypeSchema.parse(type)).toBe(type);
+import { FORMATS, STATUSES, MAX_MEDIA_ATTACHMENTS } from "../../types.js";
+
+describe("FormatSchema", () => {
+  it("accepts all valid formats", () => {
+    for (const format of FORMATS) {
+      expect(FormatSchema.parse(format)).toBe(format);
     }
   });
 
-  it("rejects invalid post types", () => {
-    expect(() => PostTypeSchema.parse("invalid")).toThrow();
-    expect(() => PostTypeSchema.parse("")).toThrow();
-    expect(() => PostTypeSchema.parse(123)).toThrow();
+  it("rejects invalid formats", () => {
+    expect(() => FormatSchema.parse("invalid")).toThrow();
+    expect(() => FormatSchema.parse("")).toThrow();
+    expect(() => FormatSchema.parse(123)).toThrow();
   });
 });
 
-describe("VisibilitySchema", () => {
-  it("accepts all valid visibility levels", () => {
-    for (const level of VISIBILITY_LEVELS) {
-      expect(VisibilitySchema.parse(level)).toBe(level);
+describe("StatusSchema", () => {
+  it("accepts all valid statuses", () => {
+    for (const status of STATUSES) {
+      expect(StatusSchema.parse(status)).toBe(status);
     }
   });
 
-  it("rejects invalid visibility levels", () => {
-    expect(() => VisibilitySchema.parse("public")).toThrow();
-    expect(() => VisibilitySchema.parse("private")).toThrow();
+  it("rejects invalid statuses", () => {
+    expect(() => StatusSchema.parse("public")).toThrow();
+    expect(() => StatusSchema.parse("private")).toThrow();
   });
 });
 
@@ -58,22 +54,22 @@ describe("RedirectTypeSchema", () => {
 
 describe("CreatePostSchema", () => {
   const validPost = {
-    type: "note",
-    content: "Hello world",
-    visibility: "quiet",
+    format: "note",
+    body: "Hello world",
+    status: "published",
   };
 
   it("accepts a valid post with required fields", () => {
     const result = CreatePostSchema.parse(validPost);
-    expect(result.type).toBe("note");
-    expect(result.content).toBe("Hello world");
-    expect(result.visibility).toBe("quiet");
+    expect(result.format).toBe("note");
+    expect(result.body).toBe("Hello world");
+    expect(result.status).toBe("published");
   });
 
-  it("accepts all post types", () => {
-    for (const type of POST_TYPES) {
+  it("accepts all formats", () => {
+    for (const format of FORMATS) {
       expect(() =>
-        CreatePostSchema.parse({ ...validPost, type }),
+        CreatePostSchema.parse({ ...validPost, format }),
       ).not.toThrow();
     }
   });
@@ -89,14 +85,38 @@ describe("CreatePostSchema", () => {
   it("accepts valid path format", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
-      path: "my-post-slug",
+      path: "my-post-path",
+    });
+    expect(result.path).toBe("my-post-path");
+  });
+
+  it("accepts single-character path", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      path: "a",
     });
-    expect(result.path).toBe("my-post-slug");
+    expect(result.path).toBe("a");
   });
 
-  it("accepts empty path", () => {
+  it("accepts empty path (transforms to undefined)", () => {
     const result = CreatePostSchema.parse({ ...validPost, path: "" });
-    expect(result.path).toBe("");
+    expect(result.path).toBeUndefined();
+  });
+
+  it("accepts multi-level path", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      path: "2024/my-post",
+    });
+    expect(result.path).toBe("2024/my-post");
+  });
+
+  it("accepts deeply nested path", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      path: "2024/01/my-post",
+    });
+    expect(result.path).toBe("2024/01/my-post");
   });
 
   it("rejects invalid path format (uppercase)", () => {
@@ -111,22 +131,52 @@ describe("CreatePostSchema", () => {
     ).toThrow();
   });
 
-  it("accepts valid source URL", () => {
+  it("rejects path starting with hyphen", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "-my-post" }),
+    ).toThrow();
+  });
+
+  it("rejects path ending with hyphen", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "my-post-" }),
+    ).toThrow();
+  });
+
+  it("rejects path with leading slash", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "/my-post" }),
+    ).toThrow();
+  });
+
+  it("rejects path with trailing slash", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "my-post/" }),
+    ).toThrow();
+  });
+
+  it("rejects path with consecutive slashes", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "2024//my-post" }),
+    ).toThrow();
+  });
+
+  it("accepts valid url", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
-      sourceUrl: "https://example.com",
+      url: "https://example.com",
     });
-    expect(result.sourceUrl).toBe("https://example.com");
+    expect(result.url).toBe("https://example.com");
   });
 
-  it("accepts empty source URL", () => {
-    const result = CreatePostSchema.parse({ ...validPost, sourceUrl: "" });
-    expect(result.sourceUrl).toBe("");
+  it("accepts empty url", () => {
+    const result = CreatePostSchema.parse({ ...validPost, url: "" });
+    expect(result.url).toBe("");
   });
 
-  it("rejects invalid source URL", () => {
+  it("rejects invalid url", () => {
     expect(() =>
-      CreatePostSchema.parse({ ...validPost, sourceUrl: "not-a-url" }),
+      CreatePostSchema.parse({ ...validPost, url: "not-a-url" }),
     ).toThrow();
   });
 
@@ -181,10 +231,84 @@ describe("CreatePostSchema", () => {
     ).toThrow();
   });
 
-  it("rejects missing required fields", () => {
+  it("accepts featured as boolean", () => {
+    const result = CreatePostSchema.parse({ ...validPost, featured: true });
+    expect(result.featured).toBe(true);
+  });
+
+  it("accepts featured as 'on' (transforms to true)", () => {
+    const result = CreatePostSchema.parse({ ...validPost, featured: "on" });
+    expect(result.featured).toBe(true);
+  });
+
+  it("accepts pinned as boolean", () => {
+    const result = CreatePostSchema.parse({ ...validPost, pinned: true });
+    expect(result.pinned).toBe(true);
+  });
+
+  it("accepts pinned as 'on' (transforms to true)", () => {
+    const result = CreatePostSchema.parse({ ...validPost, pinned: "on" });
+    expect(result.pinned).toBe(true);
+  });
+
+  it("accepts optional quoteText", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      quoteText: "A wise person once said...",
+    });
+    expect(result.quoteText).toBe("A wise person once said...");
+  });
+
+  it("accepts optional rating (1-5)", () => {
+    for (const rating of [1, 2, 3, 4, 5]) {
+      const result = CreatePostSchema.parse({ ...validPost, rating });
+      expect(result.rating).toBe(rating);
+    }
+  });
+
+  it("rejects rating outside 0-5 range", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, rating: -1 }),
+    ).toThrow();
+    expect(() => CreatePostSchema.parse({ ...validPost, rating: 6 })).toThrow();
+  });
+
+  it("accepts rating 0 (transforms to undefined)", () => {
+    const result = CreatePostSchema.parse({ ...validPost, rating: 0 });
+    expect(result.rating).toBeUndefined();
+  });
+
+  it("accepts empty string rating (transforms to undefined)", () => {
+    const result = CreatePostSchema.parse({ ...validPost, rating: "" });
+    expect(result.rating).toBeUndefined();
+  });
+
+  it("accepts optional collectionId as positive integer", () => {
+    const result = CreatePostSchema.parse({ ...validPost, collectionId: 42 });
+    expect(result.collectionId).toBe(42);
+  });
+
+  it("accepts empty string collectionId (transforms to undefined)", () => {
+    const result = CreatePostSchema.parse({ ...validPost, collectionId: "" });
+    expect(result.collectionId).toBeUndefined();
+  });
+
+  it("accepts optional replyToId", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      replyToId: "abc123",
+    });
+    expect(result.replyToId).toBe("abc123");
+  });
+
+  it("only requires format field", () => {
+    const result = CreatePostSchema.parse({ format: "note" });
+    expect(result.format).toBe("note");
+  });
+
+  it("rejects missing format", () => {
     expect(() => CreatePostSchema.parse({})).toThrow();
-    expect(() => CreatePostSchema.parse({ type: "note" })).toThrow();
-    expect(() => CreatePostSchema.parse({ content: "hello" })).toThrow();
+    expect(() => CreatePostSchema.parse({ body: "hello" })).toThrow();
   });
 });
 
@@ -199,13 +323,13 @@ describe("UpdatePostSchema", () => {
     expect(result.title).toBe("New Title");
   });
 
-  it("accepts only type", () => {
-    const result = UpdatePostSchema.parse({ type: "article" });
-    expect(result.type).toBe("article");
+  it("accepts only format", () => {
+    const result = UpdatePostSchema.parse({ format: "link" });
+    expect(result.format).toBe("link");
   });
 
   it("still validates field types", () => {
-    expect(() => UpdatePostSchema.parse({ type: "invalid" })).toThrow();
+    expect(() => UpdatePostSchema.parse({ format: "invalid" })).toThrow();
   });
 });
 
@@ -225,8 +349,8 @@ describe("parseFormData", () => {
 
   it("throws for invalid value", () => {
     const form = new FormData();
-    form.set("type", "invalid-type");
-    expect(() => parseFormData(form, "type", PostTypeSchema)).toThrow();
+    form.set("format", "invalid-format");
+    expect(() => parseFormData(form, "format", FormatSchema)).toThrow();
   });
 });
 
@@ -250,59 +374,37 @@ describe("parseFormDataOptional", () => {
 
   it("throws for invalid value", () => {
     const form = new FormData();
-    form.set("type", "invalid");
-    expect(() => parseFormDataOptional(form, "type", PostTypeSchema)).toThrow();
+    form.set("format", "invalid");
+    expect(() => parseFormDataOptional(form, "format", FormatSchema)).toThrow();
   });
 });
 
-describe("validateMediaForPostType", () => {
-  it("returns null for note with no media", () => {
-    expect(validateMediaForPostType("note", [])).toBeNull();
-  });
-
-  it("returns null for note with media", () => {
-    expect(validateMediaForPostType("note", ["id-1", "id-2"])).toBeNull();
-  });
-
-  it("returns null for article with media", () => {
-    expect(validateMediaForPostType("article", ["id-1"])).toBeNull();
-  });
-
-  it("returns null for image with at least 1 media", () => {
-    expect(validateMediaForPostType("image", ["id-1"])).toBeNull();
-  });
-
-  it("returns error for image with no media", () => {
-    const error = validateMediaForPostType("image", []);
-    expect(error).toBe("image posts require at least 1 media attachment");
-  });
-
-  it("returns null for link with 0 or 1 media", () => {
-    expect(validateMediaForPostType("link", [])).toBeNull();
-    expect(validateMediaForPostType("link", ["id-1"])).toBeNull();
+describe("validateMediaCount", () => {
+  it("returns null for empty media array", () => {
+    expect(validateMediaCount([])).toBeNull();
   });
 
-  it("returns error for link with more than 1 media", () => {
-    const error = validateMediaForPostType("link", ["id-1", "id-2"]);
-    expect(error).toBe("link posts allow at most 1 media attachment");
+  it("returns null for media within limit", () => {
+    const media = Array.from({ length: 5 }, (_, i) => `id-${i}`);
+    expect(validateMediaCount(media)).toBeNull();
   });
 
-  it("returns error for page with any media", () => {
-    const error = validateMediaForPostType("page", ["id-1"]);
-    expect(error).toBe("page posts do not allow media attachments");
-  });
-
-  it("returns null for page with no media", () => {
-    expect(validateMediaForPostType("page", [])).toBeNull();
-  });
-
-  it("returns null for quote with media", () => {
-    expect(validateMediaForPostType("quote", ["id-1", "id-2"])).toBeNull();
+  it("returns null for exactly MAX_MEDIA_ATTACHMENTS", () => {
+    const media = Array.from(
+      { length: MAX_MEDIA_ATTACHMENTS },
+      (_, i) => `id-${i}`,
+    );
+    expect(validateMediaCount(media)).toBeNull();
   });
 
-  it("returns error when exceeding max for note", () => {
-    const tooMany = Array.from({ length: 21 }, (_, i) => `id-${i}`);
-    const error = validateMediaForPostType("note", tooMany);
-    expect(error).toBe("note posts allow at most 20 media attachments");
+  it("returns error when exceeding MAX_MEDIA_ATTACHMENTS", () => {
+    const tooMany = Array.from(
+      { length: MAX_MEDIA_ATTACHMENTS + 1 },
+      (_, i) => `id-${i}`,
+    );
+    const error = validateMediaCount(tooMany);
+    expect(error).toBe(
+      `Posts allow at most ${MAX_MEDIA_ATTACHMENTS} media attachments`,
+    );
   });
 });

package/src/lib/__tests__/time.test.ts

@@ -4,6 +4,8 @@ import {
   isWithinMonth,
   toISOString,
   formatDate,
+  formatTime,
+  formatRelativeTime,
   formatYearMonth,
 } from "../time.js";
 
@@ -91,6 +93,66 @@ describe("formatDate", () => {
   });
 });
 
+describe("formatTime", () => {
+  it("formats as HH:MM in 24-hour format", () => {
+    // 2024-01-15T12:30:00Z = 1705321800
+    expect(formatTime(1705321800)).toBe("12:30");
+  });
+
+  it("zero-pads hours and minutes", () => {
+    // 2024-02-01T00:00:00Z = 1706745600
+    expect(formatTime(1706745600)).toBe("00:00");
+  });
+
+  it("formats evening time correctly", () => {
+    // 2024-02-01T23:05:00Z = 1706828700
+    expect(formatTime(1706828700)).toBe("23:05");
+  });
+
+  it("formats single-digit hour with padding", () => {
+    // 2024-02-01T09:07:00Z = 1706778420
+    expect(formatTime(1706778420)).toBe("09:07");
+  });
+});
+
+describe("formatRelativeTime", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns '1m' for timestamps less than 60 seconds ago", () => {
+    expect(formatRelativeTime(now() - 10)).toBe("1m");
+    expect(formatRelativeTime(now() - 59)).toBe("1m");
+  });
+
+  it("returns minutes for timestamps under 1 hour", () => {
+    expect(formatRelativeTime(now() - 60)).toBe("1m");
+    expect(formatRelativeTime(now() - 300)).toBe("5m");
+    expect(formatRelativeTime(now() - 3540)).toBe("59m");
+  });
+
+  it("returns hours for timestamps under 24 hours", () => {
+    expect(formatRelativeTime(now() - 3600)).toBe("1h");
+    expect(formatRelativeTime(now() - 7200)).toBe("2h");
+    expect(formatRelativeTime(now() - 82800)).toBe("23h");
+  });
+
+  it("returns days for timestamps up to 7 days", () => {
+    expect(formatRelativeTime(now() - 86400)).toBe("1d");
+    expect(formatRelativeTime(now() - 3 * 86400)).toBe("3d");
+    expect(formatRelativeTime(now() - 7 * 86400)).toBe("7d");
+  });
+
+  it("returns 'MMM D' for timestamps older than 7 days", () => {
+    // Use a fixed timestamp to get a predictable date
+    // Feb 1, 2024 00:00:00 UTC
+    const feb1 = 1706745600;
+    // Mock now() to return Feb 16, 2024
+    vi.spyOn(Date, "now").mockReturnValue((feb1 + 15 * 86400) * 1000);
+    expect(formatRelativeTime(feb1)).toBe("Feb 1");
+  });
+});
+
 describe("formatYearMonth", () => {
   it("formats as YYYY-MM", () => {
     expect(formatYearMonth(1706745600)).toBe("2024-02");