@jant/core 0.3.1 → 0.3.3

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

@@ -0,0 +1,220 @@
+import { describe, it, expect } from "vitest";
+import {
+  PostTypeSchema,
+  VisibilitySchema,
+  RedirectTypeSchema,
+  CreatePostSchema,
+  UpdatePostSchema,
+  parseFormData,
+  parseFormDataOptional,
+} from "../schemas.js";
+import { z } from "zod";
+import { POST_TYPES, VISIBILITY_LEVELS } from "../../types.js";
+
+describe("PostTypeSchema", () => {
+  it("accepts all valid post types", () => {
+    for (const type of POST_TYPES) {
+      expect(PostTypeSchema.parse(type)).toBe(type);
+    }
+  });
+
+  it("rejects invalid post types", () => {
+    expect(() => PostTypeSchema.parse("invalid")).toThrow();
+    expect(() => PostTypeSchema.parse("")).toThrow();
+    expect(() => PostTypeSchema.parse(123)).toThrow();
+  });
+});
+
+describe("VisibilitySchema", () => {
+  it("accepts all valid visibility levels", () => {
+    for (const level of VISIBILITY_LEVELS) {
+      expect(VisibilitySchema.parse(level)).toBe(level);
+    }
+  });
+
+  it("rejects invalid visibility levels", () => {
+    expect(() => VisibilitySchema.parse("public")).toThrow();
+    expect(() => VisibilitySchema.parse("private")).toThrow();
+  });
+});
+
+describe("RedirectTypeSchema", () => {
+  it("accepts 301 and 302 as strings", () => {
+    expect(RedirectTypeSchema.parse("301")).toBe("301");
+    expect(RedirectTypeSchema.parse("302")).toBe("302");
+  });
+
+  it("rejects other values", () => {
+    expect(() => RedirectTypeSchema.parse("200")).toThrow();
+    expect(() => RedirectTypeSchema.parse("404")).toThrow();
+    expect(() => RedirectTypeSchema.parse(301)).toThrow();
+  });
+});
+
+describe("CreatePostSchema", () => {
+  const validPost = {
+    type: "note",
+    content: "Hello world",
+    visibility: "quiet",
+  };
+
+  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");
+  });
+
+  it("accepts all post types", () => {
+    for (const type of POST_TYPES) {
+      expect(() =>
+        CreatePostSchema.parse({ ...validPost, type }),
+      ).not.toThrow();
+    }
+  });
+
+  it("accepts optional title", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      title: "My Post",
+    });
+    expect(result.title).toBe("My Post");
+  });
+
+  it("accepts valid path format", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      path: "my-post-slug",
+    });
+    expect(result.path).toBe("my-post-slug");
+  });
+
+  it("accepts empty path", () => {
+    const result = CreatePostSchema.parse({ ...validPost, path: "" });
+    expect(result.path).toBe("");
+  });
+
+  it("rejects invalid path format (uppercase)", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "MyPost" }),
+    ).toThrow();
+  });
+
+  it("rejects invalid path format (special chars)", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, path: "my post!" }),
+    ).toThrow();
+  });
+
+  it("accepts valid source URL", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      sourceUrl: "https://example.com",
+    });
+    expect(result.sourceUrl).toBe("https://example.com");
+  });
+
+  it("accepts empty source URL", () => {
+    const result = CreatePostSchema.parse({ ...validPost, sourceUrl: "" });
+    expect(result.sourceUrl).toBe("");
+  });
+
+  it("rejects invalid source URL", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, sourceUrl: "not-a-url" }),
+    ).toThrow();
+  });
+
+  it("accepts optional publishedAt as positive integer", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      publishedAt: 1706745600,
+    });
+    expect(result.publishedAt).toBe(1706745600);
+  });
+
+  it("rejects negative publishedAt", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, publishedAt: -1 }),
+    ).toThrow();
+  });
+
+  it("rejects non-integer publishedAt", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, publishedAt: 1.5 }),
+    ).toThrow();
+  });
+
+  it("rejects missing required fields", () => {
+    expect(() => CreatePostSchema.parse({})).toThrow();
+    expect(() => CreatePostSchema.parse({ type: "note" })).toThrow();
+    expect(() => CreatePostSchema.parse({ content: "hello" })).toThrow();
+  });
+});
+
+describe("UpdatePostSchema", () => {
+  it("accepts empty object (all fields optional)", () => {
+    const result = UpdatePostSchema.parse({});
+    expect(result).toEqual({});
+  });
+
+  it("accepts partial updates", () => {
+    const result = UpdatePostSchema.parse({ title: "New Title" });
+    expect(result.title).toBe("New Title");
+  });
+
+  it("accepts only type", () => {
+    const result = UpdatePostSchema.parse({ type: "article" });
+    expect(result.type).toBe("article");
+  });
+
+  it("still validates field types", () => {
+    expect(() => UpdatePostSchema.parse({ type: "invalid" })).toThrow();
+  });
+});
+
+describe("parseFormData", () => {
+  it("parses a valid form field", () => {
+    const form = new FormData();
+    form.set("name", "hello");
+    expect(parseFormData(form, "name", z.string())).toBe("hello");
+  });
+
+  it("throws for missing required field", () => {
+    const form = new FormData();
+    expect(() => parseFormData(form, "missing", z.string())).toThrow(
+      "Missing required field: missing",
+    );
+  });
+
+  it("throws for invalid value", () => {
+    const form = new FormData();
+    form.set("type", "invalid-type");
+    expect(() => parseFormData(form, "type", PostTypeSchema)).toThrow();
+  });
+});
+
+describe("parseFormDataOptional", () => {
+  it("returns parsed value when present", () => {
+    const form = new FormData();
+    form.set("name", "hello");
+    expect(parseFormDataOptional(form, "name", z.string())).toBe("hello");
+  });
+
+  it("returns undefined when field is missing", () => {
+    const form = new FormData();
+    expect(parseFormDataOptional(form, "missing", z.string())).toBeUndefined();
+  });
+
+  it("returns undefined when field is empty string", () => {
+    const form = new FormData();
+    form.set("name", "");
+    expect(parseFormDataOptional(form, "name", z.string())).toBeUndefined();
+  });
+
+  it("throws for invalid value", () => {
+    const form = new FormData();
+    form.set("type", "invalid");
+    expect(() => parseFormDataOptional(form, "type", PostTypeSchema)).toThrow();
+  });
+});

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

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import { encode, decode, isValidSqid } from "../sqid.js";
+
+describe("encode", () => {
+  it("encodes a numeric ID to a string", () => {
+    const result = encode(1);
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThanOrEqual(4);
+  });
+
+  it("produces minimum 4-character strings", () => {
+    expect(encode(0).length).toBeGreaterThanOrEqual(4);
+    expect(encode(1).length).toBeGreaterThanOrEqual(4);
+    expect(encode(100).length).toBeGreaterThanOrEqual(4);
+  });
+
+  it("produces different strings for different IDs", () => {
+    const a = encode(1);
+    const b = encode(2);
+    const c = encode(100);
+    expect(a).not.toBe(b);
+    expect(b).not.toBe(c);
+  });
+
+  it("produces consistent results for the same ID", () => {
+    expect(encode(42)).toBe(encode(42));
+  });
+});
+
+describe("decode", () => {
+  it("decodes an encoded string back to the original ID", () => {
+    for (const id of [0, 1, 42, 100, 999, 10000]) {
+      const encoded = encode(id);
+      expect(decode(encoded)).toBe(id);
+    }
+  });
+
+  it("returns null for empty string", () => {
+    expect(decode("")).toBe(null);
+  });
+
+  it("handles round-trip encoding", () => {
+    const original = 12345;
+    const sqid = encode(original);
+    const decoded = decode(sqid);
+    expect(decoded).toBe(original);
+  });
+});
+
+describe("isValidSqid", () => {
+  it("returns true for valid encoded sqids", () => {
+    const sqid = encode(1);
+    expect(isValidSqid(sqid)).toBe(true);
+  });
+
+  it("returns true for various valid sqids", () => {
+    for (const id of [0, 1, 100, 999]) {
+      expect(isValidSqid(encode(id))).toBe(true);
+    }
+  });
+
+  it("returns false for empty string", () => {
+    expect(isValidSqid("")).toBe(false);
+  });
+});

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

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { dsRedirect, dsToast, dsSignals } from "../sse.js";
+
+describe("dsRedirect", () => {
+  it("returns a Response with text/html content-type", () => {
+    const res = dsRedirect("/dash");
+    expect(res.headers.get("Content-Type")).toBe("text/html");
+  });
+
+  it("includes Datastar headers for append mode", () => {
+    const res = dsRedirect("/dash");
+    expect(res.headers.get("Datastar-Mode")).toBe("append");
+    expect(res.headers.get("Datastar-Selector")).toBe("body");
+  });
+
+  it("body contains redirect script with correct URL", async () => {
+    const res = dsRedirect("/dash/posts");
+    const body = await res.text();
+    expect(body).toContain("window.location.href='/dash/posts'");
+  });
+
+  it("escapes single quotes in URL", async () => {
+    const res = dsRedirect("/path/with'quote");
+    const body = await res.text();
+    expect(body).toContain("\\'");
+  });
+
+  it("merges additional headers", () => {
+    const res = dsRedirect("/dash", {
+      headers: { "Set-Cookie": "session=abc" },
+    });
+    expect(res.headers.get("Set-Cookie")).toBe("session=abc");
+    expect(res.headers.get("Content-Type")).toBe("text/html");
+  });
+});
+
+describe("dsToast", () => {
+  it("returns text/html content-type", () => {
+    const res = dsToast("Saved!");
+    expect(res.headers.get("Content-Type")).toBe("text/html");
+  });
+
+  it("targets #toast-container", () => {
+    const res = dsToast("Saved!");
+    expect(res.headers.get("Datastar-Selector")).toBe("#toast-container");
+    expect(res.headers.get("Datastar-Mode")).toBe("append");
+  });
+
+  it("defaults to success type", async () => {
+    const res = dsToast("Saved!");
+    const body = await res.text();
+    expect(body).toContain("toast-success");
+  });
+
+  it("supports error type", async () => {
+    const res = dsToast("Failed!", "error");
+    const body = await res.text();
+    expect(body).toContain("toast-error");
+  });
+
+  it("escapes HTML in message", async () => {
+    const res = dsToast("<script>alert('xss')</script>");
+    const body = await res.text();
+    expect(body).not.toContain("<script>alert");
+    expect(body).toContain("&lt;script&gt;");
+  });
+});
+
+describe("dsSignals", () => {
+  it("returns application/json content-type", () => {
+    const res = dsSignals({ count: 1 });
+    expect(res.headers.get("Content-Type")).toBe("application/json");
+  });
+
+  it("body contains JSON-serialized signals", async () => {
+    const res = dsSignals({ _error: "File too large", count: 42 });
+    const body = await res.json();
+    expect(body).toEqual({ _error: "File too large", count: 42 });
+  });
+
+  it("handles empty signals", async () => {
+    const res = dsSignals({});
+    const body = await res.json();
+    expect(body).toEqual({});
+  });
+});

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

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  now,
+  isWithinMonth,
+  toISOString,
+  formatDate,
+  formatYearMonth,
+} from "../time.js";
+
+describe("now", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns current time in seconds", () => {
+    const before = Math.floor(Date.now() / 1000);
+    const result = now();
+    const after = Math.floor(Date.now() / 1000);
+    expect(result).toBeGreaterThanOrEqual(before);
+    expect(result).toBeLessThanOrEqual(after);
+  });
+
+  it("returns an integer (not milliseconds)", () => {
+    const result = now();
+    expect(Number.isInteger(result)).toBe(true);
+    // Should be in seconds, not milliseconds (less than 10 billion)
+    expect(result).toBeLessThan(10_000_000_000);
+  });
+});
+
+describe("isWithinMonth", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns true for a timestamp within the last 30 days", () => {
+    const recent = now() - 60 * 60; // 1 hour ago
+    expect(isWithinMonth(recent)).toBe(true);
+  });
+
+  it("returns true for current timestamp", () => {
+    expect(isWithinMonth(now())).toBe(true);
+  });
+
+  it("returns false for a timestamp older than 30 days", () => {
+    const old = now() - 31 * 24 * 60 * 60; // 31 days ago
+    expect(isWithinMonth(old)).toBe(false);
+  });
+
+  it("returns false for timestamp exactly at 30-day boundary", () => {
+    // 30 days = 2592000 seconds
+    const boundary = now() - 30 * 24 * 60 * 60;
+    expect(isWithinMonth(boundary)).toBe(false);
+  });
+
+  it("returns true for timestamp just under 30 days", () => {
+    const justUnder = now() - (30 * 24 * 60 * 60 - 1);
+    expect(isWithinMonth(justUnder)).toBe(true);
+  });
+});
+
+describe("toISOString", () => {
+  it("converts Unix timestamp to ISO string", () => {
+    // Feb 1, 2024 00:00:00 UTC
+    expect(toISOString(1706745600)).toBe("2024-02-01T00:00:00.000Z");
+  });
+
+  it("converts epoch 0", () => {
+    expect(toISOString(0)).toBe("1970-01-01T00:00:00.000Z");
+  });
+
+  it("handles timestamps with time components", () => {
+    // 2024-01-15T12:30:00Z = 1705321800
+    expect(toISOString(1705321800)).toBe("2024-01-15T12:30:00.000Z");
+  });
+});
+
+describe("formatDate", () => {
+  it("formats as MMM DD, YYYY", () => {
+    expect(formatDate(1706745600)).toBe("Feb 1, 2024");
+  });
+
+  it("formats epoch start", () => {
+    expect(formatDate(0)).toBe("Jan 1, 1970");
+  });
+
+  it("uses UTC timezone consistently", () => {
+    // Dec 31, 2023 23:59:59 UTC
+    const timestamp = 1704067199;
+    expect(formatDate(timestamp)).toBe("Dec 31, 2023");
+  });
+});
+
+describe("formatYearMonth", () => {
+  it("formats as YYYY-MM", () => {
+    expect(formatYearMonth(1706745600)).toBe("2024-02");
+  });
+
+  it("zero-pads single-digit months", () => {
+    // Jan 15, 2024
+    expect(formatYearMonth(1705276800)).toBe("2024-01");
+  });
+
+  it("handles December correctly", () => {
+    // Dec 15, 2023
+    expect(formatYearMonth(1702598400)).toBe("2023-12");
+  });
+
+  it("formats epoch start", () => {
+    expect(formatYearMonth(0)).toBe("1970-01");
+  });
+});

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

