@growth-labs/cms 0.1.0

package/src/ui/screens/analytics-data.ts

@@ -0,0 +1,68 @@
+import type { ArticleAnalyticsDetail, ProviderResult } from '../../providers/types.js'
+import type { TopContentProvider } from './render-state.js'
+
+export interface ReadsPoint {
+	t: number
+	reads: number
+}
+
+export interface TrafficSource {
+	source: string
+	sessions: number
+}
+
+export interface AnalyticsData {
+	kpis: ProviderResult<Record<string, number | null>>
+	readsTimeSeries: ProviderResult<ReadsPoint[]>
+	topContent: ProviderResult<TopContentProvider[]>
+	trafficSources: ProviderResult<TrafficSource[]>
+}
+
+type ProviderStatus = ProviderResult<unknown>['status']
+
+function providerStatus(value: unknown): ProviderStatus {
+	return value === 'live' || value === 'partial' || value === 'empty' ? value : 'empty'
+}
+
+function normalizeObjectResult(result: unknown): ProviderResult<Record<string, number | null>> {
+	if (!result || typeof result !== 'object') return { status: 'empty', data: {} }
+	const record = result as { status?: unknown; data?: unknown }
+	const data =
+		record.data && typeof record.data === 'object' && !Array.isArray(record.data)
+			? (record.data as Record<string, number | null>)
+			: {}
+	return { status: providerStatus(record.status), data }
+}
+
+function normalizeArrayResult<T>(result: unknown): ProviderResult<T[]> {
+	if (!result || typeof result !== 'object') return { status: 'empty', data: [] }
+	const record = result as { status?: unknown; data?: unknown }
+	return {
+		status: providerStatus(record.status),
+		data: Array.isArray(record.data) ? (record.data as T[]) : [],
+	}
+}
+
+export function normalizeArticleAnalyticsDetail(
+	result: unknown,
+): ProviderResult<ArticleAnalyticsDetail | null> {
+	if (!result || typeof result !== 'object') return { status: 'empty', data: null }
+	const record = result as { status?: unknown; data?: unknown }
+	return {
+		status: providerStatus(record.status),
+		data:
+			record.data && typeof record.data === 'object'
+				? (record.data as ArticleAnalyticsDetail)
+				: null,
+	}
+}
+
+export function normalizeAnalyticsData(input: unknown): AnalyticsData {
+	const data = input && typeof input === 'object' ? (input as Record<string, unknown>) : {}
+	return {
+		kpis: normalizeObjectResult(data.kpis),
+		readsTimeSeries: normalizeArrayResult<ReadsPoint>(data.readsTimeSeries),
+		topContent: normalizeArrayResult<TopContentProvider>(data.topContent),
+		trafficSources: normalizeArrayResult<TrafficSource>(data.trafficSources),
+	}
+}

package/src/ui/screens/calendar-data.ts

