@spokane-folio/security-incident 1.0.28

package/src/components/incidents/helpers/cleanFormValues.js

@@ -0,0 +1,53 @@
+
+// intlDTFResolvedOptionsTZ = Intl.DateTimeFormat().resolvedOptions().timeZone
+const cleanFormValues = (formParamsObject, orgTZ, intlDTFResolvedOptionsTZ) => {
+  const trimmedTerm = formParamsObject.term?.trim();
+  const cleanedSearchParams = Object.keys(formParamsObject).reduce((acc, key) => {
+    const value = formParamsObject[key];
+
+    // includeSuppressed should only be sent when it is true
+    if (key === 'includeSuppressed' && value !== true) {
+      return acc; // skip when false or undefined
+    }
+
+    if ((key === 'currentTrespass' || key === 'expiredTrespass') && value !== true) {
+      return acc; //skip this key
+    };
+
+    // handle searchType when it is 'created-by' or 'witnessed-by'
+    // is case of use UI Select for those keys and move them to its own key outside of searchType
+    // so single source of truth (UI has options for searchType Select OR single text field filter)
+    if (key === 'searchType' && value === 'created-by' && trimmedTerm) {
+      acc['createdBy'] = trimmedTerm;
+      return acc; //skip adding 'searchType' and 'term'
+    } else if (key === 'searchType' && value === 'witnessed-by' && trimmedTerm) {
+      acc['witnessedBy'] = trimmedTerm;
+      return acc; //skip adding 'searchType' and 'term'
+    };
+
+    // check for searchType without term
+    if (key === 'searchType' && !trimmedTerm) {
+      return acc; //skip adding 'searchType' without 'term'
+    };
+
+    // if value is array and empty, skip it (locationValue, incidentTypeId)
+    if (Array.isArray(value) && value.length === 0) {
+      return acc; 
+    };
+
+    // add only non-empty, non-null, non-undefined values
+    if (value !== '' && value !== null && value !== undefined) {
+      acc[key] = key === 'term' ? trimmedTerm : value; 
+    };
+
+    return acc; 
+  }, {});
+
+  if (cleanedSearchParams.startDate && cleanedSearchParams.endDate) {
+    cleanedSearchParams.timezone = orgTZ || intlDTFResolvedOptionsTZ;
+  };
+
+  return cleanedSearchParams;
+};
+
+export default cleanFormValues;

package/src/components/incidents/helpers/computeEditedCustomers.js

