@ukiahinsure/a2ui-react-adapter 0.1.5 → 0.1.7

package/dist/index.js

@@ -215,12 +215,16 @@ var A2UIClientAdapter = class {
       envelope.surfaceId,
       this.#persistedListRowsByPath
     );
-    const nextStructure = updateSurfaceStructures(
+    const actionCompleteMessages = ensureOptionalCoverageSkipActionMessages(
       rawMessages,
+      envelope.surfaceId
+    );
+    const nextStructure = updateSurfaceStructures(
+      actionCompleteMessages,
       envelope.kind === "snapshot" ? /* @__PURE__ */ new Map() : cloneSurfaceStructures(this.#structureBySurface)
     );
     const messages = normalizeChoiceValuesInMessages(
-      rawMessages,
+      actionCompleteMessages,
       envelope.surfaceId,
       nextStructure.get(envelope.surfaceId)
     );
@@ -290,11 +294,39 @@ var A2UIClientAdapter = class {
       sourceComponentId: action.sourceComponentId,
       context: { ...action.context }
     };
+    const submittedProviderRow = submittedProviderRowFromEvent(event);
+    if (submittedProviderRow !== void 0) {
+      this.#rememberSubmittedProviderRow(
+        event.surfaceId,
+        submittedProviderRow,
+        event.context
+      );
+    }
     this.#options.onAction?.(event);
     for (const listener of this.#actionListeners) {
       listener(event);
     }
   }
+  #rememberSubmittedProviderRow(surfaceId, row, context) {
+    const rows = upsertListRow(
+      this.#persistedListRowsByPath.get("needs.providers") ?? [],
+      row
+    );
+    this.#persistedListRowsByPath.set("needs.providers", rows);
+    const surface = this.#processor.model.getSurface(surfaceId);
+    if (surface === void 0) {
+      return;
+    }
+    surface.dataModel.set("/needs.providers", cloneJsonArray(rows));
+    surface.dataModel.set("/needs/providers", cloneJsonArray(rows));
+    clearSubmittedProviderDraft(surface.dataModel, context);
+    removeSubmittedProviderDraftControls(
+      surface.componentsModel.entries,
+      eventSourceFieldPaths(context),
+      context
+    );
+    this.#notify();
+  }
   #snapshotMessages() {
     const messages = [];
     for (const surface of this.#processor.model.surfacesMap.values()) {
@@ -364,6 +396,201 @@ function cloneSurfaceStructures(source) {
     ])
   );
 }
