@nuasite/cli 0.54.0 → 0.56.0

package/dist/index.js

@@ -7295,7 +7295,7 @@ var init_check_shape = __esm(() => {
 function isBlankFieldValue(value) {
   return value === undefined || value === null || value === "";
 }
-function defaultValueForNewEntry(field, today = () => new Date) {
+function seedValueForRequiredField(field, today = () => new Date) {
   if (field.defaultValue !== undefined)
     return field.defaultValue;
   switch (field.type) {
@@ -7311,23 +7311,71 @@ function defaultValueForNewEntry(field, today = () => new Date) {
       return "";
   }
 }
+function blankFieldValue(field) {
+  if (field.defaultValue !== undefined)
+    return field.defaultValue;
+  switch (field.type) {
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    case "date":
+    case "datetime":
+    case "time":
+    case "month":
+    case "number":
+    case "year":
+    case "select":
+    case "reference":
+      return;
+    default:
+      return "";
+  }
+}
 function newRepeaterItem(fields, today) {
   const item = {};
   for (const field of fields) {
     if (!field.required || field.hidden)
       continue;
-    item[field.name] = defaultValueForNewEntry(field, today);
+    item[field.name] = seedValueForRequiredField(field, today);
   }
   return item;
 }
+function isDeclaredDerived(field) {
+  return field.derivedDeclared === true || field.layout?.derivedFrom !== undefined;
+}
 function blankRequiredFields(fields, frontmatter) {
-  return fields.filter((field) => field.required && !(field.hidden ?? field.layout?.hidden) && isBlankFieldValue(frontmatter[field.name])).map((field) => field.name);
+  return fields.filter((field) => field.required && !(field.hidden ?? field.layout?.hidden) && !isDeclaredDerived(field) && isBlankFieldValue(frontmatter[field.name])).map((field) => field.name);
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function prunedValue(value) {
+  if (Array.isArray(value))
+    return value.map(prunedValue).filter((item) => !isBlankFieldValue(item));
+  if (isPlainRecord(value))
+    return withoutBlankArrayItems(value);
+  return value;
+}
+function withoutBlankArrayItems(frontmatter) {
+  const out = {};
+  for (const [key, value] of Object.entries(frontmatter))
+    out[key] = prunedValue(value);
+  return out;
 }
 // ../cms-types/src/index.ts
 function isFieldType(value) {
   return FIELD_TYPES.includes(value);
 }
-var FIELD_TYPES;
+function isDerivedTransform(value) {
+  return DERIVED_TRANSFORMS.includes(value);
+}
+var FIELD_TYPES, DERIVED_TRANSFORMS;
 var init_src = __esm(() => {
   FIELD_TYPES = [
     "text",
@@ -7351,15 +7399,16 @@ var init_src = __esm(() => {
     "object",
     "reference"
   ];
+  DERIVED_TRANSFORMS = ["slugifyHref", "slug", "copy"];
 });
 
 // ../cms-core/src/editor-write-model.ts
-function newEntryFrontmatter(fields, today) {
+function newEntryFrontmatter(fields) {
   const frontmatter = {};
   for (const field of fields) {
     if (field.name === "title" || field.hidden)
       continue;
-    frontmatter[field.name] = defaultValueForNewEntry(field, today);
+    frontmatter[field.name] = blankFieldValue(field);
   }
   return frontmatter;
 }
@@ -7432,16 +7481,27 @@ function rejectionFinding(action, issue, kind, written) {
   finding.hint = hintFor(kind, valueAt(written, issue.path));
   return finding;
 }
+function scalarItemType(field) {
+  if (field.reference?.isArray)
+    return "reference";
+  if (field.type !== "array")
+    return;
+  return field.itemType === undefined || field.itemType === "object" ? undefined : field.itemType;
+}
 function blankItemsFor(field, current, today) {
+  const scalar = scalarItemType(field);
+  if (scalar !== undefined)
+    return [blankFieldValue({ name: field.name, type: scalar })];
   const itemFields = field.fields ?? [];
   if (itemFields.length > 0) {
     return [newRepeaterItem(itemFields.map((item) => ({ ...toWriteModelField(item), required: item.required })), today)];
   }
-  if (current.length === 0)
-    return [{}, { name: "" }];
   const first = current[0];
-  const template = isPlainObject(first) ? Object.fromEntries(Object.keys(first).map((key) => [key, ""])) : {};
-  return [{}, template];
+  if (isPlainObject(first))
+    return [{}, Object.fromEntries(Object.keys(first).map((key) => [key, ""]))];
+  if (field.itemType !== "object")
+    return [];
+  return current.length === 0 ? [{}, { name: "" }] : [{}];
 }
 async function checkEditorWrites(input) {
   const findings = [];
@@ -7472,7 +7532,7 @@ async function checkEditorWrites(input) {
     const loaded = input.collections.get(name);
     const entries = loaded?.entries ?? [];
     const kind = loaded ? collectionKind(loaded, collection.loaderPattern) : "markdown";
-    const created = applyCreateRouteFields(omitEmptyOnCreate(newEntryFrontmatter(collection.fields.map(toWriteModelField), input.today)), kind, input.today);
+    const created = withoutBlankArrayItems(applyCreateRouteFields(omitEmptyOnCreate(newEntryFrontmatter(collection.fields.map(toWriteModelField))), kind, input.today));
     const guarded = new Set(blankRequiredFields(collection.fields, created));
     const createAction = `Creating a new entry in "${name}"`;
     const createVerdict = await parseWrite(schema, created);
@@ -7486,11 +7546,11 @@ async function checkEditorWrites(input) {
         report(createKey, rejectionFinding(createAction, issue, "create", created));
       }
     }
-    const repeaters = collection.fields.filter((field) => field.type === "array" && field.itemType === "object");
-    if (repeaters.length === 0)
+    const lists = collection.fields.filter(isListField);
+    if (lists.length === 0)
       continue;
     const seed = await firstAcceptedEntry(schema, entries);
-    for (const field of repeaters) {
+    for (const field of lists) {
       const key = `${name} add:${field.name}`;
       if (!seed) {
         const hasEntries = entries.some((entry) => entry.frontmatter !== undefined);
@@ -7509,7 +7569,7 @@ async function checkEditorWrites(input) {
       const existing = Array.isArray(current) ? current : [];
       const action = `Clicking "+ Add" on "${name}.${field.name}"`;
       for (const item of blankItemsFor(field, existing, input.today)) {
-        const written = { ...seed, [field.name]: [...existing, item] };
+        const written = withoutBlankArrayItems({ ...seed, [field.name]: [...existing, item] });
         const verdict = await parseWrite(schema, written);
         if ("threw" in verdict) {
           report(key, throwFinding(action, verdict.threw));
@@ -7528,7 +7588,7 @@ var CONFIG_FILE2 = "src/content.config.ts", toWriteModelField = (field) => ({ na
   file: CONFIG_FILE2,
   message: `${action} produces a write the schema throws on: ${threw}`,
   hint: "A schema that throws instead of returning an issue is usually a refinement reading a field this write does not carry. Guard it against a missing value \u2014 `astro sync` runs the same schema over the same record."
-});
+}), isListField = (field) => field.type === "array" || field.reference?.isArray === true;
 var init_check_write = __esm(() => {
   init_check_entries();
   init_editor_write_model();
@@ -22546,9 +22606,11 @@ function parseConfigSource(source, _sourcePath) {
       });
       continue;
     }
+    const fields = parseSchemaFields(schemaObject, bindings);
+    checkDerivedFromDeclarations(collectionName, fields);
     result.set(collectionName, {
       name: collectionName,
-      fields: parseSchemaFields(schemaObject, bindings),
+      fields,
       ...hasSkippedMembers(schemaObject) ? { partialFields: true } : {},
       loaderPattern,
       loaderBase,
@@ -23046,10 +23108,64 @@ function parseFieldLayoutFromObject(obj) {
         if (value.type === "BooleanLiteral")
           layout.hidden = value.value;
         break;
+      case "derivedFrom":
+        parseDerivedFromValue(value, layout);
+        break;
     }
   }
   return Object.keys(layout).length > 0 ? layout : undefined;
 }
+function parseDerivedFromValue(value, layout) {
+  if (value.type === "StringLiteral") {
+    if (value.value)
+      layout.derivedFrom = value.value;
+    return;
+  }
+  if (value.type !== "ObjectExpression")
+    return;
+  let field;
+  let transform;
+  for (const prop of value.properties) {
+    if (prop.type !== "ObjectProperty")
+      continue;
+    const key = propertyKeyName(prop.key);
+    if (prop.value.type !== "StringLiteral")
+      continue;
+    if (key === "field")
+      field = prop.value.value;
+    else if (key === "transform" && isDerivedTransform(prop.value.value))
+      transform = prop.value.value;
+  }
+  if (!field)
+    return;
+  layout.derivedFrom = field;
+  if (transform)
+    layout.derivedTransform = transform;
+}
+function checkDerivedFromDeclarations(collectionName, fields) {
+  const siblingNames = new Set(fields.map((f) => f.name));
+  for (const field of fields) {
+    const source = field.layout?.derivedFrom;
+    if (source !== undefined && !siblingNames.has(source)) {
+      console.warn(`[cms] collection "${collectionName}": field "${field.name}" derives from "${source}", which is not a field of this collection` + ` \u2014 the field is hidden and nothing is ever computed for it`);
+    }
+    dropNestedDerivedFrom(collectionName, field.name, field.fields);
+  }
+}
+function dropNestedDerivedFrom(collectionName, path2, fields) {
+  if (!fields)
+    return;
+  for (const field of fields) {
+    const fieldPath = `${path2}.${field.name}`;
+    const layout = field.layout;
+    if (layout?.derivedFrom !== undefined) {
+      console.warn(`[cms] collection "${collectionName}": field "${fieldPath}" declares \`derivedFrom\` on a nested field, which is not supported` + ` \u2014 only top-level fields derive, so the declaration is ignored and the field stays editable`);
+      delete layout.derivedFrom;
+      delete layout.derivedTransform;
+    }
+    dropNestedDerivedFrom(collectionName, fieldPath, field.fields);
+  }
+}
 var import_parser, FIELD_HELPER_TYPES, VALID_HINT_KEYS, WRAPPER_METHODS;
 var init_content_config_ast = __esm(() => {
   init_src();
@@ -23808,6 +23924,14 @@ function applyParsedFieldLayout(field, pf) {
     field.order = layout.order;
   if (layout.sidebar)
     field.position = "sidebar";
+  if (layout.derivedFrom) {
+    field.derivedFrom = layout.derivedFrom;
+    field.derivedDeclared = true;
+    if (layout.derivedTransform)
+      field.derivedTransform = layout.derivedTransform;
+    field.hidden = layout.hidden ?? true;
+    return;
+  }
   if (layout.hidden)
     field.hidden = true;
 }