@@ -0,0 +1,124 @@
+import { isSameHtml } from './isSameHtml.js';
+import deepNormalizeForComparison from './deepNormalizeForComparison.js';
+
+// ***** helpers ***** 
+const stripUIOnlyKeys = (cust = {}) => {
+  const {
+    associatedFirstName,
+    associatedLastName,
+    ...rest
+  } = cust || {};
+  return rest;
+};
+
+const deepMergeWithFallback = (fallback, curr) => {
+  if (Array.isArray(fallback) || Array.isArray(curr)) {
+    return Array.isArray(curr) ? curr : fallback;
+  }
+  if (fallback && typeof fallback === 'object' && curr && typeof curr === 'object') {
+    const out = { ...fallback };
+    for (const k of Object.keys(curr)) {
+      out[k] = deepMergeWithFallback(fallback[k], curr[k]);
+    }
+    return out;
+  }
+  return curr !== undefined ? curr : fallback;
+};
+
+// remove empty/whitespace-only keys from details, and text-normalize description
+const normalizeCustomerForComparison = (cust) => {
+  const {
+    details,
+    description = '',
+    ...rest
+  } = stripUIOnlyKeys(cust);
+
+  const canonTrespass = (() => {
+    const t = rest?.trespass;
+    if (!t) return undefined;
+
+    const raw = Array.isArray(t.exclusionOrTrespassBasedOn)
+      ? t.exclusionOrTrespassBasedOn
+      : [];
+
+    const ids = raw
+      .map(e =>
+        typeof e === 'string'
+          ? e
+          : (e?.id ?? e?.reasonId ?? e?.value ?? '')
+      )
+      .filter(Boolean);
+
+    // treat as set for meaningful change 
+    const uniqSortedIds = Array.from(new Set(ids)).sort();
+
+    return {
+      ...t,
+      exclusionOrTrespassBasedOn: uniqSortedIds,
+    };
+  })();
+
+  // strip whitespace-only or empty-string keys from details
+  const cleanedDetails = Object.entries(details || {}).reduce((acc, [k, v]) => {
+    const trimmed = typeof v === 'string' ? v.trim() : v;
+    if (trimmed !== '' && trimmed !== null && trimmed !== undefined) {
+      acc[k] = trimmed;
+    }
+    return acc;
+  }, {});
+  const hasRealDetails = Object.keys(cleanedDetails).length > 0;
+
+  const cleaned = {
+    ...rest,
+    ...(hasRealDetails ? { details: cleanedDetails } : {}),
+    ...(canonTrespass ? { trespass: canonTrespass } : {}),
+  };
+
+  // IMPORTANT: we keep description for HTML semantic equality first;
+  // only if it’s not empty do we store a text-normalized version for deep compare.
+  if (description && !isSameHtml(description, '')) {
+    const text = typeof window !== 'undefined'
+      ? new DOMParser().parseFromString(description, 'text/html').body.textContent.trim()
+      : description; // SSR safety fallback
+    cleaned.description = text;
+  };
+
+  return deepNormalizeForComparison(cleaned);
+};
+
+
+// ***** main ***** 
+const computeEditedCustomers = (initialFormData, allCustomers) => {
+  const edited = new Set();
+
+  for (const init of (initialFormData.customers || [])) {
+    const curr = (allCustomers || []).find(c => c.id === init.id);
+    if (!curr) {
+      // removed entirely => top-level change; not a per-customer edit here
+      continue;
+    }
+
+    // first, check HTML semantic equality for description (cheap early exit)
+    const initDesc = stripUIOnlyKeys(init).description;
+    const currDesc = stripUIOnlyKeys(curr).description;
+    if (!isSameHtml(initDesc, currDesc)) {
+      edited.add(init.id);
+      continue; // already edited; no need to do deeper compare
+    }
+
+    // merge current over initial so missing fields fall back
+    const merged = deepMergeWithFallback(init, curr);
+
+    // normalize both sides the same way (strip UI keys, clean details/description, normalize)
+    const normInit = normalizeCustomerForComparison(init);
+    const normCurr = normalizeCustomerForComparison(merged);
+
+    if (JSON.stringify(normInit) !== JSON.stringify(normCurr)) {
+      edited.add(init.id);
+    }
+  }
+
+  return edited;
+};
+
+export default computeEditedCustomers;

package/src/components/incidents/helpers/convertDateIgnoringTZ.js

@@ -0,0 +1,8 @@
+
+// used for rendering instance values where only the date is considered
+function convertDateIgnoringTZ(isoString) {
+  const [yyyy, mm, dd] = isoString.split('T')[0].split('-');
+  return `${mm}/${dd}/${yyyy}`;
+};
+
+export default convertDateIgnoringTZ;

package/src/components/incidents/helpers/convertUTCISOToLocalePrettyTime.js

@@ -0,0 +1,15 @@
+
+
+const convertUTCISOToLocalePrettyTime = (isoString) => {
+  const date = new Date(isoString);
+  if (isNaN(date)) {
+    return `Invalid ISO string`
+  }
+  return date.toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true
+  });
+}
+
+export default convertUTCISOToLocalePrettyTime;

package/src/components/incidents/helpers/convertUTCISOToPrettyDate.js

@@ -0,0 +1,19 @@
+
+const convertUTCISOToPrettyDate = (dateStr) => {
+  if (!dateStr || typeof dateStr !== 'string') return '';
+
+  try {
+    const date = new Date(dateStr);
+    if (isNaN(date.getTime())) return '';
+
+    return date.toLocaleDateString(undefined, {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit'
+    });
+  } catch {
+    return '';
+  }
+};
+
+export default convertUTCISOToPrettyDate;

package/src/components/incidents/helpers/decodeParamsToForm.js

@@ -0,0 +1,20 @@
+
+const decodeParamsToForm = (obj) => ({
+  searchType: obj.searchType || 'keyword',
+  term:            obj.term               || '',
+  locationValue:   obj.locationValue ? 
+    obj.locationValue.split(',') : [],
+  incidentTypeId:  obj.incidentTypeId ? 
+    obj.incidentTypeId.split(',') : [],
+  witnessedBy:     obj.witnessedBy        || '',
+  createdBy:       obj.createdBy          || '',
+  startDate:       obj.startDate          || '',
+  endDate:         obj.endDate            || '',
+  currentTrespass: obj.currentTrespass === 'true',
+  expiredTrespass: obj.expiredTrespass === 'true',
+  staffSuppress: obj.staffSuppress || 'non',
+  sort: obj.sort || '',
+  dir: obj.dir || ''
+});
+
+export default decodeParamsToForm;

