canopycms 0.8.3 → 0.10.0

package/dist/editor/fields/DateField.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useId, useRef } from 'react';
+import { ActionIcon, Tooltip } from '@mantine/core';
+import { DatePickerInput } from '@mantine/dates';
+import { IconX } from '@tabler/icons-react';
+import dayjs from 'dayjs';
+import { calendarDayToLocalDate, localDateToCalendarDay } from '../../utils/calendar-day.js';
+import { CALENDAR_LABELS } from './DateTimeField.js';
+import { LabelledInput } from './FieldLabel.js';
+const VALUE_FORMAT = 'D MMM YYYY';
+const REMOVE_LABEL = 'Remove date';
+/**
+ * A level change unmounts the control that made it, and Esc only closes the calendar from inside
+ * it, so focus moves to the new level's first control.
+ */
+const keepFocusInCalendar = () => {
+    requestAnimationFrame(() => {
+        if (document.activeElement !== document.body)
+            return;
+        document.querySelector('[data-dates-dropdown] button')?.focus();
+    });
+};
+/** What a stored value that is no real day says: it is the only clue to the day meant. */
+const notADay = (value, readOnly, required) => {
+    const next = required ? 'Pick a date.' : 'Pick a date or remove it.';
+    return `Stored as “${value}”, which isn't a real date.${readOnly ? '' : ` ${next}`}`;
+};
+/**
+ * Editor for `type: 'date'` fields: a day, stored as `YYYY-MM-DD`, with no time and no zone. Only
+ * a pick or Remove writes, so a loaded value saves back unchanged, and a save refuses one that is
+ * no real day.
+ */
+export const DateField = ({ id, label, description, value, onChange, dataCanopyField, readOnly = false, required = false, }) => {
+    const generatedId = useId();
+    const inputId = id ?? generatedId;
+    const triggerRef = useRef(null);
+    const date = calendarDayToLocalDate(value);
+    const invalid = value !== '' && date === null;
+    const shown = date ? dayjs(date).format(VALUE_FORMAT) : invalid ? 'invalid value' : 'not set';
+    return (_jsx(LabelledInput, { label: label, inputId: inputId, canopyPath: dataCanopyField, children: _jsx(DatePickerInput, { ref: triggerRef, id: inputId, "aria-label": `${label ?? 'Date'}, ${shown}`, description: description, error: invalid ? notADay(value, readOnly, required) : undefined, size: "sm", value: date, onChange: (next) => {
+                if (readOnly || !next)
+                    return;
+                onChange(localDateToCalendarDay(next));
+                // The day is about to unmount under focus, which would drop a keyboard user to the page.
+                triggerRef.current?.focus();
+            }, valueFormat: VALUE_FORMAT, placeholder: readOnly ? undefined : 'Pick a date', ariaLabels: CALENDAR_LABELS, onLevelChange: keepFocusInCalendar, 
+            // Red is for errors here, so weekends look like other days.
+            weekendDays: [], rightSection: value && !readOnly && !required ? (_jsx(Tooltip, { label: REMOVE_LABEL, children: _jsx(ActionIcon, { variant: "subtle", color: "gray", "aria-label": REMOVE_LABEL, onClick: () => {
+                        onChange('');
+                        // The control goes with the value, so focus returns to the field.
+                        triggerRef.current?.focus();
+                    }, children: _jsx(IconX, { size: 14, "aria-hidden": true }) }) })) : undefined, rightSectionPointerEvents: "all", readOnly: readOnly, "data-canopy-field": dataCanopyField }) }));
+};

package/dist/editor/fields/DateTimeField.d.ts

@@ -11,4 +11,14 @@ export interface DateTimeFieldProps {
     /** The field's `stampOnPublish`: the description says when a submit fills it. */
     stampOnPublish?: boolean;
 }
+export declare const CALENDAR_LABELS: {
+    previousMonth: string;
+    nextMonth: string;
+    previousYear: string;
+    nextYear: string;
+    previousDecade: string;
+    nextDecade: string;
+    monthLevelControl: string;
+    yearLevelControl: string;
+};
 export declare const DateTimeField: React.FC<DateTimeFieldProps>;

package/dist/editor/fields/DateTimeField.js

@@ -4,6 +4,7 @@ import { ActionIcon, Tooltip } from '@mantine/core';
 import { DateTimePicker } from '@mantine/dates';
 import { IconX } from '@tabler/icons-react';
 import dayjs from 'dayjs';
