Fix inconsistent file extension handling in workspaces (#1899)

* refactor(workspace): extract file extension utilities for reusability

Extracted file extension matching and replacement logic into reusable utility functions (`doesFilenameMatchExtension` and `replaceFileExtension`) to improve code consistency and maintainability.

Changes:
- Added `doesFilenameMatchExtension()` utility to standardize extension checking
- Added `replaceFileExtension()` utility to handle filename extension replacement
- Replaced inline extension matching logic across ImportWorkspaceFileModal, SequenceEditor, and effects
- Added error handling for file conversion operations
- Simplified filename manipulation in sequence editor download functionality

This refactoring reduces code duplication and provides a single source of truth for file extension operations throughout the workspace handling code.

* refactor(workspaces): replace regex with string matching for file extensions

Replace regex-based pattern matching with simple string comparison in
`doesFilenameMatchExtension` and `replaceFileExtension` functions to
avoid unintended behavior with special characters.

Changes:
- Use `endsWith()` instead of regex for extension matching
- Add support for compound extensions (e.g., 'seqn.txt')
- Use string slicing instead of regex replacement
- Add validation check before replacing extension
- Remove tests for regex special character handling
- Add tests for compound extension scenarios

This prevents issues where special regex characters in extensions
(like `*`, `+`, `.`) would be interpreted as patterns rather than
literal strings, making extension matching more predictable and correct.

---------

Co-authored-by: Dan Delany <daniel.t.delany@jpl.nasa.gov>

Author: duranb

src/components/modals/ImportWorkspaceFileModal.svelte

@@ -6,7 +6,7 @@
   import * as Sidebar from '../../components/ui/Sidebar/index.js';
   import type { Workspace, WorkspaceNodeEvent } from '../../types/workspace';
   import type { WorkspaceTreeNode } from '../../types/workspace-tree-view';
-  import { joinPath, removeFirstPathSegment } from '../../utilities/workspaces.js';
+  import { doesFilenameMatchExtension, joinPath, removeFirstPathSegment } from '../../utilities/workspaces.js';
   import InputInternal from '../form/Input.svelte';
   import WorkspaceTreeView from '../workspace/WorkspaceTreeView/WorkspaceTreeView.svelte';
   import Modal from './Modal.svelte';
@@ -49,9 +49,7 @@
     selectedFileGroupings = Array.from(files ?? []).reduce(
       (previousFileGroupings: { convertableFiles: File[]; uploadableFiles: File[] }, file) => {
         if (
-          outputLanguageExtensions.findIndex(fileExtension =>
-            file.name.endsWith(`.${fileExtension.replace(/^\./, '')}`),
-          ) > -1
+          outputLanguageExtensions.findIndex(fileExtension => doesFilenameMatchExtension(fileExtension, file.name)) > -1
         ) {
           return {
             ...previousFileGroupings,

src/components/sequencing/SequenceEditor.svelte

@@ -26,6 +26,7 @@
   import { blockTheme } from '../../utilities/codemirror/themes/block';
   import { phoenixResources } from '../../utilities/sequence-editor/adaptation-resources';
   import { showFailureToast, showSuccessToast } from '../../utilities/toast';
+  import { replaceFileExtension } from '../../utilities/workspaces';
   import CssGrid from '../ui/CssGrid.svelte';
   import CssGridGutter from '../ui/CssGridGutter.svelte';
   import Panel from '../ui/Panel.svelte';
@@ -251,13 +252,12 @@
 
   function downloadOutputFormat(outputLanguage: OutputLanguage): void {
     const content = editorOutputView.state.doc.toString();
-    // Remove any existing extension and add output extension
-    const outputExt = outputLanguage.fileExtension; // Keep the dot
-    const lastDotIndex = sequenceName.lastIndexOf('.');
 
-    // If there's a dot in the filename, remove everything after it; otherwise keep the whole name
-    const filenameWithoutExt = lastDotIndex > 0 ? sequenceName.slice(0, lastDotIndex) : sequenceName;
-    const filename = filenameWithoutExt + outputExt;
+    const filename = replaceFileExtension(
+      sequenceName,
+      sequenceAdaptation.input.fileExtension,
+      outputLanguage.fileExtension,
+    );
 
     dispatch('downloadOutput', { content, filePath: sequenceFilePath, filename, outputLanguage });
   }

src/utilities/effects.ts

@@ -321,6 +321,7 @@ import {
 } from './view';
 import {
   cleanPath,
+  doesFilenameMatchExtension,
   findNodeInDirectory,
   flattenWorkspaceTreeWithPaths,
   getWorkspaceFileFolderDisplay,
@@ -329,6 +330,7 @@ import {
   isFileConflictResponse,
   joinPath,
   mapWorkspaceTreePaths,
+  replaceFileExtension,
   separateFilenameFromPath,
   WorkspaceApi,
   type BulkOperationResponses,
@@ -6050,20 +6052,28 @@ const effects = {
         const convertedFiles: File[] = await Promise.all(
           filesToConvert.map(async file => {
             const outputLanguage = sequenceAdaptation.outputs.find(language =>
-              file.name.endsWith(`.${language.fileExtension.replace(/^\./, '')}`),
+              doesFilenameMatchExtension(language.fileExtension, file.name),
             );
 
             if (outputLanguage) {
-              const fileName = file.name.replace(
-                outputLanguage.fileExtension.replace(/^\./, ''),
-                sequenceAdaptation.input.fileExtension.replace(/^\./, ''),
-              );
-              const lastModified = Date.now();
-              const content = await file.text();
-              const convertedContent = outputLanguage.toInputFormat(content, phoenixContext, fileName);
-
-              convertedFileMap[file.name] = fileName;
-              return new File([convertedContent], fileName, { lastModified, type: 'text/plain' });
+              try {
+                const fileName = replaceFileExtension(
+                  file.name,
+                  outputLanguage.fileExtension,
+                  sequenceAdaptation.input.fileExtension,
+                );
+                const lastModified = Date.now();
+                const content = await file.text();
+                const convertedContent = outputLanguage.toInputFormat(content, phoenixContext, fileName);
+
+                convertedFileMap[file.name] = fileName;
+                return new File([convertedContent], fileName, { lastModified, type: 'text/plain' });
+              } catch (error) {
+                throw Error(
+                  `There was an error trying to convert the file ${file.name}. Please check that it is formatted correctly.`,
+                  { cause: error },
+                );
+              }
             }
 
             return file;

src/utilities/workspaces.test.ts

@@ -22,6 +22,7 @@ import {
   mapWorkspaceTreePaths,
   removeFirstPathSegment,
   removeRedundantNodes,
+  replaceFileExtension,
   separateFilenameFromPath,
   shouldNodeBeVisible,
   sortWorkspaceTree,
@@ -1531,6 +1532,93 @@ describe('Workspace utility function tests', () => {
     });
   });
 
+  describe('replaceFileExtension', () => {
+    test('Should replace extension without leading dots', () => {
+      expect(replaceFileExtension('file.txt', 'txt', 'json')).toBe('file.json');
+      expect(replaceFileExtension('test.seq.json', 'seq.json', 'seqN.txt')).toBe('test.seqN.txt');
+      expect(replaceFileExtension('data.xml', 'xml', 'json')).toBe('data.json');
+    });
+
+    test('Should replace extension with leading dots', () => {
+      expect(replaceFileExtension('file.txt', '.txt', '.json')).toBe('file.json');
+      expect(replaceFileExtension('test.seq', '.seq', '.seqN')).toBe('test.seqN');
+      expect(replaceFileExtension('data.xml', '.xml', '.json')).toBe('data.json');
+    });
+
+    test('Should replace extension with mixed dot usage', () => {
+      expect(replaceFileExtension('file.txt', 'txt', '.json')).toBe('file.json');
+      expect(replaceFileExtension('test.seq', '.seq', 'seqN')).toBe('test.seqN');
+    });
+
+    test('Should be case-insensitive when matching extension', () => {
+      expect(replaceFileExtension('file.TXT', 'txt', 'json')).toBe('file.json');
+      expect(replaceFileExtension('test.SEQ', 'seq', 'seqN')).toBe('test.seqN');
+      expect(replaceFileExtension('data.Xml', 'XML', 'json')).toBe('data.json');
+    });
+
+    test('Should not replace if extension does not match', () => {
+      expect(replaceFileExtension('file.txt', 'json', 'xml')).toBe('file.txt');
+      expect(replaceFileExtension('test.seq', 'txt', 'json')).toBe('test.seq');
+      expect(replaceFileExtension('data.xml', 'seq', 'json')).toBe('data.xml');
+    });
+
+    test('Should only replace extension at the end of filename', () => {
+      expect(replaceFileExtension('file.txt.bak', 'txt', 'json')).toBe('file.txt.bak');
+      expect(replaceFileExtension('test.seq.old', 'seq', 'seqN')).toBe('test.seq.old');
+    });
+
+    test('Should handle files with multiple dots correctly', () => {
+      expect(replaceFileExtension('script.min.js', 'min.js', 'ts')).toBe('script.ts');
+      expect(replaceFileExtension('config.test.json', 'json', 'xml')).toBe('config.test.xml');
+      expect(replaceFileExtension('my.file.name.txt', 'txt', 'md')).toBe('my.file.name.md');
+    });
+
+    test('Should not replace if filename has no extension', () => {
+      expect(replaceFileExtension('README', 'txt', 'md')).toBe('README');
+      expect(replaceFileExtension('Makefile', 'txt', 'json')).toBe('Makefile');
+    });
+
+    test('Should handle files with path', () => {
+      expect(replaceFileExtension('path/to/file.txt', 'txt', 'json')).toBe('path/to/file.json');
+      expect(replaceFileExtension('folder/subfolder/test.seq', 'seq', 'seqN')).toBe('folder/subfolder/test.seqN');
+      expect(replaceFileExtension('a/b/c/data.xml', 'xml', 'json')).toBe('a/b/c/data.json');
+    });
+
+    test('Should handle hidden files (starting with dot)', () => {
+      expect(replaceFileExtension('.config.json', 'json', 'xml')).toBe('.config.xml');
+      expect(replaceFileExtension('.gitignore.txt', 'txt', 'bak')).toBe('.gitignore.bak');
+    });
+
+    test('Should not match partial extension', () => {
+      expect(replaceFileExtension('file.txt', 'tx', 'json')).toBe('file.txt');
+      expect(replaceFileExtension('file.txt', 't', 'json')).toBe('file.txt');
+      expect(replaceFileExtension('file.json', 'son', 'xml')).toBe('file.json');
+    });
+
+    test('Should not replace extension in middle of filename', () => {
+      expect(replaceFileExtension('file-txt.json', 'txt', 'xml')).toBe('file-txt.json');
+      expect(replaceFileExtension('sequential.js', 'seq', 'seqN')).toBe('sequential.js');
+    });
+
+    test('Should handle empty filename', () => {
+      expect(replaceFileExtension('', 'txt', 'json')).toBe('');
+    });
+
+    test('Should preserve target extension case', () => {
+      expect(replaceFileExtension('file.txt', 'txt', 'JSON')).toBe('file.JSON');
+      expect(replaceFileExtension('test.seq', 'seq', 'SeqN')).toBe('test.SeqN');
+    });
+
+    test('Should handle complex file extensions', () => {
+      expect(replaceFileExtension('archive.tar.gz', 'gz', 'bz2')).toBe('archive.tar.bz2');
+      expect(replaceFileExtension('script.min.js', 'min.js', 'js')).toBe('script.js');
+    });
+
+    test('Should replace when only extension matches without filename', () => {
+      expect(replaceFileExtension('.txt', 'txt', 'json')).toBe('.json');
+    });
+  });
+
   describe('hasReadonlyInTree', () => {
     test('Should return false for a file without metadata', () => {
       const node: WorkspaceTreeNode = {

src/utilities/workspaces.ts

@@ -371,6 +371,27 @@ export function isFileConflictResponse(response: BulkOperationResponse) {
   return response.status === 409;
 }
 
+export function doesFilenameMatchExtension(extension: string, filename: string) {
+  // Normalize extension to include leading dot
+  const normalizedExtension = extension.startsWith('.') ? extension : `.${extension}`;
+  // Case-insensitive check if filename ends with the extension
+  return filename.toLowerCase().endsWith(normalizedExtension.toLowerCase());
+}
+
+export function replaceFileExtension(filename: string, fromExtension: string, toExtension: string) {
+  // Normalize extensions to include leading dots
+  const normalizedFromExtension = fromExtension.startsWith('.') ? fromExtension : `.${fromExtension}`;
+  const normalizedToExtension = toExtension.startsWith('.') ? toExtension : `.${toExtension}`;
+
+  // Check if filename ends with the fromExtension (case-insensitive)
+  if (!doesFilenameMatchExtension(normalizedFromExtension, filename)) {
+    return filename;
+  }
+
+  // Replace only the extension at the end, preserving the original case of the filename
+  return `${filename.slice(0, -normalizedFromExtension.length)}${normalizedToExtension}`;
+}
+
 export const WorkspaceApi = {
   async createFolder(workspaceId: number, folderPath: string, user: User | null) {
     return reqWorkspace<Workspace>(`${workspaceId}/${folderPath}?type=directory`, 'PUT', null, user, undefined, false);