package/src/components/incidents/helpers/deepNormalizeForComparison.js

@@ -0,0 +1,39 @@
+ 
+
+const deepNormalizeForComparison = (obj) => {
+  const DATE_KEYS = new Set(['dateOfOccurrence', 'endDateOfTrespass', 'date']);
+
+  const toLocalYMD = (d) => {
+    if (!d || typeof d !== 'string') return d;
+    const md = d.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+    if (md) {
+      const [ , mm, dd, yyyy ] = md;
+      return `${yyyy}-${mm}-${dd}`;
+    }
+    const iso = d.match(/^\d{4}-\d{2}-\d{2}T/);
+    if (iso) {
+      const date = new Date(d);
+      return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+    }
+    return d.trim();
+  };
+
+  if (Array.isArray(obj)) {
+    return obj.map(deepNormalizeForComparison);
+  }
+
+  if (obj && typeof obj === 'object') {
+    return Object.entries(obj)
+      .filter(([_, v]) => v !== undefined && v !== null && v !== '')
+      .sort(([a], [b]) => a.localeCompare(b))  // sort object keys
+      .reduce((acc, [k, v]) => {
+        acc[k] = typeof v === 'string'
+          ? (DATE_KEYS.has(k) ? toLocalYMD(v.trim()) : v.trim())
+          : deepNormalizeForComparison(v);
+        return acc;
+      }, {});
+  }
+  return obj;
+};
+
+export default deepNormalizeForComparison; 

package/src/components/incidents/helpers/extractFilterString.js

@@ -0,0 +1,12 @@
+
+import buildQueryString from "./buildQueryString";
+
+const extractFilterString = (params = {}) => {
+  // return valid URL if no params
+  if (Object.keys(params).length === 0) return "";
+
+  const { limit, offset, ...filters } = params; 
+  return buildQueryString(filters);
+}
+
+export default extractFilterString;

package/src/components/incidents/helpers/formatDateAndTimeToUTCISO.js

@@ -0,0 +1,14 @@
+/* 
+  - concatenate 'mm/dd/yyyy' string and 'HH:MM AM/PM' string and format 
+    to UTC ISO format 
+  @param {string} dateString - string set by DatePicker component
+  @param {string} timeString - string set by TimePicker component
+  @returns {string} ISO formatted date string, or null if input is not present
+*/
+const formatDateAndTimeToUTCISO = (dateString, timeString) => {
+  if (!dateString || !timeString) return null;
+  const utcDateTime = new Date(`${dateString} ${timeString}`).toISOString();
+  return utcDateTime
+};
+
+export default formatDateAndTimeToUTCISO;

package/src/components/incidents/helpers/formatDateToUTCISO.js

@@ -0,0 +1,14 @@
+/* 
+  - format 'mm/dd/yyyy' (local date) string to UTC ISO format date/time at start of day, with optional add offset in seconds
+  @param {string} dateString - string set by DatePicker component
+  @param {number} offsetInSeconds - Optional - defaults to 0
+  @returns {string|null} ISO formatted date string as local machine date, or null if input is not present (EX: If in Pacific Time and dateString = '01/02/2025', the return is '2025-01-02T08:00:00.000Z' or with optional offsetInSeconds ('01/02/2025', 1) the return is '2025-01-02T08:00:01.000Z')
+*/
+const formatDateToUTCISO = (dateString, offsetInSeconds = 0) => {
+  if (!dateString) return null;
+  const dateObj = new Date(dateString); // interprets as midnight in local tz
+  dateObj.setHours(0, 0, offsetInSeconds, 0); // force local time to midnight, offset seconds
+  return dateObj.toISOString(); // convert internal epoch time to UTC ISO 
+};
+
+export default formatDateToUTCISO;

package/src/components/incidents/helpers/formatTimeToUTCISO.js

