@jant/core 0.6.14 → 0.6.16

package/src/lib/timeline.ts

@@ -14,7 +14,7 @@ import type {
 } from "../types.js";
 import type { AppVariables } from "../types/app-context.js";
 import { buildMediaMap } from "./media-helpers.js";
-import { createMediaContext, toPostView } from "./view.js";
+import { createMediaContext, resolveDraftTailId, toPostView } from "./view.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -28,7 +28,17 @@ export interface TimelineResult {
   totalCount: number;
 }
 
-type CuratedThreadSelectionMap = Map<string, Set<string>>;
+interface CuratedThreadSource {
+  posts: Array<{ post: Post; position: number }>;
+  highlightedPostIds: ReadonlySet<string>;
+}
+
+interface CuratedThreadDisplayOptions {
+  collectionPinnedThreadIds?: ReadonlySet<string>;
+  /** Visually focus the newest Post when the Thread itself is the selection. */
+  highlightLatestPost?: boolean;
+  showContextRatings: boolean;
+}
 
 async function buildTimelineItems(
   c: Context<Env>,
@@ -41,13 +51,32 @@ async function buildTimelineItems(
   // Batch load media, collections, and latest-reply contexts in parallel
   const postIds = posts.map((p) => p.id);
   const mediaCtx = createMediaContext(c.var.appConfig);
-  const [rawMediaMap, collectionsMap, threadContexts, aliasesMap] =
-    await Promise.all([
-      c.var.services.media.getByPostIds(postIds),
-      c.var.services.collections.getCollectionsByPostIds(postIds),
-      c.var.services.posts.getThreadTimelineContext(postIds),
-      c.var.services.paths.getPostAliases(postIds),
-    ]);
+  const threadIds = posts.map((p) => p.threadId);
+  const [
+    rawMediaMap,
+    collectionsMap,
+    threadContexts,
+    aliasesMap,
+    publishedTails,
+    draftInclusiveTails,
+  ] = await Promise.all([
+    c.var.services.media.getByPostIds(postIds),
+    c.var.services.collections.getCollectionsByPostIds(postIds),
+    c.var.services.posts.getThreadTimelineContext(postIds),
+    c.var.services.paths.getPostAliases(postIds),
+    // The feed never renders drafts — it would turn a reading surface into a
+    // workspace. So the author's trailing draft stays hidden here, and the
+    // reply affordance carries its ID instead of silently offering a reply
+    // the server will refuse.
+    c.var.isAuthenticated
+      ? c.var.services.posts.getThreadTailIds(threadIds)
+      : Promise.resolve(new Map<string, string>()),
+    c.var.isAuthenticated
+      ? c.var.services.posts.getThreadTailIds(threadIds, {
+          includeDrafts: true,
+        })
+      : Promise.resolve(new Map<string, string>()),
+  ]);
   const mediaMap = buildMediaMap(
     rawMediaMap,
     mediaCtx.r2PublicUrl,
@@ -57,12 +86,13 @@ async function buildTimelineItems(
     mediaCtx.sitePathPrefix,
   );
 
-  // Batch load media for thread preview posts (second + penultimate + latest)
+  // Batch load media for the bounded leading/trailing thread context.
   const contextPostIds = new Set<string>();
   for (const ctx of threadContexts.values()) {
     contextPostIds.add(ctx.latestReply.id);
-    if (ctx.secondReply) contextPostIds.add(ctx.secondReply.id);
-    if (ctx.penultimateReply) contextPostIds.add(ctx.penultimateReply.id);
+    for (const reply of [...ctx.leadingReplies, ...ctx.trailingReplies]) {
+      contextPostIds.add(reply.id);
+    }
   }
   const [contextMediaMap, contextCollectionsMap, contextAliasesMap] =
     contextPostIds.size > 0
@@ -102,25 +132,33 @@ async function buildTimelineItems(
       firstAlias(post.id),
     );
 
+    const draftTailId = resolveDraftTailId(
+      post.threadId,
+      publishedTails,
+      draftInclusiveTails,
+    );
+
     const threadCtx = threadContexts.get(post.id);
 
     if (threadCtx) {
       // Thread root is not the last post — hide reply button on it
       postView.isLastInThread = false;
 
-      const secondReplyView = threadCtx.secondReply
-        ? toPostView(
-            {
-              ...threadCtx.secondReply,
-              mediaAttachments:
-                contextMediaMap.get(threadCtx.secondReply.id) ?? [],
-            },
-            mediaCtx,
-            contextCollectionsMap.get(threadCtx.secondReply.id),
-            threadCtx.secondReply.id === threadCtx.latestReply.id,
-            firstContextAlias(threadCtx.secondReply.id),
-          )
-        : undefined;
+      const toContextPostView = (reply: Post) =>
+        toPostView(
+          {
+            ...reply,
+            mediaAttachments: contextMediaMap.get(reply.id) ?? [],
+          },
+          mediaCtx,
+          contextCollectionsMap.get(reply.id),
+          false,
+          firstContextAlias(reply.id),
+        );
+
+      const leadingReplyViews = threadCtx.leadingReplies.map(toContextPostView);
+      const trailingReplyViews =
+        threadCtx.trailingReplies.map(toContextPostView);
 
       const latestReplyView = toPostView(
         {
@@ -129,35 +167,26 @@ async function buildTimelineItems(
         },
         mediaCtx,
         contextCollectionsMap.get(threadCtx.latestReply.id),
-        true, // latestReply is the last post in the thread
+        true, // latestReply is the last published post in the thread
         firstContextAlias(threadCtx.latestReply.id),
       );
-
-      const penultimateReplyView = threadCtx.penultimateReply
-        ? toPostView(
-            {
-              ...threadCtx.penultimateReply,
-              mediaAttachments:
-                contextMediaMap.get(threadCtx.penultimateReply.id) ?? [],
-            },
-            mediaCtx,
-            contextCollectionsMap.get(threadCtx.penultimateReply.id),
-            false, // penultimateReply is not the last post
-            firstContextAlias(threadCtx.penultimateReply.id),
-          )
-        : undefined;
+      if (draftTailId) latestReplyView.draftTailId = draftTailId;
 
       return {
         post: postView,
         threadPreview: {
-          secondReply: secondReplyView,
-          penultimateReply: penultimateReplyView,
+          leadingReplies: leadingReplyViews,
+          trailingReplies: trailingReplyViews,
           latestReply: latestReplyView,
           totalReplyCount: threadCtx.totalReplyCount,
         },
       };
     }
 
+    // No published replies, so the root carries the reply affordance — and any
+    // trailing draft with it.
+    if (draftTailId) postView.draftTailId = draftTailId;
+
     return { post: postView };
   });
 }
@@ -182,13 +211,12 @@ export async function assembleTimelineItems(
 async function buildCuratedThreadItems(
   c: Context<Env>,
   rootIds: string[],
-  threadsByRootId: Map<string, Post[]>,
-  selectedPostIdsByThread: CuratedThreadSelectionMap,
-  collectionPinnedPostIds?: Set<string>,
+  threadsByRootId: Map<string, CuratedThreadSource>,
+  display: CuratedThreadDisplayOptions,
 ): Promise<TimelineItemView[]> {
   const orderedThreads = rootIds
-    .map((rootId) => threadsByRootId.get(rootId) ?? [])
-    .filter((thread) => thread.length > 0);
+    .map((rootId) => threadsByRootId.get(rootId))
+    .filter((thread): thread is CuratedThreadSource => Boolean(thread));
 
   if (orderedThreads.length === 0) {
     return [];
@@ -196,7 +224,7 @@ async function buildCuratedThreadItems(
 
   const mediaCtx = createMediaContext(c.var.appConfig);
   const postIds = orderedThreads.flatMap((thread) =>
-    thread.map((post) => post.id),
+    thread.posts.map(({ post }) => post.id),
   );
   const [rawMediaMap, collectionsMap, curatedAliasesMap] = await Promise.all([
     c.var.services.media.getByPostIds(postIds),
@@ -213,14 +241,15 @@ async function buildCuratedThreadItems(
   );
 
   return orderedThreads.reduce<TimelineItemView[]>((items, thread) => {
-    const root = thread[0];
-    if (!root) {
+    const rootEntry = thread.posts[0];
+    if (!rootEntry || rootEntry.position !== 0) {
       return items;
     }
 
-    const lastPostId = thread[thread.length - 1]?.id;
-    const postViews = thread.map((post) =>
-      toPostView(
+    const lastPostId = thread.posts[thread.posts.length - 1]?.post.id;
+    const renderedPosts = thread.posts.map(({ post, position }) => ({
+      position,
+      view: toPostView(
         {
           ...post,
           mediaAttachments: mediaMap.get(post.id) ?? [],
@@ -229,54 +258,34 @@ async function buildCuratedThreadItems(
         collectionsMap.get(post.id),
         post.id === lastPostId,
         curatedAliasesMap.get(post.id)?.[0],
-        collectionPinnedPostIds?.has(post.id),
+        post.id === post.threadId &&
+          display.collectionPinnedThreadIds?.has(post.threadId),
       ),
-    );
-    const rootView = postViews[0];
-    const selectedIds = selectedPostIdsByThread.get(root.id);
-
-    if (!rootView || !selectedIds || selectedIds.size === 0) {
-      return items;
-    }
-
-    const selectedIndices = postViews.reduce<number[]>(
-      (indices, post, index) => {
-        if (selectedIds.has(post.id)) {
-          indices.push(index);
-        }
-        return indices;
-      },
-      [],
-    );
+    }));
+    const rootView = renderedPosts[0]?.view;
 
-    if (selectedIndices.length === 0) {
+    if (!rootView) {
       return items;
     }
 
-    const selectedIndexSet = new Set(selectedIndices);
-    const visibleIndices = [
-      ...new Set([0, postViews.length - 1, ...selectedIndices]),
-    ].sort((left, right) => left - right);
-    const segments = visibleIndices.reduce<
+    const segments = renderedPosts.reduce<
       NonNullable<TimelineItemView["curatedThread"]>["segments"]
-    >((items, index, segmentIndex) => {
-      const postView = postViews[index];
-      if (!postView) {
-        return items;
-      }
-
-      const previousIndex =
-        segmentIndex === 0 ? undefined : visibleIndices[segmentIndex - 1];
+    >((items, renderedPost, segmentIndex) => {
+      const previousPosition =
+        segmentIndex === 0
+          ? undefined
+          : renderedPosts[segmentIndex - 1]?.position;
 
       items.push({
-        post: postView,
+        post: renderedPost.view,
         hiddenBeforeCount:
-          previousIndex === undefined
-            ? index === 0
-              ? 0
-              : index - 1
-            : index - previousIndex - 1,
-        highlighted: selectedIndexSet.has(index),
+          previousPosition === undefined
+            ? renderedPost.position
+            : renderedPost.position - previousPosition - 1,
+        highlighted:
+          thread.highlightedPostIds.has(renderedPost.view.id) ||
+          (display.highlightLatestPost === true &&
+            renderedPost.view.id === lastPostId),
       });
 
       return items;
@@ -286,10 +295,10 @@ async function buildCuratedThreadItems(
       return items;
     }
 
-    const isRootOnlySelection =
+    const isStandaloneRoot =
       segments.length === 1 && segments[0]?.post.id === rootView.id;
 
-    if (isRootOnlySelection) {
+    if (isStandaloneRoot) {
       items.push({ post: rootView });
       return items;
     }
@@ -298,6 +307,7 @@ async function buildCuratedThreadItems(
       post: rootView,
       curatedThread: {
         rootPost: rootView,
+        showContextRatings: display.showContextRatings,
         segments,
       },
     });
@@ -429,36 +439,31 @@ export async function assembleFeaturedTimeline(
     return { items: [], currentPage: page, totalPages, totalCount };
   }
 
-  const threadsByRootId =
-    await c.var.services.posts.getPublishedThreads(rootIds);
-  const selectedPostIdsByThread: CuratedThreadSelectionMap = new Map();
-
-  for (const [threadId, thread] of threadsByRootId) {
-    const selectedIds = thread
-      .filter((post) => post.featuredAt !== null)
-      .map((post) => post.id);
-
-    if (selectedIds.length > 0) {
-      selectedPostIdsByThread.set(threadId, new Set(selectedIds));
-    }
-  }
-
-  const items = await buildCuratedThreadItems(
-    c,
-    rootIds,
-    threadsByRootId,
-    selectedPostIdsByThread,
+  const featuredThreads =
+    await c.var.services.posts.getFeaturedThreadTimelineData(rootIds);
+  const threadsByRootId = new Map<string, CuratedThreadSource>(
+    [...featuredThreads].map(([threadId, thread]) => [
+      threadId,
+      {
+        posts: thread.posts,
+        highlightedPostIds: new Set(thread.featuredPostIds),
+      },
+    ]),
   );
 
+  const items = await buildCuratedThreadItems(c, rootIds, threadsByRootId, {
+    showContextRatings: false,
+  });
+
   return { items, currentPage: page, totalPages, totalCount };
 }
 
 /**
  * Assembles a paginated collection timeline grouped by thread root.
  *
- * Threads are ordered by collection membership time (newest/oldest) or by the
- * rated posts collected into the thread. Within each thread, collected posts are
- * expanded and intervening non-collected posts collapse into hidden-count gaps.
+ * Threads are ordered by collection activity/rating semantics. Every published
+ * post in each matching Thread is rendered; Collection membership never selects
+ * or hides individual posts within the Thread.
  *
  * @param c - Hono context (provides services + appConfig)
  * @param options - Collection IDs, optional page number, auth state, and sort
@@ -504,27 +509,28 @@ export async function assembleCollectionTimeline(
     return { items: [], currentPage: page, totalPages, totalCount };
   }
 
-  const [threadsByRootId, collectedPostIdsByThread, pinnedPostIds] =
-    await Promise.all([
-      c.var.services.posts.getPublishedThreads(rootIds),
-      c.var.services.posts.getCollectionPostIdsByThreadForCollections(
-        options.collectionIds,
-        rootIds,
-      ),
-      c.var.services.collections.getPinnedPostIds(options.collectionIds),
-    ]);
-  const selectedPostIdsByThread: CuratedThreadSelectionMap = new Map(
-    [...collectedPostIdsByThread.entries()].map(([threadId, postIds]) => [
+  const [threadsByRootId, pinnedThreadIds] = await Promise.all([
+    c.var.services.posts.getPublishedThreads(rootIds),
+    c.var.services.collections.getPinnedThreadIds(options.collectionIds),
+  ]);
+  const curatedThreadsByRootId = new Map<string, CuratedThreadSource>(
+    [...threadsByRootId].map(([threadId, thread]) => [
       threadId,
-      new Set(postIds),
+      {
+        posts: thread.map((post, position) => ({ post, position })),
+        highlightedPostIds: new Set<string>(),
+      },
     ]),
   );
   const items = await buildCuratedThreadItems(
     c,
     rootIds,
-    threadsByRootId,
-    selectedPostIdsByThread,
-    pinnedPostIds,
+    curatedThreadsByRootId,
+    {
+      collectionPinnedThreadIds: pinnedThreadIds,
+      highlightLatestPost: true,
+      showContextRatings: true,
+    },
   );
 
   return { items, currentPage: page, totalPages, totalCount };

package/src/lib/timezones.ts

@@ -336,21 +336,28 @@ export const TIMEZONES: TimezoneEntry[] = [
   },
 ];
 
-function findTimezoneEntry(value: string): TimezoneEntry | undefined {
-  return TIMEZONES.find(
-    (tz) =>
-      tz.value === value ||
-      tz.iana.includes(value) ||
-      tz.legacyValues?.includes(value),
-  );
+function findLegacyTimezoneEntry(value: string): TimezoneEntry | undefined {
+  return TIMEZONES.find((tz) => tz.legacyValues?.includes(value));
+}
+
+function resolveRuntimeTimeZone(value: string): string | null {
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: value })
+      .resolvedOptions()
+      .timeZone.trim();
+  } catch {
+    return null;
+  }
 }
 
 /**
- * Normalizes a timezone value from settings, env, or browser detection into the
- * canonical IANA identifier used by the app. Unknown values fall back to UTC.
+ * Normalizes a timezone value from settings, env, or browser detection. Any
+ * IANA name or fixed-offset identifier supported by the runtime is preserved;
+ * historical display labels are mapped to their curated replacement. Unknown
+ * values fall back to UTC.
  *
  * @param value - Timezone value to normalize
- * @returns Canonical IANA timezone identifier
+ * @returns Runtime-normalized timezone identifier or UTC
  *
  * @example
  * ```ts
@@ -365,12 +372,17 @@ export function normalizeTimeZone(value: string | null | undefined): string {
     return "UTC";
   }
 
-  return findTimezoneEntry(trimmed)?.value ?? "UTC";
+  const runtimeTimeZone = resolveRuntimeTimeZone(trimmed);
+  if (runtimeTimeZone) {
+    return runtimeTimeZone;
+  }
+
+  return findLegacyTimezoneEntry(trimmed)?.value ?? "UTC";
 }
 
 /**
- * Returns whether the app recognizes a timezone value from the curated list,
- * one of its accepted IANA aliases, or a historical legacy value.
+ * Returns whether the runtime recognizes a timezone value or the app can map
+ * it from a historical display label.
  *
  * @param value - Timezone value to validate
  * @returns `true` when the value can be normalized safely
@@ -381,7 +393,35 @@ export function isSupportedTimeZone(value: string | null | undefined): boolean {
     return false;
   }
 
-  return findTimezoneEntry(trimmed) !== undefined;
+  return (
+    resolveRuntimeTimeZone(trimmed) !== null ||
+    findLegacyTimezoneEntry(trimmed) !== undefined
+  );
+}
+
+/**
+ * Returns the curated settings options plus a valid current value that is not
+ * already represented. This keeps the UI compact without losing an IANA zone
+ * or fixed offset detected outside the curated list.
+ *
+ * @param currentValue - Current stored timezone value
+ * @returns Timezone options that can represent the current setting
+ */
+export function getTimeZoneOptions(currentValue: string): TimezoneEntry[] {
+  const normalized = normalizeTimeZone(currentValue);
+  if (TIMEZONES.some((timezone) => timezone.value === normalized)) {
+    return TIMEZONES;
+  }
+
+  return [
+    ...TIMEZONES,
+    {
+      value: normalized,
+      label: normalized,
+      offset: "",
+      iana: [normalized],
+    },
+  ];
 }
 
 /**