react-cheminfo 0.28.0 → 0.29.0

package/src/ir/core/irReducer.ts

@@ -0,0 +1,273 @@
+/**
+ * Every change the viewer can undergo, as one function over one object.
+ *
+ * A reducer rather than a graph of signals, for the reason
+ * `docs/decisions.md` gives about the glycan editor: a published component must
+ * not impose a state library on the page that mounts it, and two viewers on one
+ * page must not share a module-level singleton. The state is a plain object, so a
+ * host can save it, restore it and compare it.
+ *
+ * Every case returns the state **itself** when it has nothing to do, so a render
+ * memoised on the state is not defeated by an action that changed nothing —
+ * selecting the spectrum already selected, closing an error that is already
+ * closed.
+ */
+
+import type { IrSidePanelId } from './irSidePanels.ts';
+import type { IrDomain, IrSpectrum } from './irSpectrum.ts';
+import type { IrSettings, IrState, IrTool, PartialIrState } from './irState.ts';
+import {
+  DEFAULT_SETTINGS,
+  DEFAULT_SIDE_PANELS,
+  isIrWindow,
+  mergeIrSettings,
+} from './irState.ts';
+
+/** Everything that can be asked of the viewer. */
+export type IrAction =
+  | { type: 'addSpectra'; spectra: IrSpectrum[] }
+  | { type: 'setSpectra'; spectra: IrSpectrum[] }
+  | { type: 'removeSpectrum'; id: string }
+  | { type: 'renameSpectrum'; id: string; name: string }
+  | { type: 'setSpectrumColor'; id: string; color: string }
+  | { type: 'setSpectrumVisible'; id: string; visible: boolean }
+  | { type: 'selectSpectrum'; id: string | null }
+  | { type: 'setDomain'; domain: IrDomain }
+  | { type: 'resetDomain' }
+  | { type: 'setTool'; tool: IrTool }
+  | { type: 'togglePanel'; panelId: IrSidePanelId }
+  | { type: 'setError'; error: string | null }
+  | { type: 'setSettings'; settings: Partial<IrSettings> }
+  | { type: 'loadState'; state: PartialIrState }
+  | { type: 'clear' };
+
+/** What a viewer opens on. */
+export interface CreateIrStateOptions {
+  /**
+   * The spectra to open on.
+   * @default []
+   */
+  spectra?: IrSpectrum[];
+  /**
+   * The workspace to open in.
+   * @default DEFAULT_SETTINGS
+   */
+  settings?: Partial<IrSettings>;
+  /**
+   * The panels open to begin with.
+   * @default DEFAULT_SIDE_PANELS
+   */
+  panelIds?: IrSidePanelId[];
+}
+
+/**
+ * The state a viewer opens with.
+ *
+ * The panel list is spread rather than stored by reference: a caller's array is
+ * the caller's to mutate, and a viewer holding it would find its open panels
+ * changing under it.
+ * @param options - What it opens on.
+ * @returns The state.
+ */
+export function createIrState(options: CreateIrStateOptions = {}): IrState {
+  const { spectra = [], settings, panelIds } = options;
+  return {
+    data: { spectra: [...spectra] },
+    view: {
+      selectedId: spectra[0]?.id ?? null,
+      domain: null,
+      tool: 'read',
+      openPanelIds: [...(panelIds ?? DEFAULT_SIDE_PANELS)],
+      error: null,
+    },
+    settings: mergeIrSettings(DEFAULT_SETTINGS, settings),
+  };
+}
+
+/**
+ * Fold one action into the state.
+ * @param state - The state in force.
+ * @param action - What is being asked.
+ * @returns The new state, or the old one when nothing changed.
+ */
+export function irReducer(state: IrState, action: IrAction): IrState {
+  switch (action.type) {
+    case 'addSpectra': {
+      if (action.spectra.length === 0) return state;
+      const spectra = [...state.data.spectra, ...action.spectra];
+      return {
+        ...state,
+        data: { spectra },
+        view: {
+          ...state.view,
+          // Whatever arrived is what somebody wants to look at, so it takes the
+          // selection — but only when nothing was selected, since a spectrum
+          // added for comparison must not steal the panels from the one being
+          // read.
+          selectedId: state.view.selectedId ?? action.spectra[0]?.id ?? null,
+          error: null,
+        },
+      };
+    }
+
+    case 'setSpectra': {
+      return {
+        ...state,
+        data: { spectra: [...action.spectra] },
+        view: {
+          ...state.view,
+          selectedId: action.spectra[0]?.id ?? null,
+          // Replacing what is drawn is the one change that throws the window
+          // away: a window over one spectrum's wavenumbers means nothing over
+          // another's, and the chart refits when it is handed `null`.
+          domain: null,
+          error: null,
+        },
+      };
+    }
+
+    case 'removeSpectrum': {
+      const spectra = state.data.spectra.filter(
+        (spectrum) => spectrum.id !== action.id,
+      );
+      if (spectra.length === state.data.spectra.length) return state;
+      return {
+        ...state,
+        data: { spectra },
+        view: {
+          ...state.view,
+          selectedId:
+            state.view.selectedId === action.id
+              ? (spectra[0]?.id ?? null)
+              : state.view.selectedId,
+        },
+      };
+    }
+
+    case 'renameSpectrum': {
+      const name = action.name.trim();
+      if (name === '') {
+        return withError(state, 'A spectrum needs a name to be called by.');
+      }
+      return mapSpectrum(state, action.id, (spectrum) =>
+        spectrum.name === name ? spectrum : { ...spectrum, name },
+      );
+    }
+
+    case 'setSpectrumColor': {
+      return mapSpectrum(state, action.id, (spectrum) =>
+        spectrum.color === action.color
+          ? spectrum
+          : { ...spectrum, color: action.color },
+      );
+    }
+
+    case 'setSpectrumVisible': {
+      return mapSpectrum(state, action.id, (spectrum) =>
+        spectrum.visible === action.visible
+          ? spectrum
+          : { ...spectrum, visible: action.visible },
+      );
+    }
+
+    case 'selectSpectrum': {
+      if (state.view.selectedId === action.id) return state;
+      return { ...state, view: { ...state.view, selectedId: action.id } };
+    }
+
+    case 'setDomain': {
+      if (!isIrWindow(action.domain)) return state;
+      return { ...state, view: { ...state.view, domain: action.domain } };
+    }
+
+    case 'resetDomain': {
+      if (state.view.domain === null) return state;
+      return { ...state, view: { ...state.view, domain: null } };
+    }
+
+    case 'setTool': {
+      if (state.view.tool === action.tool) return state;
+      return { ...state, view: { ...state.view, tool: action.tool } };
+    }
+
+    case 'togglePanel': {
+      const { openPanelIds } = state.view;
+      const open = openPanelIds.includes(action.panelId);
+      return {
+        ...state,
+        view: {
+          ...state.view,
+          openPanelIds: open
+            ? openPanelIds.filter((id) => id !== action.panelId)
+            : [...openPanelIds, action.panelId],
+        },
+      };
+    }
+
+    case 'setError': {
+      if (state.view.error === action.error) return state;
+      return { ...state, view: { ...state.view, error: action.error } };
+    }
+
+    case 'setSettings': {
+      const settings = mergeIrSettings(state.settings, action.settings);
+      return { ...state, settings };
+    }
+
+    case 'loadState': {
+      const { data, view, settings } = action.state;
+      return {
+        data: data === undefined ? state.data : { spectra: [...data.spectra] },
+        view: { ...state.view, ...view },
+        settings: mergeIrSettings(state.settings, settings),
+      };
+    }
+
+    case 'clear': {
+      if (state.data.spectra.length === 0 && state.view.error === null) {
+        return state;
+      }
+      return {
+        ...state,
+        data: { spectra: [] },
+        view: { ...state.view, selectedId: null, domain: null, error: null },
+      };
+    }
+    /* Every action is handled above, and TypeScript is what keeps that true
+       when one is added — so there is nothing for a fallback to do. */
+    // no default
+  }
+}
+
+/**
+ * Change one spectrum, leaving the state alone when it did not change.
+ * @param state - The state in force.
+ * @param id - Which spectrum.
+ * @param change - What to make of it; return it unchanged for no change.
+ * @returns The new state, or the old one.
+ */
+function mapSpectrum(
+  state: IrState,
+  id: string,
+  change: (spectrum: IrSpectrum) => IrSpectrum,
+): IrState {
+  let changed = false;
+  const spectra = state.data.spectra.map((spectrum) => {
+    if (spectrum.id !== id) return spectrum;
+    const next = change(spectrum);
+    if (next !== spectrum) changed = true;
+    return next;
+  });
+  if (!changed) return state;
+  return { ...state, data: { spectra }, view: { ...state.view, error: null } };
+}
+
+/**
+ * Refuse an action, saying why.
+ * @param state - The state in force.
+ * @param error - The sentence to show whoever asked.
+ * @returns The state carrying the refusal.
+ */
+function withError(state: IrState, error: string): IrState {
+  return { ...state, view: { ...state.view, error } };
+}

