form0-core 0.1.25 → 0.2.0

package/src/utilities/ai-metadata.js

@@ -38,7 +38,11 @@ export function getFormAITasks(form) {
 
 export function getFormAINamingPolicy(form) {
   const metadata = getFormAIMetadata(form);
-  if (!metadata || typeof metadata.namingPolicy !== 'object' || Array.isArray(metadata.namingPolicy)) {
+  if (
+    !metadata ||
+    typeof metadata.namingPolicy !== 'object' ||
+    Array.isArray(metadata.namingPolicy)
+  ) {
     return null;
   }
   return metadata.namingPolicy;
@@ -78,7 +82,11 @@ export function isFieldAIInferrable(field) {
 
 export function getFieldAIChoicePolicy(field) {
   const metadata = getFieldAIMetadata(field);
-  if (!metadata || typeof metadata.choicePolicy !== 'object' || Array.isArray(metadata.choicePolicy)) {
+  if (
+    !metadata ||
+    typeof metadata.choicePolicy !== 'object' ||
+    Array.isArray(metadata.choicePolicy)
+  ) {
     return null;
   }
   return metadata.choicePolicy;
@@ -86,7 +94,11 @@ export function getFieldAIChoicePolicy(field) {
 
 export function getFieldAIProviderHints(field) {
   const metadata = getFieldAIMetadata(field);
-  if (!metadata || typeof metadata.providerHints !== 'object' || Array.isArray(metadata.providerHints)) {
+  if (
+    !metadata ||
+    typeof metadata.providerHints !== 'object' ||
+    Array.isArray(metadata.providerHints)
+  ) {
     return null;
   }
   return metadata.providerHints;

package/src/utilities/calculation-dependencies.js

@@ -260,12 +260,7 @@ function extractEvalCallArguments(code) {
 
       if (char === "'" && !inDoubleQuote && !inBacktick && !isEscapedCharacter(source, i)) {
         inSingleQuote = !inSingleQuote;
-      } else if (
-        char === '"' &&
-        !inSingleQuote &&
-        !inBacktick &&
-        !isEscapedCharacter(source, i)
-      ) {
+      } else if (char === '"' && !inSingleQuote && !inBacktick && !isEscapedCharacter(source, i)) {
         inDoubleQuote = !inDoubleQuote;
       } else if (
         char === '`' &&

package/src/utilities/calculation-expression-utils.js

@@ -10,6 +10,16 @@ export function isMultilineCalculationExpression(expression) {
 
 export function normalizeInlineCalculationExpression(expression) {
   const normalizedExpression = typeof expression === 'string' ? expression : '';
+  const expressionWithoutTrailingWhitespace = normalizedExpression.trimEnd();
 
-  return normalizedExpression.replace(/;+\s*$/u, '');
+  if (!expressionWithoutTrailingWhitespace.endsWith(';')) {
+    return normalizedExpression;
+  }
+
+  let expressionEnd = expressionWithoutTrailingWhitespace.length;
+  while (expressionEnd > 0 && expressionWithoutTrailingWhitespace[expressionEnd - 1] === ';') {
+    expressionEnd -= 1;
+  }
+
+  return expressionWithoutTrailingWhitespace.slice(0, expressionEnd);
 }

package/src/utilities/dataset-descriptors.js

@@ -6,6 +6,16 @@ import {
 
 const ROOT_DATASET_ID = '__root__';
 const CONTAINER_TYPES = new Set(['Section', 'BuildingPlanSection']);
+const TITLE_ELIGIBLE_FIELD_TYPES = new Set([
+  'TextField',
+  'NumericField',
+  'DateField',
+  'TimeField',
+  'SingleChoiceField',
+  'MultiChoiceField',
+  'BooleanField',
+  'CalculatedField',
+]);
 
 const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 
@@ -79,6 +89,8 @@ const toRepeatableLabel = (field) =>
   toTrimmedString(field?.key) ??
   'Repeatable section';
 
+const cloneTitleField = (value) => (isRecord(value) ? { ...value } : null);
+
 const normalizeCalculatedDisplayStyle = (value) => {
   const normalized = toTrimmedString(value);
   if (!normalized) {
@@ -435,6 +447,7 @@ const buildDatasetFieldDescriptor = (field, dataset) => {
     data_name: toTrimmedString(field.data_name),
     label: toFieldLabel(field),
     field_type: toTrimmedString(field.type) ?? 'UnknownField',
+    title_eligible: TITLE_ELIGIBLE_FIELD_TYPES.has(field.type),
     export_kind: getFieldExportKind(field),
     choices: Array.isArray(field.choices)
       ? field.choices.filter((choice) => isRecord(choice)).map((choice) => ({ ...choice }))
@@ -510,6 +523,7 @@ const collectRepeatableDatasets = (elements, context, datasets) => {
       root_dataset_id: ROOT_DATASET_ID,
       location_enabled: toBooleanOrDefault(element.location_enabled),
       location_required: toBooleanOrDefault(element.location_required),
+      title_field: cloneTitleField(element.title_field),
       fields: [],
     };
 
@@ -548,6 +562,7 @@ export function buildDatasetDescriptors(schema) {
     root_dataset_id: ROOT_DATASET_ID,
     location_enabled: toBooleanOrDefault(formNode.location_enabled),
     location_required: toBooleanOrDefault(formNode.location_required),
+    title_field: cloneTitleField(formNode.title_field),
     fields: [],
   };
 
@@ -669,6 +684,138 @@ export function projectDatasetRowValues(descriptor, rowValues) {
   };
 }
 
+const toLiveChoiceDisplayValues = (field, rawValue) => {
+  if (rawValue === null || typeof rawValue === 'undefined') {
+    return [];
+  }
+
+  if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+    const matched = Array.isArray(field?.choices)
+      ? field.choices.find((choice) => choice?.value === rawValue)
+      : null;
+    return [matched?.label ?? rawValue];
+  }
+
+  const selectionKey = field?.field_type === 'MultiChoiceField' ? 'choices' : 'choice';
+  const selected = Array.isArray(rawValue[selectionKey]) ? rawValue[selectionKey] : [];
+  const other = Array.isArray(rawValue.other) ? rawValue.other : [];
+  const labels = selected.map((entry) => {
+    const value = isRecord(entry) ? entry.value : entry;
+    const matched = Array.isArray(field?.choices)
+      ? field.choices.find((choice) => choice?.value === value)
+      : null;
+    return matched?.label ?? (isRecord(entry) ? (entry.label ?? entry.value) : entry);
+  });
+
+  other.forEach((entry) => {
+    labels.push(isRecord(entry) ? (entry.label ?? entry.value) : entry);
+  });
+
+  return labels.filter((entry) => entry !== null && typeof entry !== 'undefined');
+};
+
+const toTitleDisplayValue = (field, rawValue) => {
+  if (
+    isRecord(rawValue) &&
+    ['choice', 'choices', 'other'].some((key) =>
+      Object.prototype.hasOwnProperty.call(rawValue, key)
+    )
+  ) {
+    return toLiveChoiceDisplayValues(field, rawValue);
+  }
+
+  if (
+    field?.field_type === 'SingleChoiceField' ||
+    field?.field_type === 'MultiChoiceField' ||
+    field?.field_type === 'BooleanField'
+  ) {
+    if (!isRecord(rawValue)) {
+      return toLiveChoiceDisplayValues(field, rawValue);
+    }
+    return readStoredChoiceDisplayValues(field, rawValue, {
+      context: 'resolveDatasetRowTitle',
+    });
+  }
+
+  return rawValue;
+};
+
+const toTitlePart = (value) => {
+  if (Array.isArray(value)) {
+    const parts = value.map(toTitlePart).filter(Boolean);
+    return parts.length > 0 ? parts.join(', ') : null;
+  }
+
+  if (typeof value === 'string') {
+    return toTrimmedString(value);
+  }
+
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  if (isRecord(value) && Object.prototype.hasOwnProperty.call(value, 'value')) {
+    return toTitlePart(value.value);
+  }
+
+  return null;
+};
+
+/**
+ * Resolve a derived title for one root or repeatable dataset row.
+ * Supports renderer/live values and canonical stored record values.
+ */
+export function resolveDatasetRowTitle(descriptor, rowValues) {
+  const titleField = isRecord(descriptor?.title_field) ? descriptor.title_field : null;
+  const references = Array.isArray(titleField?.elements) ? titleField.elements : [];
+  if (!titleField || titleField.enabled === false || references.length === 0) {
+    return null;
+  }
+
+  const sourceRecord = isRecord(rowValues) ? rowValues : {};
+  const source = isRecord(sourceRecord.form_values) ? sourceRecord.form_values : sourceRecord;
+  const fields = Array.isArray(descriptor?.fields) ? descriptor.fields : [];
+  const fieldByReference = new Map();
+
+  fields.forEach((field) => {
+    if (field?.title_eligible !== true) {
+      return;
+    }
+    [
+      field.field_id,
+      field.output_key,
+      field.key,
+      field.data_name,
+      ...(field.aliases ?? []),
+    ].forEach((reference) => {
+      const normalized = toTrimmedString(reference);
+      if (normalized && !fieldByReference.has(normalized)) {
+        fieldByReference.set(normalized, field);
+      }
+    });
+  });
+
+  const parts = [];
+  references.forEach((reference) => {
+    const normalizedReference = toTrimmedString(reference);
+    const field = normalizedReference ? fieldByReference.get(normalizedReference) : null;
+    if (!field) {
+      return;
+    }
+    const rawValue = readFirstAliasValue(source, field.aliases ?? []);
+    const part = toTitlePart(toTitleDisplayValue(field, rawValue));
+    if (part) {
+      parts.push(part);
+    }
+  });
+
+  return parts.length > 0 ? parts.join(', ') : null;
+}
+
 export function resolveDatasetDescriptorById(schema, datasetId) {
   return buildDatasetDescriptors(schema).find((dataset) => dataset.id === datasetId) ?? null;
 }

package/src/utilities/field-helpers.js

@@ -10,7 +10,11 @@ export function flattenFields(elements) {
   }
 
   return elements.flatMap((el) => {
-    if (el.type === 'Section' || el.type === 'RepeatableSection' || el.type === 'BuildingPlanSection') {
+    if (
+      el.type === 'Section' ||
+      el.type === 'RepeatableSection' ||
+      el.type === 'BuildingPlanSection'
+    ) {
       return [el, ...flattenFields(el.elements)];
     }
 

package/src/utilities/form-event-editor.js

@@ -17,11 +17,7 @@ const COMMON_GLOBAL_FUNCTIONS = new Set([
   'Boolean',
 ]);
 
-const STRUCTURAL_FIELD_TYPES = new Set([
-  'Section',
-  'RepeatableSection',
-  'BuildingPlanSection',
-]);
+const STRUCTURAL_FIELD_TYPES = new Set(['Section', 'RepeatableSection', 'BuildingPlanSection']);
 
 const FORM_EVENT_BUILTIN_STATUS_BY_NAME = Object.freeze({
   EVAL: 'advanced',
@@ -296,11 +292,7 @@ export function getFormEventReferenceCatalog({ schema }) {
  *   referencedFields: string[],
  * }}
  */
-export function analyzeFormEventCode({
-  code,
-  schema,
-  securityConfig = DEFAULT_SECURITY_CONFIG,
-}) {
+export function analyzeFormEventCode({ code, schema, securityConfig = DEFAULT_SECURITY_CONFIG }) {
   const issues = [];
   const issueKeys = new Set();
   const usedBuiltins = [];

package/src/utilities/form-link-helpers.js

@@ -235,16 +235,22 @@ export function applyLinkedRecordSelection({
   }
 
   if (!values || typeof values !== 'object') {
-    throw new Error('applyLinkedRecordSelection requires a values object from the form engine state');
+    throw new Error(
+      'applyLinkedRecordSelection requires a values object from the form engine state'
+    );
   }
 
   const field = resolveFormField(form, fieldIdentifier);
   if (!field) {
-    throw new Error(`applyLinkedRecordSelection could not find field "${fieldIdentifier}" in the provided form`);
+    throw new Error(
+      `applyLinkedRecordSelection could not find field "${fieldIdentifier}" in the provided form`
+    );
   }
 
   if (field.type !== 'FormLinkField') {
-    throw new Error(`applyLinkedRecordSelection can only target FormLinkField fields (received ${field.type})`);
+    throw new Error(
+      `applyLinkedRecordSelection can only target FormLinkField fields (received ${field.type})`
+    );
   }
 
   const normalizedRecords = normalizeLinkedRecords(records);
@@ -255,7 +261,8 @@ export function applyLinkedRecordSelection({
     );
   }
 
-  const selectedRecords = field.allow_multiple_records === true ? normalizedRecords : normalizedRecords.slice(0, 1);
+  const selectedRecords =
+    field.allow_multiple_records === true ? normalizedRecords : normalizedRecords.slice(0, 1);
 
   values[field.data_name] = selectedRecords.map((record) => ({
     record_id: record.record_id,
@@ -275,7 +282,11 @@ export function applyLinkedRecordSelection({
       }
 
       if (field.allow_multiple_records === true) {
-        const aggregated = aggregateDefaultValues(selectedRecords, mapping.source_field_id, delimiter);
+        const aggregated = aggregateDefaultValues(
+          selectedRecords,
+          mapping.source_field_id,
+          delimiter
+        );
         values[destinationField.data_name] = aggregated;
         return;
       }

package/src/utilities/record-transformer.js

@@ -6,6 +6,7 @@
 import { FIELD_SPECS } from '../schema/field-specs.js';
 import { recordVersion } from './version-utils.js';
 import { buildRepeatableMetadata } from './repeatable-helpers.js';
+import { buildDatasetDescriptors, resolveDatasetRowTitle } from './dataset-descriptors.js';
 
 const hasMeaningfulValue = (value) => {
   if (value === null || value === undefined) {
@@ -178,26 +179,44 @@ export function createStructuredRecord(state, fields = null, options = {}, id =
       dataNameToFieldMap.set(field.data_name, field);
     });
   }
-  // Create mapping from key to field for title resolution
-  const keyToFieldMap = new Map();
-  if (Array.isArray(fields)) {
-    fields.forEach((field) => {
-      if (field.key) keyToFieldMap.set(field.key, field);
-    });
-  }
-
   // Build a comprehensive tree structure for nested RepeatableSections
   const elementsSource = Array.isArray(options.originalElements)
     ? options.originalElements
     : Array.isArray(fields)
-    ? fields
-    : [];
-
-  const {
-    repeatableSectionTree,
-    fieldOwnership,
-    sectionFields,
-  } = buildRepeatableMetadata(elementsSource);
+      ? fields
+      : [];
+
+  const { repeatableSectionTree, fieldOwnership, sectionFields } =
+    buildRepeatableMetadata(elementsSource);
+
+  const titleDatasetDescriptors = buildDatasetDescriptors({
+    form: {
+      elements: elementsSource,
+      title_field: options.title_field || null,
+    },
+  });
+  const rootTitleDescriptor = titleDatasetDescriptors.find(
+    (descriptor) => descriptor.kind === 'root'
+  );
+  const repeatableTitleDescriptors = new Map();
+  titleDatasetDescriptors.forEach((descriptor) => {
+    if (descriptor.kind !== 'repeatable') {
+      return;
+    }
+    [descriptor.repeatable_field_id, descriptor.repeatable_output_key].forEach((reference) => {
+      if (reference) {
+        repeatableTitleDescriptors.set(reference, descriptor);
+      }
+    });
+  });
+
+  const resolveRepeatableTitle = (repInfo, rowValues) => {
+    const descriptor =
+      repeatableTitleDescriptors.get(repInfo?.preferredKey) ||
+      repeatableTitleDescriptors.get(repInfo?.field?.key) ||
+      repeatableTitleDescriptors.get(repInfo?.field?.data_name);
+    return descriptor ? resolveDatasetRowTitle(descriptor, rowValues) : null;
+  };
 
   const hasStructuredRepeatableState =
     state &&
@@ -237,12 +256,7 @@ export function createStructuredRecord(state, fields = null, options = {}, id =
 
     // Apply output formatting if field spec exists
     let processedValue = value;
-    if (
-      field &&
-      field.type &&
-      FIELD_SPECS[field.type] &&
-      FIELD_SPECS[field.type].outputProducer
-    ) {
+    if (field && field.type && FIELD_SPECS[field.type] && FIELD_SPECS[field.type].outputProducer) {
       try {
         processedValue = FIELD_SPECS[field.type].outputProducer(field, value);
       } catch (err) {
@@ -384,6 +398,10 @@ export function createStructuredRecord(state, fields = null, options = {}, id =
           childRecord.form_values[childOutputKey] = childRepeatableArray;
         }
 
+        if (repInfo.field?.title_field) {
+          childRecord['@title'] = resolveRepeatableTitle(repInfo, instanceValues);
+        }
+
         if (hasMeaningfulRecord(childRecord)) {
           childRecords.push(childRecord);
         }
@@ -498,6 +516,13 @@ export function createStructuredRecord(state, fields = null, options = {}, id =
           }
         }
 
+        if (repInfo.field?.title_field) {
+          childRecord['@title'] = resolveRepeatableTitle(
+            repInfo,
+            i === 0 ? state.values : childRecord.form_values
+          );
+        }
+
         if (hasMeaningfulRecord(childRecord)) {
           childRecords.push(childRecord);
         }
@@ -600,70 +625,8 @@ export function createStructuredRecord(state, fields = null, options = {}, id =
   // Add top-level @title and @status
   // ==============================
   try {
-    // Compute @title from TitleField elements if provided in options
-    const titleField = options.title_field;
-    if (titleField && Array.isArray(titleField.elements)) {
-      const parts = [];
-      for (const ref of titleField.elements) {
-        let fieldDef = null;
-        // Prefer key lookup
-        if (keyToFieldMap.has(ref)) {
-          fieldDef = keyToFieldMap.get(ref);
-        } else if (dataNameToFieldMap.has(ref)) {
-          fieldDef = dataNameToFieldMap.get(ref);
-        }
-        if (!fieldDef) continue;
-        const value = state.values[fieldDef.data_name];
-        if (value == null) continue;
-        // Extract display text by field type
-        if (fieldDef.type === 'SingleChoiceField') {
-          let labels = [];
-          if (value.choice && Array.isArray(value.choice) && value.choice.length > 0) {
-            const v = value.choice[0].value;
-            const found = (fieldDef.choices || []).find((c) => c.value === v);
-            labels.push(found?.label || value.choice[0].label || v);
-          }
-          if (value.other && Array.isArray(value.other)) {
-            for (const o of value.other) {
-              if (o && (o.label || o.value)) labels.push(o.label || o.value);
-            }
-          }
-          const text = labels.filter(Boolean).join(', ');
-          if (text) parts.push(text);
-        } else if (fieldDef.type === 'MultiChoiceField') {
-          let labels = [];
-          if (value.choices && Array.isArray(value.choices)) {
-            for (const c of value.choices) {
-              const found = (fieldDef.choices || []).find((cc) => cc.value === c.value);
-              labels.push(found?.label || c.label || c.value);
-            }
-          }
-          if (value.other && Array.isArray(value.other)) {
-            for (const o of value.other) {
-              if (o && (o.label || o.value)) labels.push(o.label || o.value);
-            }
-          }
-          const text = labels.filter(Boolean).join(', ');
-          if (text) parts.push(text);
-        } else if (fieldDef.type === 'BooleanField') {
-          let label = '';
-          if (value.choice && Array.isArray(value.choice) && value.choice.length > 0) {
-            const v = value.choice[0].value;
-            const found = (fieldDef.choices || []).find((c) => c.value === v);
-            label = found?.label || value.choice[0].label || v;
-          }
-          if (label) parts.push(label);
-        } else {
-          const text = typeof value === 'object' ? null : String(value);
-          if (text && text.trim() !== '') parts.push(text);
-        }
-      }
-      const titleText = parts.join(', ');
-      if (titleText) {
-        record['@title'] = titleText;
-      } else {
-        record['@title'] = null;
-      }
+    if (options.title_field && rootTitleDescriptor) {
+      record['@title'] = resolveDatasetRowTitle(rootTitleDescriptor, state.values);
     }
   } catch (err) {
     console.warn('[form0] createStructuredRecord: failed to compute @title:', err);

package/src/utilities/repeatable-helpers.js

@@ -19,11 +19,12 @@ export function buildRepeatableSectionTree(
   fieldOwnership = new Map(),
   sectionFields = new Set()
 ) {
-  if (!Array.isArray(elements)) return {
-    repeatableSectionTree,
-    fieldOwnership,
-    sectionFields,
-  };
+  if (!Array.isArray(elements))
+    return {
+      repeatableSectionTree,
+      fieldOwnership,
+      sectionFields,
+    };
 
   elements.forEach((element) => {
     if (element.type === 'Section' || element.type === 'BuildingPlanSection') {