@growth-labs/cms 0.8.19 → 0.8.20

package/src/lib/publish-timezone.ts

@@ -0,0 +1,154 @@
+/**
+ * Publication-timezone helpers — ONE implementation, shared by the schedule
+ * route and the Publish tab.
+ *
+ * Why this module exists: the editor types a wall-clock time and expects the
+ * post to go out at that time in the publication's timezone. That only holds
+ * if the digits the UI DISPLAYS and the zone it SAVES agree. When they
+ * disagreed, every resave shifted `publish_at` by the zone offset — including
+ * an incidental resave that never touched the field (the 2026-09-08 P0). So
+ * display and entry must use the same converter as the server, not a second
+ * copy of the arithmetic.
+ */
+
+/** Fronts default; the server falls back to this when no zone is configured. */
+export const PUBLISH_TIMEZONE_FALLBACK = 'Europe/Paris'
+
+/** `YYYY-MM-DDTHH:MM` exactly — the shape the date and time inputs produce. */
+const LOCAL_DATE_TIME_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/
+
+type LocalDateTimeParts = { year: number; month: number; day: number; hour: number; minute: number }
+
+export function parseLocalDateTime(value: string): LocalDateTimeParts | null {
+	const match = LOCAL_DATE_TIME_RE.exec(value)
+	if (!match) return null
+	const [, y, m, d, h, min] = match
+	const parts: LocalDateTimeParts = {
+		year: Number.parseInt(y, 10),
+		month: Number.parseInt(m, 10),
+		day: Number.parseInt(d, 10),
+		hour: Number.parseInt(h, 10),
+		minute: Number.parseInt(min, 10),
+	}
+	if (
+		!Number.isInteger(parts.year) ||
+		parts.month < 1 ||
+		parts.month > 12 ||
+		parts.day < 1 ||
+		parts.day > 31 ||
+		parts.hour < 0 ||
+		parts.hour > 23 ||
+		parts.minute < 0 ||
+		parts.minute > 59
+	) {
+		return null
+	}
+	const dateCheck = new Date(Date.UTC(parts.year, parts.month - 1, parts.day))
+	if (
+		dateCheck.getUTCFullYear() !== parts.year ||
+		dateCheck.getUTCMonth() + 1 !== parts.month ||
+		dateCheck.getUTCDate() !== parts.day
+	) {
+		return null
+	}
+	return parts
+}
+
+export function getZonedParts(instantMs: number, timeZone: string): LocalDateTimeParts | null {
+	if (!isValidTimeZone(timeZone)) return null
+	const formatter = new Intl.DateTimeFormat('en-US', {
+		timeZone,
+		hour12: false,
+		year: 'numeric',
+		month: '2-digit',
+		day: '2-digit',
+		hour: '2-digit',
+		minute: '2-digit',
+		second: '2-digit',
+	})
+	const values = { year: '', month: '', day: '', hour: '', minute: '', second: '' }
+	for (const part of formatter.formatToParts(new Date(instantMs))) {
+		if (part.type in values) values[part.type as keyof typeof values] = part.value
+	}
+	const year = Number.parseInt(values.year, 10)
+	const month = Number.parseInt(values.month, 10)
+	const day = Number.parseInt(values.day, 10)
+	const hour = Number.parseInt(values.hour, 10)
+	const minute = Number.parseInt(values.minute, 10)
+	if (![year, month, day, hour, minute].every(Number.isFinite)) return null
+	return { year, month, day, hour, minute }
+}
+
+export function isValidTimeZone(timeZone: string): boolean {
+	try {
+		new Intl.DateTimeFormat('en-US', { timeZone }).format(new Date())
+		return true
+	} catch {
+		return false
+	}
+}
+
+export function getTimeZoneOffsetMs(instantMs: number, timeZone: string): number | null {
+	const zoned = getZonedParts(instantMs, timeZone)
+	if (!zoned) return null
+	const asUtc = Date.UTC(zoned.year, zoned.month - 1, zoned.day, zoned.hour, zoned.minute, 0)
+	return asUtc - instantMs
+}
+
+export function parseLocalDateTimeInZoneToUnixSeconds(
+	value: string,
+	timeZone: string,
+): number | null {
+	const target = parseLocalDateTime(value)
+	if (!target) return null
+	const targetUtcMs = Date.UTC(
+		target.year,
+		target.month - 1,
+		target.day,
+		target.hour,
+		target.minute,
+		0,
+	)
+	let candidateMs = targetUtcMs
+	for (let i = 0; i < 5; i += 1) {
+		const offsetMs = getTimeZoneOffsetMs(candidateMs, timeZone)
+		if (offsetMs === null) return null
+		const next = targetUtcMs - offsetMs
+		if (Math.abs(next - candidateMs) < 1000) {
+			candidateMs = next
+			break
+		}
+		candidateMs = next
+	}
+	const resolved = getZonedParts(candidateMs, timeZone)
+	if (
+		!resolved ||
+		resolved.year !== target.year ||
+		resolved.month !== target.month ||
+		resolved.day !== target.day ||
+		resolved.hour !== target.hour ||
+		resolved.minute !== target.minute
+	) {
+		return null
+	}
+	return Math.floor(candidateMs / 1000)
+}
+
+/**
+ * Inverse of `parseLocalDateTimeInZoneToUnixSeconds`: render an instant as the
+ * wall-clock digits an editor in `timeZone` would read, split for the date and
+ * time inputs. Returns null when the zone is unusable, so callers can fall back
+ * rather than silently display a wrong hour.
+ */
+export function formatInstantInZone(
+	instantMs: number,
+	timeZone: string,
+): { date: string; time: string } | null {
+	const parts = getZonedParts(instantMs, timeZone)
+	if (!parts) return null
+	const pad = (n: number, width = 2) => String(n).padStart(width, '0')
+	return {
+		date: `${pad(parts.year, 4)}-${pad(parts.month)}-${pad(parts.day)}`,
+		time: `${pad(parts.hour)}:${pad(parts.minute)}`,
+	}
+}

