@anthusai/papyrus 0.0.0 → 1.0.0-next.10

package/lib/doctrine.ts

@@ -0,0 +1,128 @@
+export const DOCTRINE_ITEM_TYPE = "doctrine";
+export const DOCTRINE_ITEM_STATUS = "private";
+export const DOCTRINE_ITEM_TYPE_STATUS = "doctrine#private";
+
+export type DoctrineKind = "mission" | "policy";
+export type DoctrineScope = "publication" | "category";
+
+export type DoctrineDefinition = {
+  kind: DoctrineKind;
+  label: string;
+  slug: string;
+  id: string;
+  lineageId: string;
+};
+
+export type DoctrineCategory = {
+  categorySetId: string;
+  categoryKey: string;
+  displayName: string;
+  shortTitle?: string | null;
+  rank?: number | null;
+  depth?: number | null;
+  lineageId?: string | null;
+  id?: string | null;
+};
+
+export const DOCTRINE_DEFINITIONS: DoctrineDefinition[] = [
+  {
+    kind: "mission",
+    label: "Editorial Mission",
+    slug: "editorial-doctrine-mission",
+    id: "item-editorial-doctrine-mission-v1",
+    lineageId: "item-editorial-doctrine-mission",
+  },
+  {
+    kind: "policy",
+    label: "Editorial Policy",
+    slug: "editorial-doctrine-policy",
+    id: "item-editorial-doctrine-policy-v1",
+    lineageId: "item-editorial-doctrine-policy",
+  },
+];
+
+export const DOCTRINE_DEFINITION_BY_KIND = new Map(
+  DOCTRINE_DEFINITIONS.map((definition) => [definition.kind, definition]),
+);
+
+export function buildCategoryDoctrineDefinition(category: DoctrineCategory, kind: DoctrineKind): DoctrineDefinition {
+  const safeCategoryKey = safeDoctrineKey(category.categoryKey);
+  const categoryLineageId = category.lineageId ?? category.id ?? category.categoryKey;
+  const safeCategoryLineageId = safeDoctrineKey(categoryLineageId);
+  const label = kind === "mission" ? "Category Mission" : "Category Policies";
+  return {
+    kind,
+    label,
+    slug: `desk-doctrine-${safeCategoryKey}-${kind}`,
+    id: `item-desk-doctrine-${safeCategoryLineageId}-${kind}-v1`,
+    lineageId: `item-desk-doctrine-${safeCategoryLineageId}-${kind}`,
+  };
+}
+
+export function getCategoryDoctrineDefinitions(category: DoctrineCategory): DoctrineDefinition[] {
+  return [
+    buildCategoryDoctrineDefinition(category, "mission"),
+    buildCategoryDoctrineDefinition(category, "policy"),
+  ];
+}
+
+export function categoryDoctrineEditorialValue(category: DoctrineCategory, kind: DoctrineKind): string {
+  return JSON.stringify({
+    scope: "category",
+    kind,
+    categorySetId: category.categorySetId,
+    categoryLineageId: category.lineageId ?? category.id ?? category.categoryKey,
+    categoryKey: category.categoryKey,
+    categoryDepth: category.depth ?? null,
+  });
+}
+
+export function buildDeskDoctrineDefinition(category: DoctrineCategory, kind: DoctrineKind): DoctrineDefinition {
+  return buildCategoryDoctrineDefinition(category, kind);
+}
+
+export function getDeskDoctrineDefinitions(category: DoctrineCategory): DoctrineDefinition[] {
+  return getCategoryDoctrineDefinitions(category);
+}
+
+export function deskDoctrineEditorialValue(category: DoctrineCategory, kind: DoctrineKind): string {
+  return categoryDoctrineEditorialValue(category, kind);
+}
+
+export function isDeskDoctrineSlug(slug: string | null | undefined): boolean {
+  return typeof slug === "string" && slug.startsWith("desk-doctrine-");
+}
+
+export function doctrineBodyToText(body: Array<string | null> | null | undefined): string {
+  return compactDoctrineParagraphs(body).join("\n\n");
+}
+
+export function doctrineTextToBody(text: string): string[] {
+  return normalizeDoctrineText(text)
+    .split(/\n\s*\n+/)
+    .map((paragraph) => paragraph.trim())
+    .filter(Boolean);
+}
+
+export function doctrineEditorialValue(kind: DoctrineKind): string {
+  return JSON.stringify({ kind });
+}
+
+function safeDoctrineKey(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    || "topic";
+}
+
+function normalizeDoctrineText(text: string): string {
+  return text.replace(/\r\n?/g, "\n").trim();
+}
+
+function compactDoctrineParagraphs(body: Array<string | null> | null | undefined): string[] {
+  return (body ?? [])
+    .map((paragraph) => (typeof paragraph === "string" ? paragraph.trim() : ""))
+    .filter(Boolean);
+}

