@anthusai/papyrus 0.0.0 → 1.0.0-next.1

package/lib/presentation-footer.ts

@@ -0,0 +1,92 @@
+import { getEditionSectionItems } from "./edition-sections";
+import type { EditionContent } from "./content-types";
+import type { PublicationItem } from "./publication-items";
+
+export type PresentationFooterEntry = {
+  section: string;
+  sectionKey: string;
+  articleSlug: string;
+  articleTitle: string;
+};
+
+export type PresentationFooterUtilityEntry =
+  | {
+      id: "archive";
+      label: string;
+      href: string;
+      disabled: false;
+    }
+  | {
+      id: "newsDesk";
+      label: string;
+      href: string;
+      disabled: false;
+    }
+  | {
+      id: "settings";
+      label: string;
+      href: string;
+      disabled: false;
+    }
+  | {
+      id: "login";
+      label: string;
+      disabled: true;
+    };
+
+export type PresentationFooterGeometry = {
+  height: number;
+  marginTop: number;
+  rowHeight: number;
+  sectionColumns: number;
+  sectionRows: number;
+};
+
+export const PRESENTATION_FOOTER_UTILITIES: PresentationFooterUtilityEntry[] = [
+  { id: "archive", label: "Archive", href: "/archive", disabled: false },
+  { id: "newsDesk", label: "Newsroom", href: "/newsroom", disabled: false },
+  { id: "settings", label: "Settings", href: "/settings", disabled: false },
+  { id: "login", label: "LOGIN", disabled: true },
+];
+
+export function buildPresentationFooterEntries(content: EditionContent): PresentationFooterEntry[] {
+  const entries: PresentationFooterEntry[] = [];
+  const seenSections = new Set<string>();
+
+  for (const section of content.sections) {
+    const sectionKey = section.label.trim().toLowerCase();
+    if (!sectionKey || seenSections.has(sectionKey)) continue;
+
+    const leadItem = getEditionSectionItems(section, content.items).find((item) => isFooterEligibleItem(item));
+    if (!leadItem) continue;
+
+    seenSections.add(sectionKey);
+    entries.push({
+      section: section.label,
+      sectionKey: section.key,
+      articleSlug: leadItem.slug,
+      articleTitle: getPresentationFooterItemTitle(leadItem),
+    });
+  }
+
+  return entries;
+}
+
+export function getPresentationFooterGrid(entryCount: number, maxColumns = 4): Pick<PresentationFooterGeometry, "sectionColumns" | "sectionRows"> {
+  const sectionColumns = entryCount === 0 ? 1 : Math.min(entryCount, Math.max(1, maxColumns));
+  const sectionRows = entryCount === 0 ? 0 : Math.ceil(entryCount / sectionColumns);
+  return { sectionColumns, sectionRows };
+}
+
+export function getPresentationFooterSubtitle(content: EditionContent): string {
+  const description = content.description?.trim();
+  return description && description.length > 0 ? description : "Inside Papyrus";
+}
+
+function isFooterEligibleItem(item: PublicationItem): boolean {
+  return item.type === "article" || item.type === "brief";
+}
+
+function getPresentationFooterItemTitle(item: PublicationItem): string {
+  return item.type === "article" ? item.headline : item.title;
+}

package/lib/pretext-layout.ts