package/src/routes/content.ts

@@ -66,6 +66,11 @@ import { invalidateMediaCaptureStatements, softDeleteContent } from '../engine/s
 import { normalizeSourceSections } from '../engine/source-sections.js'
 import { TagInputError } from '../engine/taxonomy.js'
 import type { ValidationError } from '../engine/validator/index.js'
+import {
+	isValidTimeZone,
+	PUBLISH_TIMEZONE_FALLBACK,
+	parseLocalDateTimeInZoneToUnixSeconds,
+} from '../lib/publish-timezone.js'
 import type { MediaSourceResolution } from '../providers/types.js'
 import { parseLayoutEnvelope } from '../schema/layout.js'
 import { parsePortableTextEnvelope } from '../schema/portable-text.js'
@@ -242,9 +247,6 @@ export interface ContentRouteConfig extends CmsRouteConfig {
 	activeWorkspaceId?: string
 }
 
-const PUBLISH_TIMEZONE_FALLBACK = 'Europe/Paris'
-const LOCAL_DATE_TIME_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/
-
 type ContentType = 'article' | 'video' | 'podcast' | 'newsletter' | 'page'
 
 /**
@@ -677,119 +679,6 @@ const ContributorsReplaceSchema = z.object({
 
 // --- timezone-aware local-datetime parsing (ported verbatim) --------------
 
-type LocalDateTimeParts = { year: number; month: number; day: number; hour: number; minute: number }
-
-function parseLocalDateTime(value: string): LocalDateTimeParts | null {
-	const match = LOCAL_DATE_TIME_RE.exec(value)
-	if (!match) return null
-	const [, y, m, d, h, min] = match
-	const parts: LocalDateTimeParts = {
-		year: Number.parseInt(y, 10),
-		month: Number.parseInt(m, 10),
-		day: Number.parseInt(d, 10),
-		hour: Number.parseInt(h, 10),
-		minute: Number.parseInt(min, 10),
-	}
-	if (
-		!Number.isInteger(parts.year) ||
-		parts.month < 1 ||
-		parts.month > 12 ||
-		parts.day < 1 ||
-		parts.day > 31 ||
-		parts.hour < 0 ||
-		parts.hour > 23 ||
-		parts.minute < 0 ||
-		parts.minute > 59
-	) {
-		return null
-	}
-	const dateCheck = new Date(Date.UTC(parts.year, parts.month - 1, parts.day))
-	if (
-		dateCheck.getUTCFullYear() !== parts.year ||
-		dateCheck.getUTCMonth() + 1 !== parts.month ||
-		dateCheck.getUTCDate() !== parts.day
-	) {
-		return null
-	}
-	return parts
-}
-
-function getZonedParts(instantMs: number, timeZone: string): LocalDateTimeParts | null {
-	const formatter = new Intl.DateTimeFormat('en-US', {
-		timeZone,
-		hour12: false,
-		year: 'numeric',
-		month: '2-digit',
-		day: '2-digit',
-		hour: '2-digit',
-		minute: '2-digit',
-		second: '2-digit',
-	})
-	const values = { year: '', month: '', day: '', hour: '', minute: '', second: '' }
-	for (const part of formatter.formatToParts(new Date(instantMs))) {
-		if (part.type in values) values[part.type as keyof typeof values] = part.value
-	}
-	const year = Number.parseInt(values.year, 10)
-	const month = Number.parseInt(values.month, 10)
-	const day = Number.parseInt(values.day, 10)
-	const hour = Number.parseInt(values.hour, 10)
-	const minute = Number.parseInt(values.minute, 10)
-	if (![year, month, day, hour, minute].every(Number.isFinite)) return null
-	return { year, month, day, hour, minute }
-}
-
-function isValidTimeZone(timeZone: string): boolean {
-	try {
-		new Intl.DateTimeFormat('en-US', { timeZone }).format(new Date())
-		return true
-	} catch {
-		return false
-	}
-}
-
-function getTimeZoneOffsetMs(instantMs: number, timeZone: string): number | null {
-	const zoned = getZonedParts(instantMs, timeZone)
-	if (!zoned) return null
-	const asUtc = Date.UTC(zoned.year, zoned.month - 1, zoned.day, zoned.hour, zoned.minute, 0)
-	return asUtc - instantMs
-}
-
-function parseLocalDateTimeInZoneToUnixSeconds(value: string, timeZone: string): number | null {
-	const target = parseLocalDateTime(value)
-	if (!target) return null
-	const targetUtcMs = Date.UTC(
-		target.year,
-		target.month - 1,
-		target.day,
-		target.hour,
-		target.minute,
-		0,
-	)
-	let candidateMs = targetUtcMs
-	for (let i = 0; i < 5; i += 1) {
-		const offsetMs = getTimeZoneOffsetMs(candidateMs, timeZone)
-		if (offsetMs === null) return null
-		const next = targetUtcMs - offsetMs
-		if (Math.abs(next - candidateMs) < 1000) {
-			candidateMs = next
-			break
-		}
-		candidateMs = next
-	}
-	const resolved = getZonedParts(candidateMs, timeZone)
-	if (
-		!resolved ||
-		resolved.year !== target.year ||
-		resolved.month !== target.month ||
-		resolved.day !== target.day ||
-		resolved.hour !== target.hour ||
-		resolved.minute !== target.minute
-	) {
-		return null
-	}
-	return Math.floor(candidateMs / 1000)
-}
-
 // --- read-side payload helpers (ported verbatim) --------------------------
 
 async function getContentPayload(ctx: RouteContext, type: string, id: string) {

package/src/ui/inspector/PublishTab.tsx

@@ -10,7 +10,8 @@
 // Compile-gated (tsc, jsx: react-jsx). No vitest — pure shapers are in
 // inspector-data.ts and tested there.
 
-import { useCallback, useEffect, useState } from 'react'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { formatInstantInZone, PUBLISH_TIMEZONE_FALLBACK } from '../../lib/publish-timezone.js'
 import type { ContentStatus } from '../../schema/types.js'
 import { apiErrorMessage } from '../api-error.js'
 import { Icon } from '../icons.js'
@@ -40,6 +41,12 @@ export interface PublishTabProps {
 	authorId: string | null
 	/** Current scheduled publish time (ISO string, null if not scheduled). */
 	publishAt: string | null
