@rivm-loculus-tools/common-frontend 0.1.0 → 0.1.4

package/src/utils/MetaDataUtil/MetaDataUtil.ts

@@ -1,292 +0,0 @@
-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/UrlUtil/UrlUtil.ts

@@ -1,35 +0,0 @@
-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/tsconfig.build.json

@@ -1,14 +0,0 @@
-{
-  "$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

@@ -1,32 +0,0 @@
-{
-  "$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

@@ -1,137 +0,0 @@
-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,
-  },
-});