@@ -0,0 +1,138 @@
+import { describe, it, expect } from "vitest";
+import { extractDomain, normalizePath, isFullUrl, slugify } from "../url.js";
+
+describe("extractDomain", () => {
+  it("extracts hostname from HTTPS URL", () => {
+    expect(extractDomain("https://example.com/path")).toBe("example.com");
+  });
+
+  it("extracts hostname from HTTP URL", () => {
+    expect(extractDomain("http://example.com")).toBe("example.com");
+  });
+
+  it("includes www subdomain", () => {
+    expect(extractDomain("https://www.example.com/path")).toBe(
+      "www.example.com",
+    );
+  });
+
+  it("handles URLs with ports", () => {
+    expect(extractDomain("http://localhost:3000/api")).toBe("localhost");
+  });
+
+  it("handles URLs with query params and hash", () => {
+    expect(extractDomain("https://example.com/path?q=1#section")).toBe(
+      "example.com",
+    );
+  });
+
+  it("returns null for invalid URLs", () => {
+    expect(extractDomain("not-a-url")).toBe(null);
+    expect(extractDomain("")).toBe(null);
+  });
+
+  it("handles complex subdomains", () => {
+    expect(extractDomain("https://blog.sub.example.com")).toBe(
+      "blog.sub.example.com",
+    );
+  });
+});
+
+describe("normalizePath", () => {
+  it("converts to lowercase", () => {
+    expect(normalizePath("About")).toBe("about");
+    expect(normalizePath("HELLO")).toBe("hello");
+  });
+
+  it("removes leading and trailing slashes", () => {
+    expect(normalizePath("/about/")).toBe("about");
+    expect(normalizePath("///about///")).toBe("about");
+  });
+
+  it("collapses multiple slashes", () => {
+    expect(normalizePath("about//contact")).toBe("about/contact");
+    expect(normalizePath("a///b////c")).toBe("a/b/c");
+  });
+
+  it("trims whitespace", () => {
+    expect(normalizePath("  about  ")).toBe("about");
+  });
+
+  it("handles combined transformations", () => {
+    expect(normalizePath("  /About/Contact//  ")).toBe("about/contact");
+  });
+
+  it("returns empty string for root path", () => {
+    expect(normalizePath("/")).toBe("");
+    expect(normalizePath("///")).toBe("");
+  });
+
+  it("handles empty input", () => {
+    expect(normalizePath("")).toBe("");
+    expect(normalizePath("  ")).toBe("");
+  });
+});
+
+describe("isFullUrl", () => {
+  it("returns true for https URLs", () => {
+    expect(isFullUrl("https://example.com")).toBe(true);
+  });
+
+  it("returns true for http URLs", () => {
+    expect(isFullUrl("http://example.com")).toBe(true);
+  });
+
+  it("returns false for relative paths", () => {
+    expect(isFullUrl("/about")).toBe(false);
+    expect(isFullUrl("about")).toBe(false);
+  });
+
+  it("returns false for domain-only strings", () => {
+    expect(isFullUrl("example.com")).toBe(false);
+  });
+
+  it("returns false for empty string", () => {
+    expect(isFullUrl("")).toBe(false);
+  });
+
+  it("returns false for other protocols", () => {
+    expect(isFullUrl("ftp://example.com")).toBe(false);
+    expect(isFullUrl("mailto:test@test.com")).toBe(false);
+  });
+});
+
+describe("slugify", () => {
+  it("converts text to lowercase hyphenated slug", () => {
+    expect(slugify("Hello World")).toBe("hello-world");
+  });
+
+  it("removes special characters", () => {
+    expect(slugify("Hello World! This is a Test.")).toBe(
+      "hello-world-this-is-a-test",
+    );
+  });
+
+  it("collapses multiple spaces", () => {
+    expect(slugify("Multiple   Spaces")).toBe("multiple-spaces");
+  });
+
+  it("trims leading/trailing whitespace and hyphens", () => {
+    expect(slugify("  Multiple   Spaces  ")).toBe("multiple-spaces");
+  });
+
+  it("replaces underscores with hyphens", () => {
+    expect(slugify("hello_world")).toBe("hello-world");
+  });
+
+  it("handles already-slugified text", () => {
+    expect(slugify("already-a-slug")).toBe("already-a-slug");
+  });
+
+  it("handles empty string", () => {
+    expect(slugify("")).toBe("");
+  });
+
+  it("removes non-word characters", () => {
+    expect(slugify("café & résumé")).toBe("caf-rsum");
+  });
+});

package/src/lib/constants.ts

@@ -27,7 +27,6 @@ export const RESERVED_PATHS = [
   "static",
   "assets",
   "health",
-  "appearance",
 ] as const;
 
 export type ReservedPath = (typeof RESERVED_PATHS)[number];