@@ -0,0 +1,126 @@
+// src/ui/screens/calendar-data.ts — pure calendar month bucketing helper.
+//
+// No React, no D1, no browser globals. Converts a flat list of dated content
+// items into a week-per-row month grid (Monday-start) that the CalendarScreen
+// renders directly.
+//
+// Exports:
+//   buildCalendarMonth(items, year, month, now?) → CalendarCell[]
+//   CalendarItem   — the input item shape (matches the calendar route response)
+//   CalendarCell   — one cell in the grid; either a leading blank or a day cell
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * A dated content item as returned by the `/admin/api/calendar?from=&to=` route.
+ * `date` is an ISO-8601 string (date-only or with time component, UTC-assumed).
+ */
+export interface CalendarItem {
+	id: string
+	type: string
+	status: string
+	slug: string
+	title: string
+	date: string
+}
+
+/** A leading blank cell before the first day of the month. */
+export interface BlankCell {
+	blank: true
+	day?: undefined
+	today?: undefined
+	items?: undefined
+}
+
+/** A real day cell carrying zero or more items. */
+export interface DayCell {
+	blank: false
+	/** Day-of-month (1-based). */
+	day: number
+	/** True when this day matches the injected `now`. */
+	today: boolean
+	items: CalendarItem[]
+}
+
+export type CalendarCell = BlankCell | DayCell
+
+// ---------------------------------------------------------------------------
+// buildCalendarMonth
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the month grid for `year` and `month` (1-based, i.e. 1=January … 12=December).
+ *
+ * Week layout: Monday-first (ISO 8601). The returned array is:
+ *   [ ...leadingBlanks, day1, day2, … dayN ]
+ *
+ * @param items  Dated content items; items outside the given month are discarded.
+ * @param year   Full year (e.g. 2026).
+ * @param month  1-based month (1–12).
+ * @param now    Optional timestamp (ms since epoch) used for today-marking.
+ *               Defaults to `Date.now()` when omitted.  Pass an explicit value
+ *               in tests to keep them deterministic.
+ */
+export function buildCalendarMonth(
+	items: CalendarItem[],
+	year: number,
+	month: number, // 1-based
+	now: number = Date.now(),
+): CalendarCell[] {
+	// ── Day-of-month helpers ──────────────────────────────────────────────────
+
+	const daysInMonth = new Date(year, month, 0).getDate() // JS month is 0-based
+
+	// Monday-start offset: how many blank cells precede day 1.
+	// JS getDay(): 0=Sun, 1=Mon … 6=Sat → convert to Mon-first: (day + 6) % 7
+	const firstDow = new Date(year, month - 1, 1).getDay()
+	const leadingBlanks = (firstDow + 6) % 7
+
+	// ── "Today" day-of-month (null when outside the current month) ────────────
+
+	const nowDate = new Date(now)
+	const todayDay =
+		nowDate.getFullYear() === year && nowDate.getMonth() + 1 === month ? nowDate.getDate() : null
+
+	// ── Bucket items by day ───────────────────────────────────────────────────
+
+	const buckets = new Map<number, CalendarItem[]>()
+
+	for (const item of items) {
+		// Parse only the date portion so that time-zone offsets in the stored ISO
+		// string don't accidentally shift the item to an adjacent day.
+		const raw = item.date
+		// Accept "YYYY-MM-DD" and "YYYY-MM-DDTHH:MM:SSZ" formats.
+		const datePart = raw.slice(0, 10) // "YYYY-MM-DD"
+		const [y, mo, d] = datePart.split('-').map(Number)
+
+		if (y !== year || mo !== month) continue // outside this month
+
+		const bucket = buckets.get(d) ?? []
+		bucket.push(item)
+		buckets.set(d, bucket)
+	}
+
+	// ── Assemble the grid ─────────────────────────────────────────────────────
+
+	const cells: CalendarCell[] = []
+
+	// Leading blank cells
+	for (let i = 0; i < leadingBlanks; i++) {
+		cells.push({ blank: true })
+	}
+
+	// Day cells
+	for (let day = 1; day <= daysInMonth; day++) {
+		cells.push({
+			blank: false,
+			day,
+			today: day === todayDay,
+			items: buckets.get(day) ?? [],
+		})
+	}
+
+	return cells
+}

package/src/ui/screens/content-insights-data.ts