@@ -0,0 +1,28 @@
+/* 
+  - format timeString to to UTC ISO w/ associated 'dateOfIncident'
+    as date value the string
+  @param {string} dateOfIncidentString - user inputted value from Datepicker 
+  component fed via formData 
+    (Ex: "10/30/2024")
+  @param {string} timeString - user inputted value from Timepicker component 
+    (Ex: "9:33 AM")
+  @returns {string} UTC ISO formatted datetime string, or null if input is not present
+    (Ex: '2024-10-16T17:27:00.000Z')
+*/
+
+const formatTimeToUTCISO = (dateOfIncidentString, timeString) => {
+  if (!dateOfIncidentString || !timeString) {
+    return null;
+  };
+
+  // check if timeString is already in ISO
+  if (!isNaN(Date.parse(timeString))) {
+    console.log("timeString: ", timeString)
+    return timeString;
+  }
+  const utcDateTime = new Date(`${dateOfIncidentString} ${timeString}`).toISOString();
+  // console.log("utcDateTime: ", utcDateTime)
+  return utcDateTime;
+}
+
+export default formatTimeToUTCISO;

package/src/components/incidents/helpers/getCurrentTime.js

@@ -0,0 +1,20 @@
+/* 
+  - @returns {string} 'hh:mm AM/PM' to populate in TimePicker component on initial render 
+*/
+
+const getCurrentTime = () => {
+  const now = new Date();
+  const hours = now.getHours();
+  const minutes = now.getMinutes();
+  const ampm = hours >= 12 ? 'PM' : 'AM';
+  const formattedHours = hours % 12 || 12; // 12-hour format
+  // console.log(`hours before format: ${hours} - formattedHours: ${formattedHours}`)
+  const formattedMinutes = minutes.toString().padStart(2, '0');
+  const currentTime = `${formattedHours}:${formattedMinutes} ${ampm}`
+  // return `${formattedHours}:${formattedMinutes} ${ampm}`
+  // console.log("@getCurrentTime - currentTime: ", currentTime)
+  return currentTime; 
+}
+
+// console.log(getCurrentTime());
+export default getCurrentTime;

package/src/components/incidents/helpers/getTodayDate.js

@@ -0,0 +1,12 @@
+/* 
+  - @returns {string} 'mm/dd/yyyy' to populate in DatePicker component on initial render 
+*/
+const getTodayDate = () => {
+  const today = new Date();
+  const day = String(today.getDate()).padStart(2, '0');
+  const month = String(today.getMonth() + 1).padStart(2, '0');
+  const year = today.getFullYear();
+  return `${month}/${day}/${year}`;
+};
+
+export default getTodayDate;

package/src/components/incidents/helpers/handlebarsHelpers.js