package/src/ir/core/irSidePanels.ts

@@ -0,0 +1,20 @@
+import type { ActivityBarItemProps } from 'react-science/ui';
+
+/**
+ * The panels the side of the viewer can hold, in the order their icons stack.
+ *
+ * One frozen list read by both the activity bar and the panel stack, so a panel
+ * switched off and on again comes back where it was rather than at the end.
+ */
+export const irSidePanels = [
+  { id: 'spectra', title: 'Spectra', icon: 'timeline-line-chart' },
+  { id: 'bands', title: 'Bands', icon: 'th-list' },
+  { id: 'metadata', title: 'Acquisition', icon: 'properties' },
+] as const satisfies ReadonlyArray<{
+  id: string;
+  title: string;
+  icon: ActivityBarItemProps['icon'];
+}>;
+
+/** Identity of one of the panels the activity bar offers. */
+export type IrSidePanelId = (typeof irSidePanels)[number]['id'];

package/src/ir/core/irSpectrum.ts

@@ -0,0 +1,155 @@
+/**
+ * What an infrared spectrum is once it has been read, whatever it was read from.
+ *
+ * One acquisition becomes one `IrSpectrum` carrying **both** value axes —
+ * absorbance and percent transmittance — over one shared array of wavenumbers.
+ * Both are held rather than one being derived on demand because `ir-spectrum`
+ * already produces both when it reads a file: it adds an `a` and a `t` variable
+ * to every spectrum whichever of the two the instrument wrote, so the conversion
+ * happens once, in the one place that knows what the file's y axis meant. Holding
+ * the answer means switching what is drawn costs nothing, and means the two
+ * axes can never drift apart through a round trip.
+ *
+ * The arrays are `Float64Array` and are replaced on a change, never written
+ * into, since every consumer holds the same object by reference. An infrared
+ * spectrum is a few thousand points rather than a mass spectrum's few hundred
+ * thousand, so holding two value axes costs nothing worth counting.
+ */
+
+import type { DataXY } from 'cheminfo-types';
+
+import type { ChartDomain } from '../../chart/core/chartDomain.ts';
+
+/**
+ * One trace of a measurement: wavenumber against whichever value axis is drawn.
+ *
+ * `DataXY` is the shape every package in this pipeline speaks — `ir-spectrum`,
+ * `common-spectrum`, `xy-parser` and `ml-spectra-processing` all take and return
+ * it — so declaring a parallel type of our own would buy nothing and cost an
+ * adapter at each boundary.
+ */
+export type IrTrace = DataXY<Float64Array>;
+
+/** The formats a spectrum can have been read from. */
+export type IrFormat = 'jcamp' | 'spc' | 'text' | 'calculated';
+
+/**
+ * Where a spectrum came from, and what the file said about the acquisition.
+ *
+ * Kept apart from `meta` because these are the facts other code branches on,
+ * while `meta` is a table to read.
+ */
+export interface IrOrigin {
+  /** The format it was read from. */
+  format: IrFormat;
+  /**
+   * Name of the file it came from, absent for a paste.
+   * @default undefined
+   */
+  fileName?: string;
+  /**
+   * Which block of that file, absent when the file held only one.
+   * @default undefined
+   */
+  blockIndex?: number;
+  /**
+   * Which value axis the file itself carried, absent when it said nothing.
+   *
+   * Worth keeping even though both axes are held: a spectrum exported as
+   * transmittance and one exported as absorbance are the same measurement, but
+   * only one of the two is what the instrument actually recorded, and the other
+   * carries whatever the conversion did to its noise.
+   * @default undefined
+   */
+  recorded?: IrMode;
+}
+
+/** One row of the acquisition table. */
+export interface IrMetaField {
+  /** How the row is named, in the display order the table fixes. */
+  label: string;
+  /** The value as the file states it. */
+  value: string;
+}
+
+/**
+ * What the file says about how the spectrum was acquired.
+ *
+ * Only ever what it actually says: a field the file leaves blank is left out
+ * rather than shown empty, so the table is short and every line in it is a fact.
+ * A plain two-column paste carries none of this, and the panel then shows the
+ * file name alone.
+ */
+export interface IrMeta {
+  /** The title record, `null` when the file carries none. */
+  title: string | null;
+  /** The fields that are populated, in display order. */
+  fields: IrMetaField[];
+}
+
+/** Which value axis is being drawn and read. */
+export type IrMode = 'absorbance' | 'transmittance';
+
+/** One spectrum as the viewer holds it. */
+export interface IrSpectrum {
+  /** Identity, stable across edits so a selection survives a rename. */
+  id: string;
+  /** What the list calls it; editable, and never used as identity. */
+  name: string;
+  /** The colour it is drawn in. */
+  color: string;
+  /**
+   * The wavenumbers in cm⁻¹, **ascending**.
+   *
+   * Ascending even though the axis is read from 4000 down to 400: which way the
+   * numbers run on screen is the chart's business, and every binary search and
+   * every extent taken off index zero downstream wants them in order. Reversing
+   * the data instead would make the drawing simpler once and everything else
+   * wrong.
+   */
+  wavenumber: Float64Array;
+  /** Absorbance at each wavenumber, as `ir-spectrum` supplied it. */
+  absorbance: Float64Array;
+  /** Percent transmittance at each wavenumber, likewise. */
+  transmittance: Float64Array;
+  /** What the file said about the acquisition, `null` when it said nothing. */
+  meta: IrMeta | null;
+  /** Where it came from. */
+  origin: IrOrigin;
+  /** Whether it is drawn. */
+  visible: boolean;
+  /**
+   * Whether the trace is left out of the automatic domain. A reference held
+   * under the pointer for comparison must not move the axes, or hovering one
+   * would throw away the zoom the user set.
+   * @default false
+   */
+  excludeFromDomain?: boolean;
+}
+
+/**
+ * The window the chart is showing, in data units.
+ *
+ * `ChartDomain` itself, not a type of our own: the arithmetic that moves a
+ * window is the shared chart's and speaks that type, and an alias here
+ * that merely renamed it would need converting at every call. `x` is in
+ * wavenumbers and runs low to high, whichever way round the axis is drawn.
+ */
+export type IrDomain = ChartDomain;
+
+/**
+ * The trace to draw for a spectrum, in whichever value axis is being read.
+ *
+ * The arrays are handed back by reference rather than copied: nothing downstream
+ * writes into a trace, and a profile of a few thousand points copied on every
+ * render of every spectrum is a copy per frame for no gain.
+ * @param spectrum - The spectrum.
+ * @param mode - Which value axis is being drawn.
+ * @returns The trace, sharing the spectrum's own arrays.
+ */
+export function traceOf(spectrum: IrSpectrum, mode: IrMode): IrTrace {
+  return {
+    x: spectrum.wavenumber,
+    y: mode === 'absorbance' ? spectrum.absorbance : spectrum.transmittance,
+  };
+}