@@ -0,0 +1,127 @@
+import type { ContentInsightRow, InsightEvidence } from '../../schema/types.js'
+
+/** InsightCard is ContentInsightRow — alias to prevent drift. */
+export type InsightCard = ContentInsightRow
+
+export interface DeskGroup {
+	desk: string
+	cards: InsightCard[]
+}
+
+export interface InsightsState {
+	loading: boolean
+	error: string | null
+	schemaNotReady: boolean
+	insights: InsightCard[]
+	runDate: string | null
+	loaded: boolean
+}
+
+export type InsightsAction =
+	| { type: 'fetch-start' }
+	| { type: 'fetch-ok'; insights: InsightCard[]; runDate: string }
+	| { type: 'fetch-error'; error: string }
+	| { type: 'schema-not-ready' }
+	| { type: 'dismiss-ok'; intentKey: string }
+
+export function initInsightsState(): InsightsState {
+	return {
+		loading: true,
+		error: null,
+		schemaNotReady: false,
+		insights: [],
+		runDate: null,
+		loaded: false,
+	}
+}
+
+export function insightsReducer(state: InsightsState, action: InsightsAction): InsightsState {
+	switch (action.type) {
+		case 'fetch-start':
+			return { ...state, loading: true, error: null, schemaNotReady: false }
+		case 'fetch-ok':
+			return {
+				loading: false,
+				error: null,
+				schemaNotReady: false,
+				insights: action.insights,
+				runDate: action.runDate,
+				loaded: true,
+			}
+		case 'fetch-error':
+			return { ...state, loading: false, error: action.error, loaded: true }
+		case 'schema-not-ready':
+			return { ...state, loading: false, error: null, schemaNotReady: true, loaded: true }
+		case 'dismiss-ok':
+			return { ...state, insights: state.insights.filter((c) => c.intent_key !== action.intentKey) }
+		default:
+			return state
+	}
+}
+
+/** Group cards by desk (desks alphabetical), each desk's cards sorted by desk_rank then headline. */
+export function deskGroups(cards: InsightCard[]): DeskGroup[] {
+	const byDesk = new Map<string, InsightCard[]>()
+	for (const c of cards) {
+		const list = byDesk.get(c.desk) ?? []
+		list.push(c)
+		byDesk.set(c.desk, list)
+	}
+	return Array.from(byDesk.keys())
+		.sort((a, b) => a.localeCompare(b))
+		.map((desk) => ({
+			desk,
+			cards: (byDesk.get(desk) as InsightCard[]).sort(
+				(a, b) => a.desk_rank - b.desk_rank || a.headline.localeCompare(b.headline),
+			),
+		}))
+}
+
+/** Which open-web discovery stream an opportunity card came from (theater split).
+ *  An opportunity card WITHOUT discoveryKind (legacy single-stream) is treated as
+ *  'competitor' so it still renders under the Competitor Watch section. */
+export function discoveryKindOf(card: InsightCard): 'competitor' | 'audience_question' {
+	return card.brief.discoveryKind === 'audience_question' ? 'audience_question' : 'competitor'
+}
+
+/** The COMPETITOR WATCH opportunity cards (RSS competitor-watch stream), by desk. */
+export function competitorWatchGroups(cards: InsightCard[]): DeskGroup[] {
+	return deskGroups(
+		cards.filter((c) => c.signal_type === 'opportunity' && discoveryKindOf(c) === 'competitor'),
+	)
+}
+
+/** The WHAT READERS ARE ASKING opportunity cards (Google-PAA stream), by desk. */
+export function audienceQuestionGroups(cards: InsightCard[]): DeskGroup[] {
+	return deskGroups(
+		cards.filter(
+			(c) => c.signal_type === 'opportunity' && discoveryKindOf(c) === 'audience_question',
+		),
+	)
+}
+
+/** The DEMAND (GSC) cards only — desk groups for the primary demand board (the two
+ *  opportunity sub-kinds render in their own sections so they aren't mixed in). */
+export function demandDeskGroups(cards: InsightCard[]): DeskGroup[] {
+	return deskGroups(cards.filter((c) => c.signal_type !== 'opportunity'))
+}
+
+/** The cross-desk Best Immediate Bets, ordered by best_bet_rank (nulls last). */
+export function bestBets(cards: InsightCard[]): InsightCard[] {
+	return cards
+		.filter((c) => c.is_best_bet === 1)
+		.sort(
+			(a, b) =>
+				(a.best_bet_rank ?? Number.MAX_SAFE_INTEGER) - (b.best_bet_rank ?? Number.MAX_SAFE_INTEGER),
+		)
+}
+
+/** The Trackers section — recurring ideas (suggestion_type = 'tracker'). */
+export function trackers(cards: InsightCard[]): InsightCard[] {
+	return cards.filter((c) => c.suggestion_type === 'tracker')
+}
+
+/** Format a demand evidence chip as a compact one-line metric string. */
+export function formatDemandEvidence(e: Extract<InsightEvidence, { query: string }>): string {
+	return `pos ${e.position.toFixed(1)} · ${e.impressions.toLocaleString('en-US')} impr · ${(e.ctr * 100).toFixed(1)}% CTR`
+}

package/src/ui/screens/content-view.ts

@@ -0,0 +1,30 @@
+// src/ui/screens/content-view.ts — pure reducer for the library↔editor toggle.
+// ContentRoute owns a ContentView state; dispatching actions moves between the
+// library list (open === null) and the editor (open !== null).
+
+export type ContentType = 'article' | 'video' | 'podcast' | 'newsletter'
+
+export interface ContentView {
+	/** null = create new; string = open existing by id */
+	open: { id: string | null; contentType?: ContentType } | null
+}
+
+export type ContentViewAction =
+	| { type: 'open'; id: string; contentType?: ContentType }
+	| { type: 'new'; contentType: ContentType }
+	| { type: 'close' }
+
+export const initialContentView: ContentView = { open: null }
+
+export function contentViewReducer(state: ContentView, action: ContentViewAction): ContentView {
+	switch (action.type) {
+		case 'open':
+			return { open: { id: action.id, contentType: action.contentType } }
+		case 'new':
+			return { open: { id: null, contentType: action.contentType } }
+		case 'close':
+			return { open: null }
+		default:
+			return state
+	}
+}

package/src/ui/screens/library-data.ts