@@ -0,0 +1,148 @@
+import DOMPurify from 'dompurify';
+import { decode } from 'html-entities';
+import { FormattedMessage } from 'react-intl';
+import Handlebars from 'handlebars';
+import convertUTCISOToPrettyDate from './convertUTCISOToPrettyDate';
+
+export function registerHandlebarsHelpers({ 
+  locationDataOptions, 
+  trespassReasons,
+  self, 
+  triggerDocumentError 
+}) {
+
+  const reasonById = new Map((trespassReasons ?? []).map(tr => [tr.id, tr.reason]));
+  if (!Handlebars.helpers.resolveTrespassReasons) {
+    // no 'path', Handlebars handles scope on this one
+    // token -> {{resolveTrespassReasons customer.trespass.exclusionOrTrespassBasedOn}}
+    Handlebars.registerHelper('resolveTrespassReasons', function(list) {
+      try {
+        if (!Array.isArray(list) || list.length === 0) return '';
+
+        const seen = new Set();
+        const reasons = [];
+
+        for (const entry of list) {
+          // handle for prev set up / strays after migration - entry is a string id
+          if (typeof entry === 'string') {
+            const r = reasonById.get(entry);
+            if (r && !seen.has(r)) { reasons.push(r); seen.add(r); }
+            continue;
+          }
+
+          // current - entry is an object
+          if (entry && typeof entry === 'object') {
+            const id = entry.id ?? entry.reasonId ?? entry.value; 
+            const r = entry.reason ?? (id ? reasonById.get(id) : undefined);
+            if (r && !seen.has(r)) { reasons.push(r); seen.add(r); }
+          }
+        }
+
+        return reasons.join(', ');
+
+      } catch (error) {
+        triggerDocumentError?.(<FormattedMessage id="generate-trespass.error-doc-incTypes" values={{ error: error.message }} />);
+        return '';
+      }
+    });
+  }
+  if (!Handlebars.helpers.resolveIncTypes) {
+    // token -> {{resolveIncTypes "incident.incidentTypes.title"}}
+    Handlebars.registerHelper('resolveIncTypes', function(path) {
+      try {
+        const keys = path.split('.');
+        const propertyKey = keys.pop();
+        let arrayValue = this;
+        for (const key of keys) arrayValue = arrayValue?.[key];
+        if (!Array.isArray(arrayValue)) return '';
+        return arrayValue
+          .map(item => item?.[propertyKey] || '')
+          .filter(Boolean)
+          .join(', ');
+      } catch (error) {
+        triggerDocumentError?.(<FormattedMessage id="generate-trespass.error-doc-incTypes" values={{ error: error.message }} />);
+        return '';
+      }
+    });
+  }
+
+  if (!Handlebars.helpers.formatLocation) {
+    // tokens -> 
+    // {{formatLocation incident.incidentLocation}}
+    // {{formatLocation customer.trespass.declarationOfService.placeSigned}}
+    Handlebars.registerHelper('formatLocation', function(locationIdString) {
+      try {
+        const matched = locationDataOptions.find(loc => loc.value === locationIdString);
+        return matched?.label || locationIdString || '';
+      } catch (error) {
+        triggerDocumentError?.(<FormattedMessage id="generate-trespass.error-doc-locationIdString" values={{ error: error.message }} />);
+        return locationIdString || '';
+      }
+    });
+  }
+
+  if (!Handlebars.helpers.formatDate) {
+    // tokens ->
+    // {{formatDate (resolve "customer.trespass.dateOfOccurrence")}}
+    // {{formatDate (resolve "customer.trespass.declarationOfService.date")}}
+    // {{formatDate (resolve "customer.trespass.endDateOfTrespass")}}
+    Handlebars.registerHelper('formatDate', function(dateString) {
+      try {
+        return convertUTCISOToPrettyDate(dateString);
+      } catch (error) {
+        triggerDocumentError(<FormattedMessage id="generate-trespass.error-doc-formatDate" values={{ dateString, error: error.message }} />);
+        return '';
+      }
+    });
+  }
+
+  if (!Handlebars.helpers.resolve) {
+    // runs on customer keys and nested keys
+    Handlebars.registerHelper('resolve', function(path, options) {
+      try {
+        const keys = path.split('.');
+        let value = this;
+        for (const key of keys) value = value?.[key];
+        if (Array.isArray(value)) {
+          const prop = options.hash?.property;
+          return prop
+            ? value.map(item => item?.[prop] || '').join(', ')
+            : value.map(item => JSON.stringify(item)).join(', ');
+        }
+        return value ?? '';
+      } catch (error) {
+        triggerDocumentError(<FormattedMessage id="generate-trespass.error-doc-resolve" values={{ path, error: error.message }} />);
+        return '';
+      }
+    });
+  }
+
+  if (!Handlebars.helpers.trespassDescriptionPlain) {
+    // token -> {{{trespassDescriptionPlain}}}
+    Handlebars.registerHelper('trespassDescriptionPlain', function () {
+      try {
+        const html = this?.customer?.trespass?.description?.trim() || this?.customer?.trespass?.descriptionOfOccurrence?.trim() || '';
+
+        // preserve HTML blocks
+        const raw = decode(DOMPurify.sanitize(html, { USE_PROFILES: { html: true } }));
+        // return raw; 
+        return new Handlebars.SafeString(raw);
+      } catch (error) {
+        triggerDocumentError(<FormattedMessage id="generate-trespass.error-doc-descriptionPlainFallback" values={{ error: error.message }} />);
+        return '';
+      }
+    });
+  }
+
+  if (!Handlebars.helpers.declarationOfServiceIssuedBy) {
+    // token -> {{declarationOfServiceIssuedBy}} (is the logged in FOLIO user 'self')
+    Handlebars.registerHelper('declarationOfServiceIssuedBy', function () {
+      try {
+        return `${self?.lastName || ''}, ${self?.firstName || ''}` || 'User not found';
+      } catch (error) {
+        triggerDocumentError(<FormattedMessage id="generate-trespass.error-doc-declarationOfServiceIssuedBy" values={{ error: error.message }} />);
+        return '';
+      }
+    });
+  }
+};

package/src/components/incidents/helpers/hasFormChangedAtCreate.js

