canopycms 0.8.3 → 0.10.0

package/dist/cli/generate-ai-content.js

@@ -68,7 +68,7 @@ var init_atomic_write = __esm({
 
 // dist/validation/field-traversal.js
 function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
 }
 function resolveBlockItem(blockField, item) {
   const templateName = typeof item.template === "string" ? item.template : typeof item._type === "string" ? item._type : void 0;
@@ -573,7 +573,7 @@ var scalarFieldTypes, markdownFieldTypes, primitiveFieldTypes, fieldTypes;
 var init_types2 = __esm({
   "dist/config/types.js"() {
     "use strict";
-    scalarFieldTypes = ["string", "number", "boolean", "datetime", "code"];
+    scalarFieldTypes = ["string", "number", "boolean", "date", "datetime", "code"];
     markdownFieldTypes = ["markdown", "mdx"];
     primitiveFieldTypes = [...scalarFieldTypes, ...markdownFieldTypes];
     fieldTypes = [
@@ -1640,6 +1640,70 @@ function isBlockStructuralKey(key) {
 // dist/utils/content-serialize.js
 init_item_keys();
 
+// dist/utils/calendar-day.js
+init_item_keys();
+init_field_traversal();
+var DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+var MS_PER_DAY = 864e5;
+var isRealDay = (year, month, day) => {
+  const lastOfMonth = /* @__PURE__ */ new Date(0);
+  lastOfMonth.setUTCFullYear(year, month, 0);
+  return month >= 1 && month <= 12 && day >= 1 && day <= lastOfMonth.getUTCDate();
+};
+var dayParts = (value) => {
+  const match = typeof value === "string" ? DAY.exec(value) : null;
+  if (!match)
+    return void 0;
+  const [year, month, day] = match.slice(1).map(Number);
+  return isRealDay(year, month, day) ? [year, month, day] : void 0;
+};
+var isCalendarDay = (value) => dayParts(value) !== void 0;
+var dayOfBareDate = (value) => value.getTime() % MS_PER_DAY === 0 ? value.toISOString().slice(0, 10) : void 0;
+var mapItems = (items, mapItem) => {
+  const next = items.map((item) => isPlainRecord(item) ? mapItem(item) : item);
+  return next.every((item, i) => item === items[i]) ? items : next;
+};
+var 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 };
+};
+var 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;
+};
+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;
+}
+var entryAsRead = (fields, data) => withItemKeys(fields, withCalendarDays(fields, data), "content");
+
 // dist/utils/debug.js
 var envFlag = (name) => typeof process !== "undefined" && process.env[name] === "true";
 var LOG_LEVELS = {
@@ -3235,9 +3299,9 @@ function asJson(value) {
   const key = identityKey(value);
   return key === void 0 || key === "undefined" ? void 0 : JSON.parse(key);
 }
-function frontmatterAsRead(raw) {
+function frontmatterAsRead(raw, fields) {
   try {
-    return asJson(matter(raw, {}).data);
+    return asJson(withCalendarDays(fields, matter(raw, {}).data));
   } catch {
     return void 0;
   }
@@ -3305,7 +3369,7 @@ ${asKey ? `${text}: v` : `v: ${text}`}
     return true;
   }
 }
-function serializeFrontmatter(editorBody, data, existingRaw, format) {
+function serializeFrontmatter(editorBody, data, existingRaw, format, fields = []) {
   const file = { content: bodyToWrite(editorBody, data, format, existingRaw) };
   if (existingRaw === void 0)
     return matter.stringify(file, data);
@@ -3313,7 +3377,7 @@ function serializeFrontmatter(editorBody, data, existingRaw, format) {
   if (existingFrontmatter === void 0)
     return matter.stringify(file, data);
   const onDisk = parseDocument2(existingFrontmatter);
-  const toReconcile = onDisk.errors.length === 0 ? withUnchangedAsOnDisk(data, frontmatterAsRead(existingRaw), onDisk.toJS()) : data;
+  const toReconcile = onDisk.errors.length === 0 ? withUnchangedAsOnDisk(data, frontmatterAsRead(existingRaw, fields), onDisk.toJS()) : data;
   const reconciled = reconcileYamlSource(existingFrontmatter, isPlainRecord2(toReconcile) ? toReconcile : data, { rootAtColumnZero: true, quote: readsAsAnotherValue });
   if (reconciled === void 0)
     return matter.stringify(file, data);
@@ -3325,7 +3389,7 @@ function serializeFrontmatter(editorBody, data, existingRaw, format) {
       }
     }
   });
-  if (isDeepStrictEqual2(frontmatterAsRead(written), asJson(data)))
+  if (isDeepStrictEqual2(frontmatterAsRead(written, fields), asJson(data)))
     return written;
   log2.debug("content-serialize", "reconciled frontmatter reads back differently; writing as gray-matter prints it");
   return matter.stringify(file, data);
@@ -3639,9 +3703,6 @@ function linkOnlyReferenceData(data, format, fields) {
   return rest;
 }
 
-// dist/content-store.js
-init_item_keys();
-
 // dist/static/seo.js
 var DEFAULT_SEO_FIELD_NAMES = {
   title: "metaTitle",
@@ -5834,7 +5895,7 @@ var ContentStore = class {
         absolutePath
       };
     }
-    doc.data = withItemKeys(fields, doc.data, "content");
+    doc.data = entryAsRead(fields, doc.data);
     if (options.resolveReferences !== false) {
       doc.data = await this.resolveReferencesInData(doc.data, fields, void 0, options.referenceAccess, {
         entry: slug ? entryLogicalPath(schemaItem.logicalPath, slug) : schemaItem.logicalPath,
@@ -5938,7 +5999,7 @@ var ContentStore = class {
           } else if (input.format === "yaml") {
             content = serializeYaml(input.data ?? {}, existingRaw);
           } else {
-            content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format);
+            content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format, fields);
           }
           await atomicWriteFile(absolutePath, content);
           const liveIndex = this._idIndex;
@@ -6830,6 +6891,7 @@ _${field.description}_` : "";
   switch (field.type) {
     case "string":
     case "number":
+    case "date":
     case "datetime":
       return `${heading} ${label}${descriptionLine}
 
@@ -6908,6 +6970,7 @@ ${items.map((item) => `- ${item}`).join("\n")}`;
 var FLAT_CELL_TYPES = /* @__PURE__ */ new Set([
   "string",
   "number",
+  "date",
   "datetime",
   "boolean",
   "select",
@@ -7845,6 +7908,7 @@ var branchMetadataShape = {
     merged: "merged"
   }).optional(),
   mergedAt: z7.string().optional(),
+  archivedAt: z7.string().optional(),
   rebaseFailure: z7.object({ message: z7.string(), firstAt: z7.string(), lastAt: z7.string() }).optional(),
   historyRewrittenFrom: z7.string().optional(),
   lastGitHubTip: z7.string().optional(),
@@ -10970,7 +11034,6 @@ import path24 from "node:path";
 import matter3 from "gray-matter";
 import { parse as yamlParse2 } from "yaml";
 init_error();
-init_item_keys();
 var log10 = createDebugLogger({ prefix: "ContentListing" });
 var normalizePath = (root, target) => {
   const result = validateAndNormalizePath(root, target);
@@ -11141,7 +11204,7 @@ var listCollectionEntries = async (root, collection, onSkip, readsId) => {
       fs20.stat(absolutePath),
       readEntryData(absolutePath, format, bodyField)
     ]);
-    const data = withItemKeys(entryType?.schema ?? [], rawData, "content");
+    const data = entryAsRead(entryType?.schema ?? [], rawData);
     const item = {
       logicalPath: entryLogicalPath(collection.logicalPath, slug),
       contentId,
@@ -11254,6 +11317,11 @@ function validateScalar(field, value, path27) {
         return [{ fieldPath: path27, message: "Expected true or false" }];
       }
       return [];
+    case "date":
+      if (value !== "" && !isCalendarDay(value)) {
+        return [{ fieldPath: path27, message: "Expected a real date, written YYYY-MM-DD" }];
+      }
+      return [];
     case "datetime":
       if (typeof value !== "string" || value !== "" && Number.isNaN(Date.parse(value))) {
         return [{ fieldPath: path27, message: "Expected a valid date/time string" }];
@@ -11408,7 +11476,7 @@ 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/cli/init.js

@@ -26,7 +26,7 @@ var scalarFieldTypes, markdownFieldTypes, primitiveFieldTypes, fieldTypes;
 var init_types = __esm({
   "dist/config/types.js"() {
     "use strict";
-    scalarFieldTypes = ["string", "number", "boolean", "datetime", "code"];
+    scalarFieldTypes = ["string", "number", "boolean", "date", "datetime", "code"];
     markdownFieldTypes = ["markdown", "mdx"];
     primitiveFieldTypes = [...scalarFieldTypes, ...markdownFieldTypes];
     fieldTypes = [

package/dist/config/types.d.ts

@@ -10,10 +10,10 @@ import type { PermissionPath } from '../authorization/types.js';
 import type { EntryLinkUrlResolver } from '../entry-link-resolver.js';
 import type { CropRect } from '../assets/transform-directives.js';
 import type { SeoFieldLocation } from '../static/seo.js';
-declare const scalarFieldTypes: readonly ["string", "number", "boolean", "datetime", "code"];
+declare const scalarFieldTypes: readonly ["string", "number", "boolean", "date", "datetime", "code"];
 export declare const markdownFieldTypes: readonly ["markdown", "mdx"];
-export declare const primitiveFieldTypes: readonly ["string", "number", "boolean", "datetime", "code", "markdown", "mdx"];
-export declare const fieldTypes: readonly ["string", "number", "boolean", "datetime", "code", "markdown", "mdx", "image", "select", "reference", "object", "block", "group"];
+export declare const primitiveFieldTypes: readonly ["string", "number", "boolean", "date", "datetime", "code", "markdown", "mdx"];
+export declare const fieldTypes: readonly ["string", "number", "boolean", "date", "datetime", "code", "markdown", "mdx", "image", "select", "reference", "object", "block", "group"];
 export type PrimitiveFieldType = (typeof primitiveFieldTypes)[number];
 export type FieldType = (typeof fieldTypes)[number];
 export type ContentFormat = 'md' | 'mdx' | 'json' | 'yaml';
@@ -211,7 +211,7 @@ export interface ObjectFieldConfig extends BaseFieldConfig {
     type: 'object';
     fields: FieldConfig[];
     /**
-     * On a `list: true` object, a direct `string` or `number` child whose value titles each
+     * On a `list: true` object, a direct `string`, `number` or `date` child whose value titles each
      * item's card; a blank or non-finite value falls back to the item's first non-blank `string`
      * field, then "Item N".
      */

package/dist/config/types.js

@@ -2,7 +2,7 @@
  * Type definitions for CanopyCMS configuration.
  * These are pure TypeScript types - Zod schemas are in ./schemas/
  */
-const scalarFieldTypes = ['string', 'number', 'boolean', 'datetime', 'code'];
+const scalarFieldTypes = ['string', 'number', 'boolean', 'date', 'datetime', 'code'];
 export const markdownFieldTypes = ['markdown', 'mdx'];
 export const primitiveFieldTypes = [...scalarFieldTypes, ...markdownFieldTypes];
 // 'image' is not a primitive: it has a structured value (ImageFieldValue) and

package/dist/config/validation.d.ts

@@ -34,9 +34,9 @@ export declare const ensureReferenceFieldsHaveScope: (fields: unknown) => void;
 export declare const forEachReferenceField: (fields: unknown, visit: (field: Record<string, unknown>) => void) => void;
 /**
  * Check that every `itemLabel` is non-blank text and, like every `itemTitleField`, sits on a
- * `list: true` object, and that every `itemTitleField` names a direct child of type `string` or
- * `number`, the only values the card heading shows as typed (a reference would show its raw id, a
- * select its stored value). Throws an error when it does not. Entry schemas reach the editor
+ * `list: true` object, and that every `itemTitleField` names a direct child of type `string`,
+ * `number` or `date`, the only values the card heading shows as typed (a reference would show its
+ * raw id, a select its stored value). Throws an error when it does not. Entry schemas reach the editor
  * through these checks, not the zod field schema.
  */
 export declare const ensureItemTitleFieldsExist: (fields: unknown) => void;
@@ -68,6 +68,12 @@ export declare const ensureStampOnPublishPlacement: (fields: unknown, scopeLabel
  * `ensureStampOnPublishPlacement`. Throws on the first problem.
  */
 export declare const ensureMaxItemsPlacement: (fields: unknown, scopeLabel?: string) => void;
+/**
+ * Check that no `date` field is `list: true`: the editor has one picker for one day, and an object
+ * list with a `date` child gives a list of days its rows. Recurses into groups, objects and block
+ * templates like `ensureStampOnPublishPlacement`. Throws on the first problem.
+ */
+export declare const ensureSingleDateFields: (fields: unknown, scopeLabel?: string) => void;
 /**
  * Check every markdown and mdx field's `mdxAllow` against its schema and its `renderAs`,
  * `mdxAllow` and `executable` against each other. Throws on the first problem.

package/dist/config/validation.js

@@ -110,9 +110,9 @@ export const forEachReferenceField = (fields, visit) => {
 };
 /**
  * Check that every `itemLabel` is non-blank text and, like every `itemTitleField`, sits on a
- * `list: true` object, and that every `itemTitleField` names a direct child of type `string` or
- * `number`, the only values the card heading shows as typed (a reference would show its raw id, a
- * select its stored value). Throws an error when it does not. Entry schemas reach the editor
+ * `list: true` object, and that every `itemTitleField` names a direct child of type `string`,
+ * `number` or `date`, the only values the card heading shows as typed (a reference would show its
+ * raw id, a select its stored value). Throws an error when it does not. Entry schemas reach the editor
  * through these checks, not the zod field schema.
  */
 export const ensureItemTitleFieldsExist = (fields) => {
@@ -140,8 +140,8 @@ export const ensureItemTitleFieldsExist = (fields) => {
                 if (typeof f.itemTitleField !== 'string' || !child) {
                     throw new Error(`${label}, which is not one of its child fields`);
                 }
-                if (child.type !== 'string' && child.type !== 'number') {
-                    throw new Error(`${label}, which must name a string or number field`);
+                if (child.type !== 'string' && child.type !== 'number' && child.type !== 'date') {
+                    throw new Error(`${label}, which must name a string, number or date field`);
                 }
             }
             ensureItemTitleFieldsExist(children);
@@ -327,6 +327,31 @@ export const ensureMaxItemsPlacement = (fields, scopeLabel = 'entry schema') =>
     };
     check(fields);
 };
+/**
+ * Check that no `date` field is `list: true`: the editor has one picker for one day, and an object
+ * list with a `date` child gives a list of days its rows. Recurses into groups, objects and block
+ * templates like `ensureStampOnPublishPlacement`. Throws on the first problem.
+ */
+export const ensureSingleDateFields = (fields, scopeLabel = 'entry schema') => {
+    const check = (scopeFields) => {
+        if (!Array.isArray(scopeFields))
+            return;
+        for (const field of scopeFields) {
+            const f = field;
+            if (f?.type === 'date' && f.list === true) {
+                throw new Error(`${scopeLabel}: field "${String(f.name)}" is a date with list: true; use an object list with a date field inside`);
+            }
+            if (f?.type === 'group' || f?.type === 'object')
+                check(f.fields);
+            if (f?.type === 'block' && Array.isArray(f.templates)) {
+                for (const template of f.templates) {
+                    check(template.fields);
+                }
+            }
+        }
+    };
+    check(fields);
+};
 /**
  * Check every markdown and mdx field's `mdxAllow` against its schema and its `renderAs`,
  * `mdxAllow` and `executable` against each other. Throws on the first problem.

package/dist/content-listing.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import { parse as yamlParse } from 'yaml';
 import { findBodyFieldName } from './utils/body-field.js';
+import { entryAsRead } from './utils/calendar-day.js';
 import { computeEntryUrl } from './utils/entry-url.js';
 import { asRecord, getFormatExtension } from './utils/format.js';
 import { resolveCollectionPath, toLogicalCollectionPath } from './content-id-index.js';
@@ -15,7 +16,6 @@ import { isNotFoundError, getErrorMessage } from './utils/error.js';
 import { createDebugLogger } from './utils/debug.js';
 import { ContentStore, ContentStoreError, createReferenceResolveCache, } from './content-store.js';
 import { isBuildMode } from './build-mode.js';
-import { withItemKeys } from './item-keys.js';
 const log = createDebugLogger({ prefix: 'ContentListing' });
 /** Validate and normalize `target` under `root`; throws ContentStoreError on a traversal. */
 const normalizePath = (root, target) => {
@@ -444,8 +444,7 @@ export const listCollectionEntries = async (root, collection, onSkip, readsId) =
             fs.stat(absolutePath),
             readEntryData(absolutePath, format, bodyField),
         ]);
-        // Keyed as `ContentStore.read` keys it, so every reader names an item alike.
-        const data = withItemKeys(entryType?.schema ?? [], rawData, 'content');
+        const data = entryAsRead(entryType?.schema ?? [], rawData);
         const item = {
             logicalPath: entryLogicalPath(collection.logicalPath, slug),
             contentId,

package/dist/content-store.js

@@ -21,7 +21,7 @@ import { serializeJson } from './utils/json-source-splice.js';
 import { withLock } from './utils/async-mutex.js';
 import { assertContentWriteLockHeld, ContentWriteLockBusyError, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS, withContentWriteLock, } from './utils/content-write-lock.js';
 import { findBodyFieldName, linkOnlyReferenceData } from './utils/body-field.js';
-import { withItemKeys } from './item-keys.js';
+import { entryAsRead } from './utils/calendar-day.js';
 import { buildMissingReference, buildResolvedReference, buildRestrictedReference, } from './entry-schema.js';
 import { warnDanglingReference } from './dangling-reference-log.js';
 import { canopyLogError } from './utils/logger.js';
@@ -786,9 +786,9 @@ export class ContentStore {
                 absolutePath,
             };
         }
-        // Keys an item saved without one by its content, before references resolve into it, as the
-        // listing and the write path do (`item-keys.ts`).
-        doc.data = withItemKeys(fields, doc.data, 'content');
+        // Before references resolve into it. An item saved without a key is keyed by its content, as
+        // the listing and the write path do (`item-keys.ts`).
+        doc.data = entryAsRead(fields, doc.data);
         if (options.resolveReferences !== false) {
             doc.data = await this.resolveReferencesInData(doc.data, fields, undefined, options.referenceAccess, {
                 entry: slug ? entryLogicalPath(schemaItem.logicalPath, slug) : schemaItem.logicalPath,
@@ -1031,7 +1031,7 @@ export class ContentStore {
                         content = serializeYaml(input.data ?? {}, existingRaw);
                     }
                     else {
-                        content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format);
+                        content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format, fields);
                     }
                     await atomicWriteFile(absolutePath, content);
                     // Update the ID index after a successful write. Look up and mutate the LIVE index

package/dist/editor/BranchManager.d.ts

@@ -9,8 +9,11 @@ export interface BranchSummary {
     name: string;
     /** What the card shows for the branch (`displayBranchName`); the full `name` keys it. */
     shortName?: string;
+    title?: string;
     status: string;
     createdBy?: string;
+    /** The creator's display name, which the filter searches. */
+    ownerName?: string;
     updatedAt?: string;
     access?: {
         users?: string[];
@@ -99,6 +102,8 @@ export interface BranchManagerProps {
     onWithdraw?: (name: string) => void;
     onApprove?: (name: string) => void;
     onRequestChanges?: (name: string) => void;
+    /** Archives a branch whose pull request closed without merging; offered to admins only. */
+    onArchive?: (name: string) => void;
     onClose?: () => void;
     comments?: CommentThread[];
     currentUserId?: string;
@@ -114,4 +119,19 @@ export interface BranchManagerProps {
     /** Names the people in branch comments; without it they show as ids */
     onGetCommentUserMetadata?: (userId: string) => Promise<UserSearchResult | null>;
 }
+/**
+ * The list's two parts: the current branch, whatever its status, then live branches in `places`;
+ * and the other archived branches in `places`.
+ * @internal Exported for tests.
+ */
+export declare const arrangeBranches: (branches: readonly BranchSummary[], currentBranchName: string | undefined, places: ReadonlyMap<string, number>) => {
+    live: BranchSummary[];
+    archived: BranchSummary[];
+};
+/**
+ * Whether `query` appears in what the card shows of the branch: its name, title or owner's name,
+ * ignoring case.
+ * @internal Exported for tests.
+ */
+export declare const matchesBranchFilter: (branch: BranchSummary, query: string) => boolean;
 export declare const BranchManager: React.FC<BranchManagerProps>;