@@ -0,0 +1,177 @@
+// src/ui/screens/library-data.ts — pure client-side Library helpers.
+//
+// These run in the browser (no D1/server imports) and operate on the list of
+// LibraryRow objects returned by GET /content (extended in P2 with an
+// optional processingState field from a JOIN on video_content).
+//
+// Three pure helpers:
+//   deriveStatusCounts — the status-tab badge numbers (mirrors GET /content/counts)
+//   groupByStatus      — the board (kanban) column grouping
+//   filterRows         — client-side keyword + status + type filter for instant UI response
+
+import type { ContentStatus, ContentType } from '../../schema/types.js'
+
+/**
+ * A single row from GET /content (list), extended with the optional
+ * processingState from video_content. The server adds this field when
+ * computing the board view; non-video rows have it as null.
+ *
+ * "processing" is a DERIVED pseudo-status (video mid-flight in Foundry), NOT
+ * a value in content_items.status (draft|scheduled|review|published|archived).
+ */
+export interface LibraryRow {
+	id: string
+	type: ContentType
+	status: ContentStatus
+	slug: string
+	title: string
+	visibility: 'free' | 'premium'
+	featured: boolean
+	publishAt: string | null
+	publishedAt: string | null
+	updatedAt: string | null
+	authorId: string | null
+	authorSlug: string | null
+	authorName: string | null
+	/** Non-null for video rows mid-flight in Foundry; null otherwise. */
+	processingState: string | null
+}
+
+/** The six tab counts shown in the Library header. */
+export interface StatusCounts {
+	all: number
+	draft: number
+	review: number
+	scheduled: number
+	published: number
+	/** Derived: video rows whose processingState is NOT in ('ready','failed'). */
+	processing: number
+}
+
+/** Board columns — the five kanban lanes. */
+export interface BoardColumns {
+	draft: LibraryRow[]
+	review: LibraryRow[]
+	scheduled: LibraryRow[]
+	published: LibraryRow[]
+	/** Processing column: videos mid-flight (processingState not ready/failed/null). */
+	processing: LibraryRow[]
+}
+
+/** Filter criteria for client-side row filtering. */
+export interface RowFilter {
+	status?: ContentStatus
+	type?: ContentType
+	/** Case-insensitive substring match against title and slug. */
+	q?: string
+}
+
+const NON_PROCESSING_STATES = new Set(['ready', 'failed'])
+
+/** Returns true when this row represents a video mid-flight in Foundry. */
+function isProcessing(row: LibraryRow): boolean {
+	return row.processingState !== null && !NON_PROCESSING_STATES.has(row.processingState)
+}
+
+/**
+ * Derive the status-tab badge counts from a flat list of LibraryRows.
+ *
+ * This is the client-side mirror of GET /content/counts — used to update tab
+ * badges immediately after a bulk action without a round-trip.
+ */
+export function deriveStatusCounts(rows: LibraryRow[]): StatusCounts {
+	let draft = 0
+	let review = 0
+	let scheduled = 0
+	let published = 0
+	let processing = 0
+
+	for (const row of rows) {
+		switch (row.status) {
+			case 'draft':
+				draft++
+				break
+			case 'review':
+				review++
+				break
+			case 'scheduled':
+				scheduled++
+				break
+			case 'published':
+				published++
+				break
+			default:
+				break
+		}
+		if (isProcessing(row)) processing++
+	}
+
+	return { all: rows.length, draft, review, scheduled, published, processing }
+}
+
+/**
+ * Group a flat list of LibraryRows into the five board (kanban) columns.
+ *
+ * A row appears in the "processing" column when its video pipeline is
+ * mid-flight regardless of its content_items.status value; otherwise it is
+ * placed in the column matching its status.
+ */
+export function groupByStatus(rows: LibraryRow[]): BoardColumns {
+	const columns: BoardColumns = {
+		draft: [],
+		review: [],
+		scheduled: [],
+		published: [],
+		processing: [],
+	}
+
+	for (const row of rows) {
+		if (isProcessing(row)) {
+			columns.processing.push(row)
+		} else {
+			// Map the status to the corresponding column (archived rows have no
+			// column — they fall through silently; P3 adds an archive tab).
+			switch (row.status) {
+				case 'draft':
+					columns.draft.push(row)
+					break
+				case 'review':
+					columns.review.push(row)
+					break
+				case 'scheduled':
+					columns.scheduled.push(row)
+					break
+				case 'published':
+					columns.published.push(row)
+					break
+				default:
+					break
+			}
+		}
+	}
+
+	return columns
+}
+
+/**
+ * Client-side row filter.
+ *
+ * Applies status, type, and keyword (q) filters in combination. The keyword
+ * match is a case-insensitive substring against both title and slug —
+ * matching the server-side LIKE behaviour so the list result is consistent.
+ */
+export function filterRows(rows: LibraryRow[], filter: RowFilter): LibraryRow[] {
+	const { status, type, q } = filter
+	const lowerQ = q ? q.toLowerCase() : null
+
+	return rows.filter((row) => {
+		if (status !== undefined && row.status !== status) return false
+		if (type !== undefined && row.type !== type) return false
+		if (lowerQ !== null) {
+			const titleMatch = row.title.toLowerCase().includes(lowerQ)
+			const slugMatch = row.slug.toLowerCase().includes(lowerQ)
+			if (!titleMatch && !slugMatch) return false
+		}
+		return true
+	})
+}