package/lib/edition-routes.ts

@@ -0,0 +1,155 @@
+const MONTH_NAMES = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+] as const;
+
+type EditionDateRouteInput = {
+  year: string;
+  month: string;
+  day: string;
+};
+
+type ParsedEditionDateRoute = {
+  editionDate: string;
+  canonicalPath: string;
+  isCanonical: boolean;
+};
+
+type ParsedEditionPageRoute = ParsedEditionDateRoute & {
+  pageNumber: number;
+};
+
+type ParsedEditionArticleRoute = ParsedEditionDateRoute & {
+  articleSlug: string;
+};
+
+type ParsedEditionSectionRoute = ParsedEditionDateRoute & {
+  sectionKey: string;
+};
+
+const RESERVED_DATE_CHILD_SEGMENTS = new Set(["page", "section"]);
+
+export function getEditionDatePath(editionDate: string): string {
+  const match = editionDate.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) return "/";
+
+  const monthIndex = Number(match[2]) - 1;
+  const monthName = MONTH_NAMES[monthIndex];
+  if (!monthName) return "/";
+
+  return `/${match[1]}/${monthName}/${match[3]}`;
+}
+
+export function getEditionPagePath(editionDate: string, pageNumber: number): string {
+  const basePath = getEditionDatePath(editionDate);
+  return pageNumber <= 1 ? basePath : `${basePath}/page/${pageNumber}`;
+}
+
+export function getEditionSectionPath(editionDate: string, sectionKey: string): string {
+  return `${getEditionDatePath(editionDate)}/section/${encodeURIComponent(sectionKey)}`;
+}
+
+export function getEditionArticlePath(editionDate: string, articleSlug: string): string {
+  return `${getEditionDatePath(editionDate)}/${encodeURIComponent(articleSlug)}`;
+}
+
+export const getEditionItemPath = getEditionArticlePath;
+
+export function parseEditionDateRoute(input: EditionDateRouteInput): ParsedEditionDateRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+
+  return {
+    ...parsed,
+    isCanonical: getCurrentDatePath(input) === parsed.canonicalPath,
+  };
+}
+
+export function parseEditionPageRoute(input: EditionDateRouteInput & { pageNumber: string }): ParsedEditionPageRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+  if (!/^\d+$/.test(input.pageNumber)) return null;
+
+  const pageNumber = Number(input.pageNumber);
+  if (!Number.isSafeInteger(pageNumber) || pageNumber < 1) return null;
+
+  const canonicalPath = getEditionPagePath(parsed.editionDate, pageNumber);
+  const currentPath = `${getCurrentDatePath(input)}/page/${input.pageNumber}`;
+  return {
+    editionDate: parsed.editionDate,
+    canonicalPath,
+    isCanonical: currentPath === canonicalPath,
+    pageNumber,
+  };
+}
+
+export function parseEditionArticleRoute(input: EditionDateRouteInput & { articleSlug: string }): ParsedEditionArticleRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+  if (RESERVED_DATE_CHILD_SEGMENTS.has(input.articleSlug.toLowerCase())) return null;
+
+  const canonicalPath = getEditionArticlePath(parsed.editionDate, input.articleSlug);
+  const currentPath = `${getCurrentDatePath(input)}/${input.articleSlug}`;
+  return {
+    editionDate: parsed.editionDate,
+    canonicalPath,
+    isCanonical: currentPath === canonicalPath,
+    articleSlug: input.articleSlug,
+  };
+}
+
+export function parseEditionSectionRoute(input: EditionDateRouteInput & { sectionKey: string }): ParsedEditionSectionRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+  if (!input.sectionKey.trim()) return null;
+
+  const canonicalPath = getEditionSectionPath(parsed.editionDate, input.sectionKey);
+  const currentPath = `${getCurrentDatePath(input)}/section/${input.sectionKey}`;
+  return {
+    editionDate: parsed.editionDate,
+    canonicalPath,
+    isCanonical: currentPath === canonicalPath,
+    sectionKey: input.sectionKey,
+  };
+}
+
+function parseEditionDateSegments(input: EditionDateRouteInput): Omit<ParsedEditionDateRoute, "isCanonical"> | null {
+  if (!/^\d{4}$/.test(input.year)) return null;
+
+  const monthIndex = MONTH_NAMES.indexOf(input.month.toLowerCase() as (typeof MONTH_NAMES)[number]);
+  if (monthIndex < 0) return null;
+
+  if (!/^\d{1,2}$/.test(input.day)) return null;
+  const dayNumber = Number(input.day);
+  if (dayNumber < 1 || dayNumber > 31) return null;
+
+  const monthNumber = monthIndex + 1;
+  const canonicalDay = String(dayNumber).padStart(2, "0");
+  const editionDate = `${input.year}-${String(monthNumber).padStart(2, "0")}-${canonicalDay}`;
+  if (!isValidIsoDate(editionDate)) return null;
+
+  return {
+    editionDate,
+    canonicalPath: getEditionDatePath(editionDate),
+  };
+}
+
+function getCurrentDatePath(input: EditionDateRouteInput): string {
+  return `/${input.year}/${input.month}/${input.day}`;
+}
+
+function isValidIsoDate(editionDate: string): boolean {
+  const [year, month, day] = editionDate.split("-").map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}

