@rivm-loculus-tools/common-frontend 0.0.0-stage → 0.1.3

package/src/utils/MetaDataUtil/MetaDataUtil.ts

@@ -0,0 +1,292 @@
+import type {
+  MetadataParseResult,
+  MetadataRecord,
+} from '../../models/metadata';
+
+export class MetaDataUtil {
+  /**
+   * Compute the best matching metadata column for the given FASTA sequence IDs.
+   */
+  public static findBestMatchingColumn = (
+    columns: string[],
+    recordsByColumn: Record<string, Record<string, MetadataRecord>>,
+    fastaIds: string[],
+  ): { bestColumn: null | string; matchCounts: Record<string, number> } => {
+    const matchCounts = MetaDataUtil.getMatchCounts(columns, recordsByColumn, fastaIds);
+    let bestColumn: null | string = null;
+    let maxMatches = -1;
+
+    if (!columns || !recordsByColumn || !fastaIds || fastaIds.length === 0) {
+      return { bestColumn: null, matchCounts: {} };
+    }
+
+    const prioritizedKeys = [
+      'displayname',
+      'accessionversion',
+      'accession',
+      'sampleid',
+      'sample_id',
+      'id',
+      'strain',
+      'isolate',
+      'submissionid',
+      'name',
+    ];
+
+    for (const col of columns) {
+      const colDict = recordsByColumn[col];
+      if (!colDict) {
+        continue;
+      }
+
+      const count = matchCounts[col];
+
+      if (count > maxMatches) {
+        maxMatches = count;
+        bestColumn = col;
+      } else if (count === maxMatches && count > 0 && bestColumn) {
+        // Tie-breaker: prioritize standard ID column names
+        const currentPriority = prioritizedKeys.indexOf(bestColumn.toLowerCase());
+        const newPriority = prioritizedKeys.indexOf(col.toLowerCase());
+        if (newPriority !== -1 && (currentPriority === -1 || newPriority < currentPriority)) {
+          bestColumn = col;
+        }
+      }
+    }
+
+    if (maxMatches <= 0) {
+      // If no matches, default to highest priority known ID column if available
+      for (const pKey of prioritizedKeys) {
+        const found = columns.find((c) => c.toLowerCase() === pKey);
+        if (found) {
+          bestColumn = found;
+          break;
+        }
+      }
+      if (!bestColumn && columns.length > 0) {
+        bestColumn = columns[0];
+      }
+    }
+
+    return { bestColumn, matchCounts };
+  };
+
+  public static getHighlightedIds(query: string, allAccessions: string[], metadataRecords: MetadataRecord[], matchKeyField: null | string = null): string[] {
+    const trimmed = query.trim().toLowerCase();
+    if (!trimmed) {
+      return [];
+    }
+
+    const matched = new Set<string>();
+
+    // Check accession names / fasta IDs
+    allAccessions.forEach((acc) => {
+      if (acc.toLowerCase().includes(trimmed)) {
+        matched.add(acc);
+      }
+    });
+
+    // Check metadata records
+    metadataRecords.forEach((rec) => {
+      const acc =
+        (matchKeyField && rec[matchKeyField]) ||
+        rec.displayName ||
+        rec.accessionVersion ||
+        rec.accession ||
+        rec.id ||
+        rec.submissionId ||
+        rec.SampleID;
+      if (acc) {
+        const matchesAnyField = Object.values(rec).some(
+          (val) => typeof val === 'string' && val.toLowerCase().includes(trimmed),
+        );
+        if (matchesAnyField) {
+          matched.add(acc);
+        }
+      }
+    });
+
+    return Array.from(matched);
+  }
+  /**
+   * Count FASTA sequence ID matches for each metadata column.
+   */
+  public static getMatchCounts = (
+    columns: string[],
+    recordsByColumn: Record<string, Record<string, MetadataRecord>>,
+    fastaIds: string[],
+  ): Record<string, number> => {
+    const matchCounts: Record<string, number> = {};
+
+    if (!columns || !recordsByColumn || !fastaIds || fastaIds.length === 0) {
+      return matchCounts;
+    }
+
+    for (const col of columns) {
+      const colDict = recordsByColumn[col];
+      if (!colDict) {
+        continue;
+      }
+
+      let count = 0;
+      for (const id of fastaIds) {
+        if (colDict[id]) {
+          count++;
+        }
+      }
+      matchCounts[col] = count;
+    }
+
+    return matchCounts;
+  };
+
+  /**
+   * Retrieve metadata record for a given sample/node name with fallback strategies.
+   */
+  public static readonly getRecordForSample = (
+    metadata: MetadataParseResult | null | undefined,
+    sampleId: string,
+    matchKeyField?: null | string,
+  ): MetadataRecord | undefined => {
+    if (!metadata || !sampleId) {
+      return undefined;
+    }
+
+    // 1. If matchKeyField is specified and exists, check it first
+    if (matchKeyField && metadata.recordsByColumn?.[matchKeyField]) {
+      const rec = metadata.recordsByColumn[matchKeyField][sampleId];
+      if (rec) {
+        return rec;
+      }
+    }
+
+    // 2. Check displayName
+    if (metadata.recordsByColumn?.['displayName']?.[sampleId]) {
+      return metadata.recordsByColumn['displayName'][sampleId];
+    }
+
+    // 3. Check accessionVersion
+    if (metadata.recordsByColumn?.['accessionVersion']?.[sampleId]) {
+      return metadata.recordsByColumn['accessionVersion'][sampleId];
+    }
+
+    // 4. Check accession maps
+    if (metadata.recordsByAccession[sampleId]) {
+      return metadata.recordsByAccession[sampleId];
+    }
+    if (metadata.recordsBySampleId[sampleId]) {
+      return metadata.recordsBySampleId[sampleId];
+    }
+
+    // 5. Broad search through all indexed columns
+    if (metadata.recordsByColumn) {
+      for (const col of Object.keys(metadata.recordsByColumn)) {
+        const match = metadata.recordsByColumn[col][sampleId];
+        if (match) {
+          return match;
+        }
+      }
+    }
+
+    return undefined;
+  };
+
+  public static parseTsv = (content: string): MetadataParseResult => {
+    if (!content?.trim()) {
+      return {
+        columns: [],
+        error: 'Empty metadata content provided.',
+        records: [],
+        recordsByAccession: {},
+        recordsByColumn: {},
+        recordsBySampleId: {},
+      };
+    }
+
+    const lines = content.trim().split('\n');
+    if (lines.length < 2) {
+      return {
+        columns: [],
+        error: 'Metadata file must contain at least a header row and one data row.',
+        records: [],
+        recordsByAccession: {},
+        recordsByColumn: {},
+        recordsBySampleId: {},
+      };
+    }
+
+    // Parse header row
+    const headerLine = lines[0].trim();
+    let delimiter = '\t';
+    if (!headerLine.includes('\t') && headerLine.includes(',')) {
+      delimiter = ',';
+    }
+    const columns = headerLine
+      .split(delimiter)
+      .map((col) => col.trim().replace(/^["']|["']$/g, ''))
+      .filter((c) => c.length > 0);
+
+    const records: MetadataRecord[] = [];
+    const recordsByAccession: Record<string, MetadataRecord> = {};
+    const recordsBySampleId: Record<string, MetadataRecord> = {};
+    const recordsByColumn: Record<string, Record<string, MetadataRecord>> = {};
+
+    columns.forEach((col) => {
+      recordsByColumn[col] = {};
+    });
+
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) {
+        continue;
+      }
+
+      const values = line.split(delimiter).map((val) => val.trim().replace(/^["']|["']$/g, ''));
+      const record: MetadataRecord = {};
+
+      columns.forEach((col, colIdx) => {
+        const val = values[colIdx] ?? '';
+        record[col] = val;
+        if (val) {
+          recordsByColumn[col][val] = record;
+        }
+      });
+
+      records.push(record);
+
+      // Index by potential ID keys
+      const accessionKey =
+        record.displayName ||
+        record.accessionVersion ||
+        record.accession ||
+        record.id ||
+        record.submissionId ||
+        record.strain ||
+        record.isolate ||
+        record.name;
+
+      if (accessionKey) {
+        recordsByAccession[accessionKey] = record;
+      }
+
+      const sampleIdKey =
+        record.SampleID ||
+        record.sampleId ||
+        record.sample_id ||
+        record.specimenCollectorSampleId ||
+        record.id;
+
+      if (sampleIdKey) {
+        recordsBySampleId[sampleIdKey] = record;
+      }
+    }
+
+    return {
+      columns,
+      records,
+      recordsByAccession,
+      recordsByColumn,
+      recordsBySampleId,
+    };
+  };
+}

package/src/utils/MetaDataUtil/index.ts

@@ -0,0 +1 @@
+export * from './MetaDataUtil';

package/src/utils/UrlUtil/UrlUtil.ts

@@ -0,0 +1,35 @@
+import { WindowService } from '@gen-epix/ui-core/classes/services/WindowService';
+
+export class UrlUtil {
+  public static clearSearchParams(): void {
+    const url = new URL(WindowService.getInstance().window.location.href);
+    url.search = '';
+    WindowService.getInstance().window.history.replaceState(null, '', url.toString());
+  }
+
+  public static fastaLabelFromUrl(url: string): string {
+    try {
+      const urlObject = new URL(url);
+      const segment = urlObject.pathname.split('/').filter(Boolean).pop();
+      if (segment) {
+        return decodeURIComponent(segment);
+      }
+      return `${urlObject.hostname}.fasta`;
+    } catch {
+      return 'remote-alignment.fasta';
+    }
+  }
+
+  public static validateFastaUrl(url: string): string {
+    let urlObject: URL;
+    try {
+      urlObject = new URL(url.trim());
+    } catch {
+      throw new Error('Enter a valid FASTA URL.');
+    }
+    if (urlObject.protocol !== 'http:' && urlObject.protocol !== 'https:') {
+      throw new Error('FASTA URLs must use HTTP or HTTPS.');
+    }
+    return urlObject.href;
+  }
+}

package/src/utils/UrlUtil/index.ts

@@ -0,0 +1 @@
+export * from './UrlUtil';

package/tsconfig.build.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.json",
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "src/**/*.test.*",
+    "src/**/*.spec.*",
+    "src/**/__tests__/**",
+    "src/**/tests/**",
+    "src/test/setup/**"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "esnext",
+    "useDefineForClassFields": true,
+    "lib": [
+      "ESNext",
+      "DOM",
+      "DOM.Iterable",
+      "WebWorker"
+    ],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "types": [
+      "vite/client"
+    ]
+  },
+  "include": [
+    "src",
+    "vite.config.ts"
+  ]
+}

package/vite.config.ts

@@ -0,0 +1,137 @@
+import {
+  globSync,
+  readFileSync,
+} from 'fs';
+import {
+  dirname,
+  join,
+} from 'path';
+
+import {
+  defineConfig,
+  esmExternalRequirePlugin,
+} from 'vite';
+import dts from 'vite-plugin-dts';
+import { viteStaticCopy } from 'vite-plugin-static-copy';
+import type { Target } from 'vite-plugin-static-copy';
+
+type PackageManifest = {
+  peerDependencies?: Record<string, string>;
+};
+
+const createPeerDependencyExternalPatterns = () => {
+  const packageJson = JSON.parse(
+    readFileSync(join(import.meta.dirname, 'package.json'), 'utf8'),
+  ) as PackageManifest;
+
+  return Object.keys(packageJson.peerDependencies ?? {}).map((dependency) => {
+    const escapedDependency = dependency.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^${escapedDependency}(?:/.+)?$`);
+  });
+};
+
+const peerDependencyExternalPatterns = createPeerDependencyExternalPatterns();
+
+const discoverEntries = (): { entries: Record<string, string>; flatKeys: Set<string> } => {
+  const entries: Record<string, string> = {};
+  const flatKeys = new Set<string>();
+
+  const srcDir = join(import.meta.dirname, 'src');
+
+  // index.ts-based entries (classes, utils): key = component directory
+  globSync([
+    join(srcDir, 'classes', '**', 'index.ts'),
+    join(srcDir, 'components', '**', 'index.ts'),
+    join(srcDir, 'constants', '**', 'index.ts'),
+    join(srcDir, 'context', '**', 'index.ts'),
+    join(srcDir, 'dataHooks', '**', 'index.ts'),
+    join(srcDir, 'hoc', '**', 'index.ts'),
+    join(srcDir, 'hooks', '**', 'index.ts'),
+    join(srcDir, 'locale', '**', 'index.ts'),
+    join(srcDir, 'pages', '**', 'index.ts'),
+    join(srcDir, 'routes', '**', 'index.ts'),
+    join(srcDir, 'stores', '**', 'index.ts'),
+    join(srcDir, 'theme', '**', 'index.ts'),
+    join(srcDir, 'utils', '**', 'index.ts'),
+  ]).forEach((file) => {
+    const relKey = dirname(file).replace(`${srcDir}/`, '');
+    entries[relKey] = `./${file.replace(`${import.meta.dirname}/`, '')}`;
+  });
+
+  // flat .ts entries (models): key = file path without extension
+  globSync([join(srcDir, 'models', '*.ts'), join(srcDir, 'constants', '*.ts'), join(srcDir, 'setup', '*.ts')])
+    .filter((file) => !file.endsWith('/index.ts'))
+    .forEach((file) => {
+      const relKey = file.replace(`${srcDir}/`, '').replace(/\.ts$/, '');
+      entries[relKey] = `./${file.replace(`${import.meta.dirname}/`, '')}`;
+      flatKeys.add(relKey);
+    });
+
+  return { entries, flatKeys };
+};
+
+const { entries: libEntries, flatKeys } = discoverEntries();
+
+// https://vitejs.dev/config/
+// eslint-disable-next-line import-x/no-default-export
+export default defineConfig({
+  build: {
+    copyPublicDir: false,
+    lib: {
+      entry: libEntries,
+      fileName: (_, entryAlias) => {
+        if (entryAlias === 'index') {
+          return 'index.js';
+        }
+        // flat .ts entries output alongside their .d.ts; index.ts entries output in a subdirectory
+        return flatKeys.has(entryAlias) ? `${entryAlias}.js` : `${entryAlias}/index.js`;
+      },
+      formats: ['es'],
+    },
+    rolldownOptions: {
+      output: {
+        chunkFileNames: '_chunks/[name].js',
+      },
+      plugins: [
+        esmExternalRequirePlugin({
+          external: peerDependencyExternalPatterns,
+        }),
+      ],
+      treeshake: true,
+    },
+    sourcemap: true,
+  },
+  plugins: [
+    dts({
+      entryRoot: './src',
+      insertTypesEntry: false,
+      tsconfigPath: './tsconfig.build.json',
+    }),
+    viteStaticCopy({
+      targets: ([
+        {
+          dest: '@types',
+          rename: { stripBase: true },
+          src: [
+            './src/@types/**/*.d.ts',
+          ],
+        },
+        {
+          dest: './locale',
+          rename: { stripBase: true },
+          src: [
+            './src/locale',
+          ],
+        },
+      ] satisfies Target[]).filter((target) => {
+        const sources = Array.isArray(target.src) ? target.src : [target.src];
+        return sources.some((pattern) => globSync(pattern).length > 0);
+      }),
+    }),
+  ],
+  server: {
+    host: false,
+    open: true,
+    port: 5173,
+  },
+});

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.