@ukiahinsure/a2ui-react-adapter 0.1.10 → 0.1.11

package/dist/index.js

@@ -1500,6 +1500,7 @@ function A2UISurfaceHost({
           validationSummaryId
         ),
         formatFieldLabels(root),
+        annotateSavedLoopTables(root),
         bindFieldInteractionGroups(
           root,
           resolvedSurfaceMetadata?.fieldInteractions ?? [],
@@ -2165,12 +2166,434 @@ function formatFieldLabels(root) {
     originals.set(label, label.textContent ?? "");
     label.textContent = displayFieldLabel(field);
   }
+  for (const element of root.querySelectorAll("*")) {
+    if (!isGeneratedTextElement(element) || originals.has(element)) {
+      continue;
+    }
+    const field = generatedFieldLabelName(element.textContent ?? "");
+    if (field === void 0) {
+      continue;
+    }
+    originals.set(element, element.textContent ?? "");
+    element.textContent = displayFieldLabel(field);
+  }
   return () => {
     for (const [label, text] of originals) {
       label.textContent = text;
     }
   };
 }
+function generatedFieldLabelName(text) {
+  const trimmed = text.trim();
+  const unwrapped = trimmed.startsWith("*") && trimmed.endsWith("*") ? trimmed.slice(1, -1).trim() : trimmed;
+  return /^[A-Za-z][A-Za-z0-9_]*$/.test(unwrapped) && /[_A-Z]/.test(unwrapped) ? unwrapped : void 0;
+}
+function annotateSavedLoopTables(root) {
+  const originals = /* @__PURE__ */ new Map();
+  const textOriginals = /* @__PURE__ */ new Map();
+  const remember = (element) => {
+    if (originals.has(element)) {
+      return;
+    }
+    originals.set(element, {
+      loopTable: element.dataset.a2uiLoopTable,
+      loopRow: element.dataset.a2uiLoopRow,
+      loopHeader: element.dataset.a2uiLoopHeader,
+      loopField: element.dataset.a2uiLoopField,
+      loopCell: element.dataset.a2uiLoopCell,
+      loopColumn: element.dataset.a2uiLoopColumn,
+      loopColumnCount: element.dataset.a2uiLoopColumnCount,
+      loopLabel: element.dataset.a2uiLoopLabel,
+      generatedHeader: element.dataset.a2uiLoopGeneratedHeader,
+      hidden: element.getAttribute("hidden"),
+      ariaHidden: element.getAttribute("aria-hidden")
+    });
+  };
+  const setText = (element, text) => {
+    if (!textOriginals.has(element)) {
+      textOriginals.set(element, element.textContent ?? "");
+    }
+    element.textContent = text;
+  };
+  const generatedElements = [];
+  const rows = [...root.querySelectorAll("div, section, article, li")].filter(
+    (row) => getSavedLoopRowFields(row).length > 0 && normalizedLoopSummaryFields(getSavedLoopSummaryFields(row)).length >= 2
+  );
+  for (const row of rows) {
+    const parent = row.parentElement;
+    if (parent !== null) {
+      remember(parent);
+      parent.dataset.a2uiLoopTable = "true";
+    }
+  }
+  const rowsByParent = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const parent = row.parentElement;
+    if (parent === null) {
+      continue;
+    }
+    const siblings = rowsByParent.get(parent) ?? [];
+    siblings.push(row);
+    rowsByParent.set(parent, siblings);
+  }
+  for (const siblings of rowsByParent.values()) {
+    const firstRow = siblings[0];
+    const parent = firstRow?.parentElement;
+    if (parent !== null && parent !== void 0 && firstRow !== void 0) {
+      const header = buildSavedLoopHeader(parent, firstRow);
+      if (header !== void 0) {
+        parent.dataset.a2uiLoopColumnCount = header.dataset.a2uiLoopColumnCount ?? void 0;
+        parent.insertBefore(header, firstRow);
+        generatedElements.push(header);
+      }
+    }
+    siblings.forEach((row, rowIndex) => {
+      remember(row);
+      row.dataset.a2uiLoopRow = "true";
+      row.dataset.a2uiLoopHeader = "false";
+      let columnIndex = 0;
+      for (const child of [...row.children]) {
+        if (!(child instanceof HTMLElement)) {
+          continue;
+        }
+        const button = child.matches("button") ? child : child.querySelector("button");
+        if (button !== null) {
+          const label = button.textContent?.trim().toLowerCase();
+          remember(child);
+          child.dataset.a2uiLoopCell = label === "save" ? "save" : "action";
+          if (label === "save") {
+            child.setAttribute("hidden", "");
+            child.setAttribute("aria-hidden", "true");
+          }
+          continue;
+        }
+        const fieldParts = getSavedLoopFieldParts(child);
+        if (fieldParts !== void 0) {
+          remember(child);
+          child.dataset.a2uiLoopField = "true";
+          const column = String(columnIndex + 1);
+          child.dataset.a2uiLoopColumn = column;
+          remember(fieldParts.label);
+          fieldParts.label.dataset.a2uiLoopCell = "label";
+          fieldParts.label.dataset.a2uiLoopColumn = column;
+          remember(fieldParts.value);
+          fieldParts.value.dataset.a2uiLoopCell = "value";
+          fieldParts.value.dataset.a2uiLoopColumn = column;
+          columnIndex += 1;
+          continue;
+        }
+        if (isSavedLoopSummary(child)) {
+          remember(child);
+          child.dataset.a2uiLoopCell = "summary";
+          child.setAttribute("hidden", "");
+          child.setAttribute("aria-hidden", "true");
+          continue;
+        }
+        remember(child);
+        child.dataset.a2uiLoopCell = columnIndex % 2 === 0 ? "label" : "value";
+        child.dataset.a2uiLoopColumn = String(Math.floor(columnIndex / 2) + 1);
+        columnIndex += 1;
+      }
+      normalizeSavedLoopRow(row, rowIndex, remember, setText, generatedElements);
+    });
+  }
+  return () => {
+    for (const [element, original] of originals) {
+      restoreDataset(element, "a2uiLoopTable", original.loopTable);
+      restoreDataset(element, "a2uiLoopRow", original.loopRow);
+      restoreDataset(element, "a2uiLoopHeader", original.loopHeader);
+      restoreDataset(element, "a2uiLoopField", original.loopField);
+      restoreDataset(element, "a2uiLoopCell", original.loopCell);
+      restoreDataset(element, "a2uiLoopColumn", original.loopColumn);
+      restoreDataset(element, "a2uiLoopColumnCount", original.loopColumnCount);
+      restoreDataset(element, "a2uiLoopLabel", original.loopLabel);
+      restoreDataset(
+        element,
+        "a2uiLoopGeneratedHeader",
+        original.generatedHeader
+      );
+      restoreAttribute(element, "hidden", original.hidden);
+      restoreAttribute(element, "aria-hidden", original.ariaHidden);
+    }
+    for (const [element, text] of textOriginals) {
+      element.textContent = text;
+    }
+    for (const element of generatedElements) {
+      element.remove();
+    }
+  };
+}
+function buildSavedLoopHeader(parent, firstRow) {
+  const fields = normalizedLoopSummaryFields(getSavedLoopSummaryFields(firstRow));
+  if (fields.length < 2) {
+    return void 0;
+  }
+  const header = parent.ownerDocument.createElement("div");
+  header.dataset.a2uiLoopGeneratedHeader = "true";
+  const columnCount = Math.min(fields.length, 3);
+  header.dataset.a2uiLoopColumnCount = String(columnCount);
+  fields.slice(0, columnCount).forEach((field, index) => {
+    const cell = parent.ownerDocument.createElement("div");
+    cell.dataset.a2uiLoopCell = "label";
+    cell.dataset.a2uiLoopColumn = String(index + 1);
+    cell.textContent = displayFieldLabel(field);
+    header.appendChild(cell);
+  });
+  const action = parent.ownerDocument.createElement("div");
+  action.dataset.a2uiLoopCell = "label";
+  action.dataset.a2uiLoopColumn = String(columnCount + 1);
+  action.textContent = "Action";
+  header.appendChild(action);
+  return header;
+}
+function normalizeSavedLoopRow(row, rowIndex, remember, setText, generatedElements) {
+  const summaryFields = normalizedLoopSummaryFields(getSavedLoopSummaryFields(row));
+  if (summaryFields.length < 2) {
+    return;
+  }
+  const columnCount = Math.min(summaryFields.length, 3);
+  row.dataset.a2uiLoopColumnCount = String(columnCount);
+  const fields = [...row.querySelectorAll("[data-a2ui-loop-field='true']")];
+  const summaryValues = getSavedLoopSummaryValues(row);
+  const action = row.querySelector("[data-a2ui-loop-cell='action']");
+  const orderedFields = summaryFields.slice(0, columnCount).map((fieldName) => {
+    const field = findSavedLoopField(fields, fieldName);
+    if (field !== void 0) {
+      return field;
+    }
+    const value = summaryValues.get(fieldName);
+    if (value === void 0) {
+      return void 0;
+    }
+    const generated = createSavedLoopField(row.ownerDocument, fieldName, value);
+    if (action !== null) {
+      row.insertBefore(generated, action);
+    } else {
+      row.appendChild(generated);
+    }
+    generatedElements.push(generated);
+    return generated;
+  }).filter((field) => field !== void 0);
+  orderedFields.forEach((field, index) => {
+    const column = String(index + 1);
+    remember(field);
+    field.dataset.a2uiLoopColumn = column;
+    const label = field.querySelector("[data-a2ui-loop-cell='label']");
+    const value = field.querySelector("[data-a2ui-loop-cell='value']");
+    if (label !== null) {
+      remember(label);
+      label.dataset.a2uiLoopColumn = column;
+      label.dataset.a2uiLoopCell = "label";
+      const displayLabel = displayFieldLabel(summaryFields[index] ?? "");
+      label.dataset.a2uiLoopLabel = displayLabel;
+      setText(label, displayLabel);
+    }
+    if (value !== null) {
+      remember(value);
+      value.dataset.a2uiLoopColumn = column;
+      value.dataset.a2uiLoopCell = "value";
+    }
+  });
+  if (action !== null) {
+    remember(action);
+    action.dataset.a2uiLoopColumn = String(columnCount + 1);
+  }
+  for (const field of fields) {
+    if (orderedFields.includes(field)) {
+      continue;
+    }
+    remember(field);
+    field.dataset.a2uiLoopCell = "save";
+    field.setAttribute("hidden", "");
+    field.setAttribute("aria-hidden", "true");
+  }
+}
+function findSavedLoopField(fields, summaryField) {
+  const expectedName = canonicalLoopFieldName(summaryField).toLowerCase();
+  const expectedLabel = displayFieldLabel(expectedName).toLowerCase();
+  return fields.find((field) => {
+    const parts = getSavedLoopFieldParts(field);
+    if (parts?.fieldName === void 0) {
+      return false;
+    }
+    const name = canonicalLoopFieldName(parts.fieldName).toLowerCase();
+    return name === expectedName || name === expectedLabel;
+  });
+}
+function createSavedLoopField(document, fieldName, value) {
+  const field = document.createElement("div");
+  field.dataset.a2uiLoopField = "true";
+  const label = document.createElement("span");
+  label.dataset.a2uiLoopCell = "label";
+  label.textContent = displayFieldLabel(fieldName);
+  const valueCell = document.createElement("div");
+  valueCell.dataset.a2uiLoopCell = "value";
+  valueCell.textContent = value;
+  field.append(label, valueCell);
+  return field;
+}
+function normalizedLoopSummaryFields(fields) {
+  const withoutInternal = uniqueStrings(
+    fields.map(canonicalLoopFieldName).filter(
+      (field) => !["itemid", "__displaytext", "role", "save", "delete", "action"].includes(
+        field.toLowerCase()
+      )
+    )
+  );
+  const providerFields = [
+    "doctor_name",
+    "doctor_location",
+    "specialization_type"
+  ];
+  const hasProviderFields = providerFields.some(
+    (field) => withoutInternal.includes(field)
+  );
+  if (hasProviderFields) {
+    return providerFields.filter((field) => withoutInternal.includes(field));
+  }
+  const prescriptionFields = [
+    "prescription_name",
+    "prescription_dosage",
+    "prescription_frequency",
+    "prescriptions"
+  ];
+  const hasPrescriptionFields = prescriptionFields.some(
+    (field) => withoutInternal.includes(field)
+  );
+  if (hasPrescriptionFields) {
+    return prescriptionFields.filter((field) => withoutInternal.includes(field));
+  }
+  const pharmacyFields = ["pharmacy_name", "pharmacy_type", "pharmacy_address"];
+  const hasPharmacyFields = pharmacyFields.some(
+    (field) => withoutInternal.includes(field)
+  );
+  if (hasPharmacyFields) {
+    return pharmacyFields.filter((field) => withoutInternal.includes(field));
+  }
+  const hospitalFields = ["hospital_name", "hospital_city_state"];
+  const hasHospitalFields = hospitalFields.some(
+    (field) => withoutInternal.includes(field)
+  );
+  if (hasHospitalFields) {
+    return hospitalFields.filter((field) => withoutInternal.includes(field));
+  }
+  return withoutInternal;
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const value of values) {
+    const key = value.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    output.push(value);
+  }
+  return output;
+}
+function getSavedLoopSummaryFields(row) {
+  const summary = [...row.children].find(
+    (child) => child instanceof HTMLElement && isSavedLoopSummary(child)
+  );
+  if (summary === void 0) {
+    return [];
+  }
+  return (summary.textContent ?? "").split(/\s+\|\s+/).map((part) => part.trim().match(/^\*?([^:*]+?)\*?\s*:/)?.[1]).filter((field) => field !== void 0);
+}
+function getSavedLoopSummaryValues(row) {
+  const summary = [...row.children].find(
+    (child) => child instanceof HTMLElement && isSavedLoopSummary(child)
+  );
+  const values = /* @__PURE__ */ new Map();
+  const text = summary?.textContent ?? "";
+  for (const part of text.split(/\s+\|\s+/)) {
+    const match = /^([^:]+):\s*(.*)$/.exec(part.trim());
+    if (match === null) {
+      continue;
+    }
+    const [, label, value] = match;
+    const fieldName = canonicalLoopFieldName(label ?? "");
+    if (fieldName && value !== void 0) {
+      values.set(fieldName, value.trim());
+    }
+  }
+  return values;
+}
+function getSavedLoopRowFields(row) {
+  if (row.dataset.a2uiActionGroup === "true" || row.querySelector("input, textarea, select") !== null || row.querySelector("button") === null) {
+    return [];
+  }
+  return [...row.children].filter(
+    (child) => child instanceof HTMLElement && !child.matches("button") && child.querySelector("button") === null && getSavedLoopFieldParts(child) !== void 0
+  );
+}
+function getSavedLoopFieldParts(element) {
+  if (!(element instanceof HTMLElement)) {
+    return void 0;
+  }
+  const children = [...element.children].filter(
+    (child) => child instanceof HTMLElement && !child.matches("button") && child.querySelector("button") === null
+  );
+  if (children.length < 2) {
+    return void 0;
+  }
+  const [label, value] = children;
+  if (label === void 0 || value === void 0) {
+    return void 0;
+  }
+  const labelText = label.textContent ?? "";
+  const fieldName = savedLoopFieldLabelName(labelText);
+  return fieldName !== void 0 || isLoopActionText(labelText) ? { fieldName, label, value } : void 0;
+}
+function savedLoopFieldLabelName(text) {
+  const trimmed = text.trim();
+  if (isLoopActionText(trimmed)) {
+    return void 0;
+  }
+  const generated = generatedFieldLabelName(trimmed);
+  if (generated !== void 0) {
+    return generated;
+  }
+  return LOOP_FIELD_LABELS.get(trimmed.replace(/\s+/g, " ").toLowerCase());
+}
+function canonicalLoopFieldName(text) {
+  const generated = generatedFieldLabelName(text);
+  if (generated !== void 0) {
+    return generated;
+  }
+  const normalized = text.trim().replace(/\s+/g, " ").toLowerCase();
+  const mapped = LOOP_FIELD_LABELS.get(normalized);
+  if (mapped !== void 0) {
+    return mapped;
+  }
+  return text;
+}
+function isLoopActionText(text) {
+  const normalized = text?.trim().toLowerCase();
+  return normalized === "save" || normalized === "delete";
+}
+var LOOP_FIELD_LABELS = /* @__PURE__ */ new Map([
+  ["role", "role"],
+  ["doctor name", "doctor_name"],
+  ["doctor location", "doctor_location"],
+  ["specialization type", "specialization_type"],
+  ["location", "location"],
+  ["prescription name", "prescription_name"],
+  ["prescription dosage", "prescription_dosage"],
+  ["prescription frequency", "prescription_frequency"],
+  ["pharmacy name", "pharmacy_name"],
+  ["pharmacy type", "pharmacy_type"],
+  ["pharmacy address", "pharmacy_address"],
+  ["hospital name", "hospital_name"],
+  ["hospital city state", "hospital_city_state"]
+]);
+function isSavedLoopSummary(element) {
+  if (element.children.length > 0) {
+    return false;
+  }
+  return /\b[A-Za-z][A-Za-z0-9_]*:\s*/.test(element.textContent ?? "");
+}
 function labelElementForControl(root, control) {
   if (control.id.length > 0) {
     const label2 = root.querySelector(