@@ -0,0 +1,179 @@
+import {
+  layoutNextLine,
+  prepareWithSegments,
+  type LayoutCursor,
+  type LayoutLine,
+  type PreparedTextWithSegments,
+} from "@chenglou/pretext";
+
+export { layoutNextLine, prepareWithSegments, type LayoutCursor, type PreparedTextWithSegments };
+
+export type TextLine = {
+  text: string;
+  width: number;
+  x: number;
+  y: number;
+  fontSize: number;
+  fontFamily: string;
+  lineHeight: number;
+  paintHeight: number;
+};
+
+export type TextObstacle = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+export type LayoutTextLinesOptions = {
+  prepared: PreparedTextWithSegments;
+  cursor: LayoutCursor;
+  maxHeight: number;
+  maxWidth: number;
+  lineHeight: number;
+  linePaintHeight: number;
+  fontSize: number;
+  fontFamily: string;
+  obstacles: TextObstacle[];
+};
+
+export function layoutTextLines({
+  prepared,
+  cursor,
+  maxHeight,
+  maxWidth,
+  lineHeight,
+  linePaintHeight,
+  fontSize,
+  fontFamily,
+  obstacles,
+}: LayoutTextLinesOptions): { lines: TextLine[]; cursor: LayoutCursor; hasMore: boolean } {
+  const lines: TextLine[] = [];
+  let current = { ...cursor };
+  const maxLines = getVisibleLineCapacity(maxHeight, lineHeight, linePaintHeight);
+
+  for (let lineIndex = 0; lineIndex < maxLines; lineIndex += 1) {
+    const y = lineIndex * lineHeight;
+    const slot = getAvailableSlot(maxWidth, y, linePaintHeight, obstacles);
+    if (!slot) continue;
+    const line = layoutNextLine(prepared, current, slot.width);
+    if (!line) return { lines, cursor: current, hasMore: false };
+    lines.push(toTextLine(line, slot.x, y, fontSize, fontFamily, lineHeight, linePaintHeight));
+    current = line.end;
+  }
+
+  const nextSlot = getNextAvailableSlot(maxWidth, maxLines, lineHeight, linePaintHeight, obstacles) ?? { x: 0, width: maxWidth };
+  return {
+    lines,
+    cursor: current,
+    hasMore: layoutNextLine(prepared, current, nextSlot.width) !== null,
+  };
+}
+
+export function layoutAllTextLines({
+  prepared,
+  maxWidth,
+  lineHeight,
+  linePaintHeight,
+  fontSize,
+  fontFamily,
+}: Omit<LayoutTextLinesOptions, "cursor" | "maxHeight" | "obstacles">): TextLine[] {
+  const lines: TextLine[] = [];
+  let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
+
+  for (let lineIndex = 0; lineIndex < 2000; lineIndex += 1) {
+    const line = layoutNextLine(prepared, cursor, maxWidth);
+    if (!line) return lines;
+    lines.push(toTextLine(line, 0, lineIndex * lineHeight, fontSize, fontFamily, lineHeight, linePaintHeight));
+    cursor = line.end;
+  }
+
+  return lines;
+}
+
+function getVisibleLineCapacity(maxHeight: number, lineHeight: number, linePaintHeight: number): number {
+  if (maxHeight < linePaintHeight) return 0;
+  return Math.floor((maxHeight - linePaintHeight) / lineHeight) + 1;
+}
+
+function getNextAvailableSlot(
+  maxWidth: number,
+  startLineIndex: number,
+  lineHeight: number,
+  linePaintHeight: number,
+  obstacles: TextObstacle[],
+): { x: number; width: number } | null {
+  for (let offset = 0; offset < 24; offset += 1) {
+    const slot = getAvailableSlot(maxWidth, (startLineIndex + offset) * lineHeight, linePaintHeight, obstacles);
+    if (slot) return slot;
+  }
+  return null;
+}
+
+function getAvailableSlot(
+  maxWidth: number,
+  y: number,
+  lineHeight: number,
+  obstacles: TextObstacle[],
+): { x: number; width: number } | null {
+  if (obstacles.length === 0) return { x: 0, width: maxWidth };
+  const bandTop = y;
+  const bandBottom = y + lineHeight;
+  const gutter = 14;
+  const intervals = obstacles
+    .filter((obstacle) => bandBottom > obstacle.y && bandTop < obstacle.y + obstacle.height)
+    .map((obstacle) => ({
+      start: clamp(obstacle.x - gutter, 0, maxWidth),
+      end: clamp(obstacle.x + obstacle.width + gutter, 0, maxWidth),
+    }))
+    .filter((interval) => interval.end > interval.start)
+    .sort((a, b) => a.start - b.start);
+
+  if (intervals.length === 0) return { x: 0, width: maxWidth };
+
+  const merged: Array<{ start: number; end: number }> = [];
+  for (const interval of intervals) {
+    const previous = merged[merged.length - 1];
+    if (previous && interval.start <= previous.end) {
+      previous.end = Math.max(previous.end, interval.end);
+    } else {
+      merged.push({ ...interval });
+    }
+  }
+
+  const gaps: Array<{ x: number; width: number }> = [];
+  let cursorX = 0;
+  for (const interval of merged) {
+    if (interval.start > cursorX) {
+      gaps.push({ x: cursorX, width: interval.start - cursorX });
+    }
+    cursorX = Math.max(cursorX, interval.end);
+  }
+  if (cursorX < maxWidth) {
+    gaps.push({ x: cursorX, width: maxWidth - cursorX });
+  }
+
+  const slot = gaps.reduce<{ x: number; width: number } | null>(
+    (best, gap) => (!best || gap.width > best.width ? gap : best),
+    null,
+  );
+  return slot && slot.width >= 80 ? slot : null;
+}
+
+function toTextLine(line: LayoutLine, x: number, y: number, fontSize: number, fontFamily: string, lineHeight: number, paintHeight: number): TextLine {
+  return {
+    text: line.text,
+    width: line.width,
+    x,
+    y,
+    fontSize,
+    fontFamily,
+    lineHeight,
+    paintHeight,
+  };
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}