+function ensureOptionalCoverageSkipActionMessages(messages, surfaceId) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!isRecord(message) || !isRecord(message.updateComponents)) {
+      continue;
+    }
+    const update = message.updateComponents;
+    if (update.surfaceId !== surfaceId || !Array.isArray(update.components)) {
+      continue;
+    }
+    const submit = update.components.find(
+      (component) => isRecord(component) && isNonEmptyString(component.id) && hasActionName(component, "flow.submit")
+    );
+    if (!isRecord(submit) || !isNonEmptyString(submit.id)) {
+      return messages;
+    }
+    const optionalCoverageField = optionalCoverageFieldName(
+      update.components,
+      submit.id
+    );
+    if (optionalCoverageField === void 0) {
+      continue;
+    }
+    const patchedSubmit = submitActionWithDefaultUnknown(
+      submit,
+      optionalCoverageField
+    );
+    const hasSkip = update.components.some(
+      (component) => hasActionName(component, "flow.skip")
+    );
+    if (hasSkip && patchedSubmit === submit) {
+      return messages;
+    }
+    if (hasSkip) {
+      const nextMessages2 = [...messages];
+      nextMessages2[index] = {
+        ...message,
+        updateComponents: {
+          ...update,
+          components: update.components.map(
+            (component) => component === submit ? patchedSubmit : component
+          )
+        }
+      };
+      return nextMessages2;
+    }
+    const parent = update.components.find(
+      (component) => isRecord(component) && Array.isArray(component.children) && component.children.includes(submit.id)
+    );
+    if (!isRecord(parent) || !Array.isArray(parent.children)) {
+      return messages;
+    }
+    const labelId = `${submit.id}:optional-skip-label`;
+    const buttonId = `${submit.id}:optional-skip`;
+    if (update.components.some(
+      (component) => isRecord(component) && (component.id === labelId || component.id === buttonId)
+    )) {
+      return messages;
+    }
+    const nextParent = {
+      ...parent,
+      children: parent.children.flatMap(
+        (child) => child === submit.id ? [buttonId, child] : [child]
+      )
+    };
+    const nextComponents = update.components.map(
+      (component) => component === parent ? nextParent : component === submit ? patchedSubmit : component
+    );
+    nextComponents.push(
+      {
+        id: labelId,
+        component: "Text",
+        text: "Skip"
+      },
+      {
+        id: buttonId,
+        component: "Button",
+        child: labelId,
+        action: {
+          event: {
+            name: "flow.submit",
+            context: { [optionalCoverageField]: "unknown" }
+          }
+        }
+      }
+    );
+    const nextMessages = [...messages];
+    nextMessages[index] = {
+      ...message,
+      updateComponents: {
+        ...update,
+        components: nextComponents
+      }
+    };
+    return nextMessages;
+  }
+  return messages;
+}
+function submitActionWithDefaultUnknown(submit, field) {
+  if (!isRecord(submit.action) || !isRecord(submit.action.event)) {
+    return submit;
+  }
+  const event = submit.action.event;
+  const context = isRecord(event.context) ? event.context : {};
+  if (Object.hasOwn(context, field)) {
+    return submit;
+  }
+  return {
+    ...submit,
+    action: {
+      ...submit.action,
+      event: {
+        ...event,
+        context: {
+          ...context,
+          [field]: "unknown"
+        }
+      }
+    }
+  };
+}
+function optionalCoverageFieldName(components, submitId) {
+  const statePrefix = componentStatePrefix(submitId);
+  if (statePrefix !== void 0) {
+    const stateField = optionalCoverageFieldFromFieldBindings(
+      components.filter(
+        (component) => isRecord(component) && isNonEmptyString(component.id) && component.id.startsWith(`${statePrefix}:`)
+      )
+    );
+    if (stateField !== void 0) {
+      return stateField;
+    }
+  }
+  const parent = components.find(
+    (component) => isRecord(component) && Array.isArray(component.children) && component.children.includes(submitId)
+  );
+  if (isRecord(parent) && Array.isArray(parent.children)) {
+    const childIds = new Set(parent.children.filter(isNonEmptyString));
+    const childField = optionalCoverageFieldFromFieldBindings(
+      components.filter(
+        (component) => isRecord(component) && isNonEmptyString(component.id) && childIds.has(component.id)
+      )
+    );
+    if (childField !== void 0) {
+      return childField;
+    }
+  }
+  return void 0;
+}
+function componentStatePrefix(componentId) {
+  const marker = ":action:";
+  const markerIndex = componentId.indexOf(marker);
+  if (markerIndex > 0) {
+    return componentId.slice(0, markerIndex);
+  }
+  const fallbackIndex = componentId.lastIndexOf(":");
+  return fallbackIndex > 0 ? componentId.slice(0, fallbackIndex) : void 0;
+}
+function optionalCoverageFieldFromFieldBindings(components) {
+  const normalized = components.flatMap((component) => componentFieldSearchText(component)).map(normalizeSearchText).join(" ");
+  if (normalized.includes("vatricarebenefits") || normalized.includes("coveragevatricarebenefits") || normalized.includes("tricareorchampvabenefits") || normalized.includes("vachampvabenefits")) {
+    return "va_tricare_benefits";
+  }
+  if (normalized.includes("employerunioncoverage") || normalized.includes("coverageemployerunioncoverage")) {
+    return "employer_union_coverage";
+  }
+  return void 0;
+}
+function componentFieldSearchText(component) {
+  if (!isRecord(component)) {
+    return [];
+  }
+  const values = [];
+  for (const key of ["label", "field"]) {
+    const value2 = component[key];
+    if (typeof value2 === "string") {
+      values.push(value2);
+    }
+  }
+  const value = component.value;
+  if (isRecord(value) && typeof value.path === "string") {
+    values.push(value.path);
+  }
+  return values;
+}
+function normalizeSearchText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function hasActionName(component, actionName) {
+  if (!isRecord(component) || !isRecord(component.action)) {
+    return false;
+  }
+  const event = component.action.event;
+  return isRecord(event) && event.name === actionName;
+}
 function updateSurfaceStructures(messages, structures) {
   for (const message of messages) {
     if (!isRecord(message)) {
@@ -581,12 +808,11 @@ function mergePersistedListRowsIntoMessages(messages, surfaceId, persistedRowsBy
 }
 function mergePersistedListRowsIntoRoot(root, persistedRowsByPath) {
   const merged = cloneJsonRecord(root);
-  const activeDraftListPaths = activeListDraftPaths(merged);
   for (const [listPath, rows] of persistedRowsByPath) {
     const dottedRows = merged[listPath];
     const nestedRows = getNestedValue(merged, listPath);
     const incomingRows = Array.isArray(dottedRows) ? dottedRows : Array.isArray(nestedRows) ? nestedRows : void 0;
-    const shouldPreserveCachedRows = rows.length > 0 && (incomingRows === void 0 || incomingRows.length === 0) && !activeDraftListPaths.has(listPath);
+    const shouldPreserveCachedRows = rows.length > 0 && (incomingRows === void 0 || incomingRows.length === 0 && (!hasListDraft(merged, listPath) || hasBlankListDraft(merged, listPath)));
     const effectiveRows = shouldPreserveCachedRows ? rows : incomingRows ?? rows;
     if (!Array.isArray(dottedRows) || shouldPreserveCachedRows) {
       merged[listPath] = cloneJsonArray(effectiveRows);
@@ -597,14 +823,32 @@ function mergePersistedListRowsIntoRoot(root, persistedRowsByPath) {
   }
   return merged;
 }
-function activeListDraftPaths(root) {
+function hasBlankListDraft(root, listPath) {
   const drafts = root.__listDrafts;
   if (!isRecord(drafts)) {
-    return /* @__PURE__ */ new Set();
+    return false;
   }
-  return new Set(
-    Object.keys(drafts).filter((listPath) => listPath.trim().length > 0)
-  );
+  const draft = drafts[listPath];
+  if (!isRecord(draft)) {
+    return false;
+  }
+  return Object.values(draft).every(isBlankDraftValue);
+}
+function hasListDraft(root, listPath) {
+  const drafts = root.__listDrafts;
+  return isRecord(drafts) && isRecord(drafts[listPath]);
+}
+function isBlankDraftValue(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0 || value.every(isBlankDraftValue);
+  }
+  return false;
 }
 function rememberPersistedListRows(persistedRowsByPath, root) {
   if (!isRecord(root)) {
@@ -614,6 +858,249 @@ function rememberPersistedListRows(persistedRowsByPath, root) {
     persistedRowsByPath.set(listPath, cloneJsonArray(rows));
   }
 }
+function submittedProviderRowFromEvent(event) {
+  if (event.actionName !== "flow.submit") {
+    return void 0;
+  }
+  const listPath = event.context.listPath;
+  if (listPath !== "needs.providers" && !hasProviderSubmitFields(event.context)) {
+    return void 0;
+  }
+  const name = firstTextField(event.context, [
+    "primary_care_provider",
+    "primaryCareProvider",
+    "primary_provider",
+    "primaryProvider",
+    "primary_care_doctor",
+    "primaryCareDoctor",
+    "pcp",
+    "providerName",
+    "provider_name",
+    "displayName",
+    "display_name",
+    "doctorName",
+    "doctorname",
+    "doctor_name",
+    "name"
+  ]);
+  const location = firstTextField(event.context, [
+    "primary_care_provider_location",
+    "primaryCareProviderLocation",
+    "provider_location",
+    "providerLocation",
+    "location_details",
+    "locationDetails",
+    "office_location",
+    "officeLocation",
+    "practice_location",
+    "practiceLocation",
+    "location",
+    "address"
+  ]);
+  if (name === void 0 && location === void 0) {
+    return void 0;
+  }
+  return {
+    itemId: "submitted-primary-care-provider",
+    ...name === void 0 ? {} : { primary_care_provider: name },
+    ...location === void 0 ? {} : { primary_care_provider_location: location },
+    __displayText: [
+      name === void 0 ? void 0 : `Provider Name: ${name}`,
+      location === void 0 ? void 0 : `Provider Location: ${location}`
+    ].filter((part) => part !== void 0).join(" | ")
+  };
+}
+function clearSubmittedProviderDraft(dataModel, context) {
+  for (const key of Object.keys(context)) {
+    if (key === "listPath") {
+      continue;
+    }
+    if (firstTextField(context, [key]) === void 0 || !isProviderSubmitField(key)) {
+      continue;
+    }
+    dataModel.set(`/__listDrafts/needs.providers/${key}`, "");
+  }
+}
+function removeSubmittedProviderDraftControls(entries, fieldPaths, context) {
+  const components = [...entries];
+  const controlIds = /* @__PURE__ */ new Set();
+  for (const [id, component] of components) {
+    if (component.type === "Button" && isProviderSubmitButton(component, context)) {
+      controlIds.add(id);
+      const child = component.properties.child;
+      if (typeof child === "string") {
+        controlIds.add(child);
+      }
+      continue;
+    }
+    if (component.type !== "TextField") {
+      continue;
+    }
+    const value = component.properties.value;
+    const label = component.properties.label;
+    if (isRecord(value) && typeof value.path === "string" && (fieldPaths.has(value.path) || isProviderDraftFieldPath(value.path)) || typeof label === "string" && isProviderSubmitLabel(label)) {
+      controlIds.add(id);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [id, component] of components) {
+      if (controlIds.has(id) || component.type === "Column") {
+        continue;
+      }
+      const children = component.properties.children;
+      if (Array.isArray(children) && children.length > 0 && children.every(
+        (child) => typeof child === "string" && controlIds.has(child)
+      )) {
+        controlIds.add(id);
+        changed = true;
+      }
+    }
+  }
+  for (const [, component] of components) {
+    const children = component.properties.children;
+    if (!Array.isArray(children)) {
+      continue;
+    }
+    const nextChildren = children.filter(
+      (child) => typeof child !== "string" || !controlIds.has(child)
+    );
+    if (nextChildren.length === children.length) {
+      continue;
+    }
+    component.properties = {
+      ...component.properties,
+      children: nextChildren
+    };
+  }
+}
+function isProviderSubmitButton(component, context) {
+  const action = component.properties.action;
+  if (!isRecord(action) || !isRecord(action.event)) {
+    return false;
+  }
+  const event = action.event;
+  return event.name === "flow.submit" && sameProviderSubmitContext(event.context, context);
+}
+function sameProviderSubmitContext(candidate, context) {
+  if (!isRecord(candidate) || candidate.listPath !== "needs.providers" && !hasProviderSubmitFields(candidate)) {
+    return false;
+  }
+  for (const key of Object.keys(context)) {
+    if (key === "listPath" || !isProviderSubmitField(key)) {
+      continue;
+    }
+    if (!(key in candidate)) {
+      return false;
+    }
+  }
+  return true;
+}
+function hasProviderSubmitFields(context) {
+  return Object.keys(context).some(
+    (key) => key !== "listPath" && isProviderSubmitField(key)
+  );
+}
+function isProviderSubmitField(key) {
+  return (/* @__PURE__ */ new Set([
+    "primary_care_provider",
+    "primaryCareProvider",
+    "primary_provider",
+    "primaryProvider",
+    "primary_care_doctor",
+    "primaryCareDoctor",
+    "pcp",
+    "providerName",
+    "provider_name",
+    "displayName",
+    "display_name",
+    "doctorName",
+    "doctorname",
+    "doctor_name",
+    "name",
+    "primary_care_provider_location",
+    "primaryCareProviderLocation",
+    "provider_location",
+    "providerLocation",
+    "location_details",
+    "locationDetails",
+    "office_location",
+    "officeLocation",
+    "practice_location",
+    "practiceLocation",
+    "location",
+    "address"
+  ])).has(key);
+}
+function eventSourceFieldPaths(context) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(context)) {
+    if (key === "listPath" || !isProviderSubmitField(key) || !isRecord(value)) {
+      continue;
+    }
+    const path = value.path;
+    if (typeof path === "string") {
+      paths.add(path);
+    }
+  }
+  return paths;
+}
+function isProviderDraftFieldPath(path) {
+  const prefix = "/__listDrafts/needs.providers/";
+  const field = path.startsWith(prefix) ? path.slice(prefix.length) : lastPathSegment(path);
+  return field !== void 0 && isProviderSubmitField(field);
+}
+function lastPathSegment(path) {
+  const normalized = path.trim().replaceAll("\\", "/");
+  const index = normalized.lastIndexOf("/");
+  const segment = index >= 0 ? normalized.slice(index + 1) : normalized;
+  return segment.length > 0 ? segment : void 0;
+}
+function isProviderSubmitLabel(label) {
+  switch (normalizeFieldKey(label)) {
+    case "provider_name":
+    case "primary_care_provider":
+    case "primary_care_provider_name":
+    case "provider_location":
+    case "primary_care_provider_location":
+    case "location_details":
+      return true;
+    default:
+      return false;
+  }
+}
+function normalizeFieldKey(key) {
+  return key.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "");
+}
+function upsertListRow(rows, row) {
+  const itemId = row.itemId;
+  if (typeof itemId !== "string" || itemId.length === 0) {
+    return [...rows, row];
+  }
+  const next = [...rows];
+  const existing = next.findIndex(
+    (candidate) => isRecord(candidate) && candidate.itemId === itemId
+  );
+  if (existing >= 0) {
+    next[existing] = row;
+    return next;
+  }
+  return [...next, row];
+}
+function firstTextField(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value !== "string") {
+      continue;
+    }
+    const text = value.trim();
+    if (text.length > 0) {
+      return text;
+    }
+  }
+  return void 0;
+}
 function listRowsFromRoot(root) {
   const rowsByPath = /* @__PURE__ */ new Map();
   for (const [key, value] of Object.entries(root)) {
@@ -796,6 +1283,7 @@ function A2UISurfaceHost({
           resolvedSurfaceMetadata?.fieldInteractions ?? []
         ),
         annotateActionControls(root),
+        suppressSkipForMandatoryFields(root, structure.fields),
         blockInvalidActionControls(root),
         setPendingGroupsDisabled(
           root,
@@ -1113,7 +1601,9 @@ function annotateActionControls(root) {
   );
   const groups = /* @__PURE__ */ new Set();
   for (const action of actions) {
+    const label = action.textContent?.trim().toLowerCase() ?? "";
     action.dataset.a2uiAction = "true";
+    action.dataset.a2uiActionLabel = label;
     if (action.parentElement !== null) {
       action.parentElement.dataset.a2uiActionGroup = "true";
       groups.add(action.parentElement);
@@ -1122,12 +1612,40 @@ function annotateActionControls(root) {
   return () => {
     for (const action of actions) {
       delete action.dataset.a2uiAction;
+      delete action.dataset.a2uiActionLabel;
     }
     for (const group of groups) {
       delete group.dataset.a2uiActionGroup;
     }
   };
 }
+function suppressSkipForMandatoryFields(root, fields) {
+  const requiredFields = fields.filter((field) => field.required);
+  if (requiredFields.length === 0 || requiredFields.every((field) => isOptionalCoverageField(field.field))) {
+    return () => void 0;
+  }
+  const skipButtons = [
+    ...root.querySelectorAll("[data-a2ui-action='true']")
+  ].filter((button) => button.dataset.a2uiActionLabel === "skip");
+  const originals = skipButtons.map((button) => ({
+    button,
+    hidden: button.hidden,
+    ariaHidden: button.getAttribute("aria-hidden")
+  }));
+  for (const button of skipButtons) {
+    button.hidden = true;
+    button.setAttribute("aria-hidden", "true");
+  }
+  return () => {
+    for (const original of originals) {
+      original.button.hidden = original.hidden;
+      restoreAttribute(original.button, "aria-hidden", original.ariaHidden);
+    }
+  };
+}
+function isOptionalCoverageField(field) {
+  return field === "employer_union_coverage" || field === "va_tricare_benefits" || field === "coverage.employerUnionCoverage" || field === "coverage.vaTricareBenefits";
+}
 var EMPTY_STRUCTURE = { fields: [], tabs: [] };
 var SurfaceErrorBoundary = class extends Component {
   state = { failedSurfaceId: void 0 };
@@ -1288,6 +1806,9 @@ function blockInvalidActionControls(root) {
     if (action === null || !root.contains(action)) {
       return;
     }
+    if (action.dataset.a2uiActionLabel === "skip") {
+      return;
+    }
     const invalid2 = firstInvalidInput(root);
     if (invalid2 === void 0) {
       return;
@@ -1985,7 +2506,7 @@ function decodeRendererAction(event) {
     const listPath = event.context.listPath;
     if (typeof listPath === "string" && listPath.length > 0) {
       const fieldEntries2 = entries.filter(([key]) => key !== "listPath");
-      const fields3 = scalarFields(fieldEntries2);
+      const fields3 = scalarFields(fieldEntries2, listPath);
       if (fields3 === null) {
         return null;
       }
@@ -2015,7 +2536,7 @@ function decodeRendererAction(event) {
     const fieldEntries2 = entries.filter(
       ([key]) => key !== "listPath" && key !== "itemId"
     );
-    const fields2 = scalarFields(fieldEntries2);
+    const fields2 = scalarFields(fieldEntries2, listPath);
     if (action !== "flow.list.delete" && (fields2 === null || Object.keys(fields2).length === 0)) {
       return null;
     }
@@ -2045,17 +2566,69 @@ function decodeRendererAction(event) {
     }
   };
 }
-function scalarFields(entries) {
+function scalarFields(entries, listPath) {
   const fields = {};
   for (const [key, value] of entries) {
     const normalized = normalizeFieldValue(value);
     if (normalized === void 0) {
       return null;
     }
-    fields[key] = normalized;
+    fields[canonicalListFieldKey(listPath, key)] = normalized;
   }
   return fields;
 }
+function canonicalListFieldKey(listPath, key) {
+  if (listPath !== "needs.providers") {
+    return key;
+  }
+  switch (normalizeFieldKey2(key)) {
+    case "primary_care_provider":
+    case "primarycareprovider":
+    case "primarycare":
+    case "primary_care":
+    case "primary_care_doctor":
+    case "primary_doctor":
+    case "primarydoctor":
+    case "primary_provider":
+    case "primaryprovider":
+    case "pcp":
+    case "provider_name":
+    case "providername":
+    case "display_name":
+    case "displayname":
+      return "primary_care_provider";
+    case "primary_care_provider_location":
+    case "primarycareproviderlocation":
+    case "primarycarelocation":
+    case "primary_care_location":
+    case "provider_location":
+    case "providerlocation":
+    case "doctor_location":
+    case "doctorlocation":
+    case "doctor_address":
+    case "doctoraddress":
+    case "location_details":
+    case "locationdetails":
+    case "provider_address":
+    case "provideraddress":
+    case "office_location":
+    case "officelocation":
+    case "practice_location":
+    case "practicelocation":
+    case "city":
+    case "city_state":
+    case "cityandstate":
+    case "city_and_state":
+    case "location":
+    case "address":
+      return "primary_care_provider_location";
+    default:
+      return key;
+  }
+}
+function normalizeFieldKey2(key) {
+  return key.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "");
+}
 function isSameLogicalAction(envelope, candidate) {
   return envelope.action === candidate.action && JSON.stringify(envelope.payload) === JSON.stringify(candidate.payload);
 }