@@ -0,0 +1,50 @@
+
+const hasFormChangedAtCreate = ({
+  formData,
+  initialFormData,
+  selectedCustomers,
+  selectedWitnesses,
+  editorWasTouched,
+}) => {
+  // ignore these keys as they are populated on render
+  const keysToIgnore = ['dateOfIncident', 'timeOfIncident', 'id'];
+
+  if (selectedCustomers.length > 0) return true;
+  if (selectedWitnesses.length > 0) return true;
+  if (editorWasTouched) {
+    // we check for was touched instead of formData was mutated b/c of our onBlur pattern to mitigate 
+    // react-quill's cleanup <-> setState feedback loop.
+    // i.e. user inputs to Editor, doesn't make onBlur and clicks directly to 'cancel' the form 
+    // would not be considered 'dirty' as no update to formData. This editorWasTouch ref handles that case. 
+    return true;
+  }
+
+  for (const key in formData) {
+    if (keysToIgnore.includes(key)) continue;
+
+    const original = initialFormData[key] ?? null;
+    const current = formData[key] ?? null;
+
+    if (Array.isArray(original) && Array.isArray(current)) {
+      if (original.length !== current.length) {
+        return true;
+      }
+
+      if (JSON.stringify(original) !== JSON.stringify(current)) {
+        return true;
+      }
+    } else if (typeof original === 'string' || typeof current === 'string') {
+      if ((original || '').trim() !== (current || '').trim()) {
+        return true;
+      }
+    } else {
+      if (JSON.stringify(original) !== JSON.stringify(current)) {
+        return true;
+      }
+    }
+  };
+
+  return false;
+};
+
+export default hasFormChangedAtCreate;

package/src/components/incidents/helpers/hasTopLevelChangeAffectedDeclaration.js

@@ -0,0 +1,90 @@
+
+import { isSameHtml } from './isSameHtml.js';
+import deepNormalizeForComparison from './deepNormalizeForComparison.js';
+
+// intentionally does not consider:
+// selectedCustomers, customers add/remove, staffSuppressed,
+// isApproximateTime, media add/remove -> these should not force global 'Update declaration' 
+const hasTopLevelChangeAffectedDeclaration = (
+  initial,
+  current, 
+  selectedWitnesses
+) => {
+  const simpleKeys = [
+    'customerNa',
+    'incidentLocation',
+    'subLocation',
+    'dateTimeOfIncident',
+    'timeOfIncident'
+  ];
+
+  // return true if any changes to simple keys
+  for (const key of simpleKeys) {
+    if (current[key] !== initial[key]) {
+      return true;
+    }
+  };
+
+  // return true if any changes to top-level detailedDescriptionOfIncident
+  if (!isSameHtml(current.detailedDescriptionOfIncident, initial.detailedDescriptionOfIncident)) {
+    return true;
+  };
+
+  // return true if any new witnesses selected for saving
+  if (selectedWitnesses.length > 0) {
+    return true;
+  };
+
+  const getSortedIds = arr => (arr || []).map(i => i.id).sort();
+
+  // return true if relevant item is removed in UI
+  if (
+    JSON.stringify(getSortedIds(current.incidentTypes)) !== JSON.stringify(getSortedIds(initial.incidentTypes)) ||
+    JSON.stringify(getSortedIds(current.incidentWitnesses)) !== JSON.stringify(getSortedIds(initial.incidentWitnesses)) ||
+    JSON.stringify(getSortedIds(current.attachments)) !== JSON.stringify(getSortedIds(initial.attachments))
+  ) {
+    return true;
+  };
+
+  const normalizedWitness = (wit) => {
+    const {
+      id,
+      isCustom,
+      firstName = '',
+      lastName = '',
+      role = '',
+      phone = '',
+      email = '',
+    } = wit;
+
+    return deepNormalizeForComparison({
+      id, 
+      isCustom,
+      firstName: firstName.trim(),
+      lastName: lastName.trim(),
+      ...(role.trim() && { role: role.trim() }),
+      ...(phone.trim() && { phone: phone.trim() }),
+      ...(email.trim() && { email: email.trim() }),
+    });
+  };
+
+  const initialCustomWitnesses = (initial.incidentWitnesses || []).filter(w => w.isCustom);
+  const currentCustomWitnesses = (current.incidentWitnesses || []).filter(w => w.isCustom);
+
+  // check for any modified custom witness
+  for (const initWit of initialCustomWitnesses) {
+    const currWit = currentCustomWitnesses.find(w => w.id === initWit.id);
+    if (!currWit) return true; 
+
+    const normInit = normalizedWitness(initWit);
+    const normCurr = normalizedWitness(currWit);
+
+    if (JSON.stringify(normInit) !== JSON.stringify(normCurr)) {
+      return true;
+    };
+  };
+
+  return false; // no changes
+};
+
+export default hasTopLevelChangeAffectedDeclaration;