package/src/ir/core/irState.ts

@@ -0,0 +1,173 @@
+/**
+ * Everything the viewer knows, in the three buckets NMRium splits its own into
+ * — the same three the mass viewer holds, under the same names.
+ *
+ * The split is the persistence boundary as much as anything: `data` is the
+ * document, `view` is where you are in it and lasts as long as the session, and
+ * `settings` is the workspace, which is how every spectrum is drawn whichever
+ * ones happen to be open.
+ *
+ * The bands are **not** in here. They are derived from the spectra and the
+ * picking settings, so holding them would mean holding an answer that has to be
+ * kept in step with its own inputs — `useIrEditor` recomputes them instead, and
+ * a stale band is then impossible rather than merely unlikely.
+ */
+
+import type { IrSidePanelId } from './irSidePanels.ts';
+import type { IrDomain, IrMode, IrSpectrum } from './irSpectrum.ts';
+import type { PickBandsOptions } from './pickBands.ts';
+
+/** The document: what a file holds. */
+export interface IrData {
+  /** The spectra, in the order they were loaded. */
+  spectra: IrSpectrum[];
+}
+
+/** What a drag across the chart is for while it is chosen. */
+export type IrTool = 'read' | 'box';
+
+/** Where you are in the viewer. */
+export interface IrView {
+  /** Identity of the spectrum the panels act on, `null` for none. */
+  selectedId: string | null;
+  /**
+   * The window being shown, `null` while the chart is showing what fits.
+   *
+   * Held here so that a toolbar button can zoom — the chart is told a window and
+   * reports every window it arrives at, and this is where the answer lives
+   * between the two.
+   */
+  domain: IrDomain | null;
+  /** Which tool a drag across the chart is running. */
+  tool: IrTool;
+  /** The side panels that are open, in the order their icons are stacked. */
+  openPanelIds: IrSidePanelId[];
+  /** Why the last action was refused, `null` as soon as one succeeds. */
+  error: string | null;
+}
+
+/** The workspace: how every spectrum is drawn, whichever ones are open. */
+export interface IrSettings {
+  /** Which value axis the spectra are read in. */
+  mode: IrMode;
+  /** Whether the bands are picked at all. */
+  pickBands: boolean;
+  /** How the bands are picked when they are. */
+  picking: PickBandsOptions;
+  /** Whether a band's label names its assignment as well as its wavenumber. */
+  showAssignments: boolean;
+  /** At most how many bands are labelled on the chart. */
+  labelLimit: number;
+  /** How far outside a table range a band may fall and still be offered it. */
+  assignmentTolerance: number;
+}
+
+/** Everything the viewer knows. */
+export interface IrState {
+  /** The spectra that are open. */
+  data: IrData;
+  /** Where you are in the viewer. */
+  view: IrView;
+  /** How spectra are drawn and read. */
+  settings: IrSettings;
+}
+
+/** Part of a state, as a host restoring one supplies it. */
+export interface PartialIrState {
+  /** The spectra that were open. */
+  data?: IrData;
+  /** Where the viewer was left. */
+  view?: Partial<IrView>;
+  /** The workspace they were drawn in. */
+  settings?: Partial<IrSettings>;
+}
+
+/** The panel the splitter brings back when it is dragged open on nothing. */
+export const DEFAULT_SIDE_PANEL: IrSidePanelId = 'spectra';
+
+/**
+ * The panels a fresh viewer opens with.
+ *
+ * The band table, because it is the reason to open an infrared spectrum at all
+ * — a trace on its own can be looked at, and it is the table beside it that lets
+ * it be read.
+ */
+export const DEFAULT_SIDE_PANELS: IrSidePanelId[] = ['spectra', 'bands'];
+
+/** At most how many bands a gesture may ask to have labelled. */
+export const MAXIMUM_LABEL_LIMIT = 200;
+
+/** How many are labelled to begin with. */
+export const DEFAULT_LABEL_LIMIT = 12;
+
+/** How the bands are picked before anybody adjusts it. */
+export const DEFAULT_PICKING: PickBandsOptions = {
+  minRelativeHeight: 0.02,
+  minPeakWidth: 4,
+};
+
+/** The workspace a fresh viewer starts from. */
+export const DEFAULT_SETTINGS: IrSettings = {
+  mode: 'transmittance',
+  pickBands: true,
+  picking: DEFAULT_PICKING,
+  showAssignments: false,
+  labelLimit: DEFAULT_LABEL_LIMIT,
+  assignmentTolerance: 5,
+};
+
+/**
+ * Fold a change into the workspace, refusing what no chart survives.
+ *
+ * A number typed into a field arrives here as `NaN` for every keystroke that is
+ * not yet a number — a lone minus sign, an empty box — and a limit of `NaN`
+ * silently stops every label being drawn. So each is checked, and the current
+ * value is kept where the new one is unusable rather than the field being
+ * fought with while it is being typed in.
+ * @param current - The workspace in force.
+ * @param change - What to change about it.
+ * @returns The new workspace.
+ */
+export function mergeIrSettings(
+  current: IrSettings,
+  change: Partial<IrSettings> = {},
+): IrSettings {
+  const asked = change.labelLimit ?? current.labelLimit;
+  const tolerance = change.assignmentTolerance ?? current.assignmentTolerance;
+  return {
+    ...current,
+    ...change,
+    picking: { ...current.picking, ...change.picking },
+    labelLimit: Number.isFinite(asked)
+      ? Math.min(MAXIMUM_LABEL_LIMIT, Math.max(0, Math.round(asked)))
+      : current.labelLimit,
+    assignmentTolerance:
+      Number.isFinite(tolerance) && tolerance >= 0
+        ? tolerance
+        : current.assignmentTolerance,
+  };
+}
+
+/**
+ * Whether a window is one a chart can be built on.
+ *
+ * Both ends finite and the low one below the high one. A window failing either
+ * makes every scale built from it infinite, which the DOM refuses outright — so
+ * a handle told to frame a band it worked out wrongly leaves the chart alone
+ * instead of blanking it.
+ * @param domain - The window to check.
+ * @returns Whether it can be shown.
+ */
+export function isIrWindow(domain: IrDomain): boolean {
+  return isWindow(domain.x) && isWindow(domain.y);
+}
+
+/**
+ * Whether one axis of a window runs from somewhere to somewhere else.
+ * @param bounds - `[from, to]` on that axis.
+ * @returns Whether it is usable.
+ */
+function isWindow(bounds: [number, number]): boolean {
+  const [from, to] = bounds;
+  return Number.isFinite(from) && Number.isFinite(to) && from < to;
+}