+import { isRealDay, localMidnight } from '../../utils/calendar-day.js';
 import { LabelledInput } from './FieldLabel.js';
 /** Whether the locale uses a 12-hour clock, as the dropdown's native time input then does. */
 const usesTwelveHourClock = () => {
@@ -15,7 +16,7 @@ const usesTwelveHourClock = () => {
 const valueFormat = () => `D MMM YYYY, ${usesTwelveHourClock() ? 'h:mm:ss A' : 'HH:mm:ss'}`;
 const REMOVE_LABEL = 'Remove date and time';
 // The picker's own controls are icon-only or unlabelled without these.
-const CALENDAR_LABELS = {
+export const CALENDAR_LABELS = {
     previousMonth: 'Previous month',
     nextMonth: 'Next month',
     previousYear: 'Previous year',
@@ -26,12 +27,6 @@ const CALENDAR_LABELS = {
     yearLevelControl: 'Choose a year',
 };
 const DATE_PART = /^(\d{4})-(\d{2})-(\d{2})([Tt ]|$)/;
-/** Whether the written year, month and day name a real day; `Date` rolls 30 Feb on to 1 Mar. */
-const isCalendarDate = (year, month, day) => {
-    const lastOfMonth = new Date(0);
-    lastOfMonth.setUTCFullYear(year, month, 0);
-    return month >= 1 && month <= 12 && day >= 1 && day <= lastOfMonth.getUTCDate();
-};
 /**
  * The stored value as a Date, or null for '', an unparsable value or a day that does not exist. A
  * date-only value is local midnight; `Date` reads UTC midnight, the evening before west of UTC.
@@ -42,15 +37,10 @@ const toDate = (iso) => {
     const datePart = DATE_PART.exec(iso);
     if (datePart) {
         const [year, month, day] = datePart.slice(1, 4).map(Number);
-        if (!isCalendarDate(year, month, day))
+        if (!isRealDay(year, month, day))
             return null;
-        if (datePart[4] === '') {
-            // setFullYear, since the constructor maps years 0-99 to 1900-1999.
-            const local = new Date(0);
-            local.setFullYear(year, month - 1, day);
-            local.setHours(0, 0, 0, 0);
-            return local;
-        }
+        if (datePart[4] === '')
+            return localMidnight(year, month, day);
     }
     const date = new Date(iso);
     return Number.isNaN(date.getTime()) ? null : date;

package/dist/editor/fields/list-item-title.js

@@ -22,7 +22,8 @@ const optionLabel = (field, value) => {
 const textFields = (fields) => flattenFields(fields).filter((f) => (f.type === 'string' || f.type === 'number' || f.type === 'select') && !f.list);
 /**
  * Which field titles an object-list item, and its text: its `itemTitleField` value when that is
- * a non-blank string or a number, else its first non-blank single-line string field.
+ * a non-blank string, which a `date` holds too, or a number, else its first non-blank single-line
+ * string field.
  */
 const titleSource = (record, objectField) => {
     const named = objectField.itemTitleField;

package/dist/editor/hooks/useBranchManager.d.ts

@@ -28,8 +28,11 @@ export declare const CREATED_BRANCH_GRACE_MS = 120000;
 interface BranchSummary {
     name: string;
     shortName?: string;
+    title?: string;
     status: string;
     createdBy?: string;
+    /** The creator's display name, when the listing carried it. */
+    ownerName?: string;
     updatedAt?: string;
     access: {
         users: string[] | undefined;
@@ -126,6 +129,8 @@ export interface UseBranchManagerReturn {
     /** Confirms first, taking an optional note; focus returns as for `handleApprove`. */
     handleRequestChanges: (branchName: string, returnFocusTo?: () => HTMLElement | null) => Promise<void>;
     handleDelete: (branchName: string) => Promise<void>;
+    /** Admin only: confirms first, then archives a branch whose pull request closed unmerged. */
+    handleArchive: (branchName: string) => Promise<void>;
     handleReloadBranchData: () => Promise<void>;
     loadBranches: () => Promise<void>;
 }

package/dist/editor/hooks/useBranchManager.js

@@ -201,7 +201,7 @@ const showDeleteConfirmation = (branchName, pr, mayHoldUnpublished, onConfirm, o
             : undefined,
         'Discard any unsaved or unmerged changes',
         mayHoldUnpublished
-            ? 'Remove the only copy of any changes that never reached GitHub, and the warning about them'
+            ? 'Remove the only copy of any changes missing from GitHub, and the warning about them'
             : undefined,
     ].filter((b) => b !== undefined);
     openConfirm({
@@ -217,6 +217,16 @@ const showDeleteConfirmation = (branchName, pr, mayHoldUnpublished, onConfirm, o
         ...confirmModalHandlers(onConfirm, onDismiss),
     });
 };
+/** Archiving is a one-way status change on a branch whose review is over. */
+const showArchiveConfirmation = (branchName, inReview, onConfirm, onDismiss) => {
+    openConfirm({
+        title: EDITOR_ACTIONS.archiveBranch,
+        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Archive “${branchName}”?\n\nIts pull request was closed without merging. This will:\n• Make the branch read-only and move it to “Archived”\n• Keep it marked as not merged\n\nAn archived branch can't go back to editing. This one stays until someone deletes it: automatic and bulk deletes only take merged branches.${inReview ? ` To keep working on it, use “${EDITOR_ACTIONS.withdrawFromReview}” instead.` : ''}` })),
+        labels: { confirm: EDITOR_ACTIONS.archiveBranch, cancel: 'Cancel' },
+        confirmProps: { color: 'orange', 'data-testid': 'confirm-archive-branch' },
+        ...confirmModalHandlers(onConfirm, onDismiss),
+    });
+};
 /**
  * How long a branch this session created stays overlaid on listings. Each warm
  * server container caches the shared filesystem separately, so for its
@@ -381,8 +391,10 @@ export function useBranchManager(options) {
             return {
                 name: b.name,
                 shortName: b.shortName,
+                title: b.title,
                 status: b.status,
                 createdBy: b.createdBy,
+                ownerName: branchesData?.ownerNames?.[b.createdBy],
                 updatedAt: b.updatedAt,
                 access: {
                     users: b.access.allowedUsers,
@@ -423,7 +435,7 @@ export function useBranchManager(options) {
                 submitBlocked: b.submitBlocked ?? true,
             };
         });
-    }, [branches, currentBranchName, options.comments]);
+    }, [branches, branchesData?.ownerNames, currentBranchName, options.comments]);
     // Explicit reload: always issues a fresh, independent fetch (raw call, not
     // SWR's `mutate()` revalidate path) so callers requesting a reload right
     // after mount aren't coalesced against the still-in-flight automatic load
@@ -730,6 +742,45 @@ export function useBranchManager(options) {
             }, () => resolve(), returnFocusTo);
         }));
     };
+    const handleArchive = (requested) => {
+        const branchNameToArchive = listedName(requested);
+        return singleFlight('archive', branchNameToArchive, () => new Promise((resolve, reject) => {
+            const status = latest.current.branches.find((b) => b.name === branchNameToArchive)?.status;
+            showArchiveConfirmation(shownName(branchNameToArchive), status === 'submitted' || status === 'approved', async () => {
+                options.setBusy(true);
+                try {
+                    const result = await apiClient.workflow.archive({
+                        branch: sendName(branchNameToArchive),
+                    });
+                    if (!result.ok)
+                        throw actionError(result, 'Failed to archive branch');
+                    notifications.show({ message: 'Branch archived', color: 'blue' });
+                    forgetCreatedBranch(branchNameToArchive);
+                    await loadBranches();
+                    resolve();
+                }
+                catch (err) {
+                    if (err instanceof RefusedError && err.status === 409) {
+                        // Nothing is lost, and the list says what changed.
+                        notifications.show({
+                            message: err.message,
+                            color: 'yellow',
+                            autoClose: false,
+                            withCloseButton: true,
+                        });
+                        await reloadBranches();
+                        resolve();
+                        return;
+                    }
+                    await reportActionFailure(err, 'Failed to archive branch', EDITOR_ACTIONS.archiveBranch);
+                    reject(err);
+                }
+                finally {
+                    options.setBusy(false);
+                }
+            }, () => resolve());
+        }));
+    };
     const handleApprove = (requested, returnFocusTo) => {
         const branchNameToApprove = listedName(requested);
         return singleFlight('approve', branchNameToApprove, () => new Promise((resolve, reject) => {
@@ -838,8 +889,7 @@ export function useBranchManager(options) {
         const branchNameToDelete = listedName(requested);
         const listedBefore = latest.current.branches;
         return singleFlight('delete', branchNameToDelete, () => new Promise((resolve) => {
-            showDeleteConfirmation(shownName(branchNameToDelete), pullRequestOf(branchNameToDelete), listedBefore.find((b) => b.name === branchNameToDelete)?.hold?.kind ===
-                'unpublished-at-merge', async () => {
+            showDeleteConfirmation(shownName(branchNameToDelete), pullRequestOf(branchNameToDelete), ['unpublished-at-merge', 'rewritten-at-merge'].includes(listedBefore.find((b) => b.name === branchNameToDelete)?.hold?.kind ?? ''), async () => {
                 options.setBusy(true);
                 try {
                     const result = await apiClient.branches.delete({
@@ -960,6 +1010,7 @@ export function useBranchManager(options) {
         handleApprove,
         handleRequestChanges,
         handleDelete,
+        handleArchive,
         handleReloadBranchData,
         loadBranches,
     };

package/dist/editor/hooks/useBranchesData.d.ts

@@ -19,6 +19,8 @@ export declare const BRANCHES_KEY = "canopy:branches";
 export interface BranchesData {
     branches: BranchListItem[];
     defaultBranch?: string;
+    /** Display names of the listed branches' creators, by user id. */
+    ownerNames?: Readonly<Record<string, string>>;
     /**
      * Client clock when this listing arrived. It makes listings fetched at
      * different moments distinct `data` values even when their branches match,

package/dist/editor/hooks/useBranchesData.js

@@ -33,10 +33,12 @@ export async function fetchBranches(apiClient, swr) {
     if (!result.ok) {
         throw new Error(result.error ?? `Failed to load branches: ${result.status}`);
     }
-    await seedUserProfiles(swr, result.data?.users ?? []);
+    const users = result.data?.users ?? [];
+    await seedUserProfiles(swr, users);
     return {
         branches: result.data?.branches ?? [],
         defaultBranch: result.data?.defaultBranch,
+        ownerNames: Object.fromEntries(users.map((user) => [user.id, user.name])),
         receivedAt: Date.now(),
     };
 }

package/dist/editor/theme.js

@@ -295,6 +295,7 @@ const canopyCssVariablesResolver = (theme) => ({
         '--mantine-color-dimmed': 'var(--mantine-color-gray-7)',
         '--mantine-color-placeholder': 'color-mix(in srgb, var(--mantine-color-gray-6) 60%, var(--mantine-color-gray-7))',
         '--canopy-danger-text': 'var(--mantine-color-red-9)',
+        '--mantine-color-error': 'var(--canopy-danger-text)',
         '--canopy-input-border': 'color-mix(in srgb, var(--mantine-color-gray-6) 80%, var(--mantine-color-gray-7))',
         '--canopy-surface-subtle': 'var(--mantine-color-gray-0)',
         '--canopy-surface-muted': 'var(--mantine-color-gray-1)',
@@ -307,6 +308,7 @@ const canopyCssVariablesResolver = (theme) => ({
         '--mantine-color-dimmed': 'color-mix(in srgb, var(--mantine-color-dark-1) 85%, var(--mantine-color-dark-2))',
         '--mantine-color-placeholder': 'color-mix(in srgb, var(--mantine-color-dark-2) 60%, var(--mantine-color-dark-1))',
         '--canopy-danger-text': 'var(--mantine-color-red-3)',
+        '--mantine-color-error': 'var(--canopy-danger-text)',
         '--canopy-input-border': 'color-mix(in srgb, var(--mantine-color-dark-2) 80%, var(--mantine-color-dark-1))',
         '--canopy-surface-subtle': 'var(--mantine-color-dark-6)',
         '--canopy-surface-muted': 'var(--mantine-color-dark-5)',
@@ -383,11 +385,15 @@ const CANOPY_STYLES = `
   box-shadow: inset 0 0 0 1px currentColor;
 }
 .mantine-DateTimePicker-day[data-selected],
-.mantine-DateTimePicker-pickerControl[data-selected] {
+.mantine-DateTimePicker-pickerControl[data-selected],
+.mantine-DatePickerInput-day[data-selected],
+.mantine-DatePickerInput-pickerControl[data-selected] {
   background-color: var(--canopy-primary-fill);
 }
 .mantine-DateTimePicker-day[data-selected]:hover,
-.mantine-DateTimePicker-pickerControl[data-selected]:hover {
+.mantine-DateTimePicker-pickerControl[data-selected]:hover,
+.mantine-DatePickerInput-day[data-selected]:hover,
+.mantine-DatePickerInput-pickerControl[data-selected]:hover {
   background-color: var(--canopy-primary-fill-hover);
 }
 input.mantine-TimeInput-input::-webkit-datetime-edit-hour-field:focus,
@@ -398,10 +404,12 @@ input.mantine-TimeInput-input::-webkit-datetime-edit-ampm-field:focus {
 }
 .mantine-Menu-item[aria-disabled='true'],
 .mantine-Combobox-empty,
-.mantine-DateTimePicker-day[data-outside] {
+.mantine-DateTimePicker-day[data-outside],
+.mantine-DatePickerInput-day[data-outside] {
   font-style: var(--canopy-dimmed-font-style);
 }
-.mantine-DateTimePicker-day[data-outside]:not([data-disabled]) {
+.mantine-DateTimePicker-day[data-outside]:not([data-disabled]),
+.mantine-DatePickerInput-day[data-outside]:not([data-disabled]) {
   opacity: 1;
 }
 `;

package/dist/entry-schema-registry.js

@@ -2,7 +2,7 @@ import { countTitleFields, findInvalidTitleFields, findTitleFieldsInLists, } fro
 import { countBodyFields, findInvalidBodyFields, findReservedBodyFieldName, } from './utils/body-field.js';
 import { RESOLVED_REFERENCE_KEYS, RESTRICTED_REFERENCE_MARKER } from './entry-schema.js';
 import { flattenGroupFields } from './utils/flatten-group-fields.js';
-import { ensureFieldNamesSpellInPaths, ensureSelectFieldsHaveOptions, ensureReferenceFieldsHaveScope, ensureItemTitleFieldsExist, ensureNoFlattenedFieldNameCollisions, ensureNoGroupsInsideComplexFields, ensureMarkdownFieldOptions, ensureMaxItemsPlacement, ensureStampOnPublishPlacement, } from './config/validation.js';
+import { ensureFieldNamesSpellInPaths, ensureSelectFieldsHaveOptions, ensureReferenceFieldsHaveScope, ensureItemTitleFieldsExist, ensureNoFlattenedFieldNameCollisions, ensureNoGroupsInsideComplexFields, ensureMarkdownFieldOptions, ensureMaxItemsPlacement, ensureSingleDateFields, ensureStampOnPublishPlacement, } from './config/validation.js';
 /** Look up a field's type by dotted path (e.g., "meta.order").
  * Groups are transparent — their children are searched at the same path level. */
 function findFieldType(fields, dottedPath) {
@@ -103,6 +103,7 @@ export function createEntrySchemaRegistry(registry) {
         ensureMarkdownFieldOptions(schema);
         ensureStampOnPublishPlacement(schema, `Entry schema registry entry "${key}"`);
         ensureMaxItemsPlacement(schema, `Entry schema registry entry "${key}"`);
+        ensureSingleDateFields(schema, `Entry schema registry entry "${key}"`);
         ensureNoFlattenedFieldNameCollisions(schema, `entry schema "${key}"`);
     }
     return registry;

package/dist/static/index.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { isBuildMode } from '../build-mode.js';
 import { findUnknownKeys, validateEntryData, } from '../validation/entry-validator.js';
 import { findBodyFieldName } from '../utils/body-field.js';
+import { withCalendarDays } from '../utils/calendar-day.js';
 import { isDataOnlyFormat } from '../utils/format.js';
 import { parseSlug } from '../paths/index.js';
 import { collectReferenceIds } from '../validation/field-traversal.js';
@@ -112,7 +113,9 @@ export async function collectStaticPaths(ctx, options = {}) {
  * gray-matter parses unquoted YAML dates in hand-authored frontmatter (`date: YYYY-MM-DD`) into
  * JS `Date` objects rather than strings. The shared validator's datetime check requires a string
  * (see `validateScalar` in entry-validator.ts), so a legitimate hand-authored or migrated entry
- * would otherwise fail this build guard. CMS-authored entries round-trip as quoted strings, so
+ * would otherwise fail this build guard. A bare date under a `date` field is read as the day
+ * written (`withCalendarDays`), and its ISO string is no day, so the scan does the same first.
+ * CMS-authored entries round-trip as quoted strings, so
  * this only affects pre-existing content — which is the primary path for adopters retrofitting
  * CanopyCMS onto an existing repo.
  *
@@ -157,7 +160,7 @@ export function findInvalidEntries(items) {
     for (const item of items) {
         if (!item.schema)
             continue;
-        const data = normalizeDatesDeep(item.data);
+        const data = normalizeDatesDeep(withCalendarDays(item.schema, item.data));
         const errors = validateEntryData(item.schema, data);
         if (errors.length > 0) {
             invalid.push({ entryPath: item.entryPath, errors });

package/dist/types.d.ts

@@ -12,6 +12,22 @@ export type CanopyGroupId = string;
  * semantics (worker rebase skip list, a set/unset endpoint, UI).
  */
 export type BranchStatus = 'editing' | 'submitted' | 'approved' | 'archived';
+/** One cycle of the worker's retention sweep (worker/archived-sweep.ts). */
+export interface ArchivedSweepReport {
+    /** Full names of the branches deleted. */
+    deleted: string[];
+    /** Due, but another process held the branch's provisioning lock; retried next cycle. */
+    skippedLocked: string[];
+    /** [REDACT] Served to the admin panel, so `error` is sanitized. */
+    failed: {
+        branch: string;
+        error: string;
+    }[];
+    /** Due, beyond this cycle's cap; the next cycle takes the oldest of them. */
+    deferred: number;
+    /** Deleted, with something left behind, sanitized as `failed` is ([REDACT]). */
+    warnings: string[];
+}
 export type SyncStatus = 'synced' | 'pending-sync' | 'sync-failed';
 export type ConflictStatus = 'clean' | 'conflicts-detected';
 export type PullRequestState = 'open' | 'closed' | 'merged';
@@ -57,6 +73,14 @@ export type BranchHold = PullRequestHold | {
 /** Admins see what to do in System health. */
  | {
     kind: 'unpublished-at-merge';
+}
+/**
+ * An archived branch rewritten on GitHub, which may hold commits GitHub dropped. `commit`, the
+ * one GitHub no longer contains, is for System health; the API leaves it out.
+ */
+ | {
+    kind: 'rewritten-at-merge';
+    commit?: string;
 };
 export interface BranchMetadata {
     name: string;
@@ -106,6 +130,11 @@ export interface BranchMetadata {
      * (worker auto-poll or markAsMerged). Absent for branches archived any other way.
      */
     mergedAt?: string;
+    /**
+     * When the branch was archived, merged or not: the clock retention counts from. A branch
+     * archived before this field existed has only `mergedAt` (branch-archive.ts).
+     */
+    archivedAt?: string;
     /**
      * Set by the worker when a rebase cycle fails for this branch; cleared on
      * the next successful cycle (and on submit). firstAt survives repeated
@@ -292,6 +321,8 @@ export interface WorkerStatusReport {
     updatedAt: string;
     lastTaskCycleAt?: string;
     lastGitSyncAt?: string;
+    /** The deployment's `archivedBranchRetentionDays`; absent when retention is off. */
+    archivedBranchRetentionDays?: number;
     lastGitSyncError?: {
         message: string;
         at: string;
@@ -314,6 +345,8 @@ export interface WorkerStatusReport {
         }[];
         /** Optional for the same reason as `tracked` below. */
         baseRefresh?: BaseRefreshReport;
+        /** The retention sweep's work this cycle; absent when it found nothing to do. */
+        archivedSweep?: ArchivedSweepReport;
         /**
          * Outcome of reconciling remote.git's `refs/heads/*` against GitHub's fetched
          * tips, never moving a head the worker finds editor work in (worker/git-sync.ts's

package/dist/utils/calendar-day.d.ts

@@ -0,0 +1,23 @@
+import type { FieldConfig } from '../config/index.js';
+/** Whether the year, month and day name a real day; `Date` rolls 30 Feb on into March. */
+export declare const isRealDay: (year: number, month: number, day: number) => boolean;
+/** Whether `value` is a `date` field's value: `YYYY-MM-DD`, naming a real day. */
+export declare const isCalendarDay: (value: unknown) => value is string;
+/**
+ * The first moment of that day in the browser's zone: 01:00 where a clock change skips midnight,
+ * the next day where a zone skipped the day whole. `new Date('YYYY-MM-DD')` is UTC midnight
+ * instead, the evening before west of UTC.
+ */
+export declare const localMidnight: (year: number, month: number, day: number) => Date;
+/** A `date` value as a picker's local `Date`, or null when it is not a real day. */
+export declare const calendarDayToLocalDate: (value: string) => Date | null;
+/** The day a picker's local `Date` shows, as a `date` value. */
+export declare const localDateToCalendarDay: (date: Date) => string;
+/**
+ * `data` with each `date` field's bare YAML date as its `YYYY-MM-DD` string, nested fields
+ * included; the same object when none needed it, so a parser's shared object is never written to.
+ * Only the schema knows a field wants a day, so other fields' bare dates stay `Date`s.
+ */
+export declare function withCalendarDays(fields: readonly FieldConfig[], data: Record<string, unknown>): Record<string, unknown>;
+/** `data` parsed from an entry file as every reader hands it on, so all of them agree. */
+export declare const entryAsRead: (fields: readonly FieldConfig[], data: Record<string, unknown>) => Record<string, unknown>;

package/dist/utils/calendar-day.js

@@ -0,0 +1,102 @@
+import { withItemKeys } from '../item-keys.js';
+import { isPlainRecord, resolveBlockItem } from '../validation/field-traversal.js';
+/**
+ * The value of a `date` field: `YYYY-MM-DD`, a day on the calendar with no time and no zone. It
+ * only meets a `Date` at its edges, a picker or a display and a YAML parser, and there it goes
+ * through the local or the UTC parts named below, never from one to the other.
+ */
+const DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const MS_PER_DAY = 86_400_000;
+const twoDigits = (n) => String(n).padStart(2, '0');
+/** Whether the year, month and day name a real day; `Date` rolls 30 Feb on into March. */
+export const isRealDay = (year, month, day) => {
+    const lastOfMonth = new Date(0);
+    lastOfMonth.setUTCFullYear(year, month, 0);
+    return month >= 1 && month <= 12 && day >= 1 && day <= lastOfMonth.getUTCDate();
+};
+const dayParts = (value) => {
+    const match = typeof value === 'string' ? DAY.exec(value) : null;
+    if (!match)
+        return undefined;
+    const [year, month, day] = match.slice(1).map(Number);
+    return isRealDay(year, month, day) ? [year, month, day] : undefined;
+};
+/** Whether `value` is a `date` field's value: `YYYY-MM-DD`, naming a real day. */
+export const isCalendarDay = (value) => dayParts(value) !== undefined;
+/**
+ * The first moment of that day in the browser's zone: 01:00 where a clock change skips midnight,
+ * the next day where a zone skipped the day whole. `new Date('YYYY-MM-DD')` is UTC midnight
+ * instead, the evening before west of UTC.
+ */
+export const localMidnight = (year, month, day) => {
+    // setFullYear, since the constructor maps years 0-99 to 1900-1999.
+    const local = new Date(0);
+    local.setFullYear(year, month - 1, day);
+    local.setHours(0, 0, 0, 0);
+    return local;
+};
+/** A `date` value as a picker's local `Date`, or null when it is not a real day. */
+export const calendarDayToLocalDate = (value) => {
+    const parts = dayParts(value);
+    return parts ? localMidnight(...parts) : null;
+};
+/** The day a picker's local `Date` shows, as a `date` value. */
+export const localDateToCalendarDay = (date) => `${String(date.getFullYear()).padStart(4, '0')}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
+/**
+ * The day gray-matter's js-yaml reads a bare `YYYY-MM-DD` as, or undefined for any other time of
+ * day. js-yaml reads it as UTC midnight, so the UTC parts are the day written whatever the
+ * machine's zone. A timestamp at UTC midnight reads alike, so it counts as a day.
+ */
+const dayOfBareDate = (value) => value.getTime() % MS_PER_DAY === 0 ? value.toISOString().slice(0, 10) : undefined;
+const mapItems = (items, mapItem) => {
+    const next = items.map((item) => (isPlainRecord(item) ? mapItem(item) : item));
+    return next.every((item, i) => item === items[i]) ? items : next;
+};
+const blockItemWithDays = (field, item) => {
+    const resolved = resolveBlockItem(field, item);
+    if (!resolved)
+        return item;
+    const data = withCalendarDays(resolved.fields, resolved.data);
+    if (data === resolved.data)
+        return item;
+    return resolved.data === item ? data : { ...item, value: data };
+};
+const valueWithDays = (field, value) => {
+    if (field.type === 'date') {
+        return value instanceof Date ? (dayOfBareDate(value) ?? value) : value;
+    }
+    if (field.type === 'object') {
+        const { fields, list } = field;
+        if (list) {
+            return Array.isArray(value)
+                ? mapItems(value, (item) => withCalendarDays(fields ?? [], item))
+                : value;
+        }
+        return isPlainRecord(value) ? withCalendarDays(fields ?? [], value) : value;
+    }
+    if (field.type === 'block' && Array.isArray(value)) {
+        return mapItems(value, (item) => blockItemWithDays(field, item));
+    }
+    return value;
+};
+/**
+ * `data` with each `date` field's bare YAML date as its `YYYY-MM-DD` string, nested fields
+ * included; the same object when none needed it, so a parser's shared object is never written to.
+ * Only the schema knows a field wants a day, so other fields' bare dates stay `Date`s.
+ */
+export function withCalendarDays(fields, data) {
+    let out = data;
+    for (const field of fields) {
+        if (field.type === 'group') {
+            out = withCalendarDays(field.fields, out);
+            continue;
+        }
+        const value = out[field.name];
+        const next = valueWithDays(field, value);
+        if (next !== value)
+            out = { ...out, [field.name]: next };
+    }
+    return out;
+}
+/** `data` parsed from an entry file as every reader hands it on, so all of them agree. */
+export const entryAsRead = (fields, data) => withItemKeys(fields, withCalendarDays(fields, data), 'content');

package/dist/utils/content-serialize.d.ts

@@ -16,6 +16,7 @@
  * is a schema question, answered one layer up by `findUnknownKeys`
  * (validation/entry-validator.ts) at the API boundary, not by a schema-blind serialiser.
  */
+import type { FieldConfig } from '../config/index.js';
 import { type MarkdownBodyFormat } from './markdown-body-splice.js';
 /**
  * Serialise entry data as a YAML file, carrying the comments of `existingRaw` through.
@@ -34,6 +35,7 @@ export declare function serializeYaml(data: Record<string, unknown>, existingRaw
  * would have produced. The result is kept only if the read path reads `data` back from it;
  * otherwise gray-matter writes it, without the comments. A fresh string the read path would
  * misread is quoted (`readsAsAnotherValue`), so this is left for a changed value meeting text the
- * two parsers read differently, as 14 meets a file's `014`.
+ * two parsers read differently, as 14 meets a file's `014`. `fields`, the entry's schema, shapes
+ * what the read path reads, so a `date` field's bare date counts as the day it writes.
  */
-export declare function serializeFrontmatter(editorBody: string, data: Record<string, unknown>, existingRaw: string | undefined, format: MarkdownBodyFormat): string;
+export declare function serializeFrontmatter(editorBody: string, data: Record<string, unknown>, existingRaw: string | undefined, format: MarkdownBodyFormat, fields?: readonly FieldConfig[]): string;

package/dist/utils/content-serialize.js

@@ -21,6 +21,7 @@ import matter from 'gray-matter';
 import { isCollection, isMap, isNode, isScalar, isSeq, parseDocument, Scalar, stringify as yamlStringify, visit, } from 'yaml';
 import { isBlockStructuralKey } from '../validation/block-structural-keys.js';
 import { ITEM_KEY, isItemKey } from '../item-keys.js';
+import { withCalendarDays } from './calendar-day.js';
 import { createDebugLogger } from './debug.js';
 import { getErrorMessage } from './error.js';
 import { preserveMarkdownSource } from './markdown-body-splice.js';
@@ -552,9 +553,9 @@ function asJson(value) {
     return key === undefined || key === 'undefined' ? undefined : JSON.parse(key);
 }
 /** Frontmatter data as the read path hands it over the API, or undefined when it cannot split. */
-function frontmatterAsRead(raw) {
+function frontmatterAsRead(raw, fields) {
     try {
-        return asJson(matter(raw, {}).data);
+        return asJson(withCalendarDays(fields, matter(raw, {}).data));
     }
     catch {
         return undefined;
@@ -648,9 +649,10 @@ function readsAsAnotherValue(text, asKey) {
  * would have produced. The result is kept only if the read path reads `data` back from it;
  * otherwise gray-matter writes it, without the comments. A fresh string the read path would
  * misread is quoted (`readsAsAnotherValue`), so this is left for a changed value meeting text the
- * two parsers read differently, as 14 meets a file's `014`.
+ * two parsers read differently, as 14 meets a file's `014`. `fields`, the entry's schema, shapes
+ * what the read path reads, so a `date` field's bare date counts as the day it writes.
  */
-export function serializeFrontmatter(editorBody, data, existingRaw, format) {
+export function serializeFrontmatter(editorBody, data, existingRaw, format, fields = []) {
     // An object, never the body string: `matter.stringify` re-parses a string as a whole file, so a
     // body starting with `---` would be read as frontmatter and dropped.
     const file = { content: bodyToWrite(editorBody, data, format, existingRaw) };
@@ -661,7 +663,7 @@ export function serializeFrontmatter(editorBody, data, existingRaw, format) {
         return matter.stringify(file, data);
     const onDisk = parseDocument(existingFrontmatter);
     const toReconcile = onDisk.errors.length === 0
-        ? withUnchangedAsOnDisk(data, frontmatterAsRead(existingRaw), onDisk.toJS())
+        ? withUnchangedAsOnDisk(data, frontmatterAsRead(existingRaw, fields), onDisk.toJS())
         : data;
     const reconciled = reconcileYamlSource(existingFrontmatter, isPlainRecord(toReconcile) ? toReconcile : data, { rootAtColumnZero: true, quote: readsAsAnotherValue });
     if (reconciled === undefined)
@@ -674,7 +676,7 @@ export function serializeFrontmatter(editorBody, data, existingRaw, format) {
             },
         },
     });
-    if (isDeepStrictEqual(frontmatterAsRead(written), asJson(data)))
+    if (isDeepStrictEqual(frontmatterAsRead(written, fields), asJson(data)))
         return written;
     log.debug('content-serialize', 'reconciled frontmatter reads back differently; writing as gray-matter prints it');
     return matter.stringify(file, data);