+	/**
+	 * Timezone the editor schedules in. The same zone is used to DISPLAY the
+	 * stored instant and to SAVE what is typed, so a resave of untouched fields
+	 * is a true no-op. Defaults to the publication timezone.
+	 */
+	publishTimezone?: string
 	/** Called after a status/field change so the parent can refresh. */
 	onChanged?: () => void
 }
@@ -85,6 +92,7 @@ export function PublishTab({
 	visibility,
 	authorId,
 	publishAt,
+	publishTimezone = PUBLISH_TIMEZONE_FALLBACK,
 	onChanged,
 }: PublishTabProps): React.ReactElement {
 	const [saving, setSaving] = useState(false)
@@ -92,16 +100,20 @@ export function PublishTab({
 	const [actionError, setActionError] = useState<string | null>(null)
 
 	// Local schedule date/time inputs.
-	const [schedDate, setSchedDate] = useState(() => {
-		if (!publishAt) return ''
-		// publishAt is an ISO string; extract the date part.
-		return publishAt.slice(0, 10)
-	})
-	const [schedTime, setSchedTime] = useState(() => {
-		if (!publishAt) return '12:00'
-		// Extract HH:MM from ISO.
-		return publishAt.slice(11, 16) || '12:00'
-	})
+	// The editor thinks in publication-local wall clock, so that is what these
+	// inputs show. Falling back to the raw UTC slice keeps an unusable zone
+	// readable rather than blank.
+	const scheduled = useMemo(() => {
+		if (!publishAt) return null
+		const ms = Date.parse(publishAt)
+		if (!Number.isFinite(ms)) return null
+		return formatInstantInZone(ms, publishTimezone)
+	}, [publishAt, publishTimezone])
+
+	const [schedDate, setSchedDate] = useState(() => scheduled?.date ?? publishAt?.slice(0, 10) ?? '')
+	const [schedTime, setSchedTime] = useState(
+		() => scheduled?.time ?? publishAt?.slice(11, 16) ?? '12:00',
+	)
 
 	// Author list (fetched once on mount).
 	const [authors, setAuthors] = useState<AuthorOption[]>([])
@@ -172,18 +184,14 @@ export function PublishTab({
 		setSaving(true)
 		setActionError(null)
 		try {
-			// schedDate/schedTime are sliced directly from the UTC ISO publishAt
-			// (no zone conversion happens anywhere in this component -- see their
-			// initializers above), so the digits shown here already ARE UTC. Tag
-			// them 'UTC' on save, not a hardcoded zone: sending literal UTC digits
-			// under a non-UTC zone label (this used 'Europe/Paris' unconditionally
-			// until the Falklands P0, 2026-09-08) made the server reinterpret them
-			// in that zone's offset, silently shifting publish_at by that zone's
-			// current UTC offset on every resave -- including an incidental
-			// resave that never touched these fields. 'UTC' makes display and
-			// save agree, so a resave of untouched fields is a true no-op.
+			// These digits are publication-local wall clock (see the initializers),
+			// so they are saved under that SAME zone. Display and save must agree:
+			// sending digits under a zone they were not rendered in made the server
+			// reinterpret them and shift publish_at by that zone's offset on every
+			// resave, including an incidental one that never touched these fields
+			// (the 2026-09-08 P0). Agreement is what keeps a resave a no-op.
 			const localDateTime = `${schedDate}T${schedTime}`
-			const body = buildScheduleBody(localDateTime, 'UTC')
+			const body = buildScheduleBody(localDateTime, publishTimezone)
 			await runAction(docId, 'schedule', body as unknown as Record<string, unknown>)
 			setSelectedStatus('scheduled')
 			onChanged?.()
@@ -192,7 +200,7 @@ export function PublishTab({
 		} finally {
 			setSaving(false)
 		}
-	}, [docId, schedDate, schedTime, saving, onChanged])
+	}, [docId, schedDate, schedTime, saving, onChanged, publishTimezone])
 
 	const handleVisibilityChange = useCallback(
 		async (newVis: 'free' | 'premium') => {
@@ -317,7 +325,7 @@ export function PublishTab({
 				{/* Scheduled date + time inputs */}
 				{showScheduleControls && (
 					<div style={schedGrid} className="fade-only">
-						<Field label="Date (UTC)">
+						<Field label={`Date (${publishTimezone})`}>
 							<input
 								className="input"
 								type="date"
@@ -325,7 +333,7 @@ export function PublishTab({
 								onChange={(e) => setSchedDate(e.target.value)}
 							/>
 						</Field>
-						<Field label="Time (UTC)">
+						<Field label={`Time (${publishTimezone})`}>
 							<input
 								className="input"
 								type="time"