@jant/core 0.3.24 → 0.3.26

package/src/lib/timezones.ts

@@ -0,0 +1,325 @@
+/**
+ * Timezone List
+ *
+ * Provides a curated list of timezones for the settings UI
+ * and a helper to map IANA timezone names to our list entries.
+ */
+
+export interface TimezoneEntry {
+  /** Display value stored in settings */
+  value: string;
+  /** Human-readable label for the select UI */
+  label: string;
+  /** UTC offset string, e.g. "+08:00" */
+  offset: string;
+  /** IANA timezone names that map to this entry */
+  iana: string[];
+}
+
+export const TIMEZONES: TimezoneEntry[] = [
+  {
+    value: "International Date Line West",
+    label: "(UTC-12:00) International Date Line West",
+    offset: "-12:00",
+    iana: ["Etc/GMT+12"],
+  },
+  {
+    value: "American Samoa",
+    label: "(UTC-11:00) American Samoa",
+    offset: "-11:00",
+    iana: ["Pacific/Pago_Pago", "Pacific/Midway", "Etc/GMT+11"],
+  },
+  {
+    value: "Hawaii",
+    label: "(UTC-10:00) Hawaii",
+    offset: "-10:00",
+    iana: ["Pacific/Honolulu", "Etc/GMT+10"],
+  },
+  {
+    value: "Alaska",
+    label: "(UTC-09:00) Alaska",
+    offset: "-09:00",
+    iana: ["America/Anchorage", "America/Juneau", "America/Nome"],
+  },
+  {
+    value: "Pacific Time (US & Canada)",
+    label: "(UTC-08:00) Pacific Time (US & Canada)",
+    offset: "-08:00",
+    iana: ["America/Los_Angeles", "America/Vancouver", "America/Tijuana"],
+  },
+  {
+    value: "Mountain Time (US & Canada)",
+    label: "(UTC-07:00) Mountain Time (US & Canada)",
+    offset: "-07:00",
+    iana: [
+      "America/Denver",
+      "America/Edmonton",
+      "America/Phoenix",
+      "America/Boise",
+    ],
+  },
+  {
+    value: "Central Time (US & Canada)",
+    label: "(UTC-06:00) Central Time (US & Canada)",
+    offset: "-06:00",
+    iana: [
+      "America/Chicago",
+      "America/Winnipeg",
+      "America/Mexico_City",
+      "America/Guatemala",
+    ],
+  },
+  {
+    value: "Eastern Time (US & Canada)",
+    label: "(UTC-05:00) Eastern Time (US & Canada)",
+    offset: "-05:00",
+    iana: [
+      "America/New_York",
+      "America/Toronto",
+      "America/Detroit",
+      "America/Indiana/Indianapolis",
+      "America/Bogota",
+      "America/Lima",
+    ],
+  },
+  {
+    value: "Atlantic Time (Canada)",
+    label: "(UTC-04:00) Atlantic Time (Canada)",
+    offset: "-04:00",
+    iana: [
+      "America/Halifax",
+      "America/Caracas",
+      "America/Santiago",
+      "America/La_Paz",
+    ],
+  },
+  {
+    value: "Newfoundland",
+    label: "(UTC-03:30) Newfoundland",
+    offset: "-03:30",
+    iana: ["America/St_Johns"],
+  },
+  {
+    value: "Buenos Aires",
+    label: "(UTC-03:00) Buenos Aires",
+    offset: "-03:00",
+    iana: [
+      "America/Argentina/Buenos_Aires",
+      "America/Sao_Paulo",
+      "America/Montevideo",
+    ],
+  },
+  {
+    value: "Mid-Atlantic",
+    label: "(UTC-02:00) Mid-Atlantic",
+    offset: "-02:00",
+    iana: ["Atlantic/South_Georgia", "Etc/GMT+2"],
+  },
+  {
+    value: "Azores",
+    label: "(UTC-01:00) Azores",
+    offset: "-01:00",
+    iana: ["Atlantic/Azores", "Atlantic/Cape_Verde"],
+  },
+  {
+    value: "UTC",
+    label: "(UTC+00:00) UTC",
+    offset: "+00:00",
+    iana: ["Etc/UTC", "UTC", "Etc/GMT", "Africa/Accra"],
+  },
+  {
+    value: "London",
+    label: "(UTC+00:00) London",
+    offset: "+00:00",
+    iana: ["Europe/London", "Europe/Dublin", "Europe/Lisbon"],
+  },
+  {
+    value: "Central European Time",
+    label: "(UTC+01:00) Central European Time",
+    offset: "+01:00",
+    iana: [
+      "Europe/Paris",
+      "Europe/Berlin",
+      "Europe/Amsterdam",
+      "Europe/Rome",
+      "Europe/Madrid",
+      "Europe/Brussels",
+      "Europe/Vienna",
+      "Europe/Warsaw",
+      "Europe/Prague",
+      "Europe/Stockholm",
+      "Europe/Oslo",
+      "Europe/Copenhagen",
+      "Europe/Zurich",
+      "Africa/Lagos",
+    ],
+  },
+  {
+    value: "Eastern European Time",
+    label: "(UTC+02:00) Eastern European Time",
+    offset: "+02:00",
+    iana: [
+      "Europe/Helsinki",
+      "Europe/Athens",
+      "Europe/Bucharest",
+      "Europe/Istanbul",
+      "Africa/Cairo",
+      "Africa/Johannesburg",
+      "Asia/Jerusalem",
+      "Asia/Beirut",
+    ],
+  },
+  {
+    value: "Moscow",
+    label: "(UTC+03:00) Moscow",
+    offset: "+03:00",
+    iana: [
+      "Europe/Moscow",
+      "Europe/Minsk",
+      "Asia/Baghdad",
+      "Asia/Riyadh",
+      "Africa/Nairobi",
+      "Asia/Kuwait",
+    ],
+  },
+  {
+    value: "Tehran",
+    label: "(UTC+03:30) Tehran",
+    offset: "+03:30",
+    iana: ["Asia/Tehran"],
+  },
+  {
+    value: "Dubai",
+    label: "(UTC+04:00) Dubai",
+    offset: "+04:00",
+    iana: ["Asia/Dubai", "Asia/Muscat", "Asia/Baku", "Asia/Tbilisi"],
+  },
+  {
+    value: "Kabul",
+    label: "(UTC+04:30) Kabul",
+    offset: "+04:30",
+    iana: ["Asia/Kabul"],
+  },
+  {
+    value: "Karachi",
+    label: "(UTC+05:00) Karachi",
+    offset: "+05:00",
+    iana: ["Asia/Karachi", "Asia/Tashkent", "Asia/Yekaterinburg"],
+  },
+  {
+    value: "Mumbai",
+    label: "(UTC+05:30) Mumbai",
+    offset: "+05:30",
+    iana: ["Asia/Kolkata", "Asia/Calcutta", "Asia/Colombo"],
+  },
+  {
+    value: "Kathmandu",
+    label: "(UTC+05:45) Kathmandu",
+    offset: "+05:45",
+    iana: ["Asia/Kathmandu"],
+  },
+  {
+    value: "Dhaka",
+    label: "(UTC+06:00) Dhaka",
+    offset: "+06:00",
+    iana: ["Asia/Dhaka", "Asia/Almaty", "Asia/Omsk"],
+  },
+  {
+    value: "Yangon",
+    label: "(UTC+06:30) Yangon",
+    offset: "+06:30",
+    iana: ["Asia/Yangon", "Asia/Rangoon"],
+  },
+  {
+    value: "Bangkok",
+    label: "(UTC+07:00) Bangkok",
+    offset: "+07:00",
+    iana: [
+      "Asia/Bangkok",
+      "Asia/Jakarta",
+      "Asia/Ho_Chi_Minh",
+      "Asia/Krasnoyarsk",
+    ],
+  },
+  {
+    value: "Beijing",
+    label: "(UTC+08:00) Beijing",
+    offset: "+08:00",
+    iana: [
+      "Asia/Shanghai",
+      "Asia/Hong_Kong",
+      "Asia/Taipei",
+      "Asia/Singapore",
+      "Asia/Kuala_Lumpur",
+      "Asia/Makassar",
+      "Asia/Irkutsk",
+      "Australia/Perth",
+    ],
+  },
+  {
+    value: "Tokyo",
+    label: "(UTC+09:00) Tokyo",
+    offset: "+09:00",
+    iana: ["Asia/Tokyo", "Asia/Seoul", "Asia/Yakutsk"],
+  },
+  {
+    value: "Adelaide",
+    label: "(UTC+09:30) Adelaide",
+    offset: "+09:30",
+    iana: ["Australia/Adelaide", "Australia/Darwin"],
+  },
+  {
+    value: "Sydney",
+    label: "(UTC+10:00) Sydney",
+    offset: "+10:00",
+    iana: [
+      "Australia/Sydney",
+      "Australia/Melbourne",
+      "Australia/Brisbane",
+      "Australia/Hobart",
+      "Pacific/Guam",
+      "Asia/Vladivostok",
+    ],
+  },
+  {
+    value: "Noumea",
+    label: "(UTC+11:00) Noumea",
+    offset: "+11:00",
+    iana: ["Pacific/Noumea", "Asia/Magadan", "Pacific/Guadalcanal"],
+  },
+  {
+    value: "Auckland",
+    label: "(UTC+12:00) Auckland",
+    offset: "+12:00",
+    iana: ["Pacific/Auckland", "Pacific/Fiji", "Asia/Kamchatka"],
+  },
+  {
+    value: "Nuku'alofa",
+    label: "(UTC+13:00) Nuku'alofa",
+    offset: "+13:00",
+    iana: ["Pacific/Tongatapu", "Pacific/Apia"],
+  },
+];
+
+/**
+ * Maps an IANA timezone name (e.g. "Asia/Shanghai") to our timezone list value
+ * (e.g. "Beijing"). Returns "UTC" if no match found.
+ *
+ * @param iana - IANA timezone identifier from Intl.DateTimeFormat
+ * @returns The matching timezone value from TIMEZONES
+ *
+ * @example
+ * ```ts
+ * mapIanaToTimezone("Asia/Shanghai"); // "Beijing"
+ * mapIanaToTimezone("America/New_York"); // "Eastern Time (US & Canada)"
+ * mapIanaToTimezone("Unknown/Zone"); // "UTC"
+ * ```
+ */
+export function mapIanaToTimezone(iana: string): string {
+  for (const tz of TIMEZONES) {
+    if (tz.iana.includes(iana)) {
+      return tz.value;
+    }
+  }
+  return "UTC";
+}