package/lib/public-placeholder-config.ts

@@ -0,0 +1,102 @@
+import "server-only";
+
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "yaml";
+
+export type PublicPlaceholderSectionType = "canonical" | "floating";
+
+export type PublicPlaceholderSection = {
+  id: string;
+  title: string;
+  shortTitle: string;
+  type: PublicPlaceholderSectionType;
+  sortOrder: number;
+};
+
+export type PublicPlaceholderTopic = {
+  key: string;
+  title: string;
+  shortTitle: string;
+  description: string;
+  rank: number;
+};
+
+const NEWSROOM_SECTIONS_CONFIG_PATH = path.join(process.cwd(), "corpora", "papyrus-newsroom-sections.yml");
+const PUBLIC_TOPICS_CONFIG_PATH = path.join(process.cwd(), "corpora", "papyrus-public-topics.yml");
+
+export function loadPublicPlaceholderSections(): PublicPlaceholderSection[] {
+  const parsed = readYamlRecord(NEWSROOM_SECTIONS_CONFIG_PATH);
+  const sections = Array.isArray(parsed.sections) ? parsed.sections : [];
+  return sections
+    .map((entry, index) => normalizePublicSection(entry, index))
+    .filter((section): section is PublicPlaceholderSection => section !== null)
+    .sort((left, right) => left.sortOrder - right.sortOrder || left.title.localeCompare(right.title));
+}
+
+export function loadPublicPlaceholderTopics(): PublicPlaceholderTopic[] {
+  const parsed = readYamlRecord(PUBLIC_TOPICS_CONFIG_PATH);
+  const topics = Array.isArray(parsed.topics) ? parsed.topics : [];
+  return topics
+    .map((entry, index) => normalizePublicTopic(entry, index))
+    .sort((left, right) => left.rank - right.rank || left.title.localeCompare(right.title));
+}
+
+function readYamlRecord(filePath: string): Record<string, unknown> {
+  const parsed = parse(fs.readFileSync(filePath, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid public placeholder config: ${filePath}`);
+  }
+  return parsed as Record<string, unknown>;
+}
+
+function normalizePublicSection(entry: unknown, index: number): PublicPlaceholderSection | null {
+  const record = objectRecord(entry);
+  const enabled = record.enabled;
+  if (enabled === false) return null;
+
+  const id = requiredString(record.id, `sections[${index}].id`);
+  const title = requiredString(record.title, `sections[${index}].title`);
+  const shortTitle = requiredString(record.shortTitle, `sections[${index}].shortTitle`);
+  const rawType = requiredString(record.type, `sections[${index}].type`);
+  const type = rawType === "canonical" ? "canonical" : rawType === "floating" || rawType === "rotating" ? "floating" : null;
+  if (!type) throw new Error(`Unsupported public section type '${rawType}' for ${id}`);
+
+  return {
+    id,
+    title,
+    shortTitle,
+    type,
+    sortOrder: numberValue(record.sortOrder) ?? index + 1,
+  };
+}
+
+function normalizePublicTopic(entry: unknown, index: number): PublicPlaceholderTopic {
+  const record = objectRecord(entry);
+  return {
+    key: requiredString(record.key, `topics[${index}].key`),
+    title: requiredString(record.title, `topics[${index}].title`),
+    shortTitle: requiredString(record.shortTitle, `topics[${index}].shortTitle`),
+    description: requiredString(record.description, `topics[${index}].description`),
+    rank: numberValue(record.rank) ?? index + 1,
+  };
+}
+
+function objectRecord(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value as Record<string, unknown>;
+}
+
+function requiredString(value: unknown, label: string): string {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  throw new Error(`Missing required public placeholder value: ${label}`);
+}
+
+function numberValue(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}

package/lib/publication-items.ts

@@ -0,0 +1,181 @@
+import {
+  type Article,
+  type ArticleAsset,
+  type ArticleImage,
+  type ArticleImageAsset,
+  type ArticleVideoAsset,
+  getArticleImageAssets,
+  getArticleText,
+  getArticleVideoAsset,
+} from "./articles";
+
+export type PublicationItemType = "article" | "brief" | "correction" | "promo" | "ad" | "sectionHeader";
+
+export type ArticlePublicationItem = Article & {
+  type: "article";
+};
+
+export type NonArticlePublicationItem = {
+  type: Exclude<PublicationItemType, "article">;
+  slug: string;
+  section?: string;
+  title: string;
+  deck?: string;
+  excerpt?: string;
+  body?: string[];
+  image?: ArticleImage;
+  video?: ArticleVideoAsset;
+  assets?: ArticleAsset[];
+  href?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type PublicationItem = ArticlePublicationItem | NonArticlePublicationItem;
+
+export function articleToPublicationItem(article: Article): ArticlePublicationItem {
+  return {
+    ...cloneArticle(article),
+    type: "article",
+  };
+}
+
+export function publicationItemToArticle(item: PublicationItem): Article | undefined {
+  if (item.type !== "article") return undefined;
+  const { type: _type, ...article } = item;
+  return cloneArticle(article);
+}
+
+export function getArticlePublicationItems(items: PublicationItem[]): ArticlePublicationItem[] {
+  return items.filter((item): item is ArticlePublicationItem => item.type === "article");
+}
+
+export function getPublicationItemText(item: PublicationItem): string {
+  if (item.type === "article") return getArticleText(item);
+  return [item.title, item.deck, ...(item.body ?? [])].filter(Boolean).join("\n\n");
+}
+
+export function getPublicationItemImageAssets(item: PublicationItem): ArticleImageAsset[] {
+  if (item.type === "article") return getArticleImageAssets(item);
+  const explicitAssets = item.assets?.filter((asset): asset is ArticleImageAsset => asset.type === "image") ?? [];
+  if (explicitAssets.length > 0) return explicitAssets;
+  if (!item.image) return [];
+  return [
+    {
+      ...item.image,
+      id: `${item.slug}-primary-image`,
+      type: "image",
+      roles: ["feature"],
+    },
+  ];
+}
+
+export function getPublicationItemVideoAsset(item: PublicationItem): ArticleVideoAsset | undefined {
+  if (item.type === "article") return getArticleVideoAsset(item);
+  const explicitAssets = item.assets?.filter((asset): asset is ArticleVideoAsset => asset.type === "video") ?? [];
+  if (explicitAssets.length > 0) {
+    return explicitAssets.find((asset) => asset.roles?.includes("lead")) ?? explicitAssets[0];
+  }
+  return item.video;
+}
+
+export function clonePublicationItems(items: PublicationItem[]): PublicationItem[] {
+  return items.map((item) => (item.type === "article" ? articleToPublicationItem(item) : cloneNonArticleItem(item)));
+}
+
+export function cloneArticle(article: Article): Article {
+  return {
+    ...article,
+    image: article.image
+      ? {
+          ...article.image,
+          layout: cloneImageLayout(article.image.layout),
+          themeVariants: cloneImageThemeVariants(article.image.themeVariants),
+        }
+      : undefined,
+    video: article.video
+      ? {
+          ...article.video,
+          roles: article.video.roles ? [...article.video.roles] : undefined,
+          themeVariants: cloneVideoThemeVariants(article.video.themeVariants),
+        }
+      : undefined,
+    assets: article.assets?.map((asset) =>
+      asset.type === "video"
+        ? {
+            ...asset,
+            roles: asset.roles ? [...asset.roles] : undefined,
+            themeVariants: cloneVideoThemeVariants(asset.themeVariants),
+          }
+        : {
+            ...asset,
+            layout: cloneImageLayout(asset.layout),
+            roles: asset.roles ? [...asset.roles] : undefined,
+            themeVariants: cloneImageThemeVariants(asset.themeVariants),
+          },
+    ),
+    pullQuotes: article.pullQuotes ? [...article.pullQuotes] : undefined,
+    body: [...article.body],
+  };
+}
+
+function cloneNonArticleItem(item: NonArticlePublicationItem): NonArticlePublicationItem {
+  return {
+    ...item,
+    image: item.image
+      ? {
+          ...item.image,
+          layout: cloneImageLayout(item.image.layout),
+          themeVariants: cloneImageThemeVariants(item.image.themeVariants),
+        }
+      : undefined,
+    video: item.video
+      ? {
+          ...item.video,
+          roles: item.video.roles ? [...item.video.roles] : undefined,
+          themeVariants: cloneVideoThemeVariants(item.video.themeVariants),
+        }
+      : undefined,
+    assets: item.assets?.map((asset) =>
+      asset.type === "video"
+        ? {
+            ...asset,
+            roles: asset.roles ? [...asset.roles] : undefined,
+            themeVariants: cloneVideoThemeVariants(asset.themeVariants),
+          }
+        : {
+            ...asset,
+            layout: cloneImageLayout(asset.layout),
+            roles: asset.roles ? [...asset.roles] : undefined,
+            themeVariants: cloneImageThemeVariants(asset.themeVariants),
+          },
+    ),
+    body: item.body ? [...item.body] : undefined,
+    metadata: item.metadata ? { ...item.metadata } : undefined,
+  };
+}
+
+function cloneImageLayout<T extends ArticleImage["layout"]>(layout: T): T {
+  if (!layout) return undefined as T;
+  return {
+    ...layout,
+    inlineFloat: layout.inlineFloat ? { ...layout.inlineFloat } : undefined,
+    focalPoint: layout.focalPoint ? { ...layout.focalPoint } : undefined,
+  } as T;
+}
+
+function cloneImageThemeVariants<T extends ArticleImage["themeVariants"]>(themeVariants: T): T {
+  if (!themeVariants) return undefined as T;
+  return {
+    ...themeVariants,
+    dark: themeVariants.dark ? { ...themeVariants.dark } : undefined,
+  } as T;
+}
+
+function cloneVideoThemeVariants<T extends ArticleVideoAsset["themeVariants"]>(themeVariants: T): T {
+  if (!themeVariants) return undefined as T;
+  return {
+    ...themeVariants,
+    light: themeVariants.light ? { ...themeVariants.light } : undefined,
+    dark: themeVariants.dark ? { ...themeVariants.dark } : undefined,
+  } as T;
+}

package/lib/reader-route-config.ts

@@ -0,0 +1 @@
+export const READER_REVALIDATE_SECONDS = 3600;

package/lib/reader-static-params.ts

@@ -0,0 +1,56 @@
+import { graphqlContentRepository } from "./graphql-content-repository";
+
+const MONTH_NAMES = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+] as const;
+
+type EditionDateStaticParam = {
+  year: string;
+  month: string;
+  day: string;
+};
+
+export async function generateEditionDateStaticParams(): Promise<EditionDateStaticParam[]> {
+  if (process.env.NODE_ENV === "development") return [];
+
+  const { editions } = await graphqlContentRepository.listPublishedEditions({ limit: 100 });
+  const params: EditionDateStaticParam[] = [];
+  for (const edition of editions) {
+    const route = editionDateToStaticParam(edition.editionDate);
+    if (route) params.push(route);
+  }
+  return params;
+}
+
+export async function generateArticleStaticParams(): Promise<Array<{ slug: string }>> {
+  if (process.env.NODE_ENV === "development") return [];
+
+  const slugs = await graphqlContentRepository.listArticleSlugs();
+  return slugs.map((slug) => ({ slug }));
+}
+
+function editionDateToStaticParam(editionDate: string): EditionDateStaticParam | null {
+  const match = editionDate.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) return null;
+
+  const monthIndex = Number(match[2]) - 1;
+  const monthName = MONTH_NAMES[monthIndex];
+  if (!monthName) return null;
+
+  return {
+    year: match[1],
+    month: monthName,
+    day: String(Number(match[3])),
+  };
+}

package/lib/reader-storage-url.ts

@@ -0,0 +1,63 @@
+import { getUrl } from "aws-amplify/storage/server";
+import { getAmplifyServerRuntime } from "./amplify-server-runtime";
+
+const STORAGE_URL_EXPIRES_IN_SECONDS = 60 * 60;
+const STORAGE_URL_CACHE_TTL_MS = 55 * 60 * 1000;
+const GUEST_READ_PREFIX = "media/";
+
+type SignedUrlCacheEntry = {
+  expiresAt: number;
+  url: string;
+};
+
+const signedUrlCache = new Map<string, SignedUrlCacheEntry>();
+
+export function isGuestReadableStoragePath(storagePath: string): boolean {
+  const normalized = storagePath.trim().replace(/^\/+/, "");
+  return normalized.startsWith(GUEST_READ_PREFIX);
+}
+
+export function buildReaderMediaProxyUrl(storagePath: string): string {
+  const normalized = storagePath.trim().replace(/^\/+/, "");
+  if (!isGuestReadableStoragePath(normalized)) {
+    throw new Error(`Storage path is not reader-public: ${storagePath}`);
+  }
+  return `/api/media/${normalized.split("/").map((segment) => encodeURIComponent(segment)).join("/")}`;
+}
+
+export async function resolveReaderStorageUrl(storagePath: string): Promise<string> {
+  const normalized = storagePath.trim().replace(/^\/+/, "");
+  if (!normalized) {
+    throw new Error("Missing storage path.");
+  }
+  if (isGuestReadableStoragePath(normalized)) {
+    return buildReaderMediaProxyUrl(normalized);
+  }
+  return signStorageUrl(normalized);
+}
+
+export async function signStorageUrl(storagePath: string): Promise<string> {
+  const normalized = storagePath.trim().replace(/^\/+/, "");
+  const cached = signedUrlCache.get(normalized);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.url;
+  }
+
+  const { runWithAmplifyServerContext } = getAmplifyServerRuntime();
+  const result = await runWithAmplifyServerContext({
+    nextServerContext: null,
+    operation: (contextSpec) =>
+      getUrl(contextSpec, {
+        path: normalized,
+        options: {
+          expiresIn: STORAGE_URL_EXPIRES_IN_SECONDS,
+        },
+      }),
+  });
+  const url = result.url.toString();
+  signedUrlCache.set(normalized, {
+    expiresAt: Date.now() + STORAGE_URL_CACHE_TTL_MS,
+    url,
+  });
+  return url;
+}