package/lib/edition-sections.ts

@@ -0,0 +1,111 @@
+import type { EditionSection } from "./content-types";
+import type { PublicationItem } from "./publication-items";
+
+export function createEditionSectionPlan(items: PublicationItem[], explicitSections?: unknown): EditionSection[] {
+  const explicit = normalizeExplicitSections(explicitSections, items);
+  if (explicit.length > 0) return explicit;
+
+  const sections = new Map<string, EditionSection>();
+  for (const item of items) {
+    const label = normalizeSectionLabel(item.section);
+    const key = createSectionKey(label);
+    const existing = sections.get(key);
+    if (existing) {
+      if (!existing.itemIds.includes(item.slug)) existing.itemIds.push(item.slug);
+      continue;
+    }
+    sections.set(key, {
+      key,
+      label,
+      itemIds: [item.slug],
+    });
+  }
+  return [...sections.values()];
+}
+
+export function findEditionSection(sections: EditionSection[], sectionKey: string): EditionSection | undefined {
+  const normalized = createSectionKey(sectionKey);
+  return sections.find((section) => section.key === normalized);
+}
+
+export function getEditionSectionItems(section: EditionSection, items: PublicationItem[]): PublicationItem[] {
+  const itemsBySlug = new Map(items.map((item) => [item.slug, item]));
+  return section.itemIds.map((itemId) => itemsBySlug.get(itemId)).filter((item): item is PublicationItem => Boolean(item));
+}
+
+export function createSectionKey(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/&/g, " and ")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "general";
+}
+
+function normalizeExplicitSections(value: unknown, items: PublicationItem[]): EditionSection[] {
+  const parsed = parseMaybeJson(value);
+  const nestedPlan = readObjectValue(parsed, "sectionPlan");
+  const entries = Array.isArray(parsed)
+    ? parsed
+    : readObjectArray(parsed, "sections")
+      ?? readObjectArray(parsed, "sectionPlan")
+      ?? readObjectArray(nestedPlan, "sections");
+  if (!entries) return [];
+
+  const itemSlugs = new Set(items.map((item) => item.slug));
+  return entries
+    .map((entry) => normalizeSectionEntry(entry, itemSlugs))
+    .filter((section): section is EditionSection => Boolean(section));
+}
+
+function normalizeSectionEntry(entry: unknown, itemSlugs: Set<string>): EditionSection | null {
+  if (!entry || typeof entry !== "object") return null;
+  const record = entry as Record<string, unknown>;
+  const label = normalizeSectionLabel(readString(record.label) ?? readString(record.title) ?? readString(record.name) ?? readString(record.key));
+  const key = createSectionKey(readString(record.key) ?? label);
+  const itemIds = readStringArray(record.itemIds ?? record.items)
+    .map((itemId) => itemId.trim())
+    .filter((itemId, index, all) => itemSlugs.has(itemId) && all.indexOf(itemId) === index);
+
+  if (!itemIds.length) return null;
+  return {
+    key,
+    label,
+    description: readString(record.description),
+    itemIds,
+  };
+}
+
+function normalizeSectionLabel(value: string | null | undefined): string {
+  const label = value?.trim();
+  return label || "General";
+}
+
+function readObjectArray(value: unknown, key: string): unknown[] | null {
+  if (!value || typeof value !== "object") return null;
+  const candidate = (value as Record<string, unknown>)[key];
+  return Array.isArray(candidate) ? candidate : null;
+}
+
+function readObjectValue(value: unknown, key: string): unknown {
+  if (!value || typeof value !== "object") return null;
+  return (value as Record<string, unknown>)[key];
+}
+
+function parseMaybeJson(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+function readString(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function readStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0);
+}