package/src/ir/core/loadIrSpectra.ts

@@ -0,0 +1,79 @@
+/**
+ * One entry point for whatever was dropped, opened or pasted.
+ *
+ * The format is decided from the bytes and the right reader is called, so a
+ * caller hands over a file and gets spectra back without knowing what it turned
+ * out to be. Each reader is imported only once the bytes turn out to need it, so
+ * a page that never opens an SPC never downloads its parser.
+ */
+
+import { describeSource } from '../../error/core/index.ts';
+
+import type { LoadedIrSpectrum } from './analysisSpectra.ts';
+import { detectIrFormat } from './detectIrFormat.ts';
+import type { IrOrigin } from './irSpectrum.ts';
+
+/** How a file is read. */
+export interface LoadIrSpectraOptions {
+  /**
+   * The file's name, which decides the reader when the content is silent and is
+   * carried onto every spectrum read out of it.
+   * @default undefined
+   */
+  fileName?: string;
+}
+
+/** What a file turned out to hold. */
+export interface LoadIrSpectraResult {
+  /** The spectra it held, in the order the file wrote them. */
+  spectra: LoadedIrSpectrum[];
+  /** What it turned out to be. */
+  format: IrOrigin['format'];
+}
+
+/**
+ * Read every infrared spectrum a file holds.
+ * @param data - The file, as bytes, or the pasted text.
+ * @param options - The file's name.
+ * @returns The spectra, and the format they were read from.
+ * @throws {Error} When nothing in the file names a format this can read, or when
+ * the reader for that format gave up on it.
+ */
+export async function loadIrSpectra(
+  data: Uint8Array | string,
+  options: LoadIrSpectraOptions = {},
+): Promise<LoadIrSpectraResult> {
+  const { fileName } = options;
+  const format = detectIrFormat(data, fileName);
+
+  if (format === 'jcamp') {
+    const { fromJcamp } = await import('./fromJcamp.ts');
+    return { spectra: fromJcamp(data, options), format };
+  }
+
+  if (format === 'spc') {
+    if (typeof data === 'string') {
+      throw new Error(
+        `${describeSource(fileName)} looks like an SPC file but arrived as text — SPC is binary, and reading it as text loses bytes it cannot get back.`,
+      );
+    }
+    const { fromSpc } = await import('./fromSpc.ts');
+    return { spectra: fromSpc(data, options), format };
+  }
+
+  if (format === 'text') {
+    // Deliberately refused rather than half-read. `ir-spectrum` adds the
+    // absorbance and transmittance pair to everything `fromJcamp` and `fromSPC`
+    // produce, but not to `fromText`, so a two-column file arrives carrying only
+    // the axis it was written in. Deriving the other one here would put a second
+    // implementation of that conversion in this package, which is exactly what
+    // depending on `ir-spectrum` is meant to avoid.
+    throw new Error(
+      `${describeSource(fileName)} is two columns of numbers, which this viewer cannot read yet: ir-spectrum derives the absorbance and transmittance pair for JCAMP-DX and SPC but not for plain text, and this package deliberately does not do that conversion itself. Export the spectrum as JCAMP-DX (.jdx) instead.`,
+    );
+  }
+
+  throw new Error(
+    `${describeSource(fileName)} is not a spectrum this viewer can read — JCAMP-DX (.jdx, .dx) and Thermo Galactic SPC (.spc) are understood.`,
+  );
+}