@striae-org/striae 4.2.1 → 4.3.1

package/app/routes/striae/striae.tsx

@@ -21,7 +21,7 @@ import { resolveEarliestAnnotationTimestamp } from '~/utils/ui';
 import { type AnnotationData, type FileData } from '~/types';
 import type * as CaseExportActions from '~/components/actions/case-export';
 import { checkCaseIsReadOnly, validateCaseNumber, renameCase, deleteCase, checkExistingCase, createNewCase, archiveCase, getCaseArchiveDetails } from '~/components/actions/case-manage';
-import { checkReadOnlyCaseExists } from '~/components/actions/case-review';
+import { checkReadOnlyCaseExists, deleteReadOnlyCase } from '~/components/actions/case-review';
 import { canCreateCase, getLimitsDescription, getUserData } from '~/utils/data';
 import styles from './striae.module.css';
 
@@ -413,6 +413,39 @@ export const Striae = ({ user }: StriaePage) => {
     }
   };
 
+  const handleClearROCase = async () => {
+    if (!currentCase) {
+      showNotification('No read-only case is currently loaded.', 'error');
+      return;
+    }
+
+    const caseToRemove = currentCase;
+    const confirmed = window.confirm(
+      `Clear the read-only case "${caseToRemove}" from the workspace? This will remove the imported review data. The original exported case is not affected.`
+    );
+
+    if (!confirmed) {
+      return;
+    }
+
+    try {
+      const success = await deleteReadOnlyCase(user, caseToRemove);
+      if (!success) {
+        showNotification(`Failed to fully clear read-only case "${caseToRemove}". Please try again.`, 'error');
+        return;
+      }
+      setCurrentCase('');
+      setFiles([]);
+      handleImageSelect({ id: 'clear', originalFilename: '/clear.jpg', uploadedAt: '' });
+      setShowNotes(false);
+      setIsAuditTrailOpen(false);
+      setIsRenameCaseModalOpen(false);
+      showNotification(`Read-only case "${caseToRemove}" cleared.`, 'success');
+    } catch (clearError) {
+      showNotification(clearError instanceof Error ? clearError.message : 'Failed to clear read-only case.', 'error');
+    }
+  };
+
   const handleArchiveCaseSubmit = async (archiveReason: string) => {
     if (!currentCase) {
       showNotification('Select a case before archiving.', 'error');
@@ -514,6 +547,7 @@ export const Striae = ({ user }: StriaePage) => {
   // Function to refresh annotation data (called when notes are saved)
   const refreshAnnotationData = () => {
     setAnnotationRefreshTrigger(prev => prev + 1);
+    setConfirmationSaveVersion(prev => prev + 1);
   };
 
   // Handle import/clear read-only case
@@ -522,6 +556,11 @@ export const Striae = ({ user }: StriaePage) => {
       if (result.caseNumber && result.isReadOnly) {
         // Successful read-only case import - load the case
         handleCaseChange(result.caseNumber);
+      } else if (result.caseNumber) {
+        setConfirmationSaveVersion(prev => prev + 1);
+        if (result.caseNumber === currentCase) {
+          refreshAnnotationData();
+        }
       } else if (!result.caseNumber && !result.isReadOnly) {
         // Read-only case cleared - reset all UI state
         setCurrentCase('');
@@ -722,6 +761,9 @@ export const Striae = ({ user }: StriaePage) => {
           void handleDeleteCaseAction();
         }}
         onArchiveCase={() => setIsArchiveCaseModalOpen(true)}
+        onClearROCase={() => {
+          void handleClearROCase();
+        }}
         onOpenViewAllFiles={() => setIsFilesModalOpen(true)}
         onDeleteCurrentFile={() => {
           void handleDeleteCurrentFileAction();
@@ -735,6 +777,7 @@ export const Striae = ({ user }: StriaePage) => {
           onOpenCase={() => {
             void handleOpenCaseModal();
           }}
+          onOpenCaseExport={() => setIsCaseExportModalOpen(true)}
           imageId={imageId}
           currentCase={currentCase}
           imageLoaded={imageLoaded}
@@ -745,6 +788,7 @@ export const Striae = ({ user }: StriaePage) => {
           setShowNotes={setShowNotes}
           onAnnotationRefresh={refreshAnnotationData}
           isReadOnly={isReadOnlyCase}
+          isArchivedCase={archiveDetails.archived}
           isConfirmed={!!annotationData?.confirmationData}
           confirmationSaveVersion={confirmationSaveVersion}
           isUploading={isUploading}

package/app/services/audit/audit-export-csv.ts

@@ -38,7 +38,8 @@ export const AUDIT_CSV_ENTRY_HEADERS = [
   'Total Files',
   'MFA Method',
   'Security Incident Type',
-  'Security Severity'
+  'Security Severity',
+  'Confirmed Files'
 ];
 
 export const formatForCSV = (value?: string | number | null): string => {
@@ -121,7 +122,8 @@ export const entryToCSVRow = (entry: ValidationAuditEntry): string => {
     caseDetails?.totalFiles?.toString() || '',
     formatForCSV(securityDetails?.mfaMethod),
     formatForCSV(securityDetails?.incidentType),
-    formatForCSV(securityDetails?.severity)
+    formatForCSV(securityDetails?.severity),
+    formatForCSV(caseDetails?.confirmedFileNames?.join('; '))
   ];
 
   return values.join(',');

package/app/services/audit/audit-export-report.ts

@@ -84,11 +84,13 @@ const generateConfirmationSummary = (entries: ValidationAuditEntry[]): string =>
 
   let totalConfirmationsImported = 0;
   let totalConfirmationsInFiles = 0;
-  const reviewingExaminers = new Set<string>();
+  const reviewingExaminers = new Map<string, { uid: string; badgeId?: string; confirmedFiles: Set<string> }>();
+  const allConfirmedFiles = new Set<string>();
 
   imports.forEach(entry => {
     const metrics = entry.details.performanceMetrics;
     const caseDetails = entry.details.caseDetails;
+    const userProfileDetails = entry.details.userProfileDetails;
 
     if (metrics?.validationStepsCompleted) {
       totalConfirmationsImported += metrics.validationStepsCompleted;
@@ -97,10 +99,36 @@ const generateConfirmationSummary = (entries: ValidationAuditEntry[]): string =>
       totalConfirmationsInFiles += caseDetails.totalAnnotations;
     }
     if (entry.details.reviewingExaminerUid) {
-      reviewingExaminers.add(entry.details.reviewingExaminerUid);
+      const uid = entry.details.reviewingExaminerUid;
+      const badgeId = userProfileDetails?.badgeId;
+      const confirmedFileNames = caseDetails?.confirmedFileNames || [];
+
+      if (!reviewingExaminers.has(uid)) {
+        reviewingExaminers.set(uid, {
+          uid,
+          badgeId,
+          confirmedFiles: new Set()
+        });
+      }
+
+      const examiner = reviewingExaminers.get(uid)!;
+      confirmedFileNames.forEach(file => {
+        examiner.confirmedFiles.add(file);
+        allConfirmedFiles.add(file);
+      });
     }
   });
 
+  const examinersDetail = Array.from(reviewingExaminers.values())
+    .map(examiner => {
+      const badgeInfo = examiner.badgeId ? ` (Badge: ${examiner.badgeId})` : '';
+      const filesInfo = examiner.confirmedFiles.size > 0
+        ? `\n    Confirmed Files: ${Array.from(examiner.confirmedFiles).sort().join(', ')}`
+        : '';
+      return `- UID: ${examiner.uid}${badgeInfo}${filesInfo}`;
+    })
+    .join('\n');
+
   return [
     `Confirmation Operations: ${confirmationEntries.length}`,
     `- Imports: ${imports.length}`,
@@ -112,8 +140,12 @@ const generateConfirmationSummary = (entries: ValidationAuditEntry[]): string =>
     `Reviewing Examiners Involved: ${reviewingExaminers.size}`,
     '',
     reviewingExaminers.size > 0
-      ? `External Reviewers: ${Array.from(reviewingExaminers).join(', ')}`
-      : 'No external reviewers detected'
+      ? `External Reviewers:\n${examinersDetail}`
+      : 'No external reviewers detected',
+    '',
+    allConfirmedFiles.size > 0
+      ? `Successfully Confirmed Files (Total: ${allConfirmedFiles.size}):\n${Array.from(allConfirmedFiles).sort().map(file => `  - ${file}`).join('\n')}`
+      : 'No files confirmed'
   ].join('\n');
 };
 

package/app/services/audit/audit.service.ts

@@ -340,6 +340,7 @@ export class AuditService {
     result: AuditResult,
     hashValid: boolean,
     confirmationsImported: number,
+    confirmedFileNames: string[] = [],
     errors: string[] = [],
     reviewingExaminerUid?: string,
     performanceMetrics?: PerformanceMetrics,
@@ -360,6 +361,7 @@ export class AuditService {
         result,
         hashValid,
         confirmationsImported,
+        confirmedFileNames,
         errors,
         reviewingExaminerUid,
         reviewerBadgeId,

package/app/services/audit/builders/audit-entry-builder.ts

@@ -19,6 +19,7 @@ export const buildValidationAuditEntry = (
       confirmationId: params.confirmationId,
       originalExaminerUid: params.originalExaminerUid,
       reviewingExaminerUid: params.reviewingExaminerUid,
+      reviewerBadgeId: params.reviewerBadgeId,
       workflowPhase: params.workflowPhase,
       securityChecks: params.securityChecks,
       performanceMetrics: params.performanceMetrics,

package/app/services/audit/builders/audit-event-builders-workflow.ts

@@ -218,6 +218,7 @@ interface BuildConfirmationImportAuditParamsInput {
   result: AuditResult;
   hashValid: boolean;
   confirmationsImported: number;
+  confirmedFileNames?: string[];
   errors?: string[];
   reviewingExaminerUid?: string;
   reviewerBadgeId?: string;
@@ -273,8 +274,13 @@ export const buildConfirmationImportAuditParams = (
     reviewerBadgeId: input.reviewerBadgeId,
     caseDetails: input.totalConfirmationsInFile !== undefined
       ? {
-          totalAnnotations: input.totalConfirmationsInFile
+          totalAnnotations: input.totalConfirmationsInFile,
+          confirmedFileNames: input.confirmedFileNames
         }
-      : undefined
+      : input.confirmedFileNames
+        ? {
+            confirmedFileNames: input.confirmedFileNames
+          }
+        : undefined
   };
 };

package/app/types/annotations.ts

@@ -22,19 +22,66 @@ export interface ConfirmationData {
   confirmedAt: string;        // ISO timestamp of confirmation
 }
 
+export interface BulletAnnotationData {
+  caliber?: string;
+  mass?: string;
+  diameter?: string;
+  calcDiameter?: string;
+  lgNumber?: number;
+  lgDirection?: string;
+  barrelType?: string;
+  // Width arrays should align with lgNumber:
+  // L1..Ln stored in order at lWidths[0..n-1], G1..Gn at gWidths[0..n-1].
+  lWidths?: string[];
+  gWidths?: string[];
+  jacketMetal?: string;
+  coreMetal?: string;
+  bulletType?: string;
+}
+
+export interface CartridgeCaseAnnotationData {
+  caliber?: string;
+  brand?: string;
+  metal?: string;
+  primerType?: string;
+  fpiShape?: string;
+  apertureShape?: string;
+  hasFpDrag?: boolean;
+  hasExtractorMarks?: boolean;
+  hasEjectorMarks?: boolean;
+  hasChamberMarks?: boolean;
+  hasMagazineLipMarks?: boolean;
+  hasPrimerShear?: boolean;
+  hasEjectionPortMarks?: boolean;
+}
+
+export interface ShotshellAnnotationData {
+  gauge?: string;
+  shotSize?: string;
+  metal?: string;
+  brand?: string;
+  fpiShape?: string;
+  hasExtractorMarks?: boolean;
+  hasEjectorMarks?: boolean;
+  hasChamberMarks?: boolean;
+}
+
 export interface AnnotationData {
   leftCase: string;
   rightCase: string;
   leftItem: string;
   rightItem: string;
   caseFontColor?: string;
-  classType?: 'Bullet' | 'Cartridge Case' | 'Other';
+  classType?: 'Bullet' | 'Cartridge Case' | 'Shotshell' | 'Other';
   customClass?: string;
   classNote?: string;
   indexType?: 'number' | 'color';
   indexNumber?: string;
   indexColor?: string;
   supportLevel?: 'ID' | 'Exclusion' | 'Inconclusive';
+  bulletData?: BulletAnnotationData;
+  cartridgeCaseData?: CartridgeCaseAnnotationData;
+  shotshellData?: ShotshellAnnotationData;
   hasSubclass?: boolean;
   includeConfirmation: boolean;
   confirmationData?: ConfirmationData;

package/app/types/audit.ts

@@ -199,6 +199,7 @@ export interface CaseAuditDetails {
   newCaseName?: string;
   totalFiles?: number;
   totalAnnotations?: number;
+  confirmedFileNames?: string[];
   createdDate?: string;
   lastModified?: string;
   deleteReason?: string;

package/app/utils/data/case-filters.ts

@@ -0,0 +1,127 @@
+export type CasesModalSortBy = 'recent' | 'alphabetical';
+
+export type CasesModalConfirmationFilter =
+  | 'all'
+  | 'pending'
+  | 'confirmed'
+  | 'none-requested';
+
+export interface CasesModalPreferences {
+  sortBy: CasesModalSortBy;
+  confirmationFilter: CasesModalConfirmationFilter;
+  showArchivedOnly: boolean;
+}
+
+export interface CasesModalCaseItem {
+  caseNumber: string;
+  createdAt: string;
+  archived: boolean;
+  isReadOnly: boolean;
+}
+
+export interface CaseConfirmationStatusValue {
+  includeConfirmation: boolean;
+  isConfirmed: boolean;
+}
+
+const DEFAULT_CASE_CONFIRMATION_STATUS: CaseConfirmationStatusValue = {
+  includeConfirmation: false,
+  isConfirmed: false,
+};
+
+function compareCaseNumbersAlphabetically(a: string, b: string): number {
+  const getComponents = (value: string) => {
+    const numbers = value.match(/\d+/g)?.map(Number) || [];
+    const letters = value.match(/[A-Za-z]+/g)?.join('') || '';
+    return { numbers, letters };
+  };
+
+  const left = getComponents(a);
+  const right = getComponents(b);
+
+  const maxLength = Math.max(left.numbers.length, right.numbers.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftNumber = left.numbers[index] || 0;
+    const rightNumber = right.numbers[index] || 0;
+
+    if (leftNumber !== rightNumber) {
+      return leftNumber - rightNumber;
+    }
+  }
+
+  return left.letters.localeCompare(right.letters);
+}
+
+function parseTimestamp(value: string): number {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function matchesConfirmationFilter(
+  caseNumber: string,
+  confirmationFilter: CasesModalConfirmationFilter,
+  caseConfirmationStatus: Record<string, CaseConfirmationStatusValue>
+): boolean {
+  if (confirmationFilter === 'all') {
+    return true;
+  }
+
+  const status = caseConfirmationStatus[caseNumber] || DEFAULT_CASE_CONFIRMATION_STATUS;
+
+  if (confirmationFilter === 'pending') {
+    return status.includeConfirmation && !status.isConfirmed;
+  }
+
+  if (confirmationFilter === 'confirmed') {
+    return status.includeConfirmation && status.isConfirmed;
+  }
+
+  return !status.includeConfirmation;
+}
+
+export function filterCasesForModal(
+  cases: CasesModalCaseItem[],
+  preferences: CasesModalPreferences,
+  caseConfirmationStatus: Record<string, CaseConfirmationStatusValue>
+): CasesModalCaseItem[] {
+  const archiveFilteredCases = preferences.showArchivedOnly
+    ? cases.filter((entry) => entry.archived && !entry.isReadOnly)
+    : cases.filter((entry) => !entry.archived && !entry.isReadOnly);
+
+  return archiveFilteredCases.filter((entry) =>
+    matchesConfirmationFilter(entry.caseNumber, preferences.confirmationFilter, caseConfirmationStatus)
+  );
+}
+
+export function sortCasesForModal(
+  cases: CasesModalCaseItem[],
+  sortBy: CasesModalSortBy
+): CasesModalCaseItem[] {
+  const next = [...cases];
+
+  if (sortBy === 'recent') {
+    return next.sort((left, right) => {
+      const difference = parseTimestamp(right.createdAt) - parseTimestamp(left.createdAt);
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareCaseNumbersAlphabetically(left.caseNumber, right.caseNumber);
+    });
+  }
+
+  return next.sort((left, right) =>
+    compareCaseNumbersAlphabetically(left.caseNumber, right.caseNumber)
+  );
+}
+
+export function getCasesForModal(
+  cases: CasesModalCaseItem[],
+  preferences: CasesModalPreferences,
+  caseConfirmationStatus: Record<string, CaseConfirmationStatusValue>
+): CasesModalCaseItem[] {
+  return sortCasesForModal(
+    filterCasesForModal(cases, preferences, caseConfirmationStatus),
+    preferences.sortBy
+  );
+}

package/app/utils/data/confirmation-summary/summary-core.ts

@@ -5,6 +5,7 @@ export interface FileConfirmationSummary {
   includeConfirmation: boolean;
   isConfirmed: boolean;
   updatedAt: string;
+  classType?: 'Bullet' | 'Cartridge Case' | 'Shotshell' | 'Other';
 }
 
 export interface CaseConfirmationSummary {
@@ -194,11 +195,20 @@ function normalizeFileConfirmationSummary(value: unknown): FileConfirmationSumma
     };
   }
 
-  return {
+  const classType = value.classType;
+  const normalizedClassType = typeof classType === 'string' && ['Bullet', 'Cartridge Case', 'Shotshell', 'Other'].includes(classType) ? (classType as 'Bullet' | 'Cartridge Case' | 'Shotshell' | 'Other') : undefined;
+
+  const summary: FileConfirmationSummary = {
     includeConfirmation: value.includeConfirmation === true,
     isConfirmed: value.isConfirmed === true,
     updatedAt: typeof value.updatedAt === 'string' && value.updatedAt.length > 0 ? value.updatedAt : getIsoNow()
   };
+
+  if (normalizedClassType) {
+    summary.classType = normalizedClassType;
+  }
+
+  return summary;
 }
 
 export function isStaleTimestamp(timestamp: string, maxAgeMs: number): boolean {
@@ -228,11 +238,17 @@ export function computeCaseConfirmationAggregate(filesById: Record<string, FileC
 export function toFileConfirmationSummary(annotationData: AnnotationData | null): FileConfirmationSummary {
   const includeConfirmation = annotationData?.includeConfirmation === true;
 
-  return {
+  const summary: FileConfirmationSummary = {
     includeConfirmation,
     isConfirmed: includeConfirmation && !!annotationData?.confirmationData,
     updatedAt: getIsoNow()
   };
+
+  if (annotationData?.classType) {
+    summary.classType = annotationData.classType;
+  }
+
+  return summary;
 }
 
 export function normalizeConfirmationSummaryDocument(payload: unknown): UserConfirmationSummaryDocument {

package/app/utils/data/file-filters.ts

@@ -0,0 +1,201 @@
+import type { FileData } from '~/types';
+import type { FileConfirmationSummary } from '~/utils/data';
+
+export type FilesModalSortBy = 'recent' | 'filename' | 'confirmation' | 'classType';
+
+export type FilesModalConfirmationFilter =
+  | 'all'
+  | 'pending'
+  | 'confirmed'
+  | 'none-requested';
+
+export type FilesModalClassTypeFilter =
+  | 'all'
+  | 'Bullet'
+  | 'Cartridge Case'
+  | 'Shotshell'
+  | 'Other';
+
+export interface FilesModalPreferences {
+  sortBy: FilesModalSortBy;
+  confirmationFilter: FilesModalConfirmationFilter;
+  classTypeFilter: FilesModalClassTypeFilter;
+}
+
+export type FileConfirmationById = Record<string, FileConfirmationSummary>;
+
+const DEFAULT_CONFIRMATION_SUMMARY: FileConfirmationSummary = {
+  includeConfirmation: false,
+  isConfirmed: false,
+  updatedAt: '',
+};
+
+function getFileConfirmationState(fileId: string, statusById: FileConfirmationById): FileConfirmationSummary {
+  return statusById[fileId] || DEFAULT_CONFIRMATION_SUMMARY;
+}
+
+function getConfirmationRank(summary: FileConfirmationSummary): number {
+  if (summary.includeConfirmation && !summary.isConfirmed) {
+    return 0;
+  }
+
+  if (summary.includeConfirmation && summary.isConfirmed) {
+    return 1;
+  }
+
+  return 2;
+}
+
+function getClassTypeRank(classType: FileConfirmationSummary['classType']): number {
+  if (classType === 'Bullet') {
+    return 0;
+  }
+
+  if (classType === 'Cartridge Case') {
+    return 1;
+  }
+
+  if (classType === 'Shotshell') {
+    return 2;
+  }
+
+  if (classType === 'Other') {
+    return 3;
+  }
+
+  return 4;
+}
+
+function parseTimestamp(value: string): number {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function matchesConfirmationFilter(
+  summary: FileConfirmationSummary,
+  confirmationFilter: FilesModalConfirmationFilter
+): boolean {
+  if (confirmationFilter === 'all') {
+    return true;
+  }
+
+  if (confirmationFilter === 'pending') {
+    return summary.includeConfirmation && !summary.isConfirmed;
+  }
+
+  if (confirmationFilter === 'confirmed') {
+    return summary.includeConfirmation && summary.isConfirmed;
+  }
+
+  return !summary.includeConfirmation;
+}
+
+function matchesClassTypeFilter(
+  summary: FileConfirmationSummary,
+  classTypeFilter: FilesModalClassTypeFilter
+): boolean {
+  if (classTypeFilter === 'all') {
+    return true;
+  }
+
+  if (classTypeFilter === 'Other') {
+    // Treat legacy/unset class types as Other for filtering.
+    return summary.classType === 'Other' || !summary.classType;
+  }
+
+  return summary.classType === classTypeFilter;
+}
+
+function matchesSearch(file: FileData, query: string): boolean {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return true;
+  }
+
+  return file.originalFilename.toLowerCase().includes(normalized);
+}
+
+export function filterFilesForModal(
+  files: FileData[],
+  preferences: FilesModalPreferences,
+  statusById: FileConfirmationById,
+  searchQuery: string
+): FileData[] {
+  return files.filter((file) => {
+    const summary = getFileConfirmationState(file.id, statusById);
+
+    return (
+      matchesSearch(file, searchQuery) &&
+      matchesConfirmationFilter(summary, preferences.confirmationFilter) &&
+      matchesClassTypeFilter(summary, preferences.classTypeFilter)
+    );
+  });
+}
+
+function compareFileNames(a: string, b: string): number {
+  return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
+}
+
+export function sortFilesForModal(
+  files: FileData[],
+  sortBy: FilesModalSortBy,
+  statusById: FileConfirmationById
+): FileData[] {
+  const next = [...files];
+
+  if (sortBy === 'recent') {
+    return next.sort((left, right) => {
+      const difference = parseTimestamp(right.uploadedAt) - parseTimestamp(left.uploadedAt);
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareFileNames(left.originalFilename, right.originalFilename);
+    });
+  }
+
+  if (sortBy === 'filename') {
+    return next.sort((left, right) =>
+      compareFileNames(left.originalFilename, right.originalFilename)
+    );
+  }
+
+  if (sortBy === 'confirmation') {
+    return next.sort((left, right) => {
+      const leftSummary = getFileConfirmationState(left.id, statusById);
+      const rightSummary = getFileConfirmationState(right.id, statusById);
+      const difference = getConfirmationRank(leftSummary) - getConfirmationRank(rightSummary);
+
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareFileNames(left.originalFilename, right.originalFilename);
+    });
+  }
+
+  return next.sort((left, right) => {
+    const leftSummary = getFileConfirmationState(left.id, statusById);
+    const rightSummary = getFileConfirmationState(right.id, statusById);
+    const difference = getClassTypeRank(leftSummary.classType) - getClassTypeRank(rightSummary.classType);
+
+    if (difference !== 0) {
+      return difference;
+    }
+
+    return compareFileNames(left.originalFilename, right.originalFilename);
+  });
+}
+
+export function getFilesForModal(
+  files: FileData[],
+  preferences: FilesModalPreferences,
+  statusById: FileConfirmationById,
+  searchQuery: string
+): FileData[] {
+  return sortFilesForModal(
+    filterFilesForModal(files, preferences, statusById, searchQuery),
+    preferences.sortBy,
+    statusById
+  );
+}