package/lib/empty-edition-layout-plan.ts

@@ -0,0 +1,109 @@
+import type { EditionLayoutPlan } from "./layout-plan";
+import { normalizeEditionLayoutPlan } from "./layout-plan";
+
+export const EMPTY_EDITION_PLACEHOLDER_SLUG = "empty-edition-placeholder";
+
+export type EmptyEditionLayoutPlanInput = {
+  placeholderSlug?: string;
+  sectionItemSlugs: string[];
+  sectionsCtaSlug: string;
+  topicItemSlugs: string[];
+  topicsCtaSlug: string;
+};
+
+export function buildEmptyEditionLayoutPlan({
+  placeholderSlug = EMPTY_EDITION_PLACEHOLDER_SLUG,
+  sectionItemSlugs,
+  sectionsCtaSlug,
+  topicItemSlugs,
+  topicsCtaSlug,
+}: EmptyEditionLayoutPlanInput): EditionLayoutPlan {
+  return normalizeEditionLayoutPlan({
+    pages: [
+      {
+        id: "page-1",
+        pageNumber: 1,
+        presetId: "front.mosaic",
+        grid: { columns: { min: 1, preferred: 6, max: 6 } },
+        regions: [
+          {
+            id: "empty-front-page",
+            type: "fullPage",
+            localGrid: { columns: { min: 1, preferred: 6, max: 6 } },
+            blocks: [
+              {
+                id: "empty-edition-placeholder-front",
+                type: "articleFrame",
+                presetId: "front.teaser",
+                itemId: placeholderSlug,
+                flowKey: placeholderSlug,
+                startCursor: "beginning",
+                role: "primary",
+                editorialPriority: "primary",
+                size: { shrinkToContent: true },
+                typography: { headlineScale: "feature" },
+                span: { min: 1, preferred: 6, max: 6 },
+                localGrid: { columns: { min: 1, preferred: 6, max: 6 } },
+                media: [],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "page-2",
+        pageNumber: 2,
+        presetId: "page.full",
+        grid: { columns: { min: 1, preferred: 6, max: 6 } },
+        regions: [
+          {
+            id: "empty-sections-page",
+            type: "fullPage",
+            size: { shrinkToContent: true },
+            localGrid: { columns: { min: 1, preferred: 6, max: 6 } },
+            blocks: [
+              {
+                id: "empty-edition-sections-stack",
+                type: "itemStack",
+                title: "Sections",
+                itemIds: [...sectionItemSlugs, sectionsCtaSlug],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "page-3",
+        pageNumber: 3,
+        presetId: "page.full",
+        grid: { columns: { min: 1, preferred: 6, max: 6 } },
+        regions: [
+          {
+            id: "empty-topics-page",
+            type: "fullPage",
+            size: { shrinkToContent: true },
+            localGrid: { columns: { min: 1, preferred: 6, max: 6 } },
+            blocks: [
+              {
+                id: "empty-edition-topics-stack",
+                type: "itemStack",
+                title: "Topics",
+                itemIds: [...topicItemSlugs, topicsCtaSlug],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  }, "EmptyGraphQLEdition.layoutPlan");
+}
+
+/** Page-1-only placeholder used on SiteBrand.rendererConfig.layoutPlan. */
+export function buildDefaultEmptyEditionLayoutPlan(): EditionLayoutPlan {
+  return buildEmptyEditionLayoutPlan({
+    sectionItemSlugs: [],
+    sectionsCtaSlug: "empty-edition-sections-newsroom",
+    topicItemSlugs: [],
+    topicsCtaSlug: "empty-edition-topics-newsroom",
+  });
+}

package/lib/empty-theme.css

@@ -0,0 +1 @@
+/* Default for `papyrus-site-theme` when a publication ships no publication/theme.css. */

package/lib/excerpts.ts

@@ -0,0 +1,8 @@
+export function truncateWords(value: string | null | undefined, maxWords: number): string {
+  const normalized = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (!normalized) return "";
+  const words = normalized.split(" ");
+  if (words.length <= maxWords) return normalized;
+  return `${words.slice(0, maxWords).join(" ")}...`;
+}
+