package/src/lib/view.ts

@@ -77,7 +77,7 @@ export function toMediaView(media: Media, ctx: MediaContext): MediaView {
     ctx.r2PublicUrl,
     ctx.s3PublicUrl,
   );
-  const url = getMediaUrl(media.id, media.storageKey, publicUrl);
+  const url = getMediaUrl(media.storageKey, publicUrl);
   const thumbnailUrl = getImageUrl(url, ctx.imageTransformUrl, {
     width: 400,
     quality: 80,
@@ -109,7 +109,7 @@ export function toMediaView(media: Media, ctx: MediaContext): MediaView {
  * @returns Render-ready PostView with pre-computed fields
  */
 export function toPostView(post: PostWithMedia, _ctx: MediaContext): PostView {
-  const permalink = post.slug ? `/${post.slug}` : `/p/${encode(post.id)}`;
+  const permalink = post.path ? `/${post.path}` : `/p/${encode(post.id)}`;
 
   // Pre-compute excerpt from raw body
   let excerpt: string | undefined;
@@ -141,7 +141,7 @@ export function toPostView(post: PostWithMedia, _ctx: MediaContext): PostView {
   return {
     id: post.id,
     permalink,
-    slug: post.slug ?? undefined,
+    path: post.path ?? undefined,
     title: post.title ?? undefined,
     bodyHtml: post.bodyHtml ?? undefined,
     excerpt,

package/src/preset.css

@@ -10,7 +10,8 @@
 @import "basecoat-css";
 @plugin "@tailwindcss/typography";
 @import "./styles/components.css";
-@import "./themes/threads/style.css";
+@import "./styles/tokens.css";
+@import "./styles/ui.css";
 
 @theme {
   --radius-default: 0.5rem;

package/src/routes/__tests__/compose.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../__tests__/helpers/app.js";
+import { composeRoutes } from "../compose.js";
+
+describe("Compose Routes", () => {
+  describe("POST /compose", () => {
+    it("redirects to signin when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ format: "note", body: "Hello" }),
+      });
+
+      expect(res.status).toBe(302);
+      expect(res.headers.get("Location")).toBe("/signin");
+    });
+
+    it("creates a note post and returns redirect", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ format: "note", body: "Hello world" }),
+      });
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toBe("text/html");
+
+      // Verify post was created
+      const posts = await services.posts.list();
+      expect(posts).toHaveLength(1);
+      expect(posts[0].format).toBe("note");
+      expect(posts[0].body).toBe("Hello world");
+      expect(posts[0].status).toBe("published");
+    });
+
+    it("creates a link post", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          format: "link",
+          body: "Check this out",
+          url: "https://example.com",
+        }),
+      });
+
+      expect(res.status).toBe(200);
+
+      const posts = await services.posts.list();
+      expect(posts).toHaveLength(1);
+      expect(posts[0].format).toBe("link");
+      expect(posts[0].url).toBe("https://example.com");
+    });
+
+    it("creates a quote post", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          format: "quote",
+          body: "Great insight",
+          quoteText: "The original quote",
+          url: "https://example.com/source",
+        }),
+      });
+
+      expect(res.status).toBe(200);
+
+      const posts = await services.posts.list();
+      expect(posts).toHaveLength(1);
+      expect(posts[0].format).toBe("quote");
+      expect(posts[0].quoteText).toBe("The original quote");
+    });
+
+    it("creates a draft when status is draft", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          format: "note",
+          body: "Draft content",
+          status: "draft",
+        }),
+      });
+
+      expect(res.status).toBe(200);
+
+      const posts = await services.posts.list({ includeDrafts: true });
+      expect(posts).toHaveLength(1);
+      expect(posts[0].status).toBe("draft");
+    });
+
+    it("returns error for invalid format", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ format: "invalid", body: "Hello" }),
+      });
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get("Content-Type")).toBe("text/html");
+      // Returns a toast error (text/html with error message)
+      const text = await res.text();
+      expect(text).toContain("toast-error");
+    });
+
+    it("attaches media IDs when provided", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      // Create media first
+      const media = await services.media.create({
+        filename: "test.jpg",
+        originalName: "test.jpg",
+        mimeType: "image/jpeg",
+        size: 1024,
+        storageKey: "media/2025/01/test.jpg",
+        width: 800,
+        height: 600,
+      });
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          format: "note",
+          body: "Post with media",
+          mediaIds: [media.id],
+        }),
+      });
+
+      expect(res.status).toBe(200);
+
+      const posts = await services.posts.list();
+      expect(posts).toHaveLength(1);
+
+      // Verify media is attached
+      const attachments = await services.media.getByPostId(posts[0].id);
+      expect(attachments).toHaveLength(1);
+      expect(attachments[0].id).toBe(media.id);
+    });
+
+    it("sets featured and pinned flags", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          format: "note",
+          body: "Featured and pinned",
+          featured: true,
+          pinned: true,
+        }),
+      });
+
+      expect(res.status).toBe(200);
+
+      const posts = await services.posts.list();
+      expect(posts).toHaveLength(1);
+      expect(posts[0].featured).toBe(1);
+      expect(posts[0].pinned).toBe(1);
+    });
+
+    it("returns error when format is missing", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ body: "No format" }),
+      });
+
+      expect(res.status).toBe(200);
+      const text = await res.text();
+      expect(text).toContain("toast-